From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 24837 invoked by alias); 24 Mar 2009 21:00:23 -0000 Received: (qmail 24831 invoked by alias); 24 Mar 2009 21:00:22 -0000 X-SWARE-Spam-Status: No, hits=4.7 required=5.0 tests=AWL,BAYES_50,J_CHICKENPOX_21,J_CHICKENPOX_22,J_CHICKENPOX_23,J_CHICKENPOX_24,J_CHICKENPOX_25,J_CHICKENPOX_26,J_CHICKENPOX_31,J_CHICKENPOX_43,J_CHICKENPOX_45,J_CHICKENPOX_46,J_CHICKENPOX_48,J_CHICKENPOX_54,J_CHICKENPOX_62,J_CHICKENPOX_63,J_CHICKENPOX_65,J_CHICKENPOX_66,J_CHICKENPOX_93,SPF_HELO_PASS X-Spam-Status: No, hits=4.7 required=5.0 tests=AWL,BAYES_50,J_CHICKENPOX_21,J_CHICKENPOX_22,J_CHICKENPOX_23,J_CHICKENPOX_24,J_CHICKENPOX_25,J_CHICKENPOX_26,J_CHICKENPOX_31,J_CHICKENPOX_43,J_CHICKENPOX_45,J_CHICKENPOX_46,J_CHICKENPOX_48,J_CHICKENPOX_54,J_CHICKENPOX_62,J_CHICKENPOX_63,J_CHICKENPOX_65,J_CHICKENPOX_66,J_CHICKENPOX_93,SPF_HELO_PASS X-Spam-Check-By: sourceware.org X-Spam-Checker-Version: SpamAssassin 3.2.5 (2008-06-10) on bastion.fedora.phx.redhat.com Subject: gfs2-utils: master - fsck.gfs2: Add gettext support To: cluster-cvs-relay@redhat.com X-Project: Cluster Project X-Git-Module: gfs2-utils.git X-Git-Refname: refs/heads/master X-Git-Reftype: branch X-Git-Oldrev: 90a7e2c443fdaa3c6bec6ff588de3f994cb78663 X-Git-Newrev: abf33c329569dffa30eb74dd7214a1c8a4ac16fe From: Steven Whitehouse Message-Id: <20090324205932.802A51201A0@lists.fedorahosted.org> Date: Tue, 24 Mar 2009 21:00:00 -0000 X-Scanned-By: MIMEDefang 2.58 on 172.16.52.254 Mailing-List: contact cluster-cvs-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Post: List-Help: , Sender: cluster-cvs-owner@sourceware.org X-SW-Source: 2009-q1/txt/msg00898.txt.bz2 Gitweb: http://git.fedorahosted.org/git/gfs2-utils.git?p=gfs2-utils.git;a=commitdiff;h=abf33c329569dffa30eb74dd7214a1c8a4ac16fe Commit: abf33c329569dffa30eb74dd7214a1c8a4ac16fe Parent: 90a7e2c443fdaa3c6bec6ff588de3f994cb78663 Author: Steven Whitehouse AuthorDate: Tue Mar 24 20:50:24 2009 +0000 Committer: Steven Whitehouse CommitterDate: Tue Mar 24 20:50:24 2009 +0000 fsck.gfs2: Add gettext support The messages need to be cleaned up a bit, but this is the guts of it anyway. Signed-off-by: Steven Whitehouse --- gfs2/fsck/eattr.c | 8 ++- gfs2/fsck/fs_recovery.c | 28 ++++---- gfs2/fsck/initialize.c | 64 +++++++++-------- gfs2/fsck/link.c | 28 ++++---- gfs2/fsck/lost_n_found.c | 22 +++--- gfs2/fsck/main.c | 99 ++++++++++++++------------ gfs2/fsck/metawalk.c | 98 +++++++++++++------------- gfs2/fsck/pass1.c | 156 +++++++++++++++++++++-------------------- gfs2/fsck/pass1b.c | 91 ++++++++++++------------ gfs2/fsck/pass1c.c | 44 ++++++------ gfs2/fsck/pass2.c | 176 +++++++++++++++++++++++----------------------- gfs2/fsck/pass3.c | 100 +++++++++++++------------- gfs2/fsck/pass4.c | 60 ++++++++-------- gfs2/fsck/pass5.c | 44 ++++++------ gfs2/fsck/rgrepair.c | 76 ++++++++++---------- gfs2/fsck/util.c | 4 +- 16 files changed, 566 insertions(+), 532 deletions(-) diff --git a/gfs2/fsck/eattr.c b/gfs2/fsck/eattr.c index 0fe2421..5898759 100644 --- a/gfs2/fsck/eattr.c +++ b/gfs2/fsck/eattr.c @@ -1,5 +1,7 @@ #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -14,7 +16,7 @@ static int clear_blk_nodup(struct gfs2_sbd *sbp, uint64_t block) } if(q.dup_block) { - log_debug("Not clearing block with marked as a duplicate\n"); + log_debug( _("Not clearing block with marked as a duplicate\n")); return 1; } @@ -74,8 +76,8 @@ int clear_eattr_entry (struct gfs2_inode *ip, if(max_ptrs > ea_hdr->ea_num_ptrs) { return 1; } else { - log_debug(" Pointers Required: %d\n" - " Pointers Reported: %d\n", + log_debug( _(" Pointers Required: %d\n" + " Pointers Reported: %d\n"), max_ptrs, ea_hdr->ea_num_ptrs); } diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c index fb830fe..fa5b547 100644 --- a/gfs2/fsck/fs_recovery.c +++ b/gfs2/fsck/fs_recovery.c @@ -4,6 +4,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "fsck.h" #include "fs_recovery.h" @@ -334,7 +336,7 @@ int gfs2_recover_journal(struct gfs2_inode *ip, int j) unsigned int pass; int error; - log_info("jid=%u: Looking at journal...\n", j); + log_info( _("jid=%u: Looking at journal...\n"), j); osi_list_init(&sd_revoke_list); error = gfs2_find_jhead(ip, &head); @@ -342,12 +344,12 @@ int gfs2_recover_journal(struct gfs2_inode *ip, int j) goto out; if (head.lh_flags & GFS2_LOG_HEAD_UNMOUNT) { - log_info("jid=%u: Journal is clean.\n", j); + log_info( _("jid=%u: Journal is clean.\n"), j); return 0; } - if (query(&opts, "\nJournal #%d (\"journal%d\") is dirty. Okay to replay it? (y/n)", + if (query(&opts, _("\nJournal #%d (\"journal%d\") is dirty. Okay to replay it? (y/n)"), j+1, j)) { - log_info("jid=%u: Replaying journal...\n", j); + log_info( _("jid=%u: Replaying journal...\n"), j); sd_found_jblocks = sd_replayed_jblocks = 0; sd_found_metablocks = sd_replayed_metablocks = 0; @@ -359,28 +361,28 @@ int gfs2_recover_journal(struct gfs2_inode *ip, int j) if (error) goto out; } - log_info("jid=%u: Found %u revoke tags\n", j, + log_info( _("jid=%u: Found %u revoke tags\n"), j, sd_found_revokes); gfs2_revoke_clean(sdp); error = clean_journal(ip, &head); if (error) goto out; - log_err("jid=%u: Replayed %u of %u journaled data blocks\n", + log_err( _("jid=%u: Replayed %u of %u journaled data blocks\n"), j, sd_replayed_jblocks, sd_found_jblocks); - log_err("jid=%u: Replayed %u of %u metadata blocks\n", + log_err( _("jid=%u: Replayed %u of %u metadata blocks\n"), j, sd_replayed_metablocks, sd_found_metablocks); } else { - if (query(&opts, "Do you want to clear the dirty journal instead? (y/n)")) { + if (query(&opts, _("Do you want to clear the dirty journal instead? (y/n)"))) { write_journal(sdp, sdp->md.journal[j], j, sdp->md.journal[j]->i_di.di_size / sdp->sd_sb.sb_bsize); } else - log_err("jid=%u: Dirty journal not replayed or cleared.\n", j); + log_err( _("jid=%u: Dirty journal not replayed or cleared.\n"), j); } out: - log_info("jid=%u: %s\n", j, (error) ? "Failed" : "Done"); + log_info( _("jid=%u: %s\n"), j, (error) ? "Failed" : "Done"); return error; } @@ -397,7 +399,7 @@ out: int replay_journals(struct gfs2_sbd *sdp){ int i; - log_notice("Recovering journals (this may take a while)"); + log_notice( _("Recovering journals (this may take a while)")); /* Get master dinode */ sdp->master_dir = gfs2_load_inode(sdp, @@ -406,7 +408,7 @@ int replay_journals(struct gfs2_sbd *sdp){ /* read in the journal index data */ if (ji_update(sdp)){ - log_err("Unable to read in jindex inode.\n"); + log_err( _("Unable to read in jindex inode.\n")); return -1; } @@ -417,7 +419,7 @@ int replay_journals(struct gfs2_sbd *sdp){ inode_put(sdp->md.journal[i], (opts.no ? not_updated : updated)); } - log_notice("\nJournal recovery complete.\n"); + log_notice( _("\nJournal recovery complete.\n")); inode_put(sdp->master_dir, not_updated); inode_put(sdp->md.jiinode, not_updated); /* Sync the buffers to disk so we get a fresh start. */ diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c index 198009f..e06b4b6 100644 --- a/gfs2/fsck/initialize.c +++ b/gfs2/fsck/initialize.c @@ -7,6 +7,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -79,12 +81,12 @@ static void empty_super_block(struct gfs2_sbd *sdp) { uint32_t i; - log_info("Freeing buffers.\n"); + log_info( _("Freeing buffers.\n")); while(!osi_list_empty(&sdp->rglist)){ struct rgrp_list *rgd; rgd = osi_list_entry(sdp->rglist.next, struct rgrp_list, list); - log_debug("Deleting rgd for 0x%llx: rgd=0x%p bits=0x%p\n", + log_debug( _("Deleting rgd for 0x%llx: rgd=0x%p bits=0x%p\n"), (unsigned long long)rgd->ri.ri_addr, rgd, rgd->bits); osi_list_del(&rgd->list); if(rgd->bits) @@ -131,7 +133,7 @@ static int set_block_ranges(struct gfs2_sbd *sdp) uint64_t rmin = 0; int error; - log_info("Setting block ranges...\n"); + log_info( _("Setting block ranges...\n")); for (tmp = sdp->rglist.next; tmp != &sdp->rglist; tmp = tmp->next) { @@ -145,8 +147,8 @@ static int set_block_ranges(struct gfs2_sbd *sdp) last_fs_block = rmax; if (last_fs_block > 0xffffffff && sizeof(unsigned long) <= 4) { - log_crit("This file system is too big for this computer to handle.\n"); - log_crit("Last fs block = 0x%llx, but sizeof(unsigned long) is %lu bytes.\n", + log_crit( _("This file system is too big for this computer to handle.\n")); + log_crit( _("Last fs block = 0x%llx, but sizeof(unsigned long) is %lu bytes.\n"), (unsigned long long)last_fs_block, sizeof(unsigned long)); goto fail; @@ -156,16 +158,16 @@ static int set_block_ranges(struct gfs2_sbd *sdp) first_data_block = rmin; if(fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){ - log_crit("Can't seek to last block in file system: %" - PRIu64" (0x%" PRIx64 ")\n", last_fs_block, last_fs_block); + log_crit( _("Can't seek to last block in file system: %" + PRIu64" (0x%" PRIx64 ")\n"), last_fs_block, last_fs_block); goto fail; } memset(buf, 0, sdp->sd_sb.sb_bsize); error = read(sdp->device_fd, buf, sdp->sd_sb.sb_bsize); if (error != sdp->sd_sb.sb_bsize){ - log_crit("Can't read last block in file system (error %u), " - "last_fs_block: %"PRIu64" (0x%" PRIx64 ")\n", error, + log_crit( _("Can't read last block in file system (error %u), " + "last_fs_block: %"PRIu64" (0x%" PRIx64 ")\n"), error, last_fs_block, last_fs_block); goto fail; } @@ -194,7 +196,7 @@ static int init_system_inodes(struct gfs2_sbd *sdp) ****************** Initialize important inodes ****************** *******************************************************************/ - log_info("Initializing special inodes...\n"); + log_info( _("Initializing special inodes...\n")); /* Get master dinode */ sdp->master_dir = gfs2_load_inode(sdp, @@ -234,42 +236,42 @@ static int init_system_inodes(struct gfs2_sbd *sdp) /* read in the ji data */ if (ji_update(sdp)){ - log_err("Unable to read in ji inode.\n"); + log_err( _("Unable to read in ji inode.\n")); return -1; } - log_warn("Validating Resource Group index.\n"); + log_warn( _("Validating Resource Group index.\n")); for (trust_lvl = blind_faith; trust_lvl <= distrust; trust_lvl++) { - log_warn("Level %d RG check.\n", trust_lvl + 1); + log_warn( _("Level %d RG check.\n"), trust_lvl + 1); if ((rg_repair(sdp, trust_lvl, &rgcount) == 0) && (ri_update(sdp, 0, &rgcount) == 0)) { - log_err("(level %d passed)\n", trust_lvl + 1); + log_err( _("(level %d passed)\n"), trust_lvl + 1); break; } else - log_err("(level %d failed)\n", trust_lvl + 1); + log_err( _("(level %d failed)\n"), trust_lvl + 1); } if (trust_lvl > distrust) { - log_err("RG recovery impossible; I can't fix this file system.\n"); + log_err( _("RG recovery impossible; I can't fix this file system.\n")); return -1; } - log_info("%u resource groups found.\n", rgcount); + log_info( _("%u resource groups found.\n"), rgcount); /******************************************************************* ******* Now, set boundary fields in the super block ************* *******************************************************************/ if(set_block_ranges(sdp)){ - log_err("Unable to determine the boundaries of the" - " file system.\n"); + log_err( _("Unable to determine the boundaries of the" + " file system.\n")); goto fail; } bl = gfs2_block_list_create(sdp, last_fs_block+1, &addl_mem_needed); if (!bl) { - log_crit("This system doesn't have enough memory + swap space to fsck this file system.\n"); - log_crit("Additional memory needed is approximately: %lluMB\n", + log_crit( _("This system doesn't have enough memory + swap space to fsck this file system.\n")); + log_crit( _("Additional memory needed is approximately: %lluMB\n"), (unsigned long long)(addl_mem_needed / 1048576ULL)); - log_crit("Please increase your swap space by that amount and run gfs2_fsck again.\n"); + log_crit( _("Please increase your swap space by that amount and run gfs2_fsck again.\n")); goto fail; } return 0; @@ -294,7 +296,7 @@ static int fill_super_block(struct gfs2_sbd *sdp) /******************************************************************** ***************** First, initialize all lists ********************** ********************************************************************/ - log_info("Initializing lists...\n"); + log_info( _("Initializing lists...\n")); osi_list_init(&sdp->rglist); init_buf_list(sdp, &sdp->buf_list, 128 << 20); init_buf_list(sdp, &sdp->nvbuf_list, 0xffffffff); @@ -310,8 +312,8 @@ static int fill_super_block(struct gfs2_sbd *sdp) sdp->bsize = sdp->sd_sb.sb_bsize; if(sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize){ - log_crit("GFS superblock is larger than the blocksize!\n"); - log_debug("sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize\n"); + log_crit( _("GFS superblock is larger than the blocksize!\n")); + log_debug( _("sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize\n")); return -1; } @@ -331,13 +333,13 @@ int initialize(struct gfs2_sbd *sbp) { if(opts.no) { if ((sbp->device_fd = open(opts.device, O_RDONLY)) < 0) { - log_crit("Unable to open device: %s\n", opts.device); + log_crit( _("Unable to open device: %s\n"), opts.device); return FSCK_USAGE; } } else { /* read in sb from disk */ if ((sbp->device_fd = open(opts.device, O_RDWR)) < 0){ - log_crit("Unable to open device: %s\n", opts.device); + log_crit( _("Unable to open device: %s\n"), opts.device); return FSCK_USAGE; } } @@ -349,7 +351,7 @@ int initialize(struct gfs2_sbd *sbp) /* Change lock protocol to be fsck_* instead of lock_* */ if(!opts.no) { if(block_mounters(sbp, 1)) { - log_err("Unable to block other mounters\n"); + log_err( _("Unable to block other mounters\n")); return FSCK_USAGE; } } @@ -373,10 +375,10 @@ static void destroy_sbp(struct gfs2_sbd *sbp) { if(!opts.no) { if(block_mounters(sbp, 0)) { - log_warn("Unable to unblock other mounters - manual intervention required\n"); - log_warn("Use 'gfs2_tool sb proto' to fix\n"); + log_warn( _("Unable to unblock other mounters - manual intervention required\n")); + log_warn( _("Use 'gfs2_tool sb proto' to fix\n")); } - log_info("Syncing the device.\n"); + log_info( _("Syncing the device.\n")); fsync(sbp->device_fd); } empty_super_block(sbp); diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c index 1e5fe7f..9666f63 100644 --- a/gfs2/fsck/link.c +++ b/gfs2/fsck/link.c @@ -3,6 +3,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -12,15 +14,15 @@ int set_link_count(struct gfs2_sbd *sbp, uint64_t inode_no, uint32_t count) { struct inode_info *ii = NULL; - log_debug("Setting link count to %u for %" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Setting link count to %u for %" PRIu64 " (0x%" PRIx64 ")\n"), count, inode_no, inode_no); /* If the list has entries, look for one that matches * inode_no */ ii = inode_hash_search(inode_hash, inode_no); if(ii) { if(ii->link_count) { - log_err("Link count already set for inode #%" PRIu64 " (0x%" - PRIx64 ")!\n", inode_no, inode_no); + log_err( _("Link count already set for inode #%" PRIu64 " (0x%" + PRIx64 ")!\n"), inode_no, inode_no); stack; return -1; } @@ -31,7 +33,7 @@ int set_link_count(struct gfs2_sbd *sbp, uint64_t inode_no, uint32_t count) /* If not match was found, add a new entry and set it's * link count to count*/ if(!(ii = (struct inode_info *) malloc(sizeof(*ii)))) { - log_err("Unable to allocate inode_info structure\n"); + log_err( _("Unable to allocate inode_info structure\n")); stack; return -1; } @@ -52,21 +54,21 @@ int increment_link(struct gfs2_sbd *sbp, uint64_t inode_no) * inode_no */ if(ii) { ii->counted_links++; - log_debug("Incremented counted links to %u for %"PRIu64" (0x%" - PRIx64 ")\n", ii->counted_links, inode_no, inode_no); + log_debug( _("Incremented counted links to %u for %"PRIu64" (0x%" + PRIx64 ")\n"), ii->counted_links, inode_no, inode_no); return 0; } - log_debug("No match found when incrementing link for %" PRIu64 - " (0x%" PRIx64 ")!\n", inode_no, inode_no); + log_debug( _("No match found when incrementing link for %" PRIu64 + " (0x%" PRIx64 ")!\n"), inode_no, inode_no); /* If no match was found, add a new entry and set its * counted links to 1 */ if(!(ii = (struct inode_info *) malloc(sizeof(*ii)))) { - log_err("Unable to allocate inode_info structure\n"); + log_err( _("Unable to allocate inode_info structure\n")); stack; return -1; } if(!memset(ii, 0, sizeof(*ii))) { - log_err("Unable to zero inode_info structure\n"); + log_err( _("Unable to zero inode_info structure\n")); stack; return -1; } @@ -84,13 +86,13 @@ int decrement_link(struct gfs2_sbd *sbp, uint64_t inode_no) ii = inode_hash_search(inode_hash, inode_no); /* If the list has entries, look for one that matches * inode_no */ - log_err("Decrementing %"PRIu64" (0x%" PRIx64 ")\n", inode_no, inode_no); + log_err( _("Decrementing %"PRIu64" (0x%" PRIx64 ")\n"), inode_no, inode_no); if(ii) { ii->counted_links--; return 0; } - log_debug("No match found when decrementing link for %" PRIu64 - " (0x%" PRIx64 ")!\n", inode_no, inode_no); + log_debug( _("No match found when decrementing link for %" PRIu64 + " (0x%" PRIx64 ")!\n"), inode_no, inode_no); return -1; } diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c index 4310770..4170380 100644 --- a/gfs2/fsck/lost_n_found.c +++ b/gfs2/fsck/lost_n_found.c @@ -5,6 +5,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "fsck.h" #include "libgfs2.h" @@ -29,7 +31,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){ if(!lf_dip) { struct gfs2_block_query q = {0}; - log_info("Locating/Creating lost and found directory\n"); + log_info( _("Locating/Creating lost and found directory\n")); lf_dip = createi(ip->i_sbd->md.rooti, "lost+found", S_IFDIR | 0700, 0); if(gfs2_block_check(ip->i_sbd, bl, lf_dip->i_di.di_num.no_addr, &q)) { @@ -54,30 +56,30 @@ int add_inode_to_lf(struct gfs2_inode *ip){ } } if(ip->i_di.di_num.no_addr == lf_dip->i_di.di_num.no_addr) { - log_err("Trying to add lost+found to itself...skipping"); + log_err( _("Trying to add lost+found to itself...skipping")); return 0; } switch(ip->i_di.di_mode & S_IFMT){ case S_IFDIR: - log_info("Adding .. entry pointing to lost+found for %llu\n", + log_info( _("Adding .. entry pointing to lost+found for %llu\n"), (unsigned long long)ip->i_di.di_num.no_addr); sprintf(tmp_name, ".."); filename_len = strlen(tmp_name); /* no trailing NULL */ if(!(filename = malloc((sizeof(char) * filename_len) + 1))) { - log_err("Unable to allocate name\n"); + log_err( _("Unable to allocate name\n")); stack; return -1; } if(!memset(filename, 0, (sizeof(char) * filename_len) + 1)) { - log_err("Unable to zero name\n"); + log_err( _("Unable to zero name\n")); stack; return -1; } memcpy(filename, tmp_name, filename_len); if(gfs2_dirent_del(ip, NULL, filename, filename_len)) - log_warn("add_inode_to_lf: " - "Unable to remove \"..\" directory entry.\n"); + log_warn( _("add_inode_to_lf: " + "Unable to remove \"..\" directory entry.\n")); dir_add(ip, filename, filename_len, &(lf_dip->i_di.di_num), DT_DIR); free(filename); @@ -123,12 +125,12 @@ int add_inode_to_lf(struct gfs2_inode *ip){ } filename_len = strlen(tmp_name); /* no trailing NULL */ if(!(filename = malloc(sizeof(char) * filename_len))) { - log_err("Unable to allocate name\n"); + log_err( _("Unable to allocate name\n")); stack; return -1; } if(!memset(filename, 0, sizeof(char) * filename_len)) { - log_err("Unable to zero name\n"); + log_err( _("Unable to zero name\n")); stack; return -1; } @@ -140,7 +142,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){ increment_link(ip->i_sbd, lf_dip->i_di.di_num.no_addr); free(filename); - log_notice("Added inode #%llu to lost+found dir\n", + log_notice( _("Added inode #%llu to lost+found dir\n"), (unsigned long long)ip->i_di.di_num.no_addr); return 0; } diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c index 3481b4f..6cc937a 100644 --- a/gfs2/fsck/main.c +++ b/gfs2/fsck/main.c @@ -7,6 +7,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "copyright.cf" #include "libgfs2.h" @@ -39,14 +41,14 @@ void print_it(const char *label, const char *fmt, const char *fmt2, ...) void usage(char *name) { - printf("Usage: %s [-hnqvVy] \n", basename(name)); + printf( _("Usage: %s [-hnqvVy] \n"), basename(name)); } void version(void) { - printf("GFS2 fsck %s (built %s %s)\n", + printf( _("GFS2 fsck %s (built %s %s)\n"), RELEASE_VERSION, __DATE__, __TIME__); - printf("%s\n", REDHAT_COPYRIGHT); + printf( _(REDHAT_COPYRIGHT "\n")); } int read_cmdline(int argc, char **argv, struct gfs2_options *opts) @@ -78,11 +80,11 @@ int read_cmdline(int argc, char **argv, struct gfs2_options *opts) break; case ':': case '?': - fprintf(stderr, "Please use '-h' for usage.\n"); + fprintf(stderr, _("Please use '-h' for usage.\n")); return FSCK_USAGE; default: - fprintf(stderr, "Bad programmer! You forgot to catch" - " the %c flag\n", c); + fprintf(stderr, _("Bad programmer! You forgot to catch" + " the %c flag\n"), c); return FSCK_USAGE; } @@ -90,11 +92,11 @@ int read_cmdline(int argc, char **argv, struct gfs2_options *opts) if(argc > optind) { opts->device = (argv[optind]); if(!opts->device) { - fprintf(stderr, "Please use '-h' for usage.\n"); + fprintf(stderr, _("Please use '-h' for usage.\n")); return FSCK_USAGE; } } else { - fprintf(stderr, "No device specified. Use '-h' for usage.\n"); + fprintf(stderr, _("No device specified. Use '-h' for usage.\n")); return FSCK_USAGE; } return 0; @@ -106,15 +108,15 @@ void interrupt(int sig) char progress[PATH_MAX]; if (!last_reported_block || last_reported_block == last_fs_block) - sprintf(progress, "progress unknown.\n"); + sprintf(progress, _("progress unknown.\n")); else - sprintf(progress, "processing block %" PRIu64 " out of %" - PRIu64 "\n", last_reported_block, last_fs_block); + sprintf(progress, _("processing block %" PRIu64 " out of %" + PRIu64 "\n"), last_reported_block, last_fs_block); response = generic_interrupt("gfs2_fsck", pass, progress, - "Do you want to abort gfs2_fsck, skip " \ + _("Do you want to abort gfs2_fsck, skip " \ "the rest of this pass or continue " \ - "(a/s/c)?", "asc"); + "(a/s/c)?"), "asc"); if(tolower(response) == 's') { skip_this_pass = TRUE; return; @@ -134,20 +136,20 @@ int check_system_inode(struct gfs2_inode *sysinode, const char *filename, uint64_t iblock = 0; struct dir_status ds = {0}; - log_info("Checking system inode '%s'\n", filename); + log_info( _("Checking system inode '%s'\n"), filename); if (sysinode) { /* Read in the system inode, look at its dentries, and start * reading through them */ iblock = sysinode->i_di.di_num.no_addr; - log_info("System inode for '%s' is located at block %" - PRIu64 " (0x%" PRIx64 ")\n", filename, + log_info( _("System inode for '%s' is located at block %" + PRIu64 " (0x%" PRIx64 ")\n"), filename, iblock, iblock); /* FIXME: check this block's validity */ if(gfs2_block_check(sysinode->i_sbd, bl, iblock, &ds.q)) { - log_crit("Can't get %s inode block %" PRIu64 " (0x%" - PRIx64 ") from block list\n", filename, + log_crit( _("Can't get %s inode block %" PRIu64 " (0x%" + PRIx64 ") from block list\n"), filename, iblock, iblock); return -1; } @@ -156,7 +158,7 @@ int check_system_inode(struct gfs2_inode *sysinode, const char *filename, /* bitmap. In that case, don't rebuild the inode. */ /* Just reuse the inode and fix the bitmap. */ if (ds.q.block_type == gfs2_block_free) { - log_info("The inode exists but the block is not marked 'in use'; fixing it.\n"); + log_info( _("The inode exists but the block is not marked 'in use'; fixing it.\n")); gfs2_block_set(sysinode->i_sbd, bl, sysinode->i_di.di_num.no_addr, mark); @@ -167,16 +169,16 @@ int check_system_inode(struct gfs2_inode *sysinode, const char *filename, } } else - log_info("System inode for '%s' is missing.\n", filename); + log_info( _("System inode for '%s' is missing.\n"), filename); /* If there are errors with the inode here, we need to * create a new inode and get it all setup - of course, * everything will be in lost+found then, but we *need* our * system inodes before we can do any of that. */ if(!sysinode || ds.q.block_type != mark) { - log_err("Invalid or missing %s system inode.\n", filename); + log_err( _("Invalid or missing %s system inode.\n"), filename); errors_found++; if ((errors_corrected += - query(&opts, "Create new %s system inode? (y/n) ", + query(&opts, _("Create new %s system inode? (y/n) "), filename))) { builder(sysinode->i_sbd); gfs2_block_set(sysinode->i_sbd, bl, @@ -188,7 +190,7 @@ int check_system_inode(struct gfs2_inode *sysinode, const char *filename, sysinode->i_di.di_num.no_addr); } else { - log_err("Cannot continue without valid %s inode\n", + log_err( _("Cannot continue without valid %s inode\n"), filename); return -1; } @@ -253,27 +255,30 @@ int main(int argc, char **argv) enum update_flags update_sys_files; int error = 0; + setlocale(LC_ALL, ""); + textdomain("fsck.gfs2"); + memset(sbp, 0, sizeof(*sbp)); if((error = read_cmdline(argc, argv, &opts))) exit(error); setbuf(stdout, NULL); - log_notice("Initializing fsck\n"); + log_notice( _("Initializing fsck\n")); if ((error = initialize(sbp))) exit(error); signal(SIGINT, interrupt); - log_notice("Starting pass1\n"); + log_notice( _("Starting pass1\n")); pass = "pass 1"; last_reported_block = 0; if ((error = pass1(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass1 interrupted \n"); + log_notice( _("Pass1 interrupted \n")); } else - log_notice("Pass1 complete \n"); + log_notice( _("Pass1 complete \n")); /* Make sure the system inodes are okay & represented in the bitmap. */ check_system_inodes(sbp); @@ -281,81 +286,81 @@ int main(int argc, char **argv) if (!fsck_abort) { last_reported_block = 0; pass = "pass 1b"; - log_notice("Starting pass1b\n"); + log_notice( _("Starting pass1b\n")); if((error = pass1b(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass1b interrupted \n"); + log_notice( _("Pass1b interrupted \n")); } else - log_notice("Pass1b complete\n"); + log_notice( _("Pass1b complete\n")); } if (!fsck_abort) { last_reported_block = 0; pass = "pass 1c"; - log_notice("Starting pass1c\n"); + log_notice( _("Starting pass1c\n")); if((error = pass1c(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass1c interrupted \n"); + log_notice( _("Pass1c interrupted \n")); } else - log_notice("Pass1c complete\n"); + log_notice( _("Pass1c complete\n")); } if (!fsck_abort) { last_reported_block = 0; pass = "pass 2"; - log_notice("Starting pass2\n"); + log_notice( _("Starting pass2\n")); if ((error = pass2(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass2 interrupted \n"); + log_notice( _("Pass2 interrupted \n")); } else - log_notice("Pass2 complete \n"); + log_notice( _("Pass2 complete \n")); } if (!fsck_abort) { last_reported_block = 0; pass = "pass 3"; - log_notice("Starting pass3\n"); + log_notice( _("Starting pass3\n")); if ((error = pass3(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass3 interrupted \n"); + log_notice( _("Pass3 interrupted \n")); } else - log_notice("Pass3 complete \n"); + log_notice( _("Pass3 complete \n")); } if (!fsck_abort) { last_reported_block = 0; pass = "pass 4"; - log_notice("Starting pass4\n"); + log_notice( _("Starting pass4\n")); if ((error = pass4(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass4 interrupted \n"); + log_notice( _("Pass4 interrupted \n")); } else - log_notice("Pass4 complete \n"); + log_notice( _("Pass4 complete \n")); } if (!fsck_abort) { last_reported_block = 0; pass = "pass 5"; - log_notice("Starting pass5\n"); + log_notice( _("Starting pass5\n")); if ((error = pass5(sbp))) exit(error); if (skip_this_pass || fsck_abort) { skip_this_pass = FALSE; - log_notice("Pass5 interrupted \n"); + log_notice( _("Pass5 interrupted \n")); error = FSCK_CANCELED; } else - log_notice("Pass5 complete \n"); + log_notice( _("Pass5 complete \n")); } else { error = FSCK_CANCELED; } @@ -375,11 +380,11 @@ int main(int argc, char **argv) inode_put(lf_dip, update_sys_files); if (!opts.no) - log_notice("Writing changes to disk\n"); + log_notice( _("Writing changes to disk\n")); bsync(&sbp->buf_list); bsync(&sbp->nvbuf_list); destroy(sbp); - log_notice("gfs2_fsck complete \n"); + log_notice( _("gfs2_fsck complete \n")); if (!error) { if (!errors_found) diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c index bb5dbd5..6f12655 100644 --- a/gfs2/fsck/metawalk.c +++ b/gfs2/fsck/metawalk.c @@ -5,6 +5,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -63,7 +65,7 @@ struct gfs2_inode *fsck_inode_get(struct gfs2_sbd *sdp, ip = calloc(1, sizeof(struct gfs2_inode)); if (ip == NULL) { - fprintf(stderr, "Out of memory in %s\n", __FUNCTION__); + fprintf(stderr, _("Out of memory in %s\n"), __FUNCTION__); exit(-1); } gfs2_dinode_in(&ip->i_di, bh->b_data); @@ -153,11 +155,11 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, else if (type == DIR_EXHASH) { dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_leaf)); leaf = (struct gfs2_leaf *)bh->b_data; - log_debug("Checking leaf %" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Checking leaf %" PRIu64 " (0x%" PRIx64 ")\n"), bh->b_blocknr, bh->b_blocknr); } else { - log_err("Invalid directory type %d specified\n", type); + log_err( _("Invalid directory type %d specified\n"), type); return -1; } @@ -172,16 +174,16 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, if (de.de_rec_len < sizeof(struct gfs2_dirent) + de.de_name_len || !de.de_name_len) { - log_err("Directory block %llu (0x%llx" + log_err( _("Directory block %llu (0x%llx" "), entry %d of directory %llu" - "(0x%llx) is corrupt.\n", + "(0x%llx) is corrupt.\n"), (unsigned long long)bh->b_blocknr, (unsigned long long)bh->b_blocknr, (*count) + 1, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; - if (query(&opts, "Attempt to repair it? (y/n) ")) { + if (query(&opts, _("Attempt to repair it? (y/n) "))) { if (dirent_repair(ip, bh, &de, dent, type, first)) break; @@ -191,21 +193,21 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, } } else { - log_err("Corrupt directory entry ignored, " - "stopped after checking %d entries.\n", + log_err( _("Corrupt directory entry ignored, " + "stopped after checking %d entries.\n"), *count); break; } } if (!de.de_inum.no_formal_ino){ if(first){ - log_debug("First dirent is a sentinel (place holder).\n"); + log_debug( _("First dirent is a sentinel (place holder).\n")); first = 0; } else { /* FIXME: Do something about this */ - log_err("Directory entry with inode number of " + log_err( _("Directory entry with inode number of " "zero in leaf %llu (0x%llx) of " - "directory %llu (0x%llx)!\n", + "directory %llu (0x%llx)!\n"), (unsigned long long)bh->b_blocknr, (unsigned long long)bh->b_blocknr, (unsigned long long)ip->i_di.di_num.no_addr, @@ -214,7 +216,7 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, } } else { if (!de.de_inum.no_addr && first) { /* reverse sentinel */ - log_debug("First dirent is a Sentinel (place holder).\n"); + log_debug( _("First dirent is a Sentinel (place holder).\n")); /* Swap the two to silently make it a proper sentinel */ de.de_inum.no_addr = de.de_inum.no_formal_ino; de.de_inum.no_formal_ino = 0; @@ -239,7 +241,7 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, } if ((char *)dent + de.de_rec_len >= bh_end){ - log_debug("Last entry processed.\n"); + log_debug( _("Last entry processed.\n")); break; } @@ -263,8 +265,8 @@ void warn_and_patch(struct gfs2_inode *ip, uint64_t *leaf_no, const char *msg) { if (*bad_leaf != *leaf_no) { - log_err("Directory Inode %llu (0x%llx) points to leaf %llu" - " (0x%llx) %s.\n", + log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu" + " (0x%llx) %s.\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)*leaf_no, @@ -272,12 +274,12 @@ void warn_and_patch(struct gfs2_inode *ip, uint64_t *leaf_no, } errors_found++; if (*leaf_no == *bad_leaf || - query(&opts, "Attempt to patch around it? (y/n) ")) { + query(&opts, _("Attempt to patch around it? (y/n) "))) { errors_corrected++; gfs2_put_leaf_nr(ip, index, old_leaf); } else - log_err("Bad leaf left in place.\n"); + log_err( _("Bad leaf left in place.\n")); *bad_leaf = *leaf_no; *leaf_no = old_leaf; } @@ -314,10 +316,10 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, continue; } else { if(ref_count != exp_count){ - log_err("Dir #%llu (0x%llx) has an incorrect " + log_err( _("Dir #%llu (0x%llx) has an incorrect " "number of pointers to leaf #%llu " " (0x%llx)\n\tFound: %u, Expected: " - "%u\n", (unsigned long long) + "%u\n"), (unsigned long long) ip->i_di.di_num.no_addr, (unsigned long long) ip->i_di.di_num.no_addr, @@ -325,7 +327,7 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, (unsigned long long)old_leaf, ref_count, exp_count); errors_found++; - if (query(&opts, "Attempt to fix it? (y/n) ")) + if (query(&opts, _("Attempt to fix it? (y/n) "))) { int factor = 0, divisor = ref_count; @@ -350,9 +352,9 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, do { /* Make sure the block number is in range. */ if(gfs2_check_range(ip->i_sbd, leaf_no)){ - log_err("Leaf block #%llu (0x%llx) is out " + log_err( _("Leaf block #%llu (0x%llx) is out " "of range for directory #%llu (0x%llx" - ").\n", (unsigned long long)leaf_no, + ").\n"), (unsigned long long)leaf_no, (unsigned long long)leaf_no, (unsigned long long) ip->i_di.di_num.no_addr, @@ -360,7 +362,7 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, ip->i_di.di_num.no_addr); warn_and_patch(ip, &leaf_no, &bad_leaf, old_leaf, index, - "that is out of range"); + _("that is out of range")); memcpy(&leaf, &oldleaf, sizeof(oldleaf)); break; } @@ -372,7 +374,7 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, if (gfs2_check_meta(lbh, GFS2_METATYPE_LF)) { warn_and_patch(ip, &leaf_no, &bad_leaf, old_leaf, index, - "that is not really a leaf"); + _("that is not really a leaf")); memcpy(&leaf, &oldleaf, sizeof(oldleaf)); brelse(lbh, (opts.no ? not_updated : updated)); break; @@ -391,18 +393,18 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, * values and replace them with the correct value. */ if (leaf.lf_dirent_format == (GFS2_FORMAT_DE << 16)) { - log_debug("incorrect lf_dirent_format at leaf #%" PRIu64 "\n", leaf_no); + log_debug( _("incorrect lf_dirent_format at leaf #%" PRIu64 "\n"), leaf_no); leaf.lf_dirent_format = GFS2_FORMAT_DE; gfs2_leaf_out(&leaf, lbh->b_data); - log_debug("Fixing lf_dirent_format.\n"); + log_debug( _("Fixing lf_dirent_format.\n")); *update = (opts.no ? not_updated : updated); } /* Make sure it's really a leaf. */ if (leaf.lf_header.mh_type != GFS2_METATYPE_LF) { - log_err("Inode %llu (0x%llx" + log_err( _("Inode %llu (0x%llx" ") points to bad leaf %llu" - " (0x%llx).\n", + " (0x%llx).\n"), (unsigned long long) ip->i_di.di_num.no_addr, (unsigned long long) @@ -413,7 +415,7 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, break; } exp_count = (1 << (ip->i_di.di_depth - leaf.lf_depth)); - log_debug("expected count %u - di_depth %u, leaf depth %u\n", + log_debug( _("expected count %u - di_depth %u, leaf depth %u\n"), exp_count, ip->i_di.di_depth, leaf.lf_depth); if(pass->check_dentry && @@ -442,11 +444,11 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, lbh = bread(&sbp->buf_list, leaf_no); gfs2_leaf_in(&leaf, lbh->b_data); - log_err("Leaf %llu (0x%llx) entry " + log_err( _("Leaf %llu (0x%llx) entry " "count in directory %llu" " (0x%llx) doesn't match " "number of entries found " - "- is %u, found %u\n", + "- is %u, found %u\n"), (unsigned long long)leaf_no, (unsigned long long)leaf_no, (unsigned long long) @@ -455,14 +457,14 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, ip->i_di.di_num.no_addr, leaf.lf_entries, count); errors_found++; - if(query(&opts, "Update leaf entry count? (y/n) ")) { + if(query(&opts, _("Update leaf entry count? (y/n) "))) { errors_corrected++; leaf.lf_entries = count; gfs2_leaf_out(&leaf, lbh->b_data); - log_warn("Leaf entry count updated\n"); + log_warn( _("Leaf entry count updated\n")); f = updated; } else - log_err("Leaf entry count left in inconsistant state\n"); + log_err( _("Leaf entry count left in inconsistant state\n")); brelse(lbh, f); } /* FIXME: Need to get entry count and @@ -473,7 +475,7 @@ int check_leaf(struct gfs2_inode *ip, enum update_flags *update, if(!leaf.lf_next) break; leaf_no = leaf.lf_next; - log_debug("Leaf chain detected.\n"); + log_debug( _("Leaf chain detected.\n")); } } while(1); old_leaf = leaf_no; @@ -532,8 +534,8 @@ static int check_eattr_entries(struct gfs2_inode *ip, update_it, pass->private)) { errors_found++; - if (query(&opts, "Repair the bad EA? " - "(y/n) ")) { + if (query(&opts, _("Repair the bad EA? " + "(y/n) "))) { errors_corrected++; ea_hdr->ea_num_ptrs = i; ea_hdr->ea_data_len = @@ -545,7 +547,7 @@ static int check_eattr_entries(struct gfs2_inode *ip, a single byte. */ return -1; } - log_err("The bad EA was not fixed.\n"); + log_err( _("The bad EA was not fixed.\n")); } tot_ealen += sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header); @@ -580,7 +582,7 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block, struct gfs2_buffer_head *bh = NULL; int error = 0; - log_debug("Checking EA leaf block #%"PRIu64" (0x%" PRIx64 ").\n", + log_debug( _("Checking EA leaf block #%"PRIu64" (0x%" PRIx64 ").\n"), block, block); if(pass->check_eattr_leaf) { @@ -618,7 +620,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect, struct gfs2_sbd *sdp = ip->i_sbd; *want_updated = not_updated; - log_debug("Checking EA indirect block #%"PRIu64" (0x%" PRIx64 ").\n", + log_debug( _("Checking EA indirect block #%"PRIu64" (0x%" PRIx64 ").\n"), indirect, indirect); if (!pass->check_eattr_indir) @@ -683,7 +685,7 @@ int check_inode_eattr(struct gfs2_inode *ip, enum update_flags *want_updated, return 0; } - log_debug("Extended attributes exist for inode #%llu (0x%llx).\n", + log_debug( _("Extended attributes exist for inode #%llu (0x%llx).\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); @@ -755,8 +757,8 @@ static int build_and_check_metalist(struct gfs2_inode *ip, goto fail; } if(err > 0) { - log_debug("Skipping block %" PRIu64 - " (0x%" PRIx64 ")\n", + log_debug( _("Skipping block %" PRIu64 + " (0x%" PRIx64 ")\n"), block, block); continue; } @@ -816,7 +818,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass) /* We don't need to record directory blocks - they will be * recorded later...i think... */ if (S_ISDIR(ip->i_di.di_mode)) - log_debug("Directory with height > 0 at %llu (0x%llx)\n", + log_debug( _("Directory with height > 0 at %llu (0x%llx)\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); @@ -952,10 +954,10 @@ int remove_dentry_from_dir(struct gfs2_sbd *sbp, uint64_t dir, struct gfs2_block_query q; int error; - log_debug("Removing dentry %" PRIu64 " (0x%" PRIx64 ") from directory %" - PRIu64" (0x%" PRIx64 ")\n", dentryblock, dentryblock, dir, dir); + log_debug( _("Removing dentry %" PRIu64 " (0x%" PRIx64 ") from directory %" + PRIu64" (0x%" PRIx64 ")\n"), dentryblock, dentryblock, dir, dir); if(gfs2_check_range(sbp, dir)) { - log_err("Parent directory out of range\n"); + log_err( _("Parent directory out of range\n")); return 1; } remove_dentry_fxns.private = &dentryblock; @@ -966,7 +968,7 @@ int remove_dentry_from_dir(struct gfs2_sbd *sbp, uint64_t dir, return -1; } if(q.block_type != gfs2_inode_dir) { - log_info("Parent block is not a directory...ignoring\n"); + log_info( _("Parent block is not a directory...ignoring\n")); return 1; } /* Need to run check_dir with a private var of dentryblock, diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c index 6a63338..eab90cb 100644 --- a/gfs2/fsck/pass1.c +++ b/gfs2/fsck/pass1.c @@ -16,6 +16,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -72,7 +74,7 @@ static int leaf(struct gfs2_inode *ip, uint64_t block, { struct block_count *bc = (struct block_count *) private; - log_debug("\tLeaf block at %15" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("\tLeaf block at %15" PRIu64 " (0x%" PRIx64 ")\n"), block, block); gfs2_block_set(ip->i_sbd, bl, block, gfs2_leaf_blk); bc->indir_count++; @@ -92,7 +94,7 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block, if (gfs2_check_range(ip->i_sbd, block)){ /* blk outside of FS */ gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr, gfs2_bad_block); - log_debug("Bad indirect block pointer (out of range).\n"); + log_debug( _("Bad indirect block pointer (out of range).\n")); return 1; } @@ -101,16 +103,16 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block, return -1; } if(q.block_type != gfs2_block_free) { - log_debug("Found duplicate block in indirect block -" - " was marked %d\n", q.block_type); + log_debug( _("Found duplicate block in indirect block -" + " was marked %d\n"), q.block_type); gfs2_block_mark(ip->i_sbd, bl, block, gfs2_dup_block); found_dup = 1; } nbh = bread(&ip->i_sbd->buf_list, block); if (gfs2_check_meta(nbh, GFS2_METATYPE_IN)){ - log_debug("Bad indirect block pointer " - "(points to something that is not an indirect block).\n"); + log_debug( _("Bad indirect block pointer " + "(points to something that is not an indirect block).\n")); if(!found_dup) { gfs2_block_set(ip->i_sbd, bl, block, gfs2_meta_inval); brelse(nbh, not_updated); @@ -119,7 +121,7 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block, }else /* blk check ok */ *bh = nbh; - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to indirect block.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to indirect block.\n"), block, block); gfs2_block_set(ip->i_sbd, bl, block, gfs2_indir_blk); bc->indir_count++; @@ -133,7 +135,7 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private) struct block_count *bc = (struct block_count *) private; if (gfs2_check_range(ip->i_sbd, block)) { - log_err( "Bad data block pointer (out of range)\n"); + log_err( _("Bad data block pointer (out of range)\n")); /* Mark the owner of this block with the bad_block * designator so we know to check it for out of range blocks later */ gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr, @@ -145,13 +147,13 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private) return -1; } if(q.block_type != gfs2_block_free) { - log_debug("Found duplicate block at %" PRIu64 " (0x%"PRIx64 ")\n", + log_debug( _("Found duplicate block at %" PRIu64 " (0x%"PRIx64 ")\n"), block, block); gfs2_block_mark(ip->i_sbd, bl, block, gfs2_dup_block); bc->data_count++; return 1; } - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to data block\n", block, + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to data block\n"), block, block); gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_used); bc->data_count++; @@ -174,15 +176,15 @@ static int clear_eas(struct gfs2_inode *ip, struct block_count *bc, struct gfs2_sbd *sdp = ip->i_sbd; *want_updated = not_updated; - log_err("Inode #%llu (0x%llx): %s", + log_err( _("Inode #%llu (0x%llx): %s"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, emsg); if (block) - log_err(" at block #%" PRIu64 " (0x%" PRIx64 ")", + log_err( _(" at block #%" PRIu64 " (0x%" PRIx64 ")"), block, block); log_err(".\n"); errors_found++; - if ((errors_corrected += query(&opts, "Clear the bad EA? (y/n) "))) { + if ((errors_corrected += query(&opts, _("Clear the bad EA? (y/n) ")))) { if (block == 0) block = ip->i_di.di_eattr; gfs2_block_clear(sdp, bl, block, gfs2_eattr_block); @@ -200,7 +202,7 @@ static int clear_eas(struct gfs2_inode *ip, struct block_count *bc, *want_updated = updated; return 1; } else { - log_err("The bad EA was not fixed.\n"); + log_err( _("The bad EA was not fixed.\n")); bc->ea_count++; return 0; } @@ -238,18 +240,18 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect, if(gfs2_check_meta(*bh, GFS2_METATYPE_IN)) { if(q.block_type != gfs2_block_free) { /* Duplicate? */ if (!clear_eas(ip, bc, indirect, 1, want_updated, - "Bad indirect EA duplicate found")) + _("Bad indirect EA duplicate found"))) gfs2_block_set(sdp, bl, indirect, gfs2_dup_block); return 1; } clear_eas(ip, bc, indirect, 0, want_updated, - "EA indirect block has incorrect type"); + _("EA indirect block has incorrect type")); return 1; } if(q.block_type != gfs2_block_free) { /* Duplicate? */ - log_err("Inode #%llu (0x%llx): Duplicate EA indirect " - "block found at #%llu (0x%llx).\n", + log_err( _("Inode #%llu (0x%llx): Duplicate EA indirect " + "block found at #%llu (0x%llx).\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)indirect, @@ -258,8 +260,8 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect, bc->ea_count++; ret = 1; } else { - log_debug("Setting #%" PRIu64 " (0x%" PRIx64 - ") to indirect EA block\n", indirect, indirect); + log_debug( _("Setting #%" PRIu64 " (0x%" PRIx64 + ") to indirect EA block\n"), indirect, indirect); gfs2_block_set(sdp, bl, indirect, gfs2_indir_blk); bc->ea_count++; } @@ -270,7 +272,7 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int indir_ok, enum update_flags *want_updated, void *private) { if (indir_ok) { - log_debug("Marking inode #%llu (0x%llx) with eattr block\n", + log_debug( _("Marking inode #%llu (0x%llx) with eattr block\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); /* Mark the inode as having an eattr in the block map @@ -280,7 +282,7 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int indir_ok, return 0; } clear_eas(ip, (struct block_count *)private, 0, 0, want_updated, - "has unrecoverable indirect EA errors"); + _("has unrecoverable indirect EA errors")); return 0; } @@ -310,8 +312,8 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr, int ret = 0; if(gfs2_check_range(sdp, el_blk)){ - log_err("Inode #%llu (0x%llx): EA extended " - "leaf block #%llu (0x%llx) is out of range.\n", + log_err( _("Inode #%llu (0x%llx): EA extended " + "leaf block #%llu (0x%llx) is out of range.\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)el_blk, @@ -333,22 +335,22 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr, if(gfs2_check_meta(el_buf, GFS2_METATYPE_ED)) { if(q.block_type != gfs2_block_free) /* Duplicate? */ clear_eas(ip, bc, el_blk, 1, want_updated, - "has bad extended EA duplicate"); + _("has bad extended EA duplicate")); else clear_eas(ip, bc, el_blk, 0, want_updated, - "EA extended leaf block has incorrect type"); + _("EA extended leaf block has incorrect type")); ret = 1; } else { /* If this looks like an EA */ if(q.block_type != gfs2_block_free) { /* Duplicate? */ - log_debug("Duplicate block found at #%" PRIu64 - " (0x%" PRIx64 ").\n", + log_debug( _("Duplicate block found at #%" PRIu64 + " (0x%" PRIx64 ").\n"), el_blk, el_blk); gfs2_block_set(sdp, bl, el_blk, gfs2_dup_block); bc->ea_count++; ret = 1; } else { - log_debug("Setting block #%" PRIu64 - " (0x%" PRIx64 ") to eattr block\n", + log_debug( _("Setting block #%" PRIu64 + " (0x%" PRIx64 ") to eattr block\n"), el_blk, el_blk); gfs2_block_set(sdp, bl, el_blk, gfs2_meta_eattr); bc->ea_count++; @@ -372,13 +374,13 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, /* This inode contains an eattr - it may be invalid, but the * eattr attributes points to a non-zero block */ if (parent != ip->i_di.di_num.no_addr) { /* if parent isn't the inode */ - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to eattr block\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to eattr block\n"), parent, parent); gfs2_block_set(sdp, bl, parent, gfs2_eattr_block); } if(gfs2_check_range(sdp, block)){ - log_warn("Inode #%llu (0x%llx): EA leaf block #%llu (0x%llx" - ") is out of range.\n", + log_warn( _("Inode #%llu (0x%llx): EA leaf block #%llu (0x%llx" + ") is out of range.\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block, (unsigned long long)block); @@ -398,25 +400,25 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, if(gfs2_check_meta(leaf_bh, GFS2_METATYPE_EA)) { if(q.block_type != gfs2_block_free) { /* Duplicate? */ clear_eas(ip, bc, block, 1, want_updated, - "Bad EA duplicate found"); + _("Bad EA duplicate found")); } else { clear_eas(ip, bc, block, 0, want_updated, - "EA leaf block has incorrect type"); + _("EA leaf block has incorrect type")); } ret = 1; brelse(leaf_bh, not_updated); } else { /* If this looks like an EA */ if(q.block_type != gfs2_block_free) { /* Duplicate? */ - log_debug("Duplicate block found at #%" PRIu64 - " (0x%" PRIx64 ").\n", + log_debug( _("Duplicate block found at #%" PRIu64 + " (0x%" PRIx64 ").\n"), block, block); gfs2_block_set(sdp, bl, block, gfs2_dup_block); bc->ea_count++; ret = 1; brelse(leaf_bh, not_updated); } else { - log_debug("Setting block #%" PRIu64 - " (0x%" PRIx64 ") to eattr block\n", + log_debug( _("Setting block #%" PRIu64 + " (0x%" PRIx64 ") to eattr block\n"), block, block); gfs2_block_set(sdp, bl, block, gfs2_meta_eattr); @@ -464,7 +466,7 @@ static int check_eattr_entries(struct gfs2_inode *ip, if(max_ptrs > ea_hdr->ea_num_ptrs) { return 1; } else { - log_debug(" Pointers Required: %d\n Pointers Reported: %d\n", + log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"), max_ptrs, ea_hdr->ea_num_ptrs); } } @@ -516,7 +518,7 @@ int clear_leaf(struct gfs2_inode *ip, uint64_t block, return -1; } if(!q.dup_block) { - log_crit("Setting leaf #%" PRIu64 " (0x%" PRIx64 ") invalid\n", + log_crit( _("Setting leaf #%" PRIu64 " (0x%" PRIx64 ") invalid\n"), block, block); if(gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free)) { stack; @@ -539,17 +541,17 @@ int add_to_dir_list(struct gfs2_sbd *sbp, uint64_t block) * matter too much */ find_di(sbp, block, &di); if(di) { - log_err("Attempting to add directory block #%" PRIu64 - " (0x%" PRIx64 ") which is already in list\n", block, block); + log_err( _("Attempting to add directory block #%" PRIu64 + " (0x%" PRIx64 ") which is already in list\n"), block, block); return -1; } if(!(newdi = (struct dir_info *) malloc(sizeof(struct dir_info)))) { - log_crit("Unable to allocate dir_info structure\n"); + log_crit( _("Unable to allocate dir_info structure\n")); return -1; } if(!memset(newdi, 0, sizeof(*newdi))) { - log_crit("Error while zeroing dir_info structure\n"); + log_crit( _("Error while zeroing dir_info structure\n")); return -1; } @@ -575,21 +577,21 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, ip = fsck_inode_get(sdp, bh); if (ip->i_di.di_num.no_addr != block) { - log_err("Inode #%llu (0x%llx): Bad inode address found: %llu " - "(0x%llx)\n", (unsigned long long)block, + log_err( _("Inode #%llu (0x%llx): Bad inode address found: %llu " + "(0x%llx)\n"), (unsigned long long)block, (unsigned long long)block, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; if((errors_corrected += - query(&opts, "Fix address in inode at block #%" - PRIu64 " (0x%" PRIx64 ")? (y/n) ", block, block))) { + query(&opts, _("Fix address in inode at block #%" + PRIu64 " (0x%" PRIx64 ")? (y/n) "), block, block))) { ip->i_di.di_num.no_addr = ip->i_di.di_num.no_formal_ino = block; gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); f = updated; } else - log_err("Address in inode at block #%" PRIu64 - " (0x%" PRIx64 ") not fixed\n", block, block); + log_err( _("Address in inode at block #%" PRIu64 + " (0x%" PRIx64 ") not fixed\n"), block, block); } if(gfs2_block_check(sdp, bl, block, &q)) { @@ -598,7 +600,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, return -1; } if(q.block_type != gfs2_block_free) { - log_debug("Found duplicate block at #%" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Found duplicate block at #%" PRIu64 " (0x%" PRIx64 ")\n"), block, block); if(gfs2_block_mark(sdp, bl, block, gfs2_dup_block)) { stack; @@ -612,7 +614,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, switch(ip->i_di.di_mode & S_IFMT) { case S_IFDIR: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to directory inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to directory inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_dir)) { stack; @@ -626,7 +628,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFREG: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to file inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to file inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_file)) { stack; @@ -635,7 +637,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFLNK: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to symlink inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to symlink inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_lnk)) { stack; @@ -644,7 +646,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFBLK: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to block dev inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to block dev inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_blk)) { stack; @@ -653,7 +655,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFCHR: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to char dev inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to char dev inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_chr)) { stack; @@ -662,7 +664,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFIFO: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to fifo inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to fifo inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_fifo)) { stack; @@ -671,7 +673,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; case S_IFSOCK: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to socket inode.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to socket inode.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_inode_sock)) { stack; @@ -680,7 +682,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, } break; default: - log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to invalid.\n", + log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to invalid.\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) { stack; @@ -700,14 +702,14 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, /* FIXME: fix height and depth here - wasn't implemented in * old fsck either, so no biggy... */ if (ip->i_di.di_height < compute_height(sdp, ip->i_di.di_size)){ - log_warn("Dinode #%llu (0x%llx) has bad height " - "Found %u, Expected >= %u\n", + log_warn( _("Dinode #%llu (0x%llx) has bad height " + "Found %u, Expected >= %u\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, ip->i_di.di_height, compute_height(sdp, ip->i_di.di_size)); /* once implemented, remove continue statement */ - log_warn("Marking inode invalid\n"); + log_warn( _("Marking inode invalid\n")); if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) { stack; fsck_inode_put(ip, f); @@ -721,14 +723,14 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, if (S_ISDIR(ip->i_di.di_mode) && (ip->i_di.di_flags & GFS2_DIF_EXHASH)) { if (((1 << ip->i_di.di_depth) * sizeof(uint64_t)) != ip->i_di.di_size){ - log_warn("Directory dinode #%llu (0x%llx" - ") has bad depth. Found %u, Expected %u\n", + log_warn( _("Directory dinode #%llu (0x%llx" + ") has bad depth. Found %u, Expected %u\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, ip->i_di.di_depth, (1 >> (ip->i_di.di_size/sizeof(uint64_t)))); /* once implemented, remove continue statement */ - log_warn("Marking inode invalid\n"); + log_warn( _("Marking inode invalid\n")); if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) { stack; fsck_inode_put(ip, f); @@ -748,7 +750,7 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, return 0; } if(error > 0) { - log_warn("Marking inode #%llu (0x%llx) invalid\n", + log_warn( _("Marking inode #%llu (0x%llx) invalid\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); /* FIXME: Must set all leaves invalid as well */ @@ -764,8 +766,8 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, if (ip->i_di.di_blocks != (1 + bc.indir_count + bc.data_count + bc.ea_count)) { - log_err("Inode #%llu (0x%llx): Ondisk block count (%llu" - ") does not match what fsck found (%llu)\n", + log_err( _("Inode #%llu (0x%llx): Ondisk block count (%llu" + ") does not match what fsck found (%llu)\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_blocks, @@ -773,14 +775,14 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, bc.data_count + bc.ea_count); errors_found++; if ((errors_corrected += - query(&opts, "Fix ondisk block count? (y/n) "))) { + query(&opts, _("Fix ondisk block count? (y/n) ")))) { ip->i_di.di_blocks = 1 + bc.indir_count + bc.data_count + bc.ea_count; gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); f = updated; } else - log_err("Bad block count for #%llu (0x%llx" - ") not fixed\n", + log_err( _("Bad block count for #%llu (0x%llx" + ") not fixed\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); } @@ -793,7 +795,7 @@ int scan_meta(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, uint64_t block) { if (gfs2_check_meta(bh, 0)) { - log_debug("Found invalid metadata at #%" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Found invalid metadata at #%" PRIu64 " (0x%" PRIx64 ")\n"), block, block); if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) { stack; @@ -803,7 +805,7 @@ int scan_meta(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh, return 0; } - log_debug("Checking metadata block #%" PRIu64 " (0x%" PRIx64 ")\n", block, + log_debug( _("Checking metadata block #%" PRIu64 " (0x%" PRIx64 ")\n"), block, block); if (!gfs2_check_meta(bh, GFS2_METATYPE_DI)) { @@ -867,14 +869,14 @@ int pass1(struct gfs2_sbd *sbp) for (tmp = sbp->rglist.next; tmp != &sbp->rglist; tmp = tmp->next, rg_count++){ - log_info("Checking metadata in Resource Group #%" PRIu64 "\n", + log_info( _("Checking metadata in Resource Group #%" PRIu64 "\n"), rg_count); rgd = osi_list_entry(tmp, struct rgrp_list, list); if(gfs2_rgrp_read(sbp, rgd)){ stack; return FSCK_ERROR; } - log_debug("RG at %llu (0x%llx) is %u long\n", + log_debug( _("RG at %llu (0x%llx) is %u long\n"), (unsigned long long)rgd->ri.ri_addr, (unsigned long long)rgd->ri.ri_addr, rgd->ri.ri_length); @@ -900,7 +902,7 @@ int pass1(struct gfs2_sbd *sbp) return FSCK_OK; } if (skip_this_pass) { - printf("Skipping pass 1 is not a good idea.\n"); + printf( _("Skipping pass 1 is not a good idea.\n")); skip_this_pass = FALSE; fflush(stdout); } diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c index bcef089..ba3f860 100644 --- a/gfs2/fsck/pass1b.c +++ b/gfs2/fsck/pass1b.c @@ -2,6 +2,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -93,10 +95,9 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, } static int check_eattr_entry(struct gfs2_inode *ip, - struct gfs2_buffer_head *leaf_bh, - struct gfs2_ea_header *ea_hdr, - struct gfs2_ea_header *ea_hdr_prev, - void *private) + struct gfs2_buffer_head *leaf_bh, + struct gfs2_ea_header *ea_hdr, + struct gfs2_ea_header *ea_hdr_prev, void *private) { return 0; } @@ -138,9 +139,9 @@ static int find_dentry(struct gfs2_inode *ip, struct gfs2_dirent *de, if(id->block_no == de->de_inum.no_addr) { id->name = strdup(filename); id->parent = ip->i_di.di_num.no_addr; - log_debug("Duplicate block %llu (0x%llx" + log_debug( _("Duplicate block %llu (0x%llx" ") is in file or directory %llu" - " (0x%llx) named %s\n", + " (0x%llx) named %s\n"), (unsigned long long)id->block_no, (unsigned long long)id->block_no, (unsigned long long) @@ -170,12 +171,12 @@ static int clear_dup_metalist(struct gfs2_inode *ip, uint64_t block, if(dh->ref_count == 1) return 1; if(block == dh->b->block_no) { - log_err("Found dup in inode \"%s\" (block #%llu" - ") with block #%llu\n", - dh->id->name ? dh->id->name : "unknown name", + log_err( _("Found dup in inode \"%s\" (block #%llu" + ") with block #%llu\n"), + dh->id->name ? dh->id->name : _("unknown name"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block); - log_err("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n", + log_err( _("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n"), dh->id->name ? dh->id->name : "", dh->id->parent, dh->id->parent); inode_hash_remove(inode_hash, ip->i_di.di_num.no_addr); @@ -195,14 +196,14 @@ static int clear_dup_data(struct gfs2_inode *ip, uint64_t block, void *private) return 1; } if(block == dh->b->block_no) { - log_err("Found dup in inode \"%s\" for block #%llu" - " (0x%llx) at block #%llu (0x%llx)\n", - dh->id->name ? dh->id->name : "unknown name", + log_err( _("Found dup in inode \"%s\" for block #%llu" + " (0x%llx) at block #%llu (0x%llx)\n"), + dh->id->name ? dh->id->name : _("unknown name"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block, (unsigned long long)block); - log_err("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n", + log_err( _("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n"), dh->id->name ? dh->id->name : "", dh->id->parent, dh->id->parent); inode_hash_remove(inode_hash, ip->i_di.di_num.no_addr); @@ -227,14 +228,14 @@ static int clear_dup_eattr_indir(struct gfs2_inode *ip, uint64_t block, if(dh->ref_count == 1) return 1; if(block == dh->b->block_no) { - log_err("Found dup in inode \"%s\" with address #%llu" - " (0x%llx) with block #%llu (0x%llx)\n", - dh->id->name ? dh->id->name : "unknown name", + log_err( _("Found dup in inode \"%s\" with address #%llu" + " (0x%llx) with block #%llu (0x%llx)\n"), + dh->id->name ? dh->id->name : _("unknown name"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block, (unsigned long long)block); - log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n", + log_err( _("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n"), dh->id->name ? dh->id->name : "", dh->id->parent, dh->id->parent); gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr, @@ -254,14 +255,14 @@ static int clear_dup_eattr_leaf(struct gfs2_inode *ip, uint64_t block, if(dh->ref_count == 1) return 1; if(block == dh->b->block_no) { - log_err("Found dup in inode \"%s\" with address #%llu" - " (0x%llx) with block #%llu (0x%llx)\n", - dh->id->name ? dh->id->name : "unknown name", + log_err( _("Found dup in inode \"%s\" with address #%llu" + " (0x%llx) with block #%llu (0x%llx)\n"), + dh->id->name ? dh->id->name : _("unknown name"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block, (unsigned long long)block); - log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n", + log_err( _("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n"), dh->id->name ? dh->id->name : "", dh->id->parent, dh->id->parent); /* mark the main eattr block invalid */ @@ -307,7 +308,7 @@ static int clear_eattr_entry (struct gfs2_inode *ip, if(max_ptrs > ea_hdr->ea_num_ptrs) return 1; else { - log_debug(" Pointers Required: %d\n Pointers Reported: %d\n", + log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"), max_ptrs, ea_hdr->ea_num_ptrs); } } @@ -328,13 +329,13 @@ static int clear_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr, if(dh->ref_count == 1) return 1; if(block == dh->b->block_no) { - log_err("Found dup in inode \"%s\" with address #%llu" - " (0x%llx) with block #%llu (0x%llx)\n", - dh->id->name ? dh->id->name : "unknown name", + log_err( _("Found dup in inode \"%s\" with address #%llu" + " (0x%llx) with block #%llu (0x%llx)\n"), + dh->id->name ? dh->id->name : _("unknown name"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)block, (unsigned long long)block); - log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n", + log_err( _("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n"), dh->id->name ? dh->id->name : "", dh->id->parent, dh->id->parent); /* mark the main eattr block invalid */ @@ -366,15 +367,15 @@ int find_block_ref(struct gfs2_sbd *sbp, uint64_t inode, struct blocks *b) enum update_flags update; ip = fsck_load_inode(sbp, inode); /* bread, inode_get */ - log_info("Checking inode %" PRIu64 " (0x%" PRIx64 + log_info( _("Checking inode %" PRIu64 " (0x%" PRIx64 ")'s metatree for references to block %" PRIu64 " (0x%" PRIx64 - ")\n", inode, inode, b->block_no, b->block_no); + ")\n"), inode, inode, b->block_no, b->block_no); if(check_metatree(ip, &find_refs)) { stack; fsck_inode_put(ip, not_updated); /* out, brelse, free */ return -1; } - log_info("Done checking metatree\n"); + log_info( _("Done checking metatree\n")); /* Check for ea references in the inode */ if(check_inode_eattr(ip, &update, &find_refs) < 0){ stack; @@ -383,15 +384,15 @@ int find_block_ref(struct gfs2_sbd *sbp, uint64_t inode, struct blocks *b) } if (myfi.found) { if(!(id = malloc(sizeof(*id)))) { - log_crit("Unable to allocate inode_with_dups structure\n"); + log_crit( _("Unable to allocate inode_with_dups structure\n")); return -1; } if(!(memset(id, 0, sizeof(*id)))) { - log_crit("Unable to zero inode_with_dups structure\n"); + log_crit( _("Unable to zero inode_with_dups structure\n")); return -1; } - log_debug("Found %d entries with block %" PRIu64 - " (0x%" PRIx64 ") in inode #%" PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Found %d entries with block %" PRIu64 + " (0x%" PRIx64 ") in inode #%" PRIu64 " (0x%" PRIx64 ")\n"), myfi.found, b->block_no, b->block_no, inode, inode); id->dup_count = myfi.found; id->block_no = inode; @@ -426,19 +427,19 @@ int handle_dup_blk(struct gfs2_sbd *sbp, struct blocks *b) dh.ref_inode_count++; dh.ref_count += id->dup_count; } - log_notice("Block %llu (0x%llx) has %d inodes referencing it" - " for a total of %d duplicate references\n", + log_notice( _("Block %llu (0x%llx) has %d inodes referencing it" + " for a total of %d duplicate references\n"), (unsigned long long)b->block_no, (unsigned long long)b->block_no, dh.ref_inode_count, dh.ref_count); osi_list_foreach(tmp, &b->ref_inode_list) { id = osi_list_entry(tmp, struct inode_with_dups, list); - log_warn("Inode %s has %d reference(s) to block %"PRIu64 - " (0x%" PRIx64 ")\n", id->name, id->dup_count, b->block_no, + log_warn( _("Inode %s has %d reference(s) to block %"PRIu64 + " (0x%" PRIx64 ")\n"), id->name, id->dup_count, b->block_no, b->block_no); /* FIXME: User input */ - log_warn("Clearing...\n"); + log_warn( _("Clearing...\n")); ip = fsck_load_inode(sbp, id->block_no); dh.b = b; dh.id = id; @@ -475,24 +476,24 @@ int pass1b(struct gfs2_sbd *sbp) find_dirents.check_dentry = &find_dentry; int rc = FSCK_OK; - log_info("Looking for duplicate blocks...\n"); + log_info( _("Looking for duplicate blocks...\n")); /* If there were no dups in the bitmap, we don't need to do anymore */ if(osi_list_empty(&sbp->dup_blocks.list)) { - log_info("No duplicate blocks found\n"); + log_info( _("No duplicate blocks found\n")); return FSCK_OK; } /* Rescan the fs looking for pointers to blocks that are in * the duplicate block map */ - log_info("Scanning filesystem for inodes containing duplicate blocks...\n"); - log_debug("Filesystem has %"PRIu64" (0x%" PRIx64 ") blocks total\n", + log_info( _("Scanning filesystem for inodes containing duplicate blocks...\n")); + log_debug( _("Filesystem has %"PRIu64" (0x%" PRIx64 ") blocks total\n"), last_fs_block, last_fs_block); for(i = 0; i < last_fs_block; i += 1) { warm_fuzzy_stuff(i); if (skip_this_pass || fsck_abort) /* if asked to skip the rest */ goto out; - log_debug("Scanning block %" PRIu64 " (0x%" PRIx64 ") for inodes\n", + log_debug( _("Scanning block %" PRIu64 " (0x%" PRIx64 ") for inodes\n"), i, i); if(gfs2_block_check(sbp, bl, i, &q)) { stack; @@ -522,7 +523,7 @@ int pass1b(struct gfs2_sbd *sbp) /* Fix dups here - it's going to slow things down a lot to fix * it later */ - log_info("Handling duplicate blocks\n"); + log_info( _("Handling duplicate blocks\n")); out: while (!osi_list_empty(&sbp->dup_blocks.list)) { b = osi_list_entry(&sbp->dup_blocks.list.next, struct blocks, diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c index 9fd21db..d83ff94 100644 --- a/gfs2/fsck/pass1c.c +++ b/gfs2/fsck/pass1c.c @@ -2,6 +2,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -13,7 +15,7 @@ static int remove_eattr_entry(struct gfs2_sbd *sdp, struct gfs2_ea_header *curr, struct gfs2_ea_header *prev) { - log_warn("Removing EA located in block #%"PRIu64" (0x%" PRIx64 ").\n", + log_warn( _("Removing EA located in block #%"PRIu64" (0x%" PRIx64 ").\n"), leaf_bh->b_blocknr, leaf_bh->b_blocknr); if(!prev) curr->ea_type = GFS2_EATYPE_UNUSED; @@ -37,9 +39,9 @@ int check_eattr_indir(struct gfs2_inode *ip, uint64_t block, *update = not_updated; if(gfs2_check_range(sbp, block)) { - log_err("Extended attributes indirect block #%llu" + log_err( _("Extended attributes indirect block #%llu" " (0x%llx) for inode #%llu" - " (0x%llx) out of range...removing\n", + " (0x%llx) out of range...removing\n"), (unsigned long long)block, (unsigned long long)block, (unsigned long long)ip->i_di.di_num.no_addr, @@ -53,9 +55,9 @@ int check_eattr_indir(struct gfs2_inode *ip, uint64_t block, return -1; } else if(q.block_type != gfs2_indir_blk) { - log_err("Extended attributes indirect block #%llu" + log_err( _("Extended attributes indirect block #%llu" " (0x%llx) for inode #%llu" - " (0x%llx) invalid...removing\n", + " (0x%llx) invalid...removing\n"), (unsigned long long)block, (unsigned long long)block, (unsigned long long)ip->i_di.di_num.no_addr, @@ -80,8 +82,8 @@ int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, *update = not_updated; if(gfs2_check_range(sbp, block)) { - log_err("Extended attributes block for inode #%llu" - " (0x%llx) out of range...removing\n", + log_err( _("Extended attributes block for inode #%llu" + " (0x%llx) out of range...removing\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); ip->i_di.di_eattr = 0; @@ -93,8 +95,8 @@ int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, return -1; } else if(q.block_type != gfs2_meta_eattr) { - log_err("Extended attributes block for inode #%llu" - " (0x%llx) invalid...removing\n", + log_err( _("Extended attributes block for inode #%llu" + " (0x%llx) invalid...removing\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); ip->i_di.di_eattr = 0; @@ -120,7 +122,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, uint32_t max_size = sdp->sd_sb.sb_bsize; if(!ea_hdr->ea_name_len){ - log_err("EA has name length == 0\n"); + log_err( _("EA has name length == 0\n")); ea_hdr->ea_flags |= GFS2_EAFLAG_LAST; ea_hdr->ea_rec_len = cpu_to_be32(max_size - offset); if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ @@ -130,7 +132,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, return 1; } if(offset + be32_to_cpu(ea_hdr->ea_rec_len) > max_size){ - log_err("EA rec length too long\n"); + log_err( _("EA rec length too long\n")); ea_hdr->ea_flags |= GFS2_EAFLAG_LAST; ea_hdr->ea_rec_len = cpu_to_be32(max_size - offset); if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ @@ -141,7 +143,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, } if(offset + be32_to_cpu(ea_hdr->ea_rec_len) == max_size && (ea_hdr->ea_flags & GFS2_EAFLAG_LAST) == 0){ - log_err("last EA has no last entry flag\n"); + log_err( _("last EA has no last entry flag\n")); ea_hdr->ea_flags |= GFS2_EAFLAG_LAST; if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ stack; @@ -150,7 +152,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, return 1; } if(!ea_hdr->ea_name_len){ - log_err("EA has name length == 0\n"); + log_err( _("EA has name length == 0\n")); if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ stack; return -1; @@ -164,7 +166,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, if(!GFS2_EATYPE_VALID(ea_hdr->ea_type) && ((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){ - log_err("EA (%s) type is invalid (%d > %d).\n", + log_err( _("EA (%s) type is invalid (%d > %d).\n"), ea_name, ea_hdr->ea_type, GFS2_EATYPE_LAST); if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ stack; @@ -181,9 +183,9 @@ static int check_eattr_entry(struct gfs2_inode *ip, max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len)+avail_size-1)/avail_size; if(max_ptrs > ea_hdr->ea_num_ptrs){ - log_err("EA (%s) has incorrect number of pointers.\n", ea_name); - log_err(" Required: %d\n" - " Reported: %d\n", + log_err( _("EA (%s) has incorrect number of pointers.\n"), ea_name); + log_err( _(" Required: %d\n" + " Reported: %d\n"), max_ptrs, ea_hdr->ea_num_ptrs); if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){ stack; @@ -191,7 +193,7 @@ static int check_eattr_entry(struct gfs2_inode *ip, } return 1; } else { - log_debug(" Pointers Required: %d\n Pointers Reported: %d\n", + log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"), max_ptrs, ea_hdr->ea_num_ptrs); } } @@ -241,7 +243,7 @@ int pass1c(struct gfs2_sbd *sbp) pass1c_fxns.check_eattr_extentry = &check_eattr_extentry; pass1c_fxns.private = NULL; - log_info("Looking for inodes containing ea blocks...\n"); + log_info( _("Looking for inodes containing ea blocks...\n")); osi_list_foreach_safe(tmp, &sbp->eattr_blocks.list, x) { ea_block = osi_list_entry(tmp, struct special_blocks, list); block_no = ea_block->block; @@ -250,12 +252,12 @@ int pass1c(struct gfs2_sbd *sbp) return FSCK_OK; bh = bread(&sbp->buf_list, block_no); if (gfs2_check_meta(bh, GFS2_METATYPE_IN)) { /* if a dinode */ - log_info("EA in inode %"PRIu64" (0x%" PRIx64 ")\n", + log_info( _("EA in inode %"PRIu64" (0x%" PRIx64 ")\n"), block_no, block_no); gfs2_block_clear(sbp, bl, block_no, gfs2_eattr_block); ip = fsck_inode_get(sbp, bh); - log_debug("Found eattr at %llu (0x%llx)\n", + log_debug( _("Found eattr at %llu (0x%llx)\n"), (unsigned long long)ip->i_di.di_eattr, (unsigned long long)ip->i_di.di_eattr); /* FIXME: Handle walking the eattr here */ diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c index 6047408..290ebf3 100644 --- a/gfs2/fsck/pass2.c +++ b/gfs2/fsck/pass2.c @@ -4,6 +4,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -24,9 +26,9 @@ int set_parent_dir(struct gfs2_sbd *sbp, uint64_t childblock, if(!find_di(sbp, childblock, &di)) { if(di->dinode == childblock) { if (di->treewalk_parent) { - log_err("Another directory at block %" PRIu64 + log_err( _("Another directory at block %" PRIu64 " (0x%" PRIx64 ") already contains" - " this child - checking %" PRIu64 " (0x%" PRIx64 ")\n", + " this child - checking %" PRIu64 " (0x%" PRIx64 ")\n"), di->treewalk_parent, di->treewalk_parent, parentblock, parentblock); return 1; @@ -34,8 +36,8 @@ int set_parent_dir(struct gfs2_sbd *sbp, uint64_t childblock, di->treewalk_parent = parentblock; } } else { - log_err("Unable to find block %"PRIu64" (0x%" PRIx64 - ") in dir_info list\n", childblock, childblock); + log_err( _("Unable to find block %"PRIu64" (0x%" PRIx64 + ") in dir_info list\n"), childblock, childblock); return -1; } @@ -55,17 +57,17 @@ int set_dotdot_dir(struct gfs2_sbd *sbp, uint64_t childblock, if(di->dotdot_parent && sbp->md.rooti->i_di.di_num.no_addr != di->dinode) { /* This should never happen */ - log_crit("Dotdot parent already set for" + log_crit( _("Dotdot parent already set for" " block %"PRIu64" (0x%" PRIx64 ") -> %" PRIu64 - " (0x%" PRIx64 ")\n", childblock, childblock, + " (0x%" PRIx64 ")\n"), childblock, childblock, di->dotdot_parent, di->dotdot_parent); return -1; } di->dotdot_parent = parentblock; } } else { - log_err("Unable to find block %"PRIu64" (0x%" PRIx64 - ") in dir_info list\n", childblock, childblock); + log_err( _("Unable to find block %"PRIu64" (0x%" PRIx64 + ") in dir_info list\n"), childblock, childblock); return -1; } @@ -133,7 +135,7 @@ static int check_file_type(uint8_t de_type, uint8_t block_type) return 1; break; default: - log_err("Invalid block type\n"); + log_err( _("Invalid block type\n")); return -1; break; } @@ -172,9 +174,9 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, /* Start of checks */ if (de->de_rec_len < GFS2_DIRENT_SIZE(de->de_name_len)){ - log_err("Dir entry with bad record or name length\n" + log_err( _("Dir entry with bad record or name length\n" "\tRecord length = %u\n" - "\tName length = %u\n", + "\tName length = %u\n"), de->de_rec_len, de->de_name_len); gfs2_block_set(sbp, bl, ip->i_di.di_num.no_addr, @@ -186,23 +188,23 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, calculated_hash = gfs2_disk_hash(filename, de->de_name_len); if (de->de_hash != calculated_hash){ - log_err("Dir entry with bad hash or name length\n" + log_err( _("Dir entry with bad hash or name length\n" "\tHash found = %u (0x%x)\n" - "\tFilename = %s\n", de->de_hash, de->de_hash, + "\tFilename = %s\n"), de->de_hash, de->de_hash, filename); - log_err("\tName length found = %u\n" - "\tHash expected = %u (0x%x)\n", + log_err( _("\tName length found = %u\n" + "\tHash expected = %u (0x%x)\n"), de->de_name_len, calculated_hash, calculated_hash); errors_found++; - if(query(&opts, "Fix directory hash for %s? (y/n) ", + if(query(&opts, _("Fix directory hash for %s? (y/n) "), filename)) { errors_corrected++; de->de_hash = calculated_hash; gfs2_dirent_out(de, (char *)dent); - log_err("Directory entry hash for %s fixed.\n", filename); + log_err( _("Directory entry hash for %s fixed.\n"), filename); } else { - log_err("Directory entry hash for %s not fixed.\n", filename); + log_err( _("Directory entry hash for %s not fixed.\n"), filename); return 1; } } @@ -215,18 +217,18 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, strncpy(tmp_name, filename, MAX_FILENAME - 1); if(gfs2_check_range(ip->i_sbd, entryblock)) { - log_err("Block # referenced by directory entry %s is out of range\n", + log_err( _("Block # referenced by directory entry %s is out of range\n"), tmp_name); errors_found++; if(query(&opts, - "Clear directory entry tp out of range block? (y/n) ")) { + _("Clear directory entry tp out of range block? (y/n) "))) { errors_corrected++; - log_err("Clearing %s\n", tmp_name); + log_err( _("Clearing %s\n"), tmp_name); dirent2_del(ip, bh, prev_de, dent); *update = updated; return 1; } else { - log_err("Directory entry to out of range block remains\n"); + log_err( _("Directory entry to out of range block remains\n")); (*count)++; ds->entry_count++; return 0; @@ -243,10 +245,10 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, /* FIXME: user interface */ /* FIXME: do i want to kill the inode here? */ /* Handle bad blocks */ - log_err("Found a bad directory entry: %s\n", filename); + log_err( _("Found a bad directory entry: %s\n"), filename); errors_found++; - if(query(&opts, "Clear entry to inode containing bad blocks? (y/n)")) { + if(query(&opts, _("Clear entry to inode containing bad blocks? (y/n)"))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); @@ -263,7 +265,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, *update = updated; return 1; } else { - log_warn("Entry to inode containing bad blocks remains\n"); + log_warn( _("Entry to inode containing bad blocks remains\n")); (*count)++; ds->entry_count++; return 0; @@ -274,9 +276,9 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, q.block_type != gfs2_inode_lnk && q.block_type != gfs2_inode_blk && q.block_type != gfs2_inode_chr && q.block_type != gfs2_inode_fifo && q.block_type != gfs2_inode_sock) { - log_err("Directory entry '%s' at block %llu (0x%llx" + log_err( _("Directory entry '%s' at block %llu (0x%llx" ") in dir inode %llu (0x%llx" - ") has an invalid block type: %d.\n", tmp_name, + ") has an invalid block type: %d.\n"), tmp_name, (unsigned long long)de->de_inum.no_addr, (unsigned long long)de->de_inum.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, @@ -284,16 +286,16 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, q.block_type); errors_found++; - if(query(&opts, "Clear directory entry to non-inode block? (y/n) ")) { + if(query(&opts, _("Clear directory entry to non-inode block? (y/n) "))) { /* FIXME: make sure all blocks referenced by * this inode are cleared in the bitmap */ errors_corrected++; dirent2_del(ip, bh, prev_de, dent); *update = updated; - log_warn("Directory entry '%s' cleared\n", tmp_name); + log_warn( _("Directory entry '%s' cleared\n"), tmp_name); return 1; } else { - log_err("Directory entry to non-inode block remains\n"); + log_err( _("Directory entry to non-inode block remains\n")); (*count)++; ds->entry_count++; return 0; @@ -306,14 +308,14 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, return -1; } if(error > 0) { - log_warn("Type '%s' in dir entry (%s, %llu/0x%llx) conflicts" - " with type '%s' in dinode. (Dir entry is stale.)\n", + log_warn( _("Type '%s' in dir entry (%s, %llu/0x%llx) conflicts" + " with type '%s' in dinode. (Dir entry is stale.)\n"), de_type_string(de->de_type), tmp_name, (unsigned long long)de->de_inum.no_addr, (unsigned long long)de->de_inum.no_addr, block_type_string(&q)); errors_found++; - if(query(&opts, "Clear stale directory entry? (y/n) ")) { + if(query(&opts, _("Clear stale directory entry? (y/n) "))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); check_inode_eattr(entry_ip, update, &clear_eattrs); @@ -323,7 +325,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, *update = updated; return 1; } else { - log_err("Stale directory entry remains\n"); + log_err( _("Stale directory entry remains\n")); (*count)++; ds->entry_count++; return 0; @@ -331,15 +333,15 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, } if(!strcmp(".", tmp_name)) { - log_debug("Found . dentry\n"); + log_debug( _("Found . dentry\n")); if(ds->dotdir) { - log_err("Already found '.' entry in directory %llu" - " (0x%llx)\n", + log_err( _("Already found '.' entry in directory %llu" + " (0x%llx)\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; - if(query(&opts, "Clear duplicate '.' entry? (y/n) ")) { + if(query(&opts, _("Clear duplicate '.' entry? (y/n) "))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); @@ -351,7 +353,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, *update = updated; return 1; } else { - log_err("Duplicate '.' entry remains\n"); + log_err( _("Duplicate '.' entry remains\n")); /* FIXME: Should we continue on here * and check the rest of the '.' * entry? */ @@ -367,10 +369,10 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, /* check that '.' refers to this inode */ if(de->de_inum.no_addr != ip->i_di.di_num.no_addr) { - log_err("'.' entry's value incorrect in directory %llu" + log_err( _("'.' entry's value incorrect in directory %llu" " (0x%llx). Points to %llu" " (0x%llx) when it should point to %llu" - " (0x%llx).\n", + " (0x%llx).\n"), (unsigned long long)de->de_inum.no_addr, (unsigned long long)de->de_inum.no_addr, (unsigned long long)de->de_inum.no_addr, @@ -378,7 +380,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; - if(query(&opts, "Remove '.' reference? (y/n) ")) { + if(query(&opts, _("Remove '.' reference? (y/n) "))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); check_inode_eattr(entry_ip, update, @@ -390,7 +392,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, return 1; } else { - log_err("Invalid '.' reference remains\n"); + log_err( _("Invalid '.' reference remains\n")); /* Not setting ds->dotdir here since * this '.' entry is invalid */ increment_link(sbp, de->de_inum.no_addr); @@ -408,14 +410,14 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, return 0; } if(!strcmp("..", tmp_name)) { - log_debug("Found .. dentry\n"); + log_debug( _("Found .. dentry\n")); if(ds->dotdotdir) { - log_err("Already found '..' entry in directory %llu" - "(0x%llx)\n", + log_err( _("Already found '..' entry in directory %llu" + "(0x%llx)\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; - if(query(&opts, "Clear duplicate '..' entry? (y/n) ")) { + if(query(&opts, _("Clear duplicate '..' entry? (y/n) "))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); @@ -427,7 +429,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, *update = 1; return 1; } else { - log_err("Duplicate '..' entry remains\n"); + log_err( _("Duplicate '..' entry remains\n")); /* FIXME: Should we continue on here * and check the rest of the '..' * entry? */ @@ -439,12 +441,12 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, } if(q.block_type != gfs2_inode_dir) { - log_err("Found '..' entry in directory %llu (0x%llx) " - "pointing to something that's not a directory", + log_err( _("Found '..' entry in directory %llu (0x%llx) " + "pointing to something that's not a directory"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); errors_found++; - if(query(&opts, "Clear bad '..' directory entry? (y/n) ")) { + if(query(&opts, _("Clear bad '..' directory entry? (y/n) "))) { errors_corrected++; entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr); check_inode_eattr(entry_ip, update, @@ -455,7 +457,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, *update = 1; return 1; } else { - log_err("Bad '..' directory entry remains\n"); + log_err( _("Bad '..' directory entry remains\n")); increment_link(sbp, de->de_inum.no_addr); (*count)++; ds->entry_count++; @@ -484,7 +486,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, /* After this point we're only concerned with * directories */ if(q.block_type != gfs2_inode_dir) { - log_debug("Found non-dir inode dentry\n"); + log_debug( _("Found non-dir inode dentry\n")); increment_link(sbp, de->de_inum.no_addr); *update = (opts.no ? not_updated : updated); (*count)++; @@ -492,23 +494,23 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, return 0; } - log_debug("Found plain directory dentry\n"); + log_debug( _("Found plain directory dentry\n")); error = set_parent_dir(sbp, entryblock, ip->i_di.di_num.no_addr); if(error > 0) { - log_err("%s: Hard link to block %" PRIu64" (0x%" PRIx64 - ") detected.\n", filename, entryblock, entryblock); + log_err( _("%s: Hard link to block %" PRIu64" (0x%" PRIx64 + ") detected.\n"), filename, entryblock, entryblock); errors_found++; - if(query(&opts, "Clear hard link to directory? (y/n) ")) { + if(query(&opts, _("Clear hard link to directory? (y/n) "))) { errors_corrected++; *update = 1; dirent2_del(ip, bh, prev_de, dent); - log_warn("Directory entry %s cleared\n", filename); + log_warn( _("Directory entry %s cleared\n"), filename); return 1; } else { - log_err("Hard link to directory remains\n"); + log_err( _("Hard link to directory remains\n")); (*count)++; ds->entry_count++; return 0; @@ -552,7 +554,7 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, enum update_flags update = not_updated; int error = 0; - log_info("Checking system directory inode '%s'\n", dirname); + log_info( _("Checking system directory inode '%s'\n"), dirname); if (sysinode) { iblock = sysinode->i_di.di_num.no_addr; @@ -582,21 +584,21 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, return -1; } if(!ds.dotdir) { - log_err("No '.' entry found for %s directory.\n", dirname); + log_err( _("No '.' entry found for %s directory.\n"), dirname); sprintf(tmp_name, "."); filename_len = strlen(tmp_name); /* no trailing NULL */ if(!(filename = malloc(sizeof(char) * filename_len))) { - log_err("Unable to allocate name string\n"); + log_err( _("Unable to allocate name string\n")); stack; return -1; } if(!(memset(filename, 0, sizeof(char) * filename_len))) { - log_err("Unable to zero name string\n"); + log_err( _("Unable to zero name string\n")); stack; return -1; } memcpy(filename, tmp_name, filename_len); - log_warn("Adding '.' entry\n"); + log_warn( _("Adding '.' entry\n")); dir_add(sysinode, filename, filename_len, &(sysinode->i_di.di_num), DT_DIR); increment_link(sysinode->i_sbd, @@ -606,23 +608,23 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, update = 1; } if(sysinode->i_di.di_entries != ds.entry_count) { - log_err("%s inode %llu (0x%llx" - "): Entries is %d - should be %d\n", dirname, + log_err( _("%s inode %llu (0x%llx" + "): Entries is %d - should be %d\n"), dirname, (unsigned long long)sysinode->i_di.di_num.no_addr, (unsigned long long)sysinode->i_di.di_num.no_addr, sysinode->i_di.di_entries, ds.entry_count); errors_found++; - if(query(&opts, "Fix entries for %s inode %llu (0x%llx" - ")? (y/n) ", dirname, + if(query(&opts, _("Fix entries for %s inode %llu (0x%llx" + ")? (y/n) "), dirname, (unsigned long long)sysinode->i_di.di_num.no_addr, (unsigned long long)sysinode->i_di.di_num.no_addr)) { errors_corrected++; sysinode->i_di.di_entries = ds.entry_count; - log_warn("Entries updated\n"); + log_warn( _("Entries updated\n")); update = 1; } else { - log_err("Entries for inode %llu (0x%llx" - ") left out of sync\n", + log_err( _("Entries for inode %llu (0x%llx" + ") left out of sync\n"), (unsigned long long) sysinode->i_di.di_num.no_addr, (unsigned long long) @@ -687,7 +689,7 @@ int pass2(struct gfs2_sbd *sbp) stack; return FSCK_ERROR; } - log_info("Checking directory inodes.\n"); + log_info( _("Checking directory inodes.\n")); /* Grab each directory inode, and run checks on it */ for(i = 0; i < last_fs_block; i++) { warm_fuzzy_stuff(i); @@ -699,16 +701,16 @@ int pass2(struct gfs2_sbd *sbp) continue; if(gfs2_block_check(sbp, bl, i, &q)) { - log_err("Can't get block %"PRIu64 " (0x%" PRIx64 - ") from block list\n", i, i); + log_err( _("Can't get block %"PRIu64 " (0x%" PRIx64 + ") from block list\n"), i, i); return FSCK_ERROR; } if(q.block_type != gfs2_inode_dir) continue; - log_debug("Checking directory inode at block %"PRIu64" (0x%" - PRIx64 ")\n", i, i); + log_debug( _("Checking directory inode at block %"PRIu64" (0x%" + PRIx64 ")\n"), i, i); memset(&ds, 0, sizeof(ds)); pass2_fxns.private = (void *) &ds; @@ -738,9 +740,9 @@ int pass2(struct gfs2_sbd *sbp) if(error == 0) { /* FIXME: factor */ errors_found++; - if(query(&opts, "Remove directory entry for bad" + if(query(&opts, _("Remove directory entry for bad" " inode %"PRIu64" (0x%" PRIx64 ") in %"PRIu64 - " (0x%" PRIx64 ")? (y/n)", i, i, di->treewalk_parent, + " (0x%" PRIx64 ")? (y/n)"), i, i, di->treewalk_parent, di->treewalk_parent)) { errors_corrected++; error = remove_dentry_from_dir(sbp, di->treewalk_parent, @@ -750,30 +752,30 @@ int pass2(struct gfs2_sbd *sbp) return FSCK_ERROR; } if(error > 0) { - log_warn("Unable to find dentry for %" + log_warn( _("Unable to find dentry for %" PRIu64 " (0x%" PRIx64 ") in %" PRIu64 - " (0x%" PRIx64 ")\n", i, i, + " (0x%" PRIx64 ")\n"), i, i, di->treewalk_parent, di->treewalk_parent); } - log_warn("Directory entry removed\n"); + log_warn( _("Directory entry removed\n")); } else - log_err("Directory entry to invalid inode remains.\n"); + log_err( _("Directory entry to invalid inode remains.\n")); } gfs2_block_set(sbp, bl, i, gfs2_meta_inval); } bh = bread(&sbp->buf_list, i); ip = fsck_inode_get(sbp, bh); if(!ds.dotdir) { - log_err("No '.' entry found\n"); + log_err( _("No '.' entry found\n")); sprintf(tmp_name, "."); filename_len = strlen(tmp_name); /* no trailing NULL */ if(!(filename = malloc(sizeof(char) * filename_len))) { - log_err("Unable to allocate name string\n"); + log_err( _("Unable to allocate name string\n")); stack; return FSCK_ERROR; } if(!memset(filename, 0, sizeof(char) * filename_len)) { - log_err("Unable to zero name string\n"); + log_err( _("Unable to zero name string\n")); stack; return FSCK_ERROR; } @@ -790,8 +792,8 @@ int pass2(struct gfs2_sbd *sbp) bh = bread(&sbp->buf_list, i); ip = fsck_inode_get(sbp, bh); if(ip->i_di.di_entries != ds.entry_count) { - log_err("Entries is %d - should be %d for inode " - "block %llu (0x%llx)\n", + log_err( _("Entries is %d - should be %d for inode " + "block %llu (0x%llx)\n"), ip->i_di.di_entries, ds.entry_count, (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c index a5c0202..e618e87 100644 --- a/gfs2/fsck/pass3.c +++ b/gfs2/fsck/pass3.c @@ -3,6 +3,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "osi_list.h" @@ -12,7 +14,7 @@ #include "metawalk.h" static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot, - uint64_t olddotdot, uint64_t block) + uint64_t olddotdot, uint64_t block) { char *filename; int filename_len; @@ -29,14 +31,14 @@ static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot, filename_len = strlen(".."); if(!(filename = malloc((sizeof(char) * filename_len) + 1))) { - log_err("Unable to allocate name\n"); + log_err( _("Unable to allocate name\n")); fsck_inode_put(ip, not_updated); fsck_inode_put(pip, not_updated); stack; return -1; } if(!memset(filename, 0, (sizeof(char) * filename_len) + 1)) { - log_err("Unable to zero name\n"); + log_err( _("Unable to zero name\n")); fsck_inode_put(ip, not_updated); fsck_inode_put(pip, not_updated); stack; @@ -44,7 +46,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot, } memcpy(filename, "..", filename_len); if(gfs2_dirent_del(ip, NULL, filename, filename_len)) - log_warn("Unable to remove \"..\" directory entry.\n"); + log_warn( _("Unable to remove \"..\" directory entry.\n")); else decrement_link(sbp, olddotdot); dir_add(ip, filename, filename_len, &pip->i_di.di_num, DT_DIR); @@ -66,22 +68,22 @@ struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp, return NULL; if(di->dotdot_parent != di->treewalk_parent) { - log_warn("Directory '..' and treewalk connections disagree for inode %" - PRIu64 " (0x%" PRIx64 ")\n", di->dinode, di->dinode); - log_notice("'..' has %" PRIu64" (0x%" PRIx64 "), treewalk has %" - PRIu64" (0x%" PRIx64 ")\n", di->dotdot_parent, + log_warn( _("Directory '..' and treewalk connections disagree for inode %" + PRIu64 " (0x%" PRIx64 ")\n"), di->dinode, di->dinode); + log_notice( _("'..' has %" PRIu64" (0x%" PRIx64 "), treewalk has %" + PRIu64" (0x%" PRIx64 ")\n"), di->dotdot_parent, di->dotdot_parent, di->treewalk_parent, di->treewalk_parent); if(gfs2_block_check(sbp, bl, di->dotdot_parent, &q_dotdot)) { - log_err("Unable to find block %"PRIu64 - " (0x%" PRIx64 ") in block map.\n", + log_err( _("Unable to find block %"PRIu64 + " (0x%" PRIx64 ") in block map.\n"), di->dotdot_parent, di->dotdot_parent); return NULL; } if(gfs2_block_check(sbp, bl, di->treewalk_parent, &q_treewalk)) { - log_err("Unable to find block %"PRIu64 - " (0x%" PRIx64 ") in block map\n", + log_err( _("Unable to find block %"PRIu64 + " (0x%" PRIx64 ") in block map\n"), di->treewalk_parent, di->treewalk_parent); return NULL; } @@ -94,12 +96,12 @@ struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp, */ if(q_dotdot.block_type != gfs2_inode_dir) { if(q_treewalk.block_type != gfs2_inode_dir) { - log_err( "Orphaned directory, move to lost+found\n"); + log_err( _("Orphaned directory, move to lost+found\n")); return NULL; } else { - log_warn("Treewalk parent is correct," - " fixing dotdot -> %"PRIu64" (0x%" PRIx64 ")\n", + log_warn( _("Treewalk parent is correct," + " fixing dotdot -> %"PRIu64" (0x%" PRIx64 ")\n"), di->treewalk_parent, di->treewalk_parent); attach_dotdot_to(sbp, di->treewalk_parent, di->dotdot_parent, di->dinode); @@ -109,15 +111,15 @@ struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp, else { if(q_treewalk.block_type != gfs2_inode_dir) { int error = 0; - log_warn(".. parent is valid, but treewalk" - "is bad - reattaching to lost+found"); + log_warn( _(".. parent is valid, but treewalk" + "is bad - reattaching to lost+found")); /* FIXME: add a dinode for this entry instead? */ errors_found++; - if(query(&opts, "Remove directory entry for bad" + if(query(&opts, _("Remove directory entry for bad" " inode %"PRIu64" (0x%" PRIx64 ") in %"PRIu64 - " (0x%" PRIx64 ")? (y/n)", di->dinode, di->dinode, + " (0x%" PRIx64 ")? (y/n)"), di->dinode, di->dinode, di->treewalk_parent, di->treewalk_parent)) { errors_corrected++; error = remove_dentry_from_dir(sbp, di->treewalk_parent, @@ -127,23 +129,23 @@ struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp, return NULL; } if(error > 0) { - log_warn("Unable to find dentry for block %" + log_warn( _("Unable to find dentry for block %" PRIu64" (0x%" PRIx64 ") in %" PRIu64 " (0x%" - PRIx64 ")\n",di->dinode, di->dinode, + PRIx64 ")\n"),di->dinode, di->dinode, di->treewalk_parent, di->treewalk_parent); } - log_warn("Directory entry removed\n"); + log_warn( _("Directory entry removed\n")); } else { - log_err("Directory entry to invalid inode remains\n"); + log_err( _("Directory entry to invalid inode remains\n")); } - log_info("Marking directory unlinked\n"); + log_info( _("Marking directory unlinked\n")); return NULL; } else { - log_err("Both .. and treewalk parents are " + log_err( _("Both .. and treewalk parents are " "directories, going with treewalk for " - "now...\n"); + "now...\n")); attach_dotdot_to(sbp, di->treewalk_parent, di->dotdot_parent, di->dinode); di->dotdot_parent = di->treewalk_parent; @@ -152,14 +154,14 @@ struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp, } else { if(gfs2_block_check(sbp, bl, di->dotdot_parent, &q_dotdot)) { - log_err("Unable to find parent block %"PRIu64 - " (0x%" PRIx64 ") in block map\n", + log_err( _("Unable to find parent block %"PRIu64 + " (0x%" PRIx64 ") in block map\n"), di->dotdot_parent, di->dotdot_parent); return NULL; } if(q_dotdot.block_type != gfs2_inode_dir) { - log_err("Orphaned directory at block %" PRIu64 " (0x%" PRIx64 - ") moved to lost+found\n", di->dinode, di->dinode); + log_err( _("Orphaned directory at block %" PRIu64 " (0x%" PRIx64 + ") moved to lost+found\n"), di->dinode, di->dinode); return NULL; } } @@ -184,12 +186,12 @@ int pass3(struct gfs2_sbd *sbp) find_di(sbp, sbp->md.rooti->i_di.di_num.no_addr, &di); if(di) { - log_info("Marking root inode connected\n"); + log_info( _("Marking root inode connected\n")); di->checked = 1; } find_di(sbp, sbp->master_dir->i_di.di_num.no_addr, &di); if(di) { - log_info("Marking master directory inode connected\n"); + log_info( _("Marking master directory inode connected\n")); di->checked = 1; } @@ -197,7 +199,7 @@ int pass3(struct gfs2_sbd *sbp) * until we find one that's been checked already. If we don't * find a parent, put in lost+found. */ - log_info("Checking directory linkage.\n"); + log_info( _("Checking directory linkage.\n")); for(i = 0; i < FSCK_HASH_SIZE; i++) { osi_list_foreach(tmp, &dir_hash[i]) { di = osi_list_entry(tmp, struct dir_info, list); @@ -216,17 +218,17 @@ int pass3(struct gfs2_sbd *sbp) return FSCK_ERROR; } if(q.bad_block) { - log_err("Found unlinked directory containing bad block\n"); + log_err( _("Found unlinked directory containing bad block\n")); errors_found++; if(query(&opts, - "Clear unlinked directory with bad blocks? (y/n) ")) { + _("Clear unlinked directory with bad blocks? (y/n) "))) { errors_corrected++; gfs2_block_set(sbp, bl, di->dinode, gfs2_block_free); break; } else - log_err("Unlinked directory with bad block remains\n"); + log_err( _("Unlinked directory with bad block remains\n")); } if(q.block_type != gfs2_inode_dir && q.block_type != gfs2_inode_file && @@ -235,22 +237,22 @@ int pass3(struct gfs2_sbd *sbp) q.block_type != gfs2_inode_chr && q.block_type != gfs2_inode_fifo && q.block_type != gfs2_inode_sock) { - log_err("Unlinked block marked as inode not an inode\n"); + log_err( _("Unlinked block marked as inode not an inode\n")); gfs2_block_set(sbp, bl, di->dinode, gfs2_block_free); - log_err("Cleared\n"); + log_err( _("Cleared\n")); break; } - log_err("Found unlinked directory at block %" PRIu64 - " (0x%" PRIx64 ")\n", di->dinode, di->dinode); + log_err( _("Found unlinked directory at block %" PRIu64 + " (0x%" PRIx64 ")\n"), di->dinode, di->dinode); ip = fsck_load_inode(sbp, di->dinode); /* Don't skip zero size directories * with eattrs */ if(!ip->i_di.di_size && !ip->i_di.di_eattr){ - log_err("Unlinked directory has zero size.\n"); + log_err( _("Unlinked directory has zero size.\n")); errors_found++; - if(query(&opts, "Remove zero-size unlinked directory? (y/n) ")) { + if(query(&opts, _("Remove zero-size unlinked directory? (y/n) "))) { errors_corrected++; gfs2_block_set(sbp, bl, di->dinode, @@ -258,34 +260,34 @@ int pass3(struct gfs2_sbd *sbp) fsck_inode_put(ip, not_updated); break; } else { - log_err("Zero-size unlinked directory remains\n"); + log_err( _("Zero-size unlinked directory remains\n")); } } errors_found++; - if(query(&opts, "Add unlinked directory to lost+found? (y/n) ")) { + if(query(&opts, _("Add unlinked directory to lost+found? (y/n) "))) { errors_corrected++; if(add_inode_to_lf(ip)) { fsck_inode_put(ip, not_updated); stack; return FSCK_ERROR; } - log_warn("Directory relinked to lost+found\n"); + log_warn( _("Directory relinked to lost+found\n")); } else { - log_err("Unlinked directory remains unlinked\n"); + log_err( _("Unlinked directory remains unlinked\n")); } fsck_inode_put(ip, not_updated); break; } else { - log_debug("Directory at block %" PRIu64 " (0x%" - PRIx64 ") connected\n", di->dinode, di->dinode); + log_debug( _("Directory at block %" PRIu64 " (0x%" + PRIx64 ") connected\n"), di->dinode, di->dinode); } di = tdi; } } } if(lf_dip) - log_debug("At end of pass3, lost+found entries is %u\n", + log_debug( _("At end of pass3, lost+found entries is %u\n"), lf_dip->i_di.di_entries); return FSCK_OK; } diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c index 38cff40..f5a5c68 100644 --- a/gfs2/fsck/pass4.c +++ b/gfs2/fsck/pass4.c @@ -1,6 +1,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -12,14 +14,14 @@ int fix_inode_count(struct gfs2_sbd *sbp, struct inode_info *ii, struct gfs2_inode *ip) { - log_info("Fixing inode count for %llu (0x%llx) \n", + log_info( _("Fixing inode count for %llu (0x%llx) \n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr); if(ip->i_di.di_nlink == ii->counted_links) return 0; ip->i_di.di_nlink = ii->counted_links; - log_debug("Changing inode %llu (0x%llx) to have %u links\n", + log_debug( _("Changing inode %llu (0x%llx) to have %u links\n"), (unsigned long long)ip->i_di.di_num.no_addr, (unsigned long long)ip->i_di.di_num.no_addr, ii->counted_links); @@ -41,32 +43,32 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) { return 0; f = not_updated; if(!(ii = osi_list_entry(tmp, struct inode_info, list))) { - log_crit("osi_list_foreach broken in scan_info_list!!\n"); + log_crit( _("osi_list_foreach broken in scan_info_list!!\n")); exit(FSCK_ERROR); } - log_debug("Checking reference count on inode at block %" PRIu64 - " (0x%" PRIx64 ")\n", ii->inode, ii->inode); + log_debug( _("Checking reference count on inode at block %" PRIu64 + " (0x%" PRIx64 ")\n"), ii->inode, ii->inode); if(ii->counted_links == 0) { - log_err("Found unlinked inode at %" PRIu64 " (0x%" PRIx64 ")\n", + log_err( _("Found unlinked inode at %" PRIu64 " (0x%" PRIx64 ")\n"), ii->inode, ii->inode); if(gfs2_block_check(sbp, bl, ii->inode, &q)) { stack; return -1; } if(q.bad_block) { - log_err("Unlinked inode %llu (0x%llx) contains" - "bad blocks\n", + log_err( _("Unlinked inode %llu (0x%llx) contains" + "bad blocks\n"), (unsigned long long)ii->inode, (unsigned long long)ii->inode); errors_found++; if(query(&opts, - "Clear unlinked inode with bad blocks? (y/n) ")) { + _("Clear unlinked inode with bad blocks? (y/n) "))) { errors_corrected++; gfs2_block_set(sbp, bl, ii->inode, gfs2_block_free); continue; } else - log_err("Unlinked inode with bad blocks not cleared\n"); + log_err( _("Unlinked inode with bad blocks not cleared\n")); } if(q.block_type != gfs2_inode_dir && q.block_type != gfs2_inode_file && @@ -75,10 +77,10 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) { q.block_type != gfs2_inode_chr && q.block_type != gfs2_inode_fifo && q.block_type != gfs2_inode_sock) { - log_err("Unlinked block marked as inode not an inode\n"); + log_err( _("Unlinked block marked as inode not an inode\n")); gfs2_block_set(sbp, bl, ii->inode, gfs2_block_free); - log_err("Cleared\n"); + log_err( _("Cleared\n")); continue; } ip = fsck_load_inode(sbp, ii->inode); @@ -87,9 +89,9 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) { * eattrs - there might be relevent info in * them. */ if(!ip->i_di.di_size && !ip->i_di.di_eattr){ - log_err("Unlinked inode has zero size\n"); + log_err( _("Unlinked inode has zero size\n")); errors_found++; - if(query(&opts, "Clear zero-size unlinked inode? (y/n) ")) { + if(query(&opts, _("Clear zero-size unlinked inode? (y/n) "))) { errors_corrected++; gfs2_block_set(sbp, bl, ii->inode, gfs2_block_free); @@ -99,7 +101,7 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) { } errors_found++; - if(query(&opts, "Add unlinked inode to lost+found? (y/n)")) { + if(query(&opts, _("Add unlinked inode to lost+found? (y/n)"))) { errors_corrected++; f = updated; if(add_inode_to_lf(ip)) { @@ -112,37 +114,37 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) { lf_addition = 1; } } else - log_err("Unlinked inode left unlinked\n"); + log_err( _("Unlinked inode left unlinked\n")); fsck_inode_put(ip, f); } /* if(ii->counted_links == 0) */ else if(ii->link_count != ii->counted_links) { - log_err("Link count inconsistent for inode %" PRIu64 - " (0x%" PRIx64 ") has %u but fsck found %u.\n", ii->inode, + log_err( _("Link count inconsistent for inode %" PRIu64 + " (0x%" PRIx64 ") has %u but fsck found %u.\n"), ii->inode, ii->inode, ii->link_count, ii->counted_links); /* Read in the inode, adjust the link count, * and write it back out */ errors_found++; - if(query(&opts, "Update link count for inode %" - PRIu64 " (0x%" PRIx64 ") ? (y/n) ", ii->inode, ii->inode)) { + if(query(&opts, _("Update link count for inode %" + PRIu64 " (0x%" PRIx64 ") ? (y/n) "), ii->inode, ii->inode)) { errors_corrected++; ip = fsck_load_inode(sbp, ii->inode); /* bread, inode_get */ fix_inode_count(sbp, ii, ip); fsck_inode_put(ip, updated); /* out, brelse, free */ - log_warn("Link count updated for inode %" - PRIu64 " (0x%" PRIx64 ") \n", ii->inode, ii->inode); + log_warn( _("Link count updated for inode %" + PRIu64 " (0x%" PRIx64 ") \n"), ii->inode, ii->inode); } else { - log_err("Link count for inode %" PRIu64 " (0x%" PRIx64 - ") still incorrect\n", ii->inode, ii->inode); + log_err( _("Link count for inode %" PRIu64 " (0x%" PRIx64 + ") still incorrect\n"), ii->inode, ii->inode); } } - log_debug("block %" PRIu64 " (0x%" PRIx64 ") has link count %d\n", + log_debug( _("block %" PRIu64 " (0x%" PRIx64 ") has link count %d\n"), ii->inode, ii->inode, ii->link_count); } /* osi_list_foreach(tmp, list) */ if (lf_addition) { if(!(ii = inode_hash_search(inode_hash, lf_dip->i_di.di_num.no_addr))) { - log_crit("Unable to find lost+found inode in inode_hash!!\n"); + log_crit( _("Unable to find lost+found inode in inode_hash!!\n")); return -1; } else { fix_inode_count(sbp, ii, lf_dip); @@ -166,9 +168,9 @@ int pass4(struct gfs2_sbd *sbp) uint32_t i; osi_list_t *list; if(lf_dip) - log_debug("At beginning of pass4, lost+found entries is %u\n", + log_debug( _("At beginning of pass4, lost+found entries is %u\n"), lf_dip->i_di.di_entries); - log_info("Checking inode reference counts.\n"); + log_info( _("Checking inode reference counts.\n")); for (i = 0; i < FSCK_HASH_SIZE; i++) { if (skip_this_pass || fsck_abort) /* if asked to skip the rest */ return FSCK_OK; @@ -180,7 +182,7 @@ int pass4(struct gfs2_sbd *sbp) } if(lf_dip) - log_debug("At end of pass4, lost+found entries is %u\n", + log_debug( _("At end of pass4, lost+found entries is %u\n"), lf_dip->i_di.di_entries); return FSCK_OK; } diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c index aa63f11..4b28a98 100644 --- a/gfs2/fsck/pass5.c +++ b/gfs2/fsck/pass5.c @@ -2,6 +2,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fsck.h" @@ -45,7 +47,7 @@ int convert_mark(struct gfs2_block_query *q, uint32_t *count) return GFS2_BLKST_USED; default: - log_err("Invalid state %d found\n", q->block_type); + log_err( _("Invalid state %d found\n"), q->block_type); return -1; } return -1; @@ -82,31 +84,31 @@ int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int buflen, So we ignore it. */ if (rg_status == GFS2_BLKST_UNLINKED && block_status == GFS2_BLKST_FREE) { - log_warn("Unlinked block found at block %" - PRIu64" (0x%" PRIx64 "), left unchanged.\n", + log_warn( _("Unlinked block found at block %" + PRIu64" (0x%" PRIx64 "), left unchanged.\n"), block, block); } else if (rg_status != block_status) { const char *blockstatus[] = {"Free", "Data", "Unlinked", "inode"}; - log_err("Ondisk and fsck bitmaps differ at" - " block %"PRIu64" (0x%" PRIx64 ") \n", block, block); - log_err("Ondisk status is %u (%s) but FSCK thinks it should be ", + log_err( _("Ondisk and fsck bitmaps differ at" + " block %"PRIu64" (0x%" PRIx64 ") \n"), block, block); + log_err( _("Ondisk status is %u (%s) but FSCK thinks it should be "), rg_status, blockstatus[rg_status]); log_err("%u (%s)\n", block_status, blockstatus[block_status]); - log_err("Metadata type is %u (%s)\n", q.block_type, + log_err( _("Metadata type is %u (%s)\n"), q.block_type, block_type_string(&q)); errors_found++; - if(query(&opts, "Fix bitmap for block %" - PRIu64" (0x%" PRIx64 ") ? (y/n) ", block, block)) { + if(query(&opts, _("Fix bitmap for block %" + PRIu64" (0x%" PRIx64 ") ? (y/n) "), block, block)) { errors_corrected++; if(gfs2_set_bitmap(sbp, block, block_status)) - log_err("Failed.\n"); + log_err( _("Failed.\n")); else - log_err("Succeeded.\n"); + log_err( _("Succeeded.\n")); } else - log_err("Bitmap at block %"PRIu64" (0x%" PRIx64 - ") left inconsistent\n", block, block); + log_err( _("Bitmap at block %"PRIu64" (0x%" PRIx64 + ") left inconsistent\n"), block, block); } (*rg_block)++; bit += GFS2_BIT_SIZE; @@ -139,8 +141,8 @@ enum update_flags update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp, /* actually adjust counters and write out to disk */ if(rgp->rg.rg_free != count[0]) { - log_err("RG #%llu (0x%llx) free count inconsistent: " - "is %u should be %u\n", + log_err( _("RG #%llu (0x%llx) free count inconsistent: " + "is %u should be %u\n"), (unsigned long long)rgp->ri.ri_addr, (unsigned long long)rgp->ri.ri_addr, rgp->rg.rg_free, count[0]); @@ -148,7 +150,7 @@ enum update_flags update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp, update = 1; } if(rgp->rg.rg_dinodes != count[1]) { - log_err("Inode count inconsistent: is %u should be %u\n", + log_err( _("Inode count inconsistent: is %u should be %u\n"), rgp->rg.rg_dinodes, count[1]); rgp->rg.rg_dinodes = count[1]; update = 1; @@ -157,19 +159,19 @@ enum update_flags update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp, /* FIXME not sure how to handle this case ATM - it * means that the total number of blocks we've counted * exceeds the blocks in the rg */ - log_err("Internal fsck error - AAHHH!\n"); + log_err( _("Internal fsck error - AAHHH!\n")); exit(FSCK_ERROR); } if(update) { errors_found++; - if(query(&opts, "Update resource group counts? (y/n) ")) { + if(query(&opts, _("Update resource group counts? (y/n) "))) { errors_corrected++; - log_warn("Resource group counts updated\n"); + log_warn( _("Resource group counts updated\n")); /* write out the rgrp */ gfs2_rgrp_out(&rgp->rg, rgp->bh[0]->b_data); return updated; } else - log_err("Resource group counts left inconsistent\n"); + log_err( _("Resource group counts left inconsistent\n")); } return not_updated; } @@ -193,7 +195,7 @@ int pass5(struct gfs2_sbd *sbp) if (skip_this_pass || fsck_abort) /* if asked to skip the rest */ return FSCK_OK; - log_info("Verifying Resource Group #%" PRIu64 "\n", rg_count); + log_info( _("Verifying Resource Group #%" PRIu64 "\n"), rg_count); memset(count, 0, sizeof(count)); rgp = osi_list_entry(tmp, struct rgrp_list, list); diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c index 4ddd740..783d216 100644 --- a/gfs2/fsck/rgrepair.c +++ b/gfs2/fsck/rgrepair.c @@ -5,6 +5,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "osi_list.h" @@ -45,7 +47,7 @@ void find_journaled_rgs(struct gfs2_sbd *sdp) osi_list_init(&false_rgrps.list); for (j = 0; j < sdp->md.journals; j++) { - log_debug("Checking for RGs in journal%d.\n", j); + log_debug( _("Checking for RGs in journal%d.\n"), j); ip = sdp->md.journal[j]; jblocks = ip->i_di.di_size / sdp->sd_sb.sb_bsize; for (b = 0; b < jblocks; b++) { @@ -55,8 +57,8 @@ void find_journaled_rgs(struct gfs2_sbd *sdp) break; bh = bread(&sdp->buf_list, dblock); if (!gfs2_check_meta(bh, GFS2_METATYPE_RG)) { - log_debug("False RG found at block " - "0x%" PRIx64 "\n", dblock); + log_debug( _("False RG found at block " + "0x%" PRIx64 "\n"), dblock); gfs2_special_set(&false_rgrps, dblock); } brelse(bh, not_updated); @@ -131,7 +133,7 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, if (((blk == sdp->sb_addr + 1) || (!gfs2_check_meta(bh, GFS2_METATYPE_RG))) && !is_false_rg(blk)) { - log_debug("RG found at block 0x%" PRIx64 "\n", blk); + log_debug( _("RG found at block 0x%" PRIx64 "\n"), blk); if (blk > sdp->sb_addr + 1) { uint64_t rgdist; @@ -152,7 +154,7 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, first_rg_dist = rgdist; if (rgdist < shortest_dist_btwn_rgs) { shortest_dist_btwn_rgs = rgdist; - log_debug("(shortest so far)\n"); + log_debug( _("(shortest so far)\n")); } else log_debug("\n"); @@ -171,8 +173,8 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, /* first_rg_dist would measure from #1 to #3, which would be bad. */ /* We need to take remedial measures to fix it (from the index). */ /* -------------------------------------------------------------- */ - log_debug("First RG distance: 0x%" PRIx64 "\n", first_rg_dist); - log_debug("Distance between RGs: 0x%" PRIx64 "\n", + log_debug( _("First RG distance: 0x%" PRIx64 "\n"), first_rg_dist); + log_debug( _("Distance between RGs: 0x%" PRIx64 "\n"), shortest_dist_btwn_rgs); if (first_rg_dist >= shortest_dist_btwn_rgs + (shortest_dist_btwn_rgs / 4)) { @@ -182,18 +184,18 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, sizeof(struct gfs2_rindex)); gfs2_rindex_in(&tmpndx, (char *)&buf); if (tmpndx.ri_addr > sdp->sb_addr + 1) { /* sanity check */ - log_warn("RG 2 is damaged: getting dist from index: "); + log_warn( _("RG 2 is damaged: getting dist from index: ")); first_rg_dist = tmpndx.ri_addr - (sdp->sb_addr + 1); log_warn("0x%" PRIx64 "\n", first_rg_dist); } else { - log_warn("RG index 2 is damaged: extrapolating dist: "); + log_warn( _("RG index 2 is damaged: extrapolating dist: ")); first_rg_dist = sdp->device.length - (sdp->rgrps - 1) * (sdp->device.length / sdp->rgrps); log_warn("0x%" PRIx64 "\n", first_rg_dist); } - log_debug("Adjusted first RG distance: 0x%" PRIx64 "\n", + log_debug( _("Adjusted first RG distance: 0x%" PRIx64 "\n"), first_rg_dist); } /* if first RG distance is within tolerance */ /* -------------------------------------------------------------- */ @@ -204,14 +206,14 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, block_bump = first_rg_dist; for (blk = sdp->sb_addr + 1; blk <= sdp->device.length; blk += block_bump) { - log_debug("Block 0x%" PRIx64 "\n", blk); + log_debug( _("Block 0x%" PRIx64 "\n"), blk); bh = bread(&sdp->nvbuf_list, blk); rg_was_fnd = (!gfs2_check_meta(bh, GFS2_METATYPE_RG)); brelse(bh, not_updated); /* Allocate a new RG and index. */ calc_rgd = malloc(sizeof(struct rgrp_list)); if (!calc_rgd) { - log_crit("Can't allocate memory for rg repair.\n"); + log_crit( _("Can't allocate memory for rg repair.\n")); return -1; } memset(calc_rgd, 0, sizeof(struct rgrp_list)); @@ -224,11 +226,11 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, /* ------------------------------------------------- */ corrupt_rgs++; if (corrupt_rgs < 5) - log_debug("Missing or damaged RG at block %" - PRIu64 " (0x%" PRIx64 ")\n", + log_debug( _("Missing or damaged RG at block %" + PRIu64 " (0x%" PRIx64 ")\n"), blk, blk); else { - log_crit("Error: too many bad RGs.\n"); + log_crit( _("Error: too many bad RGs.\n")); return -1; } } @@ -250,11 +252,11 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, } /* for subsequent bitmaps */ gfs2_compute_bitstructs(sdp, calc_rgd); - log_debug("Memory allocated for rg at 0x%llx, bh: %p\n", + log_debug( _("Memory allocated for rg at 0x%llx, bh: %p\n"), (unsigned long long)calc_rgd->ri.ri_addr, calc_rgd->bh); if (!calc_rgd->bh) { - log_crit("Can't allocate memory for bitmap repair.\n"); + log_crit( _("Can't allocate memory for bitmap repair.\n")); return -1; } calc_rgd->ri.ri_data0 = calc_rgd->ri.ri_addr + @@ -271,11 +273,11 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, GFS2_NBBY; prev_rgd->ri.ri_bitbytes = prev_rgd->ri.ri_data / GFS2_NBBY; - log_debug("Prev ri_data set to: %" PRIx32 ".\n", + log_debug( _("Prev ri_data set to: %" PRIx32 ".\n"), prev_rgd->ri.ri_data); } number_of_rgs++; - log_warn("%c RG %d at block 0x%" PRIX64 " %s", + log_warn( _("%c RG %d at block 0x%" PRIX64 " %s"), (rg_was_fnd ? ' ' : '*'), number_of_rgs, blk, (rg_was_fnd ? "intact" : "*** DAMAGED ***")); prev_rgd = calc_rgd; @@ -286,7 +288,7 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, else block_bump = shortest_dist_btwn_rgs; if (block_bump != 1) - log_warn(" [length 0x%" PRIx64 "]\n", block_bump); + log_warn( _(" [length 0x%" PRIx64 "]\n"), block_bump); } /* for each rg block */ /* ----------------------------------------------------------------- */ /* If we got to the end of the fs, we still need to fix the */ @@ -302,14 +304,14 @@ int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, osi_list_t *ret_list, prev_rgd->ri.ri_data = rgblocks; prev_rgd->ri.ri_data -= prev_rgd->ri.ri_data % GFS2_NBBY; prev_rgd->ri.ri_bitbytes = prev_rgd->ri.ri_data / GFS2_NBBY; - log_debug("Prev ri_data set to: %" PRIx32 ".\n", + log_debug( _("Prev ri_data set to: %" PRIx32 ".\n"), prev_rgd->ri.ri_data); prev_rgd = NULL; /* make sure we don't use it later */ } /* ---------------------------------------------- */ /* Now dump out the information (if verbose mode) */ /* ---------------------------------------------- */ - log_debug("RG index rebuilt as follows:\n"); + log_debug( _("RG index rebuilt as follows:\n")); for (tmp = ret_list, rgi = 0; tmp != ret_list; tmp = tmp->next, rgi++) { calc_rgd = osi_list_entry(tmp, struct rgrp_list, list); @@ -343,7 +345,7 @@ int gfs2_rindex_calculate(struct gfs2_sbd *sdp, osi_list_t *ret_list, osi_list_init(ret_list); sdp->rgsize = GFS2_DEFAULT_RGSIZE; /* compute_rgrp_layout adjusts */ if (device_geometry(sdp)) { - fprintf(stderr, "Geometry error\n"); + fprintf(stderr, _("Geometry error\n")); exit(-1); } fix_device_geometry(sdp); @@ -351,7 +353,7 @@ int gfs2_rindex_calculate(struct gfs2_sbd *sdp, osi_list_t *ret_list, compute_rgrp_layout(sdp, FALSE); build_rgrps(sdp, FALSE); /* FALSE = calc but don't write to disk. */ *num_rgs = 0; - log_debug("fs_total_size = 0x%" PRIX64 " blocks.\n", + log_debug( _("fs_total_size = 0x%" PRIX64 " blocks.\n"), sdp->device.length); /* ----------------------------------------------------------------- */ /* Calculate how many RGs there are supposed to be based on the */ @@ -361,7 +363,7 @@ int gfs2_rindex_calculate(struct gfs2_sbd *sdp, osi_list_t *ret_list, /* the index. */ /* ----------------------------------------------------------------- */ *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex); - log_warn("L2: number of rgs in the index = %d.\n", *num_rgs); + log_warn( _("L2: number of rgs in the index = %d.\n"), *num_rgs); return 0; } @@ -374,15 +376,15 @@ int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_list *rg, { int x = errblock - rg->ri.ri_addr; - log_err("Block #%"PRIu64" (0x%" PRIx64") (%d of %d) is neither" - " GFS2_METATYPE_RB nor GFS2_METATYPE_RG.\n", + log_err( _("Block #%"PRIu64" (0x%" PRIx64") (%d of %d) is neither" + " GFS2_METATYPE_RB nor GFS2_METATYPE_RG.\n"), rg->bh[x]->b_blocknr, rg->bh[x]->b_blocknr, (int)x+1, (int)rg->ri.ri_length); errors_found++; if (query(&opts, "Fix the RG? (y/n)")) { errors_corrected++; - log_err("Attempting to repair the RG.\n"); + log_err( _("Attempting to repair the RG.\n")); rg->bh[x] = bread(&sdp->nvbuf_list, rg->ri.ri_addr + x); if (x) { struct gfs2_meta_header mh; @@ -436,7 +438,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count) error = gfs2_rindex_rebuild(sdp, &expected_rglist, &calc_rg_count); if (error) { - log_crit("Error rebuilding rg list.\n"); + log_crit( _("Error rebuilding rg list.\n")); gfs2_rgrp_free(&expected_rglist, not_updated); return -1; } @@ -446,16 +448,16 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count) osi_list_init(&sdp->rglist); /* Just to be safe */ rindex_read(sdp, 0, &rgcount_from_index); if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) { - log_warn("WARNING: rindex file is corrupt.\n"); + log_warn( _("WARNING: rindex file is corrupt.\n")); gfs2_rgrp_free(&expected_rglist, not_updated); gfs2_rgrp_free(&sdp->rglist, not_updated); return -1; } - log_warn("L%d: number of rgs expected = %lld.\n", trust_lvl + 1, + log_warn( _("L%d: number of rgs expected = %lld.\n"), trust_lvl + 1, (unsigned long long)sdp->rgrps); if (calc_rg_count != sdp->rgrps) { - log_warn("L%d: They don't match; either (1) the fs was extended, (2) an odd\n", trust_lvl + 1); - log_warn("L%d: rg size was used, or (3) we have a corrupt rg index.\n", trust_lvl + 1); + log_warn( _("L%d: They don't match; either (1) the fs was extended, (2) an odd\n"), trust_lvl + 1); + log_warn( _("L%d: rg size was used, or (3) we have a corrupt rg index.\n"), trust_lvl + 1); gfs2_rgrp_free(&expected_rglist, not_updated); gfs2_rgrp_free(&sdp->rglist, not_updated); return -1; @@ -484,9 +486,9 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count) } } if (trust_lvl < distrust && descrepencies > (trust_lvl * 8)) { - log_warn("Level %d didn't work. Too many descepencies.\n", + log_warn( _("Level %d didn't work. Too many descepencies.\n"), trust_lvl + 1); - log_warn("%d out of %d RGs did not match what was expected.\n", + log_warn( _("%d out of %d RGs did not match what was expected.\n"), descrepencies, rg); gfs2_rgrp_free(&expected_rglist, not_updated); gfs2_rgrp_free(&sdp->rglist, not_updated); @@ -512,7 +514,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count) /* If we modified the index, write it back to disk. */ if (rindex_modified) { errors_found++; - if (query(&opts, "Fix the index? (y/n)")) { + if (query(&opts, _("Fix the index? (y/n)"))) { errors_corrected++; gfs2_rindex_out(&expected->ri, (char *)&buf); gfs2_writei(sdp->md.riinode, (char *)&buf, @@ -535,7 +537,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count) gfs2_compute_bitstructs(sdp, actual); } else - log_err("RG index not fixed.\n"); + log_err( _("RG index not fixed.\n")); rindex_modified = FALSE; } diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c index 46b1de3..af88a7f 100644 --- a/gfs2/fsck/util.c +++ b/gfs2/fsck/util.c @@ -4,6 +4,8 @@ #include #include #include +#include +#define _(String) gettext(String) #include "libgfs2.h" #include "fs_bits.h" @@ -61,7 +63,7 @@ void warm_fuzzy_stuff(uint64_t block) seconds = tv.tv_sec; if (last_fs_block) { percent = (block * 100) / last_fs_block; - log_notice("\r%" PRIu64 " percent complete.\r", percent); + log_notice( _("\r%" PRIu64 " percent complete.\r"), percent); } } }