mirror of https://github.com/vitalif/e2fsprogs
Many files:
badblocks.c, e2fsck.h, ehandler.c, emptydir.c, extend.c, flushb.c, iscan.c, message.c, pass1.c, pass1b.c, pass3.c pass4.c, pass5.c, problem.c, scantest.c, swapfs.c, unix.c, util.c: Add Internationalization support as suggested by Marco d'Itri <md@linux.it>.bitmap-optimize
Theodore Ts'o
parent
565aea1f40
commit
0c4a07264e
|
|
@ -1,3 +1,11 @@
|
|||
2000-02-06 Theodore Ts'o <tytso@valinux.com>
|
||||
|
||||
* badblocks.c, e2fsck.h, ehandler.c, emptydir.c, extend.c,
|
||||
flushb.c, iscan.c, message.c, pass1.c, pass1b.c, pass3.c
|
||||
pass4.c, pass5.c, problem.c, scantest.c, swapfs.c,
|
||||
unix.c, util.c: Add Internationalization support as
|
||||
suggested by Marco d'Itri <md@linux.it>.
|
||||
|
||||
2000-02-02 Theodore Ts'o <tytso@valinux.com>
|
||||
|
||||
* e2fsck.h, flushb.c, scantest.c: Remove uneeded include of
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
|
|||
|
||||
static void invalid_block(ext2_filsys fs, blk_t blk)
|
||||
{
|
||||
printf("Bad block %u out of range; ignored.\n", blk);
|
||||
printf(_("Bad block %u out of range; ignored.\n"), blk);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -42,7 +42,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
check_bb_inode_blocks, 0);
|
||||
if (retval) {
|
||||
com_err("ext2fs_block_iterate", retval,
|
||||
"while sanity checking the bad blocks inode");
|
||||
_("while sanity checking the bad blocks inode"));
|
||||
goto fatal;
|
||||
}
|
||||
|
||||
|
|
@ -54,7 +54,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
retval = ext2fs_read_bb_inode(fs, &bb_list);
|
||||
if (retval) {
|
||||
com_err("ext2fs_read_bb_inode", retval,
|
||||
"while reading the bad blocks inode");
|
||||
_("while reading the bad blocks inode"));
|
||||
goto fatal;
|
||||
}
|
||||
}
|
||||
|
|
@ -68,7 +68,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
f = fopen(bad_blocks_file, "r");
|
||||
if (!f) {
|
||||
com_err("read_bad_blocks_file", errno,
|
||||
"while trying to open %s", bad_blocks_file);
|
||||
_("while trying to open %s"), bad_blocks_file);
|
||||
goto fatal;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -78,7 +78,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
f = popen(buf, "r");
|
||||
if (!f) {
|
||||
com_err("read_bad_blocks_file", errno,
|
||||
"while trying popen '%s'", buf);
|
||||
_("while trying popen '%s'"), buf);
|
||||
goto fatal;
|
||||
}
|
||||
}
|
||||
|
|
@ -89,7 +89,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
pclose(f);
|
||||
if (retval) {
|
||||
com_err("ext2fs_read_bb_FILE", retval,
|
||||
"while reading in list of bad blocks from file");
|
||||
_("while reading in list of bad blocks from file"));
|
||||
goto fatal;
|
||||
}
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
|
|||
retval = ext2fs_update_bb_inode(fs, bb_list);
|
||||
if (retval) {
|
||||
com_err("ext2fs_update_bb_inode", retval,
|
||||
"while updating bad block inode");
|
||||
_("while updating bad block inode"));
|
||||
goto fatal;
|
||||
}
|
||||
|
||||
|
|
@ -128,7 +128,7 @@ static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
|
|||
*/
|
||||
if (*block_nr >= fs->super->s_blocks_count ||
|
||||
*block_nr < fs->super->s_first_data_block) {
|
||||
printf("Warning illegal block %u found in bad block inode. Cleared.\n", *block_nr);
|
||||
printf(_("Warning illegal block %u found in bad block inode. Cleared.\n"), *block_nr);
|
||||
*block_nr = 0;
|
||||
return BLOCK_CHANGED;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,6 +31,24 @@
|
|||
#include "ext2fs/ext2fs.h"
|
||||
#endif
|
||||
|
||||
#ifdef ENABLE_NLS
|
||||
#include <libintl.h>
|
||||
#include <locale.h>
|
||||
#define _(a) (gettext (a))
|
||||
#ifdef gettext_noop
|
||||
#define N_(a) gettext_noop (a)
|
||||
#else
|
||||
#define N_(a) (a)
|
||||
#endif
|
||||
/* FIXME */
|
||||
#define NLS_CAT_NAME "e2fsprogs"
|
||||
#define LOCALEDIR "/usr/share/locale"
|
||||
/* FIXME */
|
||||
#else
|
||||
#define _(a) (a)
|
||||
#define N_(a) a
|
||||
#endif
|
||||
|
||||
|
||||
/* Everything is STDC, these days */
|
||||
#define NOARGS void
|
||||
|
|
|
|||
|
|
@ -50,13 +50,13 @@ static errcode_t e2fsck_handle_read_error(io_channel channel,
|
|||
return 0;
|
||||
}
|
||||
if (operation)
|
||||
printf("Error reading block %lu (%s) while %s. ", block,
|
||||
printf(_("Error reading block %lu (%s) while %s. "), block,
|
||||
error_message(error), operation);
|
||||
else
|
||||
printf("Error reading block %lu (%s). ", block,
|
||||
printf(_("Error reading block %lu (%s). "), block,
|
||||
error_message(error));
|
||||
preenhalt(ctx);
|
||||
if (ask(ctx, "Ignore error", 1))
|
||||
if (ask(ctx, _("Ignore error"), 1))
|
||||
return 0;
|
||||
|
||||
return error;
|
||||
|
|
@ -94,13 +94,13 @@ static errcode_t e2fsck_handle_write_error(io_channel channel,
|
|||
}
|
||||
|
||||
if (operation)
|
||||
printf("Error writing block %lu (%s) while %s. ", block,
|
||||
printf(_("Error writing block %lu (%s) while %s. "), block,
|
||||
error_message(error), operation);
|
||||
else
|
||||
printf("Error writing block %lu (%s). ", block,
|
||||
printf(_("Error writing block %lu (%s). "), block,
|
||||
error_message(error));
|
||||
preenhalt(ctx);
|
||||
if (ask(ctx, "Ignore error", 1))
|
||||
if (ask(ctx, _("Ignore error"), 1))
|
||||
return 0;
|
||||
|
||||
return error;
|
||||
|
|
|
|||
|
|
@ -53,12 +53,12 @@ empty_dir_info init_empty_dir(e2fsck_t ctx)
|
|||
if (retval)
|
||||
goto errout;
|
||||
|
||||
retval = ext2fs_allocate_block_bitmap(ctx->fs, "empty dirblocks",
|
||||
retval = ext2fs_allocate_block_bitmap(ctx->fs, _("empty dirblocks"),
|
||||
&edi->empty_dir_blocks);
|
||||
if (retval)
|
||||
goto errout;
|
||||
|
||||
retval = ext2fs_allocate_inode_bitmap(ctx->fs, "empty dir map",
|
||||
retval = ext2fs_allocate_inode_bitmap(ctx->fs, _("empty dir map"),
|
||||
&edi->dir_map);
|
||||
if (retval)
|
||||
goto errout;
|
||||
|
|
@ -94,7 +94,7 @@ void add_empty_dirblock(empty_dir_info edi,
|
|||
if (db->ino == 11)
|
||||
return; /* Inode number 11 is usually lost+found */
|
||||
|
||||
printf("Empty directory block %d (#%d) in inode %d\n",
|
||||
printf(_("Empty directory block %d (#%d) in inode %d\n"),
|
||||
db->blk, db->blockcnt, db->ino);
|
||||
|
||||
ext2fs_mark_block_bitmap(edi->empty_dir_blocks, db->blk);
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
static void usage(char *progname)
|
||||
{
|
||||
fprintf(stderr, "%s: %s filename nblocks blocksize\n",
|
||||
fprintf(stderr, _("%s: %s filename nblocks blocksize\n"),
|
||||
progname, progname);
|
||||
exit(1);
|
||||
}
|
||||
|
|
@ -39,13 +39,13 @@ int main(int argc, char **argv)
|
|||
blocksize = strtoul(argv[3], 0, 0);
|
||||
|
||||
if (nblocks < 0) {
|
||||
fprintf(stderr, "Illegal number of blocks!\n");
|
||||
fprintf(stderr, _("Illegal number of blocks!\n"));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
block = malloc(blocksize);
|
||||
if (block == 0) {
|
||||
fprintf(stderr, "Couldn't allocate block buffer(size=%d)\n",
|
||||
fprintf(stderr, _("Couldn't allocate block buffer (size=%d)\n"),
|
||||
blocksize);
|
||||
exit(1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ const char *progname;
|
|||
|
||||
static void usage(NOARGS)
|
||||
{
|
||||
fprintf(stderr, "Usage: %s disk\n", progname);
|
||||
fprintf(stderr, _("Usage: %s disk\n"), progname);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ int main(int argc, char **argv)
|
|||
return 0;
|
||||
#else
|
||||
fprintf(stderr,
|
||||
"BLKFLSBUF ioctl not supported! Can't flush buffers.\n");
|
||||
_("BLKFLSBUF ioctl not supported! Can't flush buffers.\n"));
|
||||
return 1;
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ struct resource_track global_rtrack;
|
|||
static void usage(NOARGS)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"Usage: %s [-F] [-I inode_buffer_blocks] device\n",
|
||||
_("Usage: %s [-F] [-I inode_buffer_blocks] device\n"),
|
||||
program_name);
|
||||
exit(1);
|
||||
}
|
||||
|
|
@ -66,7 +66,7 @@ static void PRS(int argc, char *argv[])
|
|||
#ifdef BLKFLSBUF
|
||||
flush = 1;
|
||||
#else
|
||||
fprintf(stderr, "-F not supported");
|
||||
fprintf(stderr, _("-F not supported"));
|
||||
exit(1);
|
||||
#endif
|
||||
break;
|
||||
|
|
@ -82,18 +82,18 @@ static void PRS(int argc, char *argv[])
|
|||
int fd = open(device_name, O_RDONLY, 0);
|
||||
|
||||
if (fd < 0) {
|
||||
com_err("open", errno, "while opening %s for flushing",
|
||||
device_name);
|
||||
com_err("open", errno,
|
||||
_("while opening %s for flushing"), device_name);
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
if (ioctl(fd, BLKFLSBUF, 0) < 0) {
|
||||
com_err("BLKFLSBUF", errno, "while trying to flush %s",
|
||||
device_name);
|
||||
com_err("BLKFLSBUF", errno,
|
||||
_("while trying to flush %s"), device_name);
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
close(fd);
|
||||
#else
|
||||
fprintf(stderr, "BLKFLSBUF not supported");
|
||||
fprintf(stderr, _("BLKFLSBUF not supported"));
|
||||
exit(1);
|
||||
#endif /* BLKFLSBUF */
|
||||
}
|
||||
|
|
@ -116,7 +116,7 @@ int main (int argc, char *argv[])
|
|||
retval = ext2fs_open(device_name, 0,
|
||||
0, 0, unix_io_manager, &fs);
|
||||
if (retval) {
|
||||
com_err(program_name, retval, "while trying to open %s",
|
||||
com_err(program_name, retval, _("while trying to open %s"),
|
||||
device_name);
|
||||
exit(1);
|
||||
}
|
||||
|
|
@ -125,7 +125,7 @@ int main (int argc, char *argv[])
|
|||
|
||||
retval = ext2fs_open_inode_scan(fs, inode_buffer_blocks, &scan);
|
||||
if (retval) {
|
||||
com_err(program_name, retval, "while opening inode scan");
|
||||
com_err(program_name, retval, _("while opening inode scan"));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
|
@ -133,7 +133,7 @@ int main (int argc, char *argv[])
|
|||
retval = ext2fs_get_next_inode(scan, &ino, &inode);
|
||||
if (retval) {
|
||||
com_err(program_name, retval,
|
||||
"while getting next inode");
|
||||
_("while getting next inode"));
|
||||
exit(1);
|
||||
}
|
||||
if (ino == 0)
|
||||
|
|
@ -142,7 +142,7 @@ int main (int argc, char *argv[])
|
|||
}
|
||||
|
||||
print_resource_track(NULL, &global_rtrack);
|
||||
printf("%d inodes scanned.\n", num_inodes);
|
||||
printf(_("%d inodes scanned.\n"), num_inodes);
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -92,26 +92,26 @@
|
|||
* letter <i> in the table below.
|
||||
*/
|
||||
static const char *abbrevs[] = {
|
||||
"Aerror allocating",
|
||||
"bblock",
|
||||
"Bbitmap",
|
||||
"Cconflicts with some other fs @b",
|
||||
"iinode",
|
||||
"Iillegal",
|
||||
"Ddeleted",
|
||||
"ddirectory",
|
||||
"eentry",
|
||||
"E@e '%Dn' in %p (%i)",
|
||||
"ffilesystem",
|
||||
"Ffor @i %i (%Q) is",
|
||||
"ggroup",
|
||||
"llost+found",
|
||||
"Lis a link",
|
||||
"uunattached",
|
||||
"rroot @i",
|
||||
"sshould be",
|
||||
"Ssuper@b",
|
||||
"zzero-length",
|
||||
N_("Aerror allocating"),
|
||||
N_("bblock"),
|
||||
N_("Bbitmap"),
|
||||
N_("Cconflicts with some other fs @b"),
|
||||
N_("iinode"),
|
||||
N_("Iillegal"),
|
||||
N_("Ddeleted"),
|
||||
N_("ddirectory"),
|
||||
N_("eentry"),
|
||||
N_("E@e '%Dn' in %p (%i)"),
|
||||
N_("ffilesystem"),
|
||||
N_("Ffor @i %i (%Q) is"),
|
||||
N_("ggroup"),
|
||||
N_("llost+found"),
|
||||
N_("Lis a link"),
|
||||
N_("uunattached"),
|
||||
N_("rroot @i"),
|
||||
N_("sshould be"),
|
||||
N_("Ssuper@b"),
|
||||
N_("zzero-length"),
|
||||
"@@",
|
||||
0
|
||||
};
|
||||
|
|
@ -122,13 +122,13 @@ static const char *abbrevs[] = {
|
|||
#define num_special_inodes 7
|
||||
static const char *special_inode_name[] =
|
||||
{
|
||||
"<The NULL inode>", /* 0 */
|
||||
"<The bad blocks inode>", /* 1 */
|
||||
N_("<The NULL inode>"), /* 0 */
|
||||
N_("<The bad blocks inode>"), /* 1 */
|
||||
"/", /* 2 */
|
||||
"<The ACL index inode>", /* 3 */
|
||||
"<The ACL data inode>", /* 4 */
|
||||
"<The boot loader inode>", /* 5 */
|
||||
"<The undelete directory inode>" /* 6 */
|
||||
N_("<The ACL index inode>"), /* 3 */
|
||||
N_("<The ACL data inode>"), /* 4 */
|
||||
N_("<The boot loader inode>"), /* 5 */
|
||||
N_("<The undelete directory inode>") /* 6 */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -167,7 +167,7 @@ static void print_pathname(ext2_filsys fs, ino_t dir, ino_t ino)
|
|||
char *path;
|
||||
|
||||
if (!dir && (ino < num_special_inodes)) {
|
||||
fputs(special_inode_name[ino], stdout);
|
||||
fputs(_(special_inode_name[ino]), stdout);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -202,7 +202,7 @@ static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch,
|
|||
*first = 0;
|
||||
fputc(toupper(*str++), stdout);
|
||||
}
|
||||
print_e2fsck_message(ctx, str, pctx, *first);
|
||||
print_e2fsck_message(ctx, _(str), pctx, *first);
|
||||
} else
|
||||
printf("@%c", ch);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ void e2fsck_pass1(e2fsck_t ctx)
|
|||
/*
|
||||
* Allocate bitmaps structures
|
||||
*/
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "in-use inode map",
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
|
||||
&ctx->inode_used_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 1;
|
||||
|
|
@ -214,8 +214,8 @@ void e2fsck_pass1(e2fsck_t ctx)
|
|||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "directory inode map",
|
||||
&ctx->inode_dir_map);
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
|
||||
_("directory inode map"), &ctx->inode_dir_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 2;
|
||||
fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
|
||||
|
|
@ -223,15 +223,14 @@ void e2fsck_pass1(e2fsck_t ctx)
|
|||
return;
|
||||
}
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
|
||||
"regular file inode map",
|
||||
&ctx->inode_reg_map);
|
||||
_("regular file inode map"), &ctx->inode_reg_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 6;
|
||||
fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
pctx.errcode = ext2fs_allocate_block_bitmap(fs, "in-use block map",
|
||||
pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
|
||||
&ctx->block_found_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 1;
|
||||
|
|
@ -239,7 +238,7 @@ void e2fsck_pass1(e2fsck_t ctx)
|
|||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
pctx.errcode = ext2fs_allocate_block_bitmap(fs, "illegal block map",
|
||||
pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("illegal block map"),
|
||||
&ctx->block_illegal_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 2;
|
||||
|
|
@ -272,7 +271,7 @@ void e2fsck_pass1(e2fsck_t ctx)
|
|||
block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
|
||||
"block interate buffer");
|
||||
e2fsck_use_inode_shortcuts(ctx, 1);
|
||||
ehandler_operation("doing inode scan");
|
||||
ehandler_operation(_("doing inode scan"));
|
||||
pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
|
||||
&scan);
|
||||
if (pctx.errcode) {
|
||||
|
|
@ -583,7 +582,7 @@ endit:
|
|||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME2) {
|
||||
e2fsck_clear_progbar(ctx);
|
||||
print_resource_track("Pass 1", &rtrack);
|
||||
print_resource_track(_("Pass 1"), &rtrack);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -641,7 +640,8 @@ static void process_inodes(e2fsck_t ctx, char *block_buf)
|
|||
#if 0
|
||||
printf("%u ", pctx.ino);
|
||||
#endif
|
||||
sprintf(buf, "reading indirect blocks of inode %lu", pctx.ino);
|
||||
sprintf(buf, _("reading indirect blocks of inode %lu"),
|
||||
pctx.ino);
|
||||
ehandler_operation(buf);
|
||||
check_blocks(ctx, &pctx, block_buf);
|
||||
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
|
||||
|
|
@ -676,7 +676,7 @@ static void alloc_bad_map(e2fsck_t ctx)
|
|||
|
||||
clear_problem_context(&pctx);
|
||||
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, "bad inode map",
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, _("bad inode map"),
|
||||
&ctx->inode_bad_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 3;
|
||||
|
|
@ -696,7 +696,7 @@ static void alloc_bb_map(e2fsck_t ctx)
|
|||
|
||||
clear_problem_context(&pctx);
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
|
||||
"inode in bad block map",
|
||||
_("inode in bad block map"),
|
||||
&ctx->inode_bb_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 4;
|
||||
|
|
@ -716,7 +716,7 @@ static void alloc_imagic_map(e2fsck_t ctx)
|
|||
|
||||
clear_problem_context(&pctx);
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
|
||||
"imagic inode map",
|
||||
_("imagic inode map"),
|
||||
&ctx->inode_imagic_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 5;
|
||||
|
|
@ -743,7 +743,7 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
|
|||
if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
|
||||
if (!ctx->block_dup_map) {
|
||||
pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
|
||||
"multiply claimed block map",
|
||||
_("multiply claimed block map"),
|
||||
&ctx->block_dup_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 3;
|
||||
|
|
@ -1270,15 +1270,15 @@ static void handle_fs_bad_blocks(e2fsck_t ctx)
|
|||
|
||||
for (i = 0; i < fs->group_desc_count; i++) {
|
||||
if (ctx->invalid_block_bitmap_flag[i]) {
|
||||
new_table_block(ctx, first_block, i, "block bitmap",
|
||||
new_table_block(ctx, first_block, i, _("block bitmap"),
|
||||
1, &fs->group_desc[i].bg_block_bitmap);
|
||||
}
|
||||
if (ctx->invalid_inode_bitmap_flag[i]) {
|
||||
new_table_block(ctx, first_block, i, "inode bitmap",
|
||||
new_table_block(ctx, first_block, i, _("inode bitmap"),
|
||||
1, &fs->group_desc[i].bg_inode_bitmap);
|
||||
}
|
||||
if (ctx->invalid_inode_table_flag[i]) {
|
||||
new_table_block(ctx, first_block, i, "inode table",
|
||||
new_table_block(ctx, first_block, i, _("inode table"),
|
||||
fs->inode_blocks_per_group,
|
||||
&fs->group_desc[i].bg_inode_table);
|
||||
ctx->flags |= E2F_FLAG_RESTART;
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf)
|
|||
clear_problem_context(&pctx);
|
||||
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
|
||||
"multiply claimed inode map", &inode_dup_map);
|
||||
_("multiply claimed inode map"), &inode_dup_map);
|
||||
if (pctx.errcode) {
|
||||
fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
|
|
@ -212,7 +212,7 @@ static void pass1b(e2fsck_t ctx, char *block_buf)
|
|||
}
|
||||
if (retval)
|
||||
com_err(ctx->program_name, retval,
|
||||
"while calling ext2fs_block_iterate in pass1b");
|
||||
_("while calling ext2fs_block_iterate in pass1b"));
|
||||
|
||||
next:
|
||||
pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode);
|
||||
|
|
@ -506,7 +506,7 @@ static int delete_file_block(ext2_filsys fs,
|
|||
*block_nr);
|
||||
} else
|
||||
com_err("delete_file_block", 0,
|
||||
"internal error; can't find dup_blk for %d\n",
|
||||
_("internal error; can't find dup_blk for %d\n"),
|
||||
*block_nr);
|
||||
} else {
|
||||
ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
|
||||
|
|
@ -531,7 +531,7 @@ static void delete_file(e2fsck_t ctx, struct dup_inode *dp, char* block_buf)
|
|||
delete_file_block, &pb);
|
||||
if (retval)
|
||||
com_err("delete_file", retval,
|
||||
"while calling ext2fs_block_iterate for inode %d",
|
||||
_("while calling ext2fs_block_iterate for inode %d"),
|
||||
dp->ino);
|
||||
ext2fs_unmark_inode_bitmap(ctx->inode_used_map, dp->ino);
|
||||
ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, dp->ino);
|
||||
|
|
@ -613,7 +613,7 @@ static int clone_file_block(ext2_filsys fs,
|
|||
return BLOCK_CHANGED;
|
||||
} else
|
||||
com_err("clone_file_block", 0,
|
||||
"internal error; can't find dup_blk for %d\n",
|
||||
_("internal error; can't find dup_blk for %d\n"),
|
||||
*block_nr);
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -641,13 +641,13 @@ static int clone_file(e2fsck_t ctx, struct dup_inode *dp, char* block_buf)
|
|||
ext2fs_free_mem((void **) &cs.buf);
|
||||
if (retval) {
|
||||
com_err("clone_file", retval,
|
||||
"while calling ext2fs_block_iterate for inode %d",
|
||||
_("while calling ext2fs_block_iterate for inode %d"),
|
||||
dp->ino);
|
||||
return retval;
|
||||
}
|
||||
if (cs.errcode) {
|
||||
com_err("clone_file", cs.errcode,
|
||||
"returned from clone_file_block");
|
||||
_("returned from clone_file_block"));
|
||||
return retval;
|
||||
}
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -83,14 +83,14 @@ void e2fsck_pass3(e2fsck_t ctx)
|
|||
* Allocate some bitmaps to do loop detection.
|
||||
*/
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
|
||||
"inode loop detection bitmap", &inode_loop_detect);
|
||||
_("inode loop detection bitmap"), &inode_loop_detect);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 1;
|
||||
fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
goto abort_exit;
|
||||
}
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs, "inode done bitmap",
|
||||
pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"),
|
||||
&inode_done_map);
|
||||
if (pctx.errcode) {
|
||||
pctx.num = 2;
|
||||
|
|
@ -101,7 +101,7 @@ void e2fsck_pass3(e2fsck_t ctx)
|
|||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME) {
|
||||
e2fsck_clear_progbar(ctx);
|
||||
print_resource_track("Peak memory", &ctx->global_rtrack);
|
||||
print_resource_track(_("Peak memory"), &ctx->global_rtrack);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -141,7 +141,7 @@ abort_exit:
|
|||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME2) {
|
||||
e2fsck_clear_progbar(ctx);
|
||||
print_resource_track("Pass 3", &rtrack);
|
||||
print_resource_track(_("Pass 3"), &rtrack);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -556,8 +556,8 @@ static errcode_t adjust_inode_count(e2fsck_t ctx, ino_t ino, int adj)
|
|||
inode.i_links_count--;
|
||||
} else {
|
||||
/* Should never happen */
|
||||
printf("Debug error in e2fsck adjust_inode_count, "
|
||||
"should never happen.\n");
|
||||
printf(_("Debug error in e2fsck adjust_inode_count, "
|
||||
"should never happen.\n"));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ void e2fsck_pass4(e2fsck_t ctx)
|
|||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME2) {
|
||||
e2fsck_clear_progbar(ctx);
|
||||
print_resource_track("Pass 4", &rtrack);
|
||||
print_resource_track(_("Pass 4"), &rtrack);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ void e2fsck_pass5(e2fsck_t ctx)
|
|||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME2) {
|
||||
e2fsck_clear_progbar(ctx);
|
||||
print_resource_track("Pass 5", &rtrack);
|
||||
print_resource_track(_("Pass 5"), &rtrack);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
416
e2fsck/problem.c
416
e2fsck/problem.c
File diff suppressed because it is too large
Load Diff
|
|
@ -77,7 +77,7 @@ static void print_resource_track(struct resource_track *track)
|
|||
gettimeofday(&time_end, 0);
|
||||
getrusage(RUSAGE_SELF, &r);
|
||||
|
||||
printf("Memory used: %d, elapsed time: %6.3f/%6.3f/%6.3f\n",
|
||||
printf(_("Memory used: %d, elapsed time: %6.3f/%6.3f/%6.3f\n"),
|
||||
(int) (((char *) sbrk(0)) - ((char *) track->brk_start)),
|
||||
timeval_subtract(&time_end, &track->time_start),
|
||||
timeval_subtract(&r.ru_utime, &track->user_start),
|
||||
|
|
@ -96,7 +96,7 @@ int main (int argc, char *argv[])
|
|||
ino_t ino;
|
||||
struct ext2_inode inode;
|
||||
|
||||
printf("size of inode=%d\n", sizeof(inode));
|
||||
printf(_("size of inode=%d\n"), sizeof(inode));
|
||||
|
||||
device_name = "/dev/hda3";
|
||||
|
||||
|
|
@ -105,19 +105,19 @@ int main (int argc, char *argv[])
|
|||
retval = ext2fs_open(device_name, 0,
|
||||
0, 0, unix_io_manager, &fs);
|
||||
if (retval) {
|
||||
com_err(argv[0], retval, "while trying to open %s",
|
||||
com_err(argv[0], retval, _("while trying to open %s"),
|
||||
device_name);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
retval = ext2fs_open_inode_scan(fs, 0, &scan);
|
||||
if (retval) {
|
||||
com_err(argv[0], retval, "while opening inode scan");
|
||||
com_err(argv[0], retval, _("while opening inode scan"));
|
||||
exit(1);
|
||||
}
|
||||
retval = ext2fs_get_next_inode(scan, &ino, &inode);
|
||||
if (retval) {
|
||||
com_err(argv[0], retval, "while starting inode scan");
|
||||
com_err(argv[0], retval, _("while starting inode scan"));
|
||||
exit(1);
|
||||
}
|
||||
while (ino) {
|
||||
|
|
@ -128,7 +128,7 @@ int main (int argc, char *argv[])
|
|||
retval = ext2fs_get_next_inode(scan, &ino, &inode);
|
||||
if (retval) {
|
||||
com_err(argv[0], retval,
|
||||
"while doing inode scan");
|
||||
_("while doing inode scan"));
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -93,13 +93,13 @@ static void swap_inode_blocks(e2fsck_t ctx, ino_t ino, char *block_buf,
|
|||
swap_block, &sb);
|
||||
if (retval) {
|
||||
com_err("swap_inode_blocks", retval,
|
||||
"while calling ext2fs_block_iterate");
|
||||
_("while calling ext2fs_block_iterate"));
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
if (sb.errcode) {
|
||||
com_err("swap_inode_blocks", sb.errcode,
|
||||
"while calling iterator function");
|
||||
_("while calling iterator function"));
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
|
|
@ -120,7 +120,7 @@ static void swap_inodes(e2fsck_t ctx)
|
|||
(void **) &buf);
|
||||
if (retval) {
|
||||
com_err("swap_inodes", retval,
|
||||
"while allocating inode buffer");
|
||||
_("while allocating inode buffer"));
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
|
|
@ -132,7 +132,7 @@ static void swap_inodes(e2fsck_t ctx)
|
|||
fs->inode_blocks_per_group, buf);
|
||||
if (retval) {
|
||||
com_err("swap_inodes", retval,
|
||||
"while reading inode table (group %d)",
|
||||
_("while reading inode table (group %d)"),
|
||||
group);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
|
|
@ -170,7 +170,7 @@ static void swap_inodes(e2fsck_t ctx)
|
|||
fs->inode_blocks_per_group, buf);
|
||||
if (retval) {
|
||||
com_err("swap_inodes", retval,
|
||||
"while writing inode table (group %d)",
|
||||
_("while writing inode table (group %d)"),
|
||||
group);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
|
|
@ -191,17 +191,17 @@ void swap_filesys(e2fsck_t ctx)
|
|||
#endif
|
||||
|
||||
if (!(ctx->options & E2F_OPT_PREEN))
|
||||
printf("Pass 0: Doing byte-swap of filesystem\n");
|
||||
printf(_("Pass 0: Doing byte-swap of filesystem\n"));
|
||||
|
||||
#ifdef MTRACE
|
||||
mtrace_print("Byte swap");
|
||||
#endif
|
||||
|
||||
if (fs->super->s_mnt_count) {
|
||||
fprintf(stderr, "%s: the filesystem must be freshly "
|
||||
fprintf(stderr, _("%s: the filesystem must be freshly "
|
||||
"checked using fsck\n"
|
||||
"and not mounted before trying to "
|
||||
"byte-swap it.\n", ctx->device_name);
|
||||
"byte-swap it.\n"), ctx->device_name);
|
||||
ctx->flags |= E2F_FLAG_ABORT;
|
||||
return;
|
||||
}
|
||||
|
|
@ -224,7 +224,7 @@ void swap_filesys(e2fsck_t ctx)
|
|||
|
||||
#ifdef RESOURCE_TRACK
|
||||
if (ctx->options & E2F_OPT_TIME2)
|
||||
print_resource_track("Byte swap", &rtrack);
|
||||
print_resource_track(_("Byte swap"), &rtrack);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
162
e2fsck/unix.c
162
e2fsck/unix.c
|
|
@ -58,12 +58,12 @@ static int read_only_root = 0;
|
|||
static void usage(e2fsck_t ctx)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"Usage: %s [-panyrcdfvstFSV] [-b superblock] [-B blocksize]\n"
|
||||
_("Usage: %s [-panyrcdfvstFSV] [-b superblock] [-B blocksize]\n"
|
||||
"\t\t[-I inode_buffer_blocks] [-P process_inode_size]\n"
|
||||
"\t\t[-l|-L bad_blocks_file] [-C fd] device\n",
|
||||
"\t\t[-l|-L bad_blocks_file] [-C fd] device\n"),
|
||||
ctx->program_name);
|
||||
|
||||
fprintf(stderr, "\nEmergency help:\n"
|
||||
fprintf(stderr, _("\nEmergency help:\n"
|
||||
" -p Automatic repair (no questions)\n"
|
||||
" -n Make no changes to the filesystem\n"
|
||||
" -y Assume \"yes\" to all questions\n"
|
||||
|
|
@ -74,7 +74,7 @@ static void usage(e2fsck_t ctx)
|
|||
" -B blocksize Force blocksize when looking for superblock\n"
|
||||
" -l bad_blocks_file Add to badblocks list\n"
|
||||
" -L bad_blocks_file Set badblocks list\n"
|
||||
);
|
||||
));
|
||||
|
||||
exit(FSCK_USAGE);
|
||||
}
|
||||
|
|
@ -101,12 +101,51 @@ static void show_stats(e2fsck_t ctx)
|
|||
frag_percent = (frag_percent + 5) / 10;
|
||||
|
||||
if (!verbose) {
|
||||
printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n",
|
||||
printf(_("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n"),
|
||||
ctx->device_name, inodes_used, inodes,
|
||||
frag_percent / 10, frag_percent % 10,
|
||||
blocks_used, blocks);
|
||||
return;
|
||||
}
|
||||
/*
|
||||
* This is a bit ugly. But I think there will nearly always be more
|
||||
* than one "thing" to report about, so I won't try writing complex
|
||||
* code to handle one/two/many forms of all words.
|
||||
* Some languages (Italian, at least) never uses the plural form
|
||||
* of foreign words, so in real life this could not be a problem.
|
||||
* md@linux.it - 2000-1-15
|
||||
*/
|
||||
#ifdef ENABLE_NLS
|
||||
printf (_("\n%8d inodes used (%d%%)\n"), inodes_used,
|
||||
(inodes_used != 1), 100 * inodes_used / inodes);
|
||||
printf (_("%8d non-contiguous inodes (%0d.%d%%)\n"),
|
||||
ctx->fs_fragmented, frag_percent / 10, frag_percent % 10);
|
||||
printf (_(" # of inodes with ind/dind/tind blocks: %d/%d/%d\n"),
|
||||
ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count);
|
||||
printf (_("%8d blocks used (%d%%)\n"
|
||||
"%8d bad blocks\n"), blocks_used,
|
||||
100 * blocks_used / blocks, ctx->fs_badblocks_count);
|
||||
printf (_("\n%8d regular files\n"
|
||||
"%8d directories\n"
|
||||
"%8d character device files\n"
|
||||
"%8d block device files\n"
|
||||
"%8d fifos\n"
|
||||
"%8d links\n"
|
||||
"%8d symbolic links (%d fast symbolic links)\n"
|
||||
"%8d sockets\n"
|
||||
"--------\n"
|
||||
"%8d files\n"),
|
||||
ctx->fs_regular_count,
|
||||
ctx->fs_directory_count,
|
||||
ctx->fs_chardev_count,
|
||||
ctx->fs_blockdev_count,
|
||||
ctx->fs_fifo_count,
|
||||
ctx->fs_links_count - dir_links,
|
||||
ctx->fs_symlinks_count,
|
||||
ctx->fs_fast_symlinks_count,
|
||||
ctx->fs_sockets_count,
|
||||
ctx->fs_total_count - dir_links);
|
||||
#else
|
||||
printf ("\n%8d inode%s used (%d%%)\n", inodes_used,
|
||||
(inodes_used != 1) ? "s" : "",
|
||||
100 * inodes_used / inodes);
|
||||
|
|
@ -148,6 +187,7 @@ static void show_stats(e2fsck_t ctx)
|
|||
ctx->fs_sockets_count, (ctx->fs_sockets_count != 1) ? "s" : "",
|
||||
ctx->fs_total_count - dir_links,
|
||||
((ctx->fs_total_count - dir_links) != 1) ? "s" : "");
|
||||
#endif
|
||||
}
|
||||
|
||||
static void check_mount(e2fsck_t ctx)
|
||||
|
|
@ -158,7 +198,7 @@ static void check_mount(e2fsck_t ctx)
|
|||
retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
|
||||
if (retval) {
|
||||
com_err("ext2fs_check_if_mount", retval,
|
||||
"while determining whether %s is mounted.",
|
||||
_("while determining whether %s is mounted."),
|
||||
ctx->filesystem_name);
|
||||
return;
|
||||
}
|
||||
|
|
@ -180,21 +220,21 @@ static void check_mount(e2fsck_t ctx)
|
|||
#endif
|
||||
|
||||
if (ctx->options & E2F_OPT_READONLY) {
|
||||
printf("Warning! %s is mounted.\n", ctx->filesystem_name);
|
||||
printf(_("Warning! %s is mounted.\n"), ctx->filesystem_name);
|
||||
return;
|
||||
}
|
||||
|
||||
printf("%s is mounted. ", ctx->filesystem_name);
|
||||
printf(_("%s is mounted. "), ctx->filesystem_name);
|
||||
if (!isatty(0) || !isatty(1)) {
|
||||
printf("Cannot continue, aborting.\n\n");
|
||||
printf(_("Cannot continue, aborting.\n\n"));
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
printf("\n\n\007\007\007\007WARNING!!! "
|
||||
printf(_("\n\n\007\007\007\007WARNING!!! "
|
||||
"Running e2fsck on a mounted filesystem may cause\n"
|
||||
"SEVERE filesystem damage.\007\007\007\n\n");
|
||||
cont = ask_yn("Do you really want to continue", -1);
|
||||
"SEVERE filesystem damage.\007\007\007\n\n"));
|
||||
cont = ask_yn(_("Do you really want to continue"), -1);
|
||||
if (!cont) {
|
||||
printf ("check aborted.\n");
|
||||
printf (_("check aborted.\n"));
|
||||
exit (0);
|
||||
}
|
||||
return;
|
||||
|
|
@ -214,21 +254,21 @@ static void check_if_skip(e2fsck_t ctx)
|
|||
return;
|
||||
|
||||
if (fs->super->s_state & EXT2_ERROR_FS)
|
||||
reason = "contains a file system with errors";
|
||||
reason = _("contains a file system with errors");
|
||||
else if ((fs->super->s_state & EXT2_VALID_FS) == 0)
|
||||
reason = "was not cleanly unmounted";
|
||||
reason = _("was not cleanly unmounted");
|
||||
else if (fs->super->s_mnt_count >=
|
||||
(unsigned) fs->super->s_max_mnt_count)
|
||||
reason = "has reached maximal mount count";
|
||||
reason = _("has reached maximal mount count");
|
||||
else if (fs->super->s_checkinterval &&
|
||||
time(0) >= (fs->super->s_lastcheck +
|
||||
fs->super->s_checkinterval))
|
||||
reason = "has gone too long without being checked";
|
||||
reason = _("has gone too long without being checked");
|
||||
if (reason) {
|
||||
printf("%s %s, check forced.\n", ctx->device_name, reason);
|
||||
printf(_("%s %s, check forced.\n"), ctx->device_name, reason);
|
||||
return;
|
||||
}
|
||||
printf("%s: clean, %d/%d files, %d/%d blocks\n", ctx->device_name,
|
||||
printf(_("%s: clean, %d/%d files, %d/%d blocks\n"), ctx->device_name,
|
||||
fs->super->s_inodes_count - fs->super->s_free_inodes_count,
|
||||
fs->super->s_inodes_count,
|
||||
fs->super->s_blocks_count - fs->super->s_free_blocks_count,
|
||||
|
|
@ -328,8 +368,8 @@ static void reserve_stdio_fds(NOARGS)
|
|||
if (fd > 2)
|
||||
break;
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "ERROR: Couldn't open "
|
||||
"/dev/null (%s)\n",
|
||||
fprintf(stderr, _("ERROR: Couldn't open "
|
||||
"/dev/null (%s)\n"),
|
||||
strerror(errno));
|
||||
break;
|
||||
}
|
||||
|
|
@ -432,8 +472,8 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
|
|||
else
|
||||
ctx->options |= E2F_OPT_TIME;
|
||||
#else
|
||||
fprintf(stderr, "The -t option is not "
|
||||
"supported on this version of e2fsck.\n");
|
||||
fprintf(stderr, _("The -t option is not "
|
||||
"supported on this version of e2fsck.\n"));
|
||||
#endif
|
||||
break;
|
||||
case 'c':
|
||||
|
|
@ -474,7 +514,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
|
|||
#ifdef BLKFLSBUF
|
||||
flush = 1;
|
||||
#else
|
||||
fatal_error(ctx, "-F not supported");
|
||||
fatal_error(ctx, _("-F not supported"));
|
||||
#endif
|
||||
break;
|
||||
case 'v':
|
||||
|
|
@ -512,24 +552,26 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
|
|||
int fd = open(ctx->filesystem_name, O_RDONLY, 0);
|
||||
|
||||
if (fd < 0) {
|
||||
com_err("open", errno, "while opening %s for flushing",
|
||||
com_err("open", errno,
|
||||
_("while opening %s for flushing"),
|
||||
ctx->filesystem_name);
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
if (ioctl(fd, BLKFLSBUF, 0) < 0) {
|
||||
com_err("BLKFLSBUF", errno, "while trying to flush %s",
|
||||
com_err("BLKFLSBUF", errno,
|
||||
_("while trying to flush %s"),
|
||||
ctx->filesystem_name);
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
close(fd);
|
||||
#else
|
||||
fatal_error(ctx, "BLKFLSBUF not supported");
|
||||
fatal_error(ctx, _("BLKFLSBUF not supported"));
|
||||
#endif /* BLKFLSBUF */
|
||||
}
|
||||
if (swapfs) {
|
||||
if (cflag || bad_blocks_file) {
|
||||
fprintf(stderr, "Incompatible options not "
|
||||
"allowed when byte-swapping.\n");
|
||||
fprintf(stderr, _("Incompatible options not "
|
||||
"allowed when byte-swapping.\n"));
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
}
|
||||
|
|
@ -573,19 +615,24 @@ int main (int argc, char *argv[])
|
|||
#endif
|
||||
#ifdef MCHECK
|
||||
mcheck(0);
|
||||
#endif
|
||||
#ifdef ENABLE_NLS
|
||||
setlocale(LC_MESSAGES, "");
|
||||
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
|
||||
textdomain(NLS_CAT_NAME);
|
||||
#endif
|
||||
my_ver = ext2fs_parse_version_string(my_ver_string);
|
||||
lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
|
||||
if (my_ver > lib_ver) {
|
||||
fprintf( stderr, "Error: ext2fs library version "
|
||||
"out of date!\n");
|
||||
fprintf( stderr, _("Error: ext2fs library version "
|
||||
"out of date!\n"));
|
||||
show_version_only++;
|
||||
}
|
||||
|
||||
retval = PRS(argc, argv, &ctx);
|
||||
if (retval) {
|
||||
com_err("e2fsck", retval,
|
||||
"while trying to initialize program");
|
||||
_("while trying to initialize program"));
|
||||
exit(1);
|
||||
}
|
||||
reserve_stdio_fds();
|
||||
|
|
@ -595,12 +642,12 @@ int main (int argc, char *argv[])
|
|||
#endif
|
||||
|
||||
if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
|
||||
fprintf (stderr, "e2fsck %s, %s for EXT2 FS %s, %s\n",
|
||||
fprintf (stderr, _("e2fsck %s, %s for EXT2 FS %s, %s\n"),
|
||||
my_ver_string, my_ver_date, EXT2FS_VERSION,
|
||||
EXT2FS_DATE);
|
||||
|
||||
if (show_version_only) {
|
||||
fprintf(stderr, "\tUsing %s, %s\n",
|
||||
fprintf(stderr, _("\tUsing %s, %s\n"),
|
||||
error_message(EXT2_ET_BASE), lib_ver_date);
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -612,7 +659,7 @@ int main (int argc, char *argv[])
|
|||
!(ctx->options & E2F_OPT_YES)) {
|
||||
if (!isatty (0) || !isatty (1))
|
||||
fatal_error(ctx,
|
||||
"need terminal for interactive repairs");
|
||||
_("need terminal for interactive repairs"));
|
||||
}
|
||||
ctx->superblock = ctx->use_superblock;
|
||||
restart:
|
||||
|
|
@ -642,9 +689,9 @@ restart:
|
|||
((retval == EXT2_ET_BAD_MAGIC) ||
|
||||
((retval == 0) && ext2fs_check_desc(fs)))) {
|
||||
if (!fs || (fs->group_desc_count > 1)) {
|
||||
printf("%s trying backup blocks...\n",
|
||||
retval ? "Couldn't find ext2 superblock," :
|
||||
"Group descriptors look bad...");
|
||||
printf(_("%s trying backup blocks...\n"),
|
||||
retval ? _("Couldn't find ext2 superblock,") :
|
||||
_("Group descriptors look bad..."));
|
||||
ctx->superblock = get_backup_sb(fs);
|
||||
if (fs)
|
||||
ext2fs_close(fs);
|
||||
|
|
@ -652,28 +699,28 @@ restart:
|
|||
}
|
||||
}
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval, "while trying to open %s",
|
||||
com_err(ctx->program_name, retval, _("while trying to open %s"),
|
||||
ctx->filesystem_name);
|
||||
if (retval == EXT2_ET_REV_TOO_HIGH) {
|
||||
printf("The filesystem revision is apparently "
|
||||
printf(_("The filesystem revision is apparently "
|
||||
"too high for this version of e2fsck.\n"
|
||||
"(Or the filesystem superblock "
|
||||
"is corrupt)\n\n");
|
||||
"is corrupt)\n\n"));
|
||||
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
|
||||
} else if (retval == EXT2_ET_SHORT_READ)
|
||||
printf("Could this be a zero-length partition?\n");
|
||||
printf(_("Could this be a zero-length partition?\n"));
|
||||
else if ((retval == EPERM) || (retval == EACCES))
|
||||
printf("You must have %s access to the "
|
||||
"filesystem or be root\n",
|
||||
printf(_("You must have %s access to the "
|
||||
"filesystem or be root\n"),
|
||||
(ctx->options & E2F_OPT_READONLY) ?
|
||||
"r/o" : "r/w");
|
||||
else if (retval == ENXIO)
|
||||
printf("Possibly non-existent or swap device?\n");
|
||||
printf(_("Possibly non-existent or swap device?\n"));
|
||||
#ifdef EROFS
|
||||
else if (retval == EROFS)
|
||||
printf("Disk write-protected; use the -n option "
|
||||
printf(_("Disk write-protected; use the -n option "
|
||||
"to do a read-only\n"
|
||||
"check of the device.\n");
|
||||
"check of the device.\n"));
|
||||
#endif
|
||||
else
|
||||
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
|
||||
|
|
@ -684,10 +731,10 @@ restart:
|
|||
#ifdef EXT2_CURRENT_REV
|
||||
if (fs->super->s_rev_level > E2FSCK_CURRENT_REV) {
|
||||
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
|
||||
"while trying to open %s",
|
||||
_("while trying to open %s"),
|
||||
ctx->filesystem_name);
|
||||
get_newer:
|
||||
fatal_error(ctx, "Get a newer version of e2fsck!");
|
||||
fatal_error(ctx, _("Get a newer version of e2fsck!"));
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
|
|
@ -752,8 +799,8 @@ restart:
|
|||
if (normalize_swapfs) {
|
||||
if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ==
|
||||
ext2fs_native_flag()) {
|
||||
fprintf(stderr, "%s: Filesystem byte order "
|
||||
"already normalized.\n", ctx->device_name);
|
||||
fprintf(stderr, _("%s: Filesystem byte order "
|
||||
"already normalized.\n"), ctx->device_name);
|
||||
exit(FSCK_ERROR);
|
||||
}
|
||||
}
|
||||
|
|
@ -771,19 +818,20 @@ restart:
|
|||
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval,
|
||||
"while reading bad blocks inode");
|
||||
_("while reading bad blocks inode"));
|
||||
preenhalt(ctx);
|
||||
printf("This doesn't bode well, but we'll try to go on...\n");
|
||||
printf(_("This doesn't bode well,"
|
||||
" but we'll try to go on...\n"));
|
||||
}
|
||||
|
||||
run_result = e2fsck_run(ctx);
|
||||
e2fsck_clear_progbar(ctx);
|
||||
if (run_result == E2F_FLAG_RESTART) {
|
||||
printf("Restarting e2fsck from the beginning...\n");
|
||||
printf(_("Restarting e2fsck from the beginning...\n"));
|
||||
retval = e2fsck_reset_context(ctx);
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval,
|
||||
"while resetting context");
|
||||
_("while resetting context"));
|
||||
exit(1);
|
||||
}
|
||||
ext2fs_close(fs);
|
||||
|
|
@ -800,10 +848,10 @@ restart:
|
|||
if (ext2fs_test_changed(fs)) {
|
||||
exit_value = FSCK_NONDESTRUCT;
|
||||
if (!(ctx->options & E2F_OPT_PREEN))
|
||||
printf("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n",
|
||||
printf(_("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"),
|
||||
ctx->device_name);
|
||||
if (root_filesystem && !read_only_root) {
|
||||
printf("%s: ***** REBOOT LINUX *****\n",
|
||||
printf(_("%s: ***** REBOOT LINUX *****\n"),
|
||||
ctx->device_name);
|
||||
exit_value = FSCK_REBOOT;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,6 +67,8 @@ int ask_yn(const char * string, int def)
|
|||
{
|
||||
int c;
|
||||
const char *defstr;
|
||||
char *short_yes = _("yY");
|
||||
char *short_no = _("nN");
|
||||
|
||||
#ifdef HAVE_TERMIOS_H
|
||||
struct termios termios, tmp;
|
||||
|
|
@ -80,22 +82,21 @@ int ask_yn(const char * string, int def)
|
|||
#endif
|
||||
|
||||
if (def == 1)
|
||||
defstr = "<y>";
|
||||
defstr = _("<y>");
|
||||
else if (def == 0)
|
||||
defstr = "<n>";
|
||||
defstr = _("<n>");
|
||||
else
|
||||
defstr = " (y/n)";
|
||||
defstr = _(" (y/n)");
|
||||
printf("%s%s? ", string, defstr);
|
||||
while (1) {
|
||||
fflush (stdout);
|
||||
if ((c = read_a_char()) == EOF)
|
||||
break;
|
||||
c = toupper(c);
|
||||
if (c == 'Y') {
|
||||
if (strchr(short_yes, (char) c)) {
|
||||
def = 1;
|
||||
break;
|
||||
}
|
||||
else if (c == 'N') {
|
||||
else if (strchr(short_no, (char) c)) {
|
||||
def = 0;
|
||||
break;
|
||||
}
|
||||
|
|
@ -115,15 +116,15 @@ int ask_yn(const char * string, int def)
|
|||
int ask (e2fsck_t ctx, const char * string, int def)
|
||||
{
|
||||
if (ctx->options & E2F_OPT_NO) {
|
||||
printf ("%s? no\n\n", string);
|
||||
printf (_("%s? no\n\n"), string);
|
||||
return 0;
|
||||
}
|
||||
if (ctx->options & E2F_OPT_YES) {
|
||||
printf ("%s? yes\n\n", string);
|
||||
printf (_("%s? yes\n\n"), string);
|
||||
return 1;
|
||||
}
|
||||
if (ctx->options & E2F_OPT_PREEN) {
|
||||
printf ("%s? %s\n\n", string, def ? "yes" : "no");
|
||||
printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
|
||||
return def;
|
||||
}
|
||||
return ask_yn(string, def);
|
||||
|
|
@ -136,17 +137,17 @@ void e2fsck_read_bitmaps(e2fsck_t ctx)
|
|||
|
||||
if (ctx->invalid_bitmaps) {
|
||||
com_err(ctx->program_name, 0,
|
||||
"e2fsck_read_bitmaps: illegal bitmap block(s) for %s",
|
||||
_("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
|
||||
ctx->device_name);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
|
||||
ehandler_operation("reading inode and block bitmaps");
|
||||
ehandler_operation(_("reading inode and block bitmaps"));
|
||||
retval = ext2fs_read_bitmaps(fs);
|
||||
ehandler_operation(0);
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval,
|
||||
"while retrying to read bitmaps for %s",
|
||||
_("while retrying to read bitmaps for %s"),
|
||||
ctx->device_name);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
|
|
@ -158,24 +159,24 @@ void e2fsck_write_bitmaps(e2fsck_t ctx)
|
|||
errcode_t retval;
|
||||
|
||||
if (ext2fs_test_bb_dirty(fs)) {
|
||||
ehandler_operation("writing block bitmaps");
|
||||
ehandler_operation(_("writing block bitmaps"));
|
||||
retval = ext2fs_write_block_bitmap(fs);
|
||||
ehandler_operation(0);
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval,
|
||||
"while retrying to write block bitmaps for %s",
|
||||
_("while retrying to write block bitmaps for %s"),
|
||||
ctx->device_name);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (ext2fs_test_ib_dirty(fs)) {
|
||||
ehandler_operation("writing inode bitmaps");
|
||||
ehandler_operation(_("writing inode bitmaps"));
|
||||
retval = ext2fs_write_inode_bitmap(fs);
|
||||
ehandler_operation(0);
|
||||
if (retval) {
|
||||
com_err(ctx->program_name, retval,
|
||||
"while retrying to write inode bitmaps for %s",
|
||||
_("while retrying to write inode bitmaps for %s"),
|
||||
ctx->device_name);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
|
|
@ -188,8 +189,8 @@ void preenhalt(e2fsck_t ctx)
|
|||
|
||||
if (!(ctx->options & E2F_OPT_PREEN))
|
||||
return;
|
||||
fprintf(stderr, "\n\n%s: UNEXPECTED INCONSISTENCY; "
|
||||
"RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n",
|
||||
fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
|
||||
"RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
|
||||
ctx->device_name);
|
||||
if (fs != NULL) {
|
||||
fs->super->s_state |= EXT2_ERROR_FS;
|
||||
|
|
@ -251,20 +252,21 @@ void print_resource_track(const char *desc, struct resource_track *track)
|
|||
|
||||
#ifdef HAVE_MALLINFO
|
||||
malloc_info = mallinfo();
|
||||
printf("Memory used: %d/%d, ", malloc_info.arena, malloc_info.hblkhd);
|
||||
printf(_("Memory used: %d/%d, "),
|
||||
malloc_info.arena, malloc_info.hblkhd);
|
||||
#else
|
||||
printf("Memory used: %d, ",
|
||||
printf(_("Memory used: %d, "),
|
||||
(int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
|
||||
#endif
|
||||
#ifdef HAVE_GETRUSAGE
|
||||
getrusage(RUSAGE_SELF, &r);
|
||||
|
||||
printf("elapsed time: %6.3f/%6.3f/%6.3f\n",
|
||||
printf(_("elapsed time: %6.3f/%6.3f/%6.3f\n"),
|
||||
timeval_subtract(&time_end, &track->time_start),
|
||||
timeval_subtract(&r.ru_utime, &track->user_start),
|
||||
timeval_subtract(&r.ru_stime, &track->system_start));
|
||||
#else
|
||||
printf("elapsed time: %6.3f\n",
|
||||
printf(_("elapsed time: %6.3f\n"),
|
||||
timeval_subtract(&time_end, &track->time_start));
|
||||
#endif
|
||||
}
|
||||
|
|
@ -278,7 +280,7 @@ void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
|
|||
retval = ext2fs_read_inode(ctx->fs, ino, inode);
|
||||
if (retval) {
|
||||
com_err("ext2fs_read_inode", retval,
|
||||
"while reading inode %ld in %s", ino, proc);
|
||||
_("while reading inode %ld in %s"), ino, proc);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
}
|
||||
|
|
@ -291,7 +293,7 @@ extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
|
|||
retval = ext2fs_write_inode(ctx->fs, ino, inode);
|
||||
if (retval) {
|
||||
com_err("ext2fs_write_inode", retval,
|
||||
"while writing inode %ld in %s", ino, proc);
|
||||
_("while writing inode %ld in %s"), ino, proc);
|
||||
fatal_error(ctx, 0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue