commit 0fb59c1416efb28367ca5fb06221edb9ecf49423
Author: Bob Peterson <bob@ganesha.peterson>
Date: Mon Feb 15 10:43:06 2010 -0600
gfs2: Add gettext support
This patch is a crosswrite of patch ead42ed from STABLE3 to RHEL55.
This roughs in internationalization by translating the majority of
messages to use gettext. This is necessary because with it, GFS2
patches are very difficult to back-port from upstream.
rhbz#455300
diff --git a/gfs2/fsck/eattr.c b/gfs2/fsck/eattr.c
index 5f43ba6..675a2fc 100644
--- a/gfs2/fsck/eattr.c
+++ b/gfs2/fsck/eattr.c
@@ -12,7 +12,8 @@
#include <stdint.h>
#include <string.h>
-#include <linux_endian.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -27,7 +28,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;
}
@@ -87,8 +88,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 a90aa77..e6e0396 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -18,6 +18,8 @@
#include <string.h>
#include <time.h>
#include <unistd.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "fsck.h"
#include "fs_recovery.h"
@@ -365,16 +367,16 @@ int fix_journal_seq_no(struct gfs2_inode *ip)
prev_seq = lh.lh_sequence;
continue;
}
- log_err("Journal block %u (0x%x): sequence no. 0x%llx out of "
- "order.\n", blk, blk, lh.lh_sequence);
- log_info("Low: 0x%llx, High: 0x%llx, Prev: 0x%llx\n",
- (unsigned long long)lowest_seq,
- (unsigned long long)highest_seq,
- (unsigned long long)prev_seq);
+ log_err( _("Journal block %u (0x%x): sequence no. 0x%llx "
+ "out of order.\n"), blk, blk, lh.lh_sequence);
+ log_info( _("Low: 0x%llx, High: 0x%llx, Prev: 0x%llx\n"),
+ (unsigned long long)lowest_seq,
+ (unsigned long long)highest_seq,
+ (unsigned long long)prev_seq);
highest_seq++;
lh.lh_sequence = highest_seq;
prev_seq = lh.lh_sequence;
- log_warn("Renumbering it as 0x%llx\n", lh.lh_sequence);
+ log_warn( _("Renumbering it as 0x%llx\n"), lh.lh_sequence);
block_map(ip, blk, &new, &dblock, &extlen, FALSE, not_updated);
bh = bread(&ip->i_sbd->buf_list, dblock);
gfs2_log_header_out(&lh, bh->b_data);
@@ -428,74 +430,76 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
int error;
*was_clean = 0;
- 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);
if (error) {
if (opts.no) {
- log_err("Journal #%d (\"journal%d\") is corrupt.\n"
- "Not fixing it due to the -n option.\n",
+ log_err( _("Journal #%d (\"journal%d\") is corrupt.\n"
+ "Not fixing it due to the -n option.\n"),
j+1, j);
goto out;
}
if (!preen_is_safe(sdp, preen, force_check)) {
- log_err("Journal #%d (\"journal%d\") is corrupt.\n",
+ log_err(_("Journal #%d (\"journal%d\") is corrupt.\n"),
j+1, j);
- log_err("I'm not fixing it because it may be unsafe:\n"
- "Locking protocol is not lock_nolock and "
- "the -a or -p option was specified.\n");
- log_err("Please make sure no node has the file system "
- "mounted then rerun fsck.gfs2 manually "
- "without -a or -p.\n");
+ log_err(_("I'm not fixing it because it may be unsafe:\n"
+ "Locking protocol is not lock_nolock and "
+ "the -a or -p option was specified.\n"));
+ log_err(_("Please make sure no node has the file system "
+ "mounted then rerun fsck.gfs2 manually "
+ "without -a or -p.\n"));
goto out;
}
- if (!query(&opts, "\nJournal #%d (\"journal%d\") is "
- "corrupt. Okay to repair it? (y/n)",
+ if (!query(&opts, _("\nJournal #%d (\"journal%d\") is "
+ "corrupt. Okay to repair it? (y/n)"),
j+1, j)) {
- log_err("jid=%u: The journal was not repaired.\n",
- j);
+ log_err( _("jid=%u: The journal was not repaired.\n"),
+ j);
goto out;
}
- log_info("jid=%u: Repairing journal...\n", j);
+ log_info( _("jid=%u: Repairing journal...\n"), j);
error = fix_journal_seq_no(ip);
if (error) {
- log_err("jid=%u: Unable to repair the bad journal.\n",
- j);
+ log_err( _("jid=%u: Unable to repair the bad "
+ "journal.\n"), j);
goto out;
}
error = gfs2_find_jhead(ip, &head);
if (error) {
- log_err("jid=%u: Unable to fix the bad journal.\n", j);
+ log_err( _("jid=%u: Unable to fix the bad journal.\n"),
+ j);
goto out;
}
- log_err("jid=%u: The journal was successfully fixed.\n", j);
+ log_err( _("jid=%u: The journal was successfully fixed.\n"),
+ j);
}
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);
*was_clean = 1;
return 0;
}
if (opts.no) {
- log_err("Journal #%d (\"journal%d\") is dirty; not replaying"
- " due to the -n option.\n",
+ log_err(_("Journal #%d (\"journal%d\") is dirty; not replaying"
+ " due to the -n option.\n"),
j+1, j);
goto out;
}
if (!preen_is_safe(sdp, preen, force_check)) {
- log_err("Journal #%d (\"journal%d\") is dirty.\n", j+1, j);
- log_err("I'm not replaying it because it may be unsafe:\n"
- "Locking protocol is not lock_nolock and "
- "the -a or -p option was specified.\n");
- log_err("Please make sure no node has the file system "
- "mounted then rerun fsck.gfs2 manually "
- "without -a or -p.\n");
+ log_err( _("Journal #%d (\"journal%d\") is dirty.\n"), j+1, j);
+ log_err( _("I'm not replaying it because it may be unsafe:\n"
+ "Locking protocol is not lock_nolock and "
+ "the -a or -p option was specified.\n"));
+ log_err( _("Please make sure no node has the file system "
+ "mounted then rerun fsck.gfs2 manually "
+ "without -a or -p.\n"));
error = FSCK_ERROR;
goto out;
}
- 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);
+ 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);
sd_found_jblocks = sd_replayed_jblocks = 0;
sd_found_metablocks = sd_replayed_metablocks = 0;
@@ -507,28 +511,28 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
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;
}
@@ -560,7 +564,7 @@ int replay_journals(struct gfs2_sbd *sdp, int preen, int force_check,
/* 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;
}
@@ -574,8 +578,8 @@ int replay_journals(struct gfs2_sbd *sdp, int preen, int force_check,
if (!gave_msg && dirty_journals == 1 && !opts.no &&
preen_is_safe(sdp, preen, force_check)) {
gave_msg = 1;
- log_notice("Recovering journals (this may "
- "take a while)\n");
+ log_notice( _("Recovering journals (this may "
+ "take a while)\n"));
}
*clean_journals += clean;
}
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 93fef78..48e71c3 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -21,8 +21,11 @@
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
+#include <libintl.h>
#include <errno.h>
+#define _(String) gettext(String)
+
#include "libgfs2.h"
#include "fsck.h"
#include "util.h"
@@ -83,13 +86,13 @@ 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%p: rgd=0x%p bits=0x%p\n",
- rgd->ri.ri_addr, rgd, rgd->bits);
+ 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)
free(rgd->bits);
@@ -136,7 +139,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)
{
@@ -150,9 +153,10 @@ 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 %d bytes.\n",
- last_fs_block, sizeof(unsigned long));
+ 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 %zu bytes.\n"),
+ (unsigned long long)last_fs_block,
+ sizeof(unsigned long));
goto fail;
}
@@ -160,16 +164,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;
}
@@ -198,7 +202,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,
@@ -237,41 +241,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_warn("(level %d passed)\n", trust_lvl + 1);
+ log_warn( _("(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: %ldMB\n", addl_mem_needed / 1048576);
- log_crit("Please increase your swap space by that amount and run gfs2_fsck again.\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"));
goto fail;
}
return 0;
@@ -296,7 +301,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);
@@ -312,8 +317,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;
}
@@ -346,7 +351,7 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
int is_mounted, ro;
if (open_flag == O_RDONLY || errno != EBUSY) {
- log_crit("Unable to open device: %s\n", opts.device);
+ log_crit( _("Unable to open device: %s\n"), opts.device);
return FSCK_USAGE;
}
/* We can't open it EXCL. It may be already open rw (in which
@@ -388,7 +393,7 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
/* Change lock protocol to be fsck_* instead of lock_* */
if(!opts.no && preen_is_safe(sbp, preen, force_check)) {
if(block_mounters(sbp, 1)) {
- log_err("Unable to block other mounters\n");
+ log_err( _("Unable to block other mounters\n"));
return FSCK_USAGE;
}
}
@@ -405,7 +410,7 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
*all_clean = 1;
else {
if (force_check || !preen)
- log_notice("\nJournal recovery complete.\n");
+ log_notice( _("\nJournal recovery complete.\n"));
}
if (!force_check && *all_clean && preen)
@@ -417,7 +422,7 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
return FSCK_OK;
mount_fail:
- log_crit("Device %s is busy.\n", opts.device);
+ log_crit( _("Device %s is busy.\n"), opts.device);
return FSCK_USAGE;
}
@@ -425,10 +430,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 <device> proto' to fix\n");
+ log_warn( _("Unable to unblock other mounters - manual intervention required\n"));
+ log_warn( _("Use 'gfs2_tool sb <device> proto' to fix\n"));
}
- log_info("Syncing the device.\n");
+ log_info( _("Syncing the device.\n"));
fsync(sbp->device_fd);
}
empty_super_block(sbp);
@@ -439,8 +444,8 @@ static void destroy_sbp(struct gfs2_sbd *sbp)
write(sbp->device_fd, "2", 1);
close(sbp->device_fd);
} else
- log_err("fsck.gfs2: Non-fatal error dropping "
- "caches.\n");
+ log_err( _("fsck.gfs2: Non-fatal error dropping "
+ "caches.\n"));
}
}
diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c
index fa01b42..96dc261 100644
--- a/gfs2/fsck/link.c
+++ b/gfs2/fsck/link.c
@@ -16,6 +16,8 @@
#include <stdint.h>
#include <string.h>
#include <unistd.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -25,15 +27,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;
}
@@ -44,7 +46,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;
}
@@ -65,21 +67,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;
}
@@ -97,13 +99,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 3990e44..e55b5f2 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -18,6 +18,8 @@
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "fsck.h"
#include "libgfs2.h"
@@ -42,7 +44,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)) {
@@ -67,30 +69,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 %"PRIu64"\n",
- ip->i_di.di_num.no_addr);
+ 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);
@@ -128,12 +130,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;
}
@@ -145,7 +147,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 #%"PRIu64" to lost+found dir\n",
- ip->i_di.di_num.no_addr);
+ 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 5f30f12..b2fba6c 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -19,6 +19,9 @@
#include <stdarg.h>
#include <ctype.h>
#include <signal.h>
+#include <libintl.h>
+#include <locale.h>
+#define _(String) gettext(String)
#include "copyright.cf"
#include "libgfs2.h"
@@ -102,11 +105,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;
}
@@ -118,7 +121,7 @@ int read_cmdline(int argc, char **argv, struct gfs2_options *opts)
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;
@@ -130,15 +133,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;
@@ -158,20 +161,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;
}
@@ -180,7 +183,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);
@@ -191,15 +194,15 @@ 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 (query(&opts, "Create new %s system inode? (y/n) ",
+ if (query(&opts, _("Create new %s system inode? (y/n) "),
filename)) {
errors_corrected++;
builder(sysinode->i_sbd);
@@ -212,7 +215,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;
}
@@ -301,35 +304,35 @@ void check_statfs(struct gfs2_sbd *sdp)
if (sc.sc_total == sdp->blks_total &&
sc.sc_free == (sdp->blks_total - sdp->blks_alloced) &&
sc.sc_dinodes == sdp->dinodes_alloced) {
- log_info("The statfs file is accurate.\n");
+ log_info( _("The statfs file is accurate.\n"));
return;
}
- log_err("The statfs file is wrong:\n\n");
- log_err("Current statfs values:\n");
- log_err("blocks: %lld (0x%llx)\n",
+ log_err( _("The statfs file is wrong:\n\n"));
+ log_err( _("Current statfs values:\n"));
+ log_err( _("blocks: %lld (0x%llx)\n"),
sc.sc_total, sc.sc_total);
- log_err("free: %lld (0x%llx)\n",
+ log_err( _("free: %lld (0x%llx)\n"),
sc.sc_free, sc.sc_free);
- log_err("dinodes: %lld (0x%llx)\n\n",
+ log_err( _("dinodes: %lld (0x%llx)\n\n"),
sc.sc_dinodes, sc.sc_dinodes);
- log_err("Calculated statfs values:\n");
- log_err("blocks: %lld (0x%llx)\n",
+ log_err( _("Calculated statfs values:\n"));
+ log_err( _("blocks: %lld (0x%llx)\n"),
sdp->blks_total, sdp->blks_total);
- log_err("free: %lld (0x%llx)\n",
+ log_err( _("free: %lld (0x%llx)\n"),
sdp->blks_total - sdp->blks_alloced,
sdp->blks_total - sdp->blks_alloced);
- log_err("dinodes: %lld (0x%llx)\n",
+ log_err( _("dinodes: %lld (0x%llx)\n"),
sdp->dinodes_alloced, sdp->dinodes_alloced);
errors_found++;
- if (!query(&opts, "Okay to fix the master statfs file? (y/n)")) {
- log_err("The statfs file was not fixed.\n");
+ if (!query(&opts, _("Okay to fix the master statfs file? (y/n)"))) {
+ log_err( _("The statfs file was not fixed.\n"));
return;
}
do_init_statfs(sdp);
- log_err("The statfs file was fixed.\n");
+ log_err( _("The statfs file was fixed.\n"));
errors_corrected++;
}
@@ -342,33 +345,36 @@ int main(int argc, char **argv)
int error = 0;
int all_clean = 0;
+ setlocale(LC_ALL, "");
+ textdomain("gfs2-utils");
+
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, force_check, preen, &all_clean)))
exit(error);
if (!force_check && all_clean && preen) {
- log_err("%s: clean.\n", opts.device);
+ log_err( _("%s: clean.\n"), opts.device);
destroy(sbp);
exit(FSCK_OK);
}
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);
@@ -376,81 +382,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;
}
@@ -473,12 +479,12 @@ int main(int argc, char **argv)
inode_put(lf_dip, update_sys_files);
if (!opts.no && errors_corrected)
- 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 be62cfa..a0ac86b 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -18,6 +18,8 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -204,11 +206,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;
}
@@ -226,14 +228,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_inum.no_formal_ino && !de.de_name_len && !first)) {
- log_err("Directory block %" PRIu64 "(0x%"
- PRIx64 "), entry %d of directory %"
- PRIu64 "(0x%" PRIx64 ") is corrupt.\n",
- bh->b_blocknr, bh->b_blocknr, (*count) + 1,
- ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr);
+ log_err( _("Directory block %llu (0x%llx"
+ "), entry %d of directory %llu"
+ "(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)) {
if (first) /* make a new sentinel */
@@ -241,53 +245,54 @@ int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
else
dirblk_truncate(ip, prev, bh);
*update = updated;
- log_err("Unable to repair corrupt "
- "directory entry; the entry "
- "was removed instead.\n");
+ log_err( _("Unable to repair corrupt "
+ "directory entry; the "
+ "entry was removed "
+ "instead.\n"));
return 0;
} else {
- log_err("Corrupt directory entry "
- "repaired.\n");
+ log_err( _("Corrupt directory entry "
+ "repaired.\n"));
errors_corrected++;
*update = updated;
/* keep looping through dentries */
}
} 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);
return 0;
}
}
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 {
- log_err("Directory entry with inode number of "
- "zero in leaf %" PRIu64 "(0x%" PRIx64
- ") of directory %" PRIu64 " (0x%"
- PRIx64 ")!\n", bh->b_blocknr,
- bh->b_blocknr,
- ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr);
+ log_err( _("Directory entry with inode number of "
+ "zero in leaf %llu (0x%llx) of "
+ "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,
+ (unsigned long long)ip->i_di.di_num.no_addr);
if (query(&opts,
- "Attempt to remove it? (y/n) ")) {
+ _("Attempt to remove it? (y/n) "))) {
dirblk_truncate(ip, prev, bh);
*update = 1;
- log_err("The corrupt directory entry "
- "was removed.\n");
+ log_err(_("The corrupt directory "
+ "entry was removed.\n"));
} else {
- log_err("Corrupt directory entry "
- "ignored, stopped after "
- "checking %d entries.\n",
- *count);
+ log_err( _("Corrupt directory entry "
+ "ignored, stopped after "
+ "checking %d entries.\n"),
+ *count);
}
return 0;
}
} 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;
@@ -309,7 +314,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;
}
@@ -333,25 +338,27 @@ void warn_and_patch(struct gfs2_inode *ip, uint64_t *leaf_no,
uint64_t first_ok_leaf, int index, const char *msg)
{
if (*bad_leaf != *leaf_no) {
- log_err("Directory Inode %" PRIu64 "(0x%"
- PRIx64 ") points to leaf %" PRIu64 " (0x%"
- PRIx64 ") %s.\n", ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr, *leaf_no, *leaf_no, msg);
+ 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,
+ (unsigned long long)*leaf_no, msg);
}
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++;
if (gfs2_check_range(ip->i_sbd, old_leaf) == 0)
gfs2_put_leaf_nr(ip, index, old_leaf);
else
gfs2_put_leaf_nr(ip, index, first_ok_leaf);
- log_err("Directory Inode %" PRIu64 "(0x%" PRIx64
- ") repaired.\n", ip->i_di.di_num.no_addr,
+ log_err( _("Directory Inode %" PRIu64 "(0x%" PRIx64
+ ") repaired.\n"), ip->i_di.di_num.no_addr,
ip->i_di.di_num.no_addr);
}
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;
}
@@ -410,14 +417,18 @@ int check_leaf_blks(struct gfs2_inode *ip, enum update_flags *update,
}
if (gfs2_check_range(ip->i_sbd, old_leaf) == 0 &&
ref_count != exp_count) {
- log_err("Dir #%" PRIu64 " (0x%" PRIx64 ") has an "
- "incorrect number of pointers to leaf #%"
- PRIu64 " (0x%" PRIx64 ")\n\tFound: %u, "
- "Expected: %u\n", ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr, old_leaf, old_leaf,
- ref_count, exp_count);
+ 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)
+ ip->i_di.di_num.no_addr,
+ (unsigned long long)
+ ip->i_di.di_num.no_addr,
+ (unsigned long long)old_leaf,
+ (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;
errors_corrected++;
@@ -442,15 +453,17 @@ int check_leaf_blks(struct gfs2_inode *ip, enum update_flags *update,
break;
/* Make sure the block number is in range. */
if(gfs2_check_range(ip->i_sbd, leaf_no)){
- log_err("Leaf block #%" PRIu64 " (0x%"
- PRIx64 ") is out of range for "
- "directory #%" PRIu64 " (0x%"
- PRIx64 ").\n", leaf_no, leaf_no,
+ log_err( _("Leaf block #%llu (0x%llx) is out "
+ "of range for directory #%llu (0x%llx"
+ ").\n"), (unsigned long long)leaf_no,
+ (unsigned long long)leaf_no,
+ (unsigned long long)
ip->i_di.di_num.no_addr,
+ (unsigned long long)
ip->i_di.di_num.no_addr);
warn_and_patch(ip, &leaf_no, &bad_leaf,
old_leaf, first_ok_leaf,
- index, "that is out of range");
+ index, _("that is out of range"));
memcpy(&leaf, &oldleaf, sizeof(oldleaf));
break;
}
@@ -462,7 +475,7 @@ int check_leaf_blks(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, first_ok_leaf, index,
- "that is not really a leaf");
+ _("that is not really a leaf"));
memcpy(&leaf, &oldleaf, sizeof(oldleaf));
brelse(lbh, not_updated);
break;
@@ -481,26 +494,29 @@ int check_leaf_blks(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 %" PRIu64 " (0x%"
- PRIx64 ") points to bad leaf "
- PRIu64 " (0x%" PRIx64 ").\n",
+ log_err( _("Inode %llu (0x%llx"
+ ") points to bad leaf %llu"
+ " (0x%llx).\n"),
+ (unsigned long long)
ip->i_di.di_num.no_addr,
+ (unsigned long long)
ip->i_di.di_num.no_addr,
- leaf_no, leaf_no);
+ (unsigned long long)leaf_no,
+ (unsigned long long)leaf_no);
brelse(lbh, *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 &&
@@ -525,11 +541,11 @@ int check_leaf_blks(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)
@@ -538,14 +554,14 @@ int check_leaf_blks(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
@@ -556,7 +572,7 @@ int check_leaf_blks(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); /* while we have chained leaf blocks */
old_leaf = leaf_no;
@@ -621,9 +637,9 @@ static int check_eattr_entries(struct gfs2_inode *ip,
update_it,
pass->private)) {
errors_found++;
- if (query(&opts, "Repair the bad "
- "Extended Attribute? "
- "(y/n) ")) {
+ if (query(&opts, _("Repair the bad "
+ "Extended Attribute? "
+ "(y/n) "))) {
errors_corrected++;
ea_hdr->ea_num_ptrs = i;
ea_hdr->ea_data_len =
@@ -636,11 +652,12 @@ static int check_eattr_entries(struct gfs2_inode *ip,
gfs2_block_set(sdp, bl,
ip->i_di.di_eattr,
gfs2_meta_eattr);
- log_err("The EA was fixed.\n");
+ log_err( _("The EA was "
+ "fixed.\n"));
} else {
error = 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 -
@@ -679,7 +696,7 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block,
int error = 0;
enum update_flags updated_this_leaf = not_updated;
- 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) {
@@ -732,7 +749,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
uint64_t di_eattr_save = ip->i_di.di_eattr;
*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)
@@ -757,8 +774,8 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
leaf_pointer_errors++;
if (update_indir_block == not_updated) {
errors_found++;
- if (query(&opts, "Fix the indirect "
- "block too? (y/n) ")) {
+ if (query(&opts, _("Fix the indirect "
+ "block too? (y/n) "))) {
update_indir_block = updated;
errors_corrected++;
*ea_leaf_ptr = 0;
@@ -836,7 +853,7 @@ int check_inode_eattr(struct gfs2_inode *ip, enum update_flags *want_updated,
if(!ip->i_di.di_eattr)
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);
@@ -917,8 +934,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;
}
@@ -979,7 +996,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);
@@ -1124,10 +1141,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;
@@ -1138,7 +1155,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,
@@ -1234,12 +1251,12 @@ int delete_blocks(struct gfs2_inode *ip, uint64_t block,
if (gfs2_block_check(ip->i_sbd, bl, block, &q))
return 0;
if (!q.dup_block) {
- log_info("Deleting %s block %lld (0x%llx) as part "
- "of inode %lld (0x%llx)\n", btype,
- (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);
+ log_info( _("Deleting %s block %lld (0x%llx) as part "
+ "of inode %lld (0x%llx)\n"), btype,
+ (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);
gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free);
gfs2_free_block(ip->i_sbd, block);
}
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index af788e0..edcb7ec 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -29,6 +29,8 @@
#include <time.h>
#include <sys/ioctl.h>
#include <inttypes.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -87,7 +89,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++;
@@ -107,7 +109,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;
}
@@ -116,16 +118,16 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
return -1;
}
if(q.block_type != gfs2_block_free) {
- log_err("Found duplicate block referenced as metadata in "
- "indirect block - was marked %d\n", q.block_type);
+ log_err( _("Found duplicate block referenced as metadata 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);
@@ -136,8 +138,8 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
*bh = nbh;
if (!found_dup) {
- log_debug("Setting %" PRIu64 " (0x%" PRIx64 ") to indirect "
- "block.\n", block, block);
+ 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++;
@@ -152,11 +154,11 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
int error = 0, btype;
if (gfs2_check_range(ip->i_sbd, block)) {
- log_err("inode %lld (0x%llx) has a bad data block pointer "
- "%lld (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);
+ log_err( _("inode %lld (0x%llx) has a bad data block pointer "
+ "%lld (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);
/* Mark the owner of this block with the bad_block
* designator so we know to check it for out of range
* blocks later */
@@ -166,13 +168,13 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
}
if(gfs2_block_check(ip->i_sbd, bl, block, &q)) {
stack;
- log_err("Found bad block referenced as data at %"
- PRIu64 " (0x%"PRIx64 ")\n", block, block);
+ log_err( _("Found bad block referenced as data at %"
+ PRIu64 " (0x%"PRIx64 ")\n"), block, block);
return -1;
}
if(q.block_type != gfs2_block_free) {
- log_err("Found duplicate block referenced as data at %"
- PRIu64 " (0x%"PRIx64 ")\n", block, block);
+ log_err( _("Found duplicate block referenced as data at %"
+ PRIu64 " (0x%"PRIx64 ")\n"), block, block);
if (q.block_type != gfs2_meta_inval) {
gfs2_block_mark(ip->i_sbd, bl, block, gfs2_dup_block);
/* If the prev ref was as data, this is likely a data
@@ -194,8 +196,8 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
gfs2_block_unmark(ip->i_sbd, bl, block, gfs2_meta_inval);
gfs2_block_mark(ip->i_sbd, bl, block, gfs2_dup_block);
}
- log_debug("Marking block %llu (0x%llx) as data block\n",
- (unsigned long long)block, (unsigned long long)block);
+ log_debug( _("Marking block %llu (0x%llx) as data block\n"),
+ (unsigned long long)block, (unsigned long long)block);
gfs2_block_mark(ip->i_sbd, bl, block, gfs2_block_used);
/* This is also confusing, so I'll clarify. There are two bitmaps:
@@ -220,15 +222,15 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
"metadata", "reserved"};
errors_found++;
- log_err("Block #%llu (0x%llx) seems to be data, but is marked "
- "as %s.\n", (unsigned long long)block,
- (unsigned long long)block, allocdesc[btype]);
- if(query(&opts, "Okay to mark it as 'data'? (y/n)")) {
+ log_err( _("Block %llu (0x%llx) seems to be data, but is "
+ "marked as %s.\n"), (unsigned long long)block,
+ (unsigned long long)block, allocdesc[btype]);
+ if(query(&opts, _("Okay to mark it as 'data'? (y/n)"))) {
errors_corrected++;
gfs2_set_bitmap(ip->i_sbd, block, GFS2_BLKST_USED);
- log_err("The block was reassigned as data.\n");
+ log_err( _("The block was reassigned as data.\n"));
} else {
- log_err("The invalid block was ignored.\n");
+ log_err( _("The invalid block was ignored.\n"));
}
}
bc->data_count++;
@@ -256,12 +258,12 @@ static int ask_remove_inode_eattr(struct gfs2_inode *ip,
struct block_count *bc,
enum update_flags *want_updated)
{
- log_err("Inode %lld (0x%llx) has unrecoverable Extended Attribute "
- "errors.\n", (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err( _("Inode %lld (0x%llx) has unrecoverable Extended Attribute "
+ "errors.\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 all Extended Attributes from the "
- "inode? (y/n) ")) {
+ if (query(&opts, _("Clear all Extended Attributes from the "
+ "inode? (y/n) "))) {
struct gfs2_block_query q;
errors_corrected++;
@@ -270,12 +272,12 @@ static int ask_remove_inode_eattr(struct gfs2_inode *ip,
return -1;
}
if (!remove_inode_eattr(ip, bc, q.dup_block, want_updated))
- log_err("Extended attributes were removed.\n");
+ log_err( _("Extended attributes were removed.\n"));
else
- log_err("Unable to remove inode eattr pointer; "
- "the error remains.\n");
+ log_err( _("Unable to remove inode eattr pointer; "
+ "the error remains.\n"));
} else {
- log_err("Extended attributes were not removed.\n");
+ log_err( _("Extended attributes were not removed.\n"));
}
return 0;
}
@@ -296,26 +298,28 @@ 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 #%" PRIu64 " (0x%" PRIx64 "): %s",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr, emsg);
- log_err(" at block #%lld (0x%llx).\n",
- (unsigned long long)block, (unsigned long long)block);
+ 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);
+ log_err( _(" at block #%lld (0x%llx).\n"),
+ (unsigned long long)block, (unsigned long long)block);
errors_found++;
- if (query(&opts, "Clear the bad Extended Attribute? (y/n) ")) {
+ if (query(&opts, _("Clear the bad Extended Attribute? (y/n) "))) {
errors_corrected++;
if (block == ip->i_di.di_eattr) {
remove_inode_eattr(ip, bc, duplicate, want_updated);
- log_err("The bad extended attribute was removed.\n");
+ log_err( _("The bad extended attribute was "
+ "removed.\n"));
} else if (!duplicate) {
gfs2_block_set(sdp, bl, block, gfs2_block_free);
gfs2_set_bitmap(sdp, block, GFS2_BLKST_FREE);
- log_err("The bad Extended Attribute was "
- "removed.\n");
+ log_err( _("The bad Extended Attribute was "
+ "removed.\n"));
}
*want_updated = updated;
return 1;
} else {
- log_err("The bad Extended Attribute was not fixed.\n");
+ log_err( _("The bad Extended Attribute was not fixed.\n"));
bc->ea_count++;
return 0;
}
@@ -353,8 +357,8 @@ 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 Extended Attribute "
- "duplicate found")) {
+ _("Bad indirect Extended Attribute "
+ "duplicate found"))) {
gfs2_block_mark(sdp, bl, indirect,
gfs2_dup_block);
bc->ea_count++;
@@ -362,23 +366,25 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
return 1;
}
clear_eas(ip, bc, indirect, 0, want_updated,
- "Extended Attribute indirect block has incorrect "
- "type");
+ _("Extended Attribute indirect block has incorrect "
+ "type"));
return 1;
}
if(q.block_type != gfs2_block_free) { /* Duplicate? */
- log_err("Inode #%" PRIu64 " (0x%" PRIx64
- "): Duplicate Extended Attribute indirect block "
- "found at #%" PRIu64 " (0x%" PRIx64 ").\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- indirect, indirect);
+ log_err( _("Inode #%llu (0x%llx): Duplicate Extended "
+ "Attribute 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,
+ (unsigned long long)indirect);
gfs2_block_mark(sdp, bl, indirect, gfs2_dup_block);
bc->ea_count++;
ret = 1;
} else {
- log_debug("Setting #%" PRIu64 " (0x%" PRIx64
- ") to indirect Extended Attribute block\n",
- indirect, indirect);
+ log_debug( _("Setting #%" PRIu64 " (0x%" PRIx64
+ ") to indirect Extended Attribute block\n"),
+ indirect, indirect);
gfs2_block_set(sdp, bl, indirect, gfs2_indir_blk);
bc->ea_count++;
}
@@ -393,31 +399,31 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,
if (leaf_pointer_errors == leaf_pointers) /* All eas were bad */
return ask_remove_inode_eattr(ip, bc, want_updated);
- log_debug("Marking inode #%lld (0x%llx) with extended "
- "attribute block\n",
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug( _("Marking inode #%llu (0x%llx) with extended "
+ "attribute 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
so pass1c can check it. */
gfs2_block_mark(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
gfs2_eattr_block);
if (!leaf_pointer_errors)
return 0;
- log_err("Inode %lld (0x%llx) has recoverable indirect "
- "Extended Attribute errors.\n",
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err( _("Inode %lld (0x%llx) has recoverable indirect "
+ "Extended Attribute errors.\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, "Okay to fix the block count for the inode? "
- "(y/n) ")) {
+ if (query(&opts, _("Okay to fix the block count for the inode? "
+ "(y/n) "))) {
errors_corrected++;
ip->i_di.di_blocks = 1 + bc->indir_count +
bc->data_count + bc->ea_count;
*want_updated = updated;
- log_err("Block count fixed.\n");
+ log_err( _("Block count fixed.\n"));
return 1;
}
- log_err("Block count not fixed.\n");
+ log_err( _("Block count not fixed.\n"));
return 1;
}
@@ -441,19 +447,19 @@ static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
if(gfs2_check_meta(leaf_bh, btype)) {
if(q.block_type != gfs2_block_free) { /* Duplicate? */
clear_eas(ip, bc, block, 1, want_updated,
- "Bad Extended Attribute duplicate found");
+ _("Bad Extended Attribute duplicate found"));
} else {
clear_eas(ip, bc, block, 0, want_updated,
- "Extended Attribute leaf block "
- "has incorrect type");
+ _("Extended Attribute leaf block "
+ "has incorrect type"));
}
brelse(leaf_bh, *want_updated);
return 1;
}
if(q.block_type != gfs2_block_free) { /* Duplicate? */
- log_debug("Duplicate block found at #%lld (0x%llx).\n",
- (unsigned long long)block,
- (unsigned long long)block);
+ log_debug( _("Duplicate block found at #%lld (0x%llx).\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
gfs2_block_mark(sdp, bl, block, gfs2_dup_block);
bc->ea_count++;
brelse(leaf_bh, not_updated);
@@ -464,13 +470,13 @@ static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
errors that caused clear_eas to be called. What we
need to do here is remove the subsequent ea blocks. */
clear_eas(ip, bc, block, 0, want_updated,
- "Extended Attribute block removed due to "
- "previous errors.\n");
+ _("Extended Attribute block removed due to "
+ "previous errors.\n"));
brelse(leaf_bh, *want_updated);
return 1;
}
- log_debug("Setting block #%lld (0x%llx) to eattr block\n",
- (unsigned long long)block, (unsigned long long)block);
+ log_debug( _("Setting block #%lld (0x%llx) to eattr block\n"),
+ (unsigned long long)block, (unsigned long long)block);
/* Point of confusion: We've got to set the ea block itself to
gfs2_meta_eattr here. Elsewhere we mark the inode with
gfs2_eattr_block meaning it contains an eattr for pass1c. */
@@ -504,15 +510,15 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr,
int error;
if(gfs2_check_range(sdp, el_blk)){
- log_err("Inode #%llu (0x%llx): Extended Attribute block "
- "%llu (0x%llx) has an extended leaf block #%llu "
- "(0x%llx) that 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)ip->i_di.di_eattr,
- (unsigned long long)ip->i_di.di_eattr,
- (unsigned long long)el_blk,
- (unsigned long long)el_blk);
+ log_err( _("Inode #%llu (0x%llx): Extended Attribute block "
+ "%llu (0x%llx) has an extended leaf block #%llu "
+ "(0x%llx) that 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)ip->i_di.di_eattr,
+ (unsigned long long)ip->i_di.di_eattr,
+ (unsigned long long)el_blk,
+ (unsigned long long)el_blk);
gfs2_block_set(sdp, bl, ip->i_di.di_eattr, gfs2_bad_block);
return 1;
}
@@ -534,13 +540,14 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
* Clarification: If we're here we're checking a leaf block, and the
* source dinode needs to be marked as having extended attributes.
* That instructs pass1c to check the contents of the ea blocks. */
- log_debug("Setting inode %lld (0x%llx) as having eattr "
- "block\n", (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug( _("Setting inode %lld (0x%llx) as having eattr "
+ "block(s) attached.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr);
gfs2_block_mark(sdp, bl, ip->i_di.di_num.no_addr, gfs2_eattr_block);
if(gfs2_check_range(sdp, block)) {
- log_warn("Inode #%llu (0x%llx): Extended Attribute leaf "
- "block #%llu (0x%llx) is out of range.\n",
+ log_warn( _("Inode #%llu (0x%llx): Extended Attribute 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);
@@ -585,7 +592,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);
}
}
@@ -631,14 +638,15 @@ int clear_leaf(struct gfs2_inode *ip, uint64_t block,
{
struct gfs2_block_query q = {0};
- log_crit("Clearing leaf #%" PRIu64 " (0x%" PRIx64 ")\n", block, block);
+ log_crit( _("Clearing leaf #%" PRIu64 " (0x%" PRIx64 ")\n"),
+ block, block);
if(gfs2_block_check(ip->i_sbd, bl, block, &q)) {
stack;
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;
@@ -660,17 +668,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;
}
@@ -696,20 +704,22 @@ 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 #%" PRIu64 " (0x%" PRIx64
- "): Bad inode address found: %" PRIu64 " (0x%" PRIx64 ")\n",
- block, block, ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr);
+ 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(query(&opts, "Fix address in inode at block #%"
- PRIu64 " (0x%" PRIx64 ")? (y/n) ", block, block)) {
+ if(query(&opts, _("Fix address in inode at block #%"
+ PRIu64 " (0x%" PRIx64 ")? (y/n) "),
+ block, block)) {
errors_corrected++;
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)) {
@@ -718,8 +728,8 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
return -1;
}
if(q.block_type != gfs2_block_free) {
- log_err("Found duplicate block referenced as an inode at #%"
- PRIu64 " (0x%" PRIx64 ")\n", block, block);
+ log_err( _("Found duplicate block referenced as an inode at "
+ "#%" PRIu64 " (0x%" PRIx64 ")\n"), block, block);
if(gfs2_block_mark(sdp, bl, block, gfs2_dup_block)) {
stack;
fsck_inode_put(ip, f);
@@ -732,7 +742,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;
@@ -746,7 +756,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;
@@ -755,7 +765,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;
@@ -764,7 +774,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;
@@ -773,7 +783,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;
@@ -782,7 +792,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;
@@ -791,7 +801,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;
@@ -800,7 +810,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;
@@ -820,12 +830,12 @@ 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 #%" PRIu64 " (0x%" PRIx64 ") has bad height "
- "Found %u, Expected >= %u\n", ip->i_di.di_num.no_addr,
+ log_warn( _("Dinode #%" PRIu64 " (0x%" PRIx64 ") has bad height "
+ "Found %u, Expected >= %u\n"), ip->i_di.di_num.no_addr,
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);
@@ -839,13 +849,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 #%" PRIu64 " (0x%" PRIx64
- ") has bad depth. Found %u, Expected %u\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- ip->i_di.di_depth,
- (1 >> (ip->i_di.di_size/sizeof(uint64_t))));
+ 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);
@@ -865,9 +876,9 @@ int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
return 0;
}
if(error > 0) {
- log_warn("Marking inode #%lld (0x%llx) invalid\n",
+ log_warn( _("Marking inode #%llu (0x%llx) invalid\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
- 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 */
check_metatree(ip, &invalidate_metatree);
gfs2_block_set(sdp, bl, ip->i_di.di_num.no_addr,
@@ -885,26 +896,31 @@ 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 #%" PRIu64 " (0x%" PRIx64 "): Ondisk block count (%"
- PRIu64 ") does not match what fsck found (%" PRIu64 ")\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- ip->i_di.di_blocks,
- 1 + bc.indir_count + bc.data_count + bc.ea_count);
- log_info("inode has: %lld, but fsck counts: Dinode:1 + indir:"
- "%lld + data: %lld + ea: %lld\n",
- ip->i_di.di_blocks, 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"),
+ (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,
+ (unsigned long long)1 + bc.indir_count +
+ bc.data_count + bc.ea_count);
+ log_info( _("inode has: %lld, but fsck counts: Dinode:1 + "
+ "indir:%lld + data: %lld + ea: %lld\n"),
+ (unsigned long long)ip->i_di.di_blocks,
+ (unsigned long long)bc.indir_count,
+ (unsigned long long)bc.data_count,
+ (unsigned long long)bc.ea_count);
errors_found++;
- if (query(&opts, "Fix ondisk block count? (y/n) ")) {
+ if (query(&opts, _("Fix ondisk block count? (y/n) "))) {
errors_corrected++;
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 #%" PRIu64 " (0x%" PRIx64
- ") not fixed\n", ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr);
+ 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);
}
fsck_inode_put(ip, f);
@@ -917,23 +933,24 @@ int scan_meta(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
if (gfs2_check_meta(bh, 0)) {
errors_found++;
- log_err("Found invalid metadata block at #%llu (0x%llx)\n",
- (unsigned long long)block, (unsigned long long)block);
+ log_info( _("Found invalid metadata at #%llu (0x%llx)\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) {
stack;
return -1;
}
- if(query(&opts, "Okay to free the invalid block? (y/n)")) {
+ if(query(&opts, _("Okay to free the invalid block? (y/n)"))) {
errors_corrected++;
gfs2_set_bitmap(sdp, block, GFS2_BLKST_FREE);
- log_err("The invalid block was freed.\n");
+ log_err( _("The invalid block was freed.\n"));
} else {
- log_err("The invalid block was ignored.\n");
+ log_err( _("The invalid block was ignored.\n"));
}
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)) {
@@ -997,15 +1014,17 @@ 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 %" PRIu64 " (0x%" PRIx64 ") is %u long\n",
- rgd->ri.ri_addr, rgd->ri.ri_addr, rgd->ri.ri_length);
+ 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);
for (i = 0; i < rgd->ri.ri_length; i++) {
if(gfs2_block_set(sbp, bl, rgd->ri.ri_addr + i,
gfs2_meta_other)){
@@ -1028,7 +1047,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 9b11cab..ff59968 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -16,6 +16,8 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -146,11 +148,16 @@ 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 %" PRIu64 " (0x%" PRIx64
- ") is in file or directory %" PRIu64
- " (0x%" PRIx64 ") named %s\n", id->block_no,
- id->block_no, ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr, filename);
+ log_debug( _("Duplicate block %llu (0x%llx"
+ ") is in file or directory %llu"
+ " (0x%llx) named %s\n"),
+ (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no,
+ (unsigned long long)
+ ip->i_di.di_num.no_addr,
+ (unsigned long long)
+ ip->i_di.di_num.no_addr,
+ filename);
/* If there are duplicates of
* duplicates, I guess we'll miss them
* here */
@@ -173,15 +180,15 @@ 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 duplicate reference in inode \"%s\" at block #%"
- PRIu64 " (0x%" PRIx64 ") to block #%" PRIu64 " (0x%"
- PRIx64 ")\n",
- dh->id->name ? dh->id->name : "unknown name",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- block, block);
- log_err("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n",
- dh->id->name ? dh->id->name : "", dh->id->parent,
- dh->id->parent);
+ log_err( _("Found duplicate reference in inode \"%s\" at "
+ "block #%llu (0x%llx) to 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"),
+ dh->id->name ? dh->id->name : "", dh->id->parent,
+ dh->id->parent);
inode_hash_remove(inode_hash, ip->i_di.di_num.no_addr);
/* Setting the block to invalid means the inode is
* cleared in pass2 */
@@ -209,12 +216,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 #%" PRIu64
- " (0x%" PRIx64 ") with block #%" PRIu64 " (0x%" PRIx64 ")\n",
- dh->id->name ? dh->id->name : "unknown name",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr, block,
- block);
- log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n",
+ 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"),
dh->id->name ? dh->id->name : "",
dh->id->parent, dh->id->parent);
gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr,
@@ -234,12 +243,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 #%" PRIu64
- " (0x%" PRIx64 ") with block #%" PRIu64 " (0x%" PRIx64 ")\n",
- dh->id->name ? dh->id->name : "unknown name",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr, block,
- block);
- log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n",
+ 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"),
dh->id->name ? dh->id->name : "",
dh->id->parent, dh->id->parent);
/* mark the main eattr block invalid */
@@ -285,7 +296,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);
}
}
@@ -306,12 +317,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 #%" PRIu64
- " (0x%" PRIx64 ") with block #%" PRIu64 " (0x%" PRIx64 ")\n",
- dh->id->name ? dh->id->name : "unknown name",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr, block,
- block);
- log_err("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n",
+ 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"),
dh->id->name ? dh->id->name : "",
dh->id->parent, dh->id->parent);
/* mark the main eattr block invalid */
@@ -343,15 +355,15 @@ int find_block_ref(struct gfs2_sbd *sbp, uint64_t inode, struct dup_blocks *b)
enum update_flags update;
ip = fsck_load_inode(sbp, inode); /* bread, inode_get */
- log_debug("Checking inode %" PRIu64 " (0x%" PRIx64 ")'s "
- "metatree for references to block %" PRIu64" (0x% " PRIx64
- ")\n", inode, inode, b->block_no, b->block_no);
+ log_debug( _("Checking inode %" PRIu64 " (0x%" PRIx64 ")'s "
+ "metatree for references to block %" PRIu64 " (0x%" PRIx64
+ ")\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_debug("Done checking metatree\n");
+ log_debug( _("Done checking metatree\n"));
/* Check for ea references in the inode */
if(check_inode_eattr(ip, &update, &find_refs) < 0){
stack;
@@ -360,15 +372,15 @@ int find_block_ref(struct gfs2_sbd *sbp, uint64_t inode, struct dup_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;
@@ -421,15 +433,17 @@ int handle_dup_blk(struct gfs2_sbd *sbp, struct dup_blocks *b)
if (be32_to_cpu(cmagic) == GFS2_MAGIC) {
tmp = b->ref_inode_list.next;
id = osi_list_entry(tmp, struct inode_with_dups, list);
- log_warn("Inode %s (%lld/0x%llx) has a reference to "
- "data block %"PRIu64" (0x%" PRIx64 "), but "
- "the block is really metadata.\n",
- id->name, id->block_no, id->block_no,
- b->block_no, b->block_no);
+ log_warn( _("Inode %s (%lld/0x%llx) has a reference to"
+ " data block %llu (0x%llx), "
+ "but the block is really metadata.\n"),
+ id->name, (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no,
+ (unsigned long long)b->block_no,
+ (unsigned long long)b->block_no);
errors_found++;
- if (query(&opts, "Clear the inode? (y/n) ")) {
+ if (query(&opts, _("Clear the inode? (y/n) "))) {
errors_corrected++;
- log_warn("Clearing inode %lld (0x%llx)...\n",
+ log_warn( _("Clearing inode %lld (0x%llx)...\n"),
(unsigned long long)id->block_no,
(unsigned long long)id->block_no);
ip = fsck_load_inode(sbp, id->block_no);
@@ -442,33 +456,39 @@ int handle_dup_blk(struct gfs2_sbd *sbp, struct dup_blocks *b)
gfs2_meta_inval);
fsck_inode_put(ip, updated);
} else {
- log_warn("The bad inode was not cleared.");
+ log_warn( _("The bad inode was not cleared."));
}
return 0;
}
}
- log_notice("Block %" PRIu64 " (0x%" PRIx64 ") has %d inodes referencing it"
- " for a total of %d duplicate references\n",
- b->block_no, b->block_no, dh.ref_inode_count,
- dh.ref_count);
+ 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 (%lld/0x%llx) has %d reference(s) to "
- "block %"PRIu64" (0x%" PRIx64 ")\n",
- id->name, id->block_no, id->block_no,
- id->dup_count, b->block_no, b->block_no);
+ log_warn( _("Inode %s (%lld/0x%llx) has %d reference(s) to "
+ "block %llu (0x%llx)\n"), id->name,
+ (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no,
+ id->dup_count, (unsigned long long)b->block_no,
+ (unsigned long long)b->block_no);
}
osi_list_foreach(tmp, &b->ref_inode_list) {
id = osi_list_entry(tmp, struct inode_with_dups, list);
errors_found++;
- if (!(query(&opts, "Okay to clear inode %lld (0x%llx)? (y/n) ",
- id->block_no, id->block_no))) {
- log_warn("The bad inode was not cleared...\n");
+ if (!(query(&opts, _("Okay to clear inode %lld (0x%llx)? "
+ "(y/n) "),
+ (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no))) {
+ log_warn( _("The bad inode was not cleared...\n"));
continue;
}
errors_corrected++;
- log_warn("Clearing inode %lld (0x%llx)...\n",
+ log_warn( _("Clearing inode %lld (0x%llx)...\n"),
(unsigned long long)id->block_no,
(unsigned long long)id->block_no);
ip = fsck_load_inode(sbp, id->block_no);
@@ -509,24 +529,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;
@@ -557,7 +577,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:
osi_list_foreach_safe(tmp, &sbp->dup_blocks.list, x) {
b = osi_list_entry(tmp, struct dup_blocks, list);
diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c
index 4736433..f707efc 100644
--- a/gfs2/fsck/pass1c.c
+++ b/gfs2/fsck/pass1c.c
@@ -15,6 +15,8 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -35,9 +37,9 @@ static int remove_eattr_entry(struct gfs2_sbd *sdp,
if (curr->ea_flags & GFS2_EAFLAG_LAST)
prev->ea_flags |= GFS2_EAFLAG_LAST;
}
- log_err("Bad Extended Attribute at block #%"PRIu64
- " (0x%" PRIx64 ") removed.\n",
- leaf_bh->b_blocknr, leaf_bh->b_blocknr);
+ log_err( _("Bad Extended Attribute at block #%"PRIu64
+ " (0x%" PRIx64 ") removed.\n"),
+ leaf_bh->b_blocknr, leaf_bh->b_blocknr);
return 0;
}
@@ -48,8 +50,8 @@ static int ask_remove_eattr_entry(struct gfs2_sbd *sdp,
int fix_curr, int fix_curr_len)
{
errors_found++;
- if (query(&opts, "Remove the bad Extended Attribute entry? "
- "(y/n) ")) {
+ if (query(&opts, _("Remove the bad Extended Attribute entry? "
+ "(y/n) "))) {
errors_corrected++;
if (fix_curr)
curr->ea_flags |= GFS2_EAFLAG_LAST;
@@ -64,7 +66,7 @@ static int ask_remove_eattr_entry(struct gfs2_sbd *sdp,
return -1;
}
} else {
- log_err("Bad Extended Attribute not removed.\n");
+ log_err( _("Bad Extended Attribute not removed.\n"));
}
return 1;
}
@@ -73,13 +75,13 @@ static int ask_remove_eattr(struct gfs2_inode *ip,
enum update_flags *need_update)
{
errors_found++;
- if (query(&opts, "Remove the bad Extended Attribute? (y/n) ")) {
+ if (query(&opts, _("Remove the bad Extended Attribute? (y/n) "))) {
errors_corrected++;
ip->i_di.di_eattr = 0;
*need_update = updated;
- log_err("Bad Extended Attribute removed.\n");
+ log_err( _("Bad Extended Attribute removed.\n"));
} else
- log_err("Bad Extended Attribute not removed.\n");
+ log_err( _("Bad Extended Attribute not removed.\n"));
return 1;
}
@@ -93,9 +95,9 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
*need_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,
@@ -107,9 +109,9 @@ static 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.\n",
+ " (0x%llx) invalid.\n"),
(unsigned long long)block,
(unsigned long long)block,
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -131,8 +133,8 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
struct gfs2_block_query q;
if(gfs2_check_range(sbp, block)) {
- log_err("Extended attributes block for inode #%llu"
- " (0x%llx) out of range.\n",
+ log_err( _("Extended attributes block for inode #%llu"
+ " (0x%llx) out of range.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
return ask_remove_eattr(ip, need_update);
@@ -142,8 +144,8 @@ static 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.\n",
+ log_err( _("Extended attributes block for 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);
return ask_remove_eattr(ip, need_update);
@@ -167,23 +169,23 @@ 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"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 1, 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"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 1, 1);
}
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"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
if(!ea_hdr->ea_name_len){
- log_err("EA has name length == 0\n");
+ log_err( _("EA has name length == 0\n"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
@@ -194,7 +196,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);
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
@@ -208,16 +210,14 @@ 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",
- 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"),
+ max_ptrs, ea_hdr->ea_num_ptrs);
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
} else {
- log_debug(" Pointers Required: %d\n"
- "Pointers Reported: %d\n",
- max_ptrs, ea_hdr->ea_num_ptrs);
+ log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
+ max_ptrs, ea_hdr->ea_num_ptrs);
}
}
return 0;
@@ -265,7 +265,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;
@@ -275,12 +275,12 @@ int pass1c(struct gfs2_sbd *sbp)
return FSCK_OK;
bh = bread(&sbp->buf_list, block_no);
if (!gfs2_check_meta(bh, GFS2_METATYPE_DI)) { /* 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_unmark(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 c664226..a7dbb41 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -17,6 +17,8 @@
#include <string.h>
#include <inttypes.h>
#include <sys/stat.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -37,9 +39,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;
@@ -47,8 +49,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;
}
@@ -68,17 +70,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;
}
@@ -147,7 +149,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;
}
@@ -193,9 +195,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,
@@ -207,23 +209,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;
}
}
@@ -236,18 +238,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;
@@ -262,10 +264,10 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* This entry's inode has bad blocks in it */
/* 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, "Delete inode containing bad blocks? (y/n)")) {
+ if(query(&opts, _("Delete inode containing bad blocks? (y/n)"))) {
errors_corrected++;
entry_ip = fsck_load_inode(sbp, de->de_inum.no_addr);
check_inode_eattr(entry_ip, update,
@@ -276,11 +278,11 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
gfs2_block_set(sbp, bl, de->de_inum.no_addr,
gfs2_block_free);
*update = updated;
- log_warn("The inode containing bad blocks was "
- "deleted.\n");
+ log_warn( _("The inode containing bad blocks was "
+ "deleted.\n"));
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;
@@ -291,23 +293,26 @@ 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' for block %" PRIu64
- " (0x%" PRIx64 ") in dir inode %" PRIu64 " (0x%" PRIx64
- ") block type %d: %s.\n", tmp_name,
- de->de_inum.no_addr, de->de_inum.no_addr,
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- q.block_type, q.block_type == gfs2_meta_inval ?
- "previously marked invalid" : "is not an inode");
+ log_err( _("Directory entry '%s' at block %llu (0x%llx"
+ ") in dir inode %llu (0x%llx"
+ ") block type %d: %s.\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,
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ q.block_type, q.block_type == gfs2_meta_inval ?
+ _("previously marked invalid") :
+ _("is not an inode"));
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) "))) {
struct gfs2_buffer_head *bhi;
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);
/* If it was previously marked invalid (i.e. known
to be bad, not just a free block, etc.) then
@@ -332,7 +337,7 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
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;
@@ -345,13 +350,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, %" PRIu64 "/0x%" PRIx64 ") "
- "conflicts with type '%s' in dinode. (Dir entry is stale.)\n",
- de_type_string(de->de_type), tmp_name,
- de->de_inum.no_addr, de->de_inum.no_addr,
- block_type_string(&q));
+ 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);
@@ -359,10 +365,10 @@ int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
dirent2_del(ip, bh, prev_de, dent);
*update = updated;
- log_err("Stale directory entry deleted\n");
+ log_err( _("Stale directory entry deleted\n"));
return 1;
} else {
- log_err("Stale directory entry remains\n");
+ log_err( _("Stale directory entry remains\n"));
(*count)++;
ds->entry_count++;
return 0;
@@ -370,14 +376,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 %" PRIu64 " (0x%"
- PRIx64 ")\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr);
+ 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);
@@ -389,7 +396,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? */
@@ -405,10 +412,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,
@@ -416,7 +423,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,
@@ -428,7 +435,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);
@@ -446,13 +453,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 %" PRIu64 " (0x%"
- PRIx64 ")\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr);
+ 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);
@@ -464,7 +472,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? */
@@ -476,12 +484,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 %" PRIu64 " (0x%"
- PRIx64 ") pointing to"
- " something that's not a directory",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr);
+ 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,
@@ -492,7 +500,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++;
@@ -521,7 +529,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)++;
@@ -529,23 +537,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;
@@ -589,7 +597,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;
@@ -619,25 +627,25 @@ 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);
errors_found++;
- if (query(&opts, "Is it okay to add '.' entry? (y/n) ")) {
+ if (query(&opts, _("Is it okay to add '.' entry? (y/n) "))) {
errors_corrected++;
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,
@@ -646,28 +654,30 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
free(filename);
update = 1;
} else
- log_err("The directory was not fixed.\n");
+ log_err( _("The directory was not fixed.\n"));
}
if(sysinode->i_di.di_entries != ds.entry_count) {
- log_err("%s inode %" PRIu64 " (0x%" PRIx64
- "): Entries is %d - should be %d\n", dirname,
- sysinode->i_di.di_num.no_addr,
- sysinode->i_di.di_num.no_addr,
+ 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 %" PRIu64 " (0x%"
- PRIx64 ")? (y/n) ", dirname,
- sysinode->i_di.di_num.no_addr,
- sysinode->i_di.di_num.no_addr)) {
+ 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 %" PRIu64 " (0x%" PRIx64
- ") left out of sync\n",
- sysinode->i_di.di_num.no_addr,
- sysinode->i_di.di_num.no_addr);
+ 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)
+ sysinode->i_di.di_num.no_addr);
}
}
@@ -730,7 +740,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++) {
need_update = 0;
@@ -743,16 +753,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;
@@ -782,9 +792,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,
@@ -794,39 +804,39 @@ 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 for directory inode at "
- "block %"PRIu64" (0x%" PRIx64 ")\n", i, i);
+ log_err(_("No '.' entry found for directory inode at "
+ "block %"PRIu64" (0x%" PRIx64 ")\n"), i, i);
errors_found++;
if (query(&opts,
- "Is it okay to add '.' entry? (y/n) ")) {
+ _("Is it okay to add '.' entry? (y/n) "))) {
errors_corrected++;
sprintf(tmp_name, ".");
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 FSCK_ERROR;
}
if(!memset(filename, 0, sizeof(char) *
filename_len)) {
- log_err("Unable to zero name\n");
+ log_err( _("Unable to zero name\n"));
stack;
return FSCK_ERROR;
}
@@ -838,27 +848,27 @@ int pass2(struct gfs2_sbd *sbp)
ip->i_di.di_num.no_addr);
ds.entry_count++;
free(filename);
- log_err("The directory was fixed.\n");
+ log_err( _("The directory was fixed.\n"));
need_update = UPDATED;
} else {
- log_err("The directory was not fixed.\n");
+ log_err( _("The directory was not fixed.\n"));
}
}
if(ip->i_di.di_entries != ds.entry_count) {
- log_err("Entries is %d - should be %d for inode "
- "block %" PRIu64 " (0x%" PRIx64 ")\n",
+ log_err( _("Entries is %d - should be %d for inode "
+ "block %llu (0x%llx)\n"),
ip->i_di.di_entries, ds.entry_count,
- ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr);
+ (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,
- "Fix the entry count? (y/n) ")) {
+ _("Fix the entry count? (y/n) "))) {
errors_corrected++;
ip->i_di.di_entries = ds.entry_count;
need_update = UPDATED;
} else {
- log_err("The entry count was not fixed.\n");
+ log_err( _("The entry count was not fixed.\n"));
}
}
fsck_inode_put(ip, need_update); /* does a gfs2_dinode_out,
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index a78d81e..46bd3aa 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -16,6 +16,8 @@
#include <inttypes.h>
#include <string.h>
#include <dirent.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "osi_list.h"
@@ -42,14 +44,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;
@@ -57,7 +59,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);
@@ -79,22 +81,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;
}
@@ -107,12 +109,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);
@@ -122,15 +124,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,
@@ -140,23 +142,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;
@@ -165,14 +167,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;
}
}
@@ -197,12 +199,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;
}
@@ -210,7 +212,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);
@@ -229,17 +231,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 &&
@@ -248,22 +250,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,
@@ -271,35 +273,35 @@ 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"));
fsck_inode_put(ip, updated);
} 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 a06647b..e217236 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -14,6 +14,8 @@
#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -34,15 +36,17 @@ struct metawalk_fxns pass4_fxns_delete = {
int fix_inode_count(struct gfs2_sbd *sbp, struct inode_info *ii,
struct gfs2_inode *ip)
{
- log_info("Fixing inode count for %" PRIu64 " (0x%" PRIx64 ") \n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr);
+ 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 %" PRIu64 " (0x%" PRIx64 ") to have %u links\n",
- ip->i_di.di_num.no_addr, ip->i_di.di_num.no_addr,
- ii->counted_links);
+ 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);
return 0;
}
@@ -61,26 +65,26 @@ 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, "Delete unlinked inode with "
- "bad blocks? (y/n) ")) {
+ if(query(&opts,
+ _("Delete unlinked inode with bad blocks? (y/n) "))) {
errors_corrected++;
ip = fsck_load_inode(sbp, ii->inode);
check_inode_eattr(ip, &f,
@@ -91,7 +95,7 @@ int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) {
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 &&
@@ -100,20 +104,22 @@ 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 is "
- "not an inode (%d)\n", q.block_type);
+ log_err( _("Unlinked block marked as inode is "
+ "not an inode (%d)\n"),
+ q.block_type);
ip = fsck_load_inode(sbp, ii->inode);
- if(query(&opts, "Delete unlinked inode "
- "? (y/n) ")) {
+ if(query(&opts, _("Delete unlinked inode "
+ "? (y/n) "))) {
check_inode_eattr(ip, &f,
&pass4_fxns_delete);
check_metatree(ip, &pass4_fxns_delete);
fsck_inode_put(ip, updated);
gfs2_block_set(sbp, bl, ii->inode,
gfs2_block_free);
- log_err("The inode was deleted\n");
+ log_err( _("The inode was deleted\n"));
} else {
- log_err("The inode was not deleted\n");
+ log_err( _("The inode was not "
+ "deleted\n"));
fsck_inode_put(ip, not_updated);
}
continue;
@@ -124,9 +130,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);
@@ -136,7 +142,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)) {
@@ -149,37 +155,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);
@@ -203,9 +209,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;
@@ -217,7 +223,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 ec89adf..aa9d3bd 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -15,6 +15,8 @@
#include <string.h>
#include <inttypes.h>
#include <stdlib.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fsck.h"
@@ -58,7 +60,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;
@@ -98,61 +100,59 @@ int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int buflen,
block_status == GFS2_BLKST_FREE) {
errors_found++;
if (free_unlinked == -1) {
- log_err("Unlinked inode block found at block %"
- "llu (0x%llx).\n",
- (unsigned long long)block,
- (unsigned long long)block);
- if(query(&opts, "Do you want me to fix the "
- "bitmap for all unlinked blocks? "
- "(y/n) "))
+ log_err( _("Unlinked inode block found at "
+ "block %llu (0x%llx).\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
+ if(query(&opts, _("Do you want me to fix the "
+ "bitmap for all unlinked "
+ "blocks? (y/n) ")))
free_unlinked = 1;
else
free_unlinked = 0;
}
if (free_unlinked) {
if(gfs2_set_bitmap(sbp, block, block_status))
- log_err("Unlinked block %llu (0x%llx)"
- " bitmap not fixed.\n",
+ log_err(_("Unlinked block %llu "
+ "(0x%llx) bitmap not fixed."
+ "\n"),
(unsigned long long)block,
(unsigned long long)block);
else {
- log_err("Unlinked block %llu (0x%llx)"
- " bitmap fixed.\n",
+ log_err(_("Unlinked block %llu "
+ "(0x%llx) bitmap fixed.\n"),
(unsigned long long)block,
(unsigned long long)block);
errors_corrected++;
}
} else {
- log_info("Unlinked block found at block %"
- PRIu64" (0x%" PRIx64 "), left "
- "unchanged.\n", block, block);
+ log_info( _("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 ",
- 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,
- block_type_string(&q));
+ 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,
+ 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;
@@ -185,14 +185,16 @@ 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 #%" PRIu64 " (0x%" PRIx64
- ") free count inconsistent: is %u should be %u\n",
- rgp->ri.ri_addr, rgp->ri.ri_addr, rgp->rg.rg_free, count[0]);
+ 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]);
rgp->rg.rg_free = count[0];
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;
@@ -201,19 +203,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;
}
@@ -237,7 +239,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 e8429a6..35e7811 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -18,6 +18,8 @@
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "osi_list.h"
@@ -58,7 +60,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++) {
@@ -68,8 +70,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);
@@ -144,14 +146,15 @@ 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;
rgdist = blk - block_of_last_rg;
- log_debug("dist 0x%" PRIx64 " = 0x% " PRIx64
- " - 0x%" PRIx64, rgdist,
- blk, block_of_last_rg);
+ log_debug("dist 0x%llx = 0x%llx - 0x%llx",
+ (unsigned long long)rgdist,
+ (unsigned long long)blk,
+ (unsigned long long)block_of_last_rg);
/* ----------------------------------------- */
/* We found an RG. Check to see if we need */
/* to set the first_rg_dist based on whether */
@@ -164,7 +167,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");
@@ -183,8 +186,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)) {
@@ -194,18 +197,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 */
/* -------------------------------------------------------------- */
@@ -216,14 +219,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));
@@ -236,11 +239,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;
}
}
@@ -262,10 +265,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%p, bh:\n",
- calc_rgd->ri.ri_addr, calc_rgd->bh);
+ 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 +
@@ -282,11 +286,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;
@@ -297,7 +301,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 */
@@ -313,20 +317,21 @@ 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);
- log_debug("%d: 0x%" PRIx64 " / %x / 0x%"
- PRIx64 " / 0x%x / 0x%x\n", rgi + 1,
- calc_rgd->ri.ri_addr, calc_rgd->ri.ri_length,
+ log_debug("%d: 0x%llx / %x / 0x%llx"
+ " / 0x%x / 0x%x\n", rgi + 1,
+ (unsigned long long)calc_rgd->ri.ri_addr,
+ calc_rgd->ri.ri_length,
calc_rgd->ri.ri_data0, calc_rgd->ri.ri_data,
calc_rgd->ri.ri_bitbytes);
}
@@ -358,7 +363,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 */
@@ -368,7 +373,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);
/* Move the rg list to the return list */
ret_list->next = sdp->rglist.next;
ret_list->prev = sdp->rglist.prev;
@@ -386,15 +391,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;
@@ -448,7 +453,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;
}
@@ -458,16 +463,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 = %d.\n", trust_lvl + 1,
- sdp->rgrps);
+ 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;
@@ -496,9 +501,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);
@@ -525,7 +530,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,
@@ -547,7 +552,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count)
free(actual->bits);
}
else
- log_err("RG index not fixed.\n");
+ log_err( _("RG index not fixed.\n"));
gfs2_compute_bitstructs(sdp, actual);
rindex_modified = FALSE;
}
diff --git a/gfs2/fsck/test_block_list.c b/gfs2/fsck/test_block_list.c
index 049eb91..b8e47e6 100644
--- a/gfs2/fsck/test_block_list.c
+++ b/gfs2/fsck/test_block_list.c
@@ -36,7 +36,7 @@ int main(int argc, char **argv)
block_mark(il, BITS-2, meta_inval);
block_mark(il, BITS-1, meta_free);
if(block_mark(il, BITS, meta_free)) {
- fprintf(stderr, "Block %d out of bounds\n", BITS);
+ fprintf(stderr, _("Block %d out of bounds\n"), BITS);
}
/*for(i = 0; i < BITS; i++) {
@@ -65,7 +65,7 @@ void print_map(struct block_list *il, int count)
int i, j;
struct block_query q;
- printf("Printing map of blocks - 60 blocks per row\n");
+ printf( _("Printing map of blocks - 60 blocks per row\n"));
j = 0;
for(i = 0; i < count; i++) {
@@ -83,7 +83,7 @@ void print_map(struct block_list *il, int count)
}
printf("\n");
- printf("Printing map of bad blocks - 60 blocks per row\n");
+ printf( _("Printing map of bad blocks - 60 blocks per row\n"));
j = 0;
for(i = 0; i < count; i++) {
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 074e6f9..ac609cb 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -18,6 +18,8 @@
#include <unistd.h>
#include <sys/time.h>
#include <stdio.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "fs_bits.h"
@@ -75,7 +77,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);
}
}
}
diff --git a/gfs2/mkfs/main.c b/gfs2/mkfs/main.c
index b8ff325..359b1c3 100644
--- a/gfs2/mkfs/main.c
+++ b/gfs2/mkfs/main.c
@@ -23,6 +23,9 @@
#include <time.h>
#include <errno.h>
#include <libgen.h>
+#include <libintl.h>
+#include <locale.h>
+#define _(String) gettext(String)
#include <linux/types.h>
#include "libgfs2.h"
@@ -44,6 +47,8 @@ main(int argc, char *argv[])
char *p, *whoami;
prog_name = argv[0];
+ setlocale(LC_ALL, "");
+ textdomain("gfs2-utils");
SRANDOM;
p = strdup(prog_name);
@@ -60,7 +65,7 @@ main(int argc, char *argv[])
main_shrink(argc, argv);
#endif
else
- die("I don't know who I am!\n");
+ die( _("I don't know who I am!\n"));
free(p);
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index 1fe9e63..6e52a56 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -28,6 +28,8 @@
#include <errno.h>
#include <stdarg.h>
#include <linux/types.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include "libgfs2.h"
#include "gfs2_mkfs.h"
@@ -56,7 +58,7 @@ extern int rename2system(struct gfs2_sbd *sdp, char *new_dir, char *new_name);
static void usage(void)
{
fprintf(stdout,
- "Usage:\n"
+ _("Usage:\n"
"\n"
"gfs2_grow [options] /path/to/filesystem\n"
"\n"
@@ -65,7 +67,7 @@ static void usage(void)
" -q Quiet, reduce verbosity\n"
" -T Test, do everything except update FS\n"
" -V Version information\n"
- " -v Verbose, increase verbosity\n");
+ " -v Verbose, increase verbosity\n"));
}
void decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
@@ -90,8 +92,8 @@ void decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
decrease_verbosity();
break;
case 'T':
- printf("(Test mode--File system will not "
- "be changed)\n");
+ printf( _("(Test mode--File system will not "
+ "be changed)\n"));
test = 1;
break;
case 'v':
@@ -100,11 +102,11 @@ void decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
case ':':
case '?':
/* Unknown flag */
- fprintf(stderr, "Please use '-h' for usage.\n");
+ fprintf(stderr, _("Please use '-h' for usage.\n"));
exit(EXIT_FAILURE);
default:
- fprintf(stderr, "Bad programmer! You forgot"
- " to catch the %c flag\n", opt);
+ fprintf(stderr, _("Bad programmer! You forgot"
+ " to catch the %c flag\n"), opt);
exit(EXIT_FAILURE);
break;
}
@@ -203,11 +205,11 @@ void fix_rindex(struct gfs2_sbd *sdp, int rindex_fd, int old_rg_count)
rg = 0;
osi_list_foreach(tmp, &sdp->rglist)
rg++;
- log_info("%d new rindex entries.\n", rg);
+ log_info( _("%d new rindex entries.\n"), rg);
writelen = rg * sizeof(struct gfs2_rindex);
zalloc(buf, writelen);
if (!buf)
- die("Unable to allocate memory for buffers.\n");
+ die( _("Unable to allocate memory for buffers.\n"));
/* Now add the new rg entries to the rg index. Here we */
/* need to use the gfs2 kernel code rather than the libgfs2 */
/* code so we have a live update while mounted. */
@@ -223,8 +225,8 @@ void fix_rindex(struct gfs2_sbd *sdp, int rindex_fd, int old_rg_count)
lseek(rindex_fd, 0, SEEK_END);
count = write(rindex_fd, buf, writelen);
if (count != writelen)
- log_crit("Error writing new rindex entries;"
- "aborted.\n");
+ log_crit( _("Error writing new rindex entries;"
+ "aborted.\n"));
fsync(rindex_fd);
}
free(buf);
@@ -236,14 +238,14 @@ void fix_rindex(struct gfs2_sbd *sdp, int rindex_fd, int old_rg_count)
*/
static void print_info(struct gfs2_sbd *sdp)
{
- log_notice("FS: Mount Point: %s\n", sdp->path_name);
- log_notice("FS: Device: %s\n", sdp->device_name);
- log_notice("FS: Size: %" PRIu64 " (0x%" PRIx64 ")\n",
+ log_notice( _("FS: Mount Point: %s\n"), sdp->path_name);
+ log_notice( _("FS: Device: %s\n"), sdp->device_name);
+ log_notice( _("FS: Size: %" PRIu64 " (0x%" PRIx64 ")\n"),
fssize, fssize);
- log_notice("FS: RG size: %u (0x%x)\n", rgsize, rgsize);
- log_notice("DEV: Size: %"PRIu64" (0x%" PRIx64")\n",
+ log_notice( _("FS: RG size: %u (0x%x)\n"), rgsize, rgsize);
+ log_notice( _("DEV: Size: %"PRIu64" (0x%" PRIx64")\n"),
sdp->device.length, sdp->device.length);
- log_notice("The file system grew by %" PRIu64 "MB.\n",
+ log_notice( _("The file system grew by %" PRIu64 "MB.\n"),
fsgrowth / MB);
}
@@ -272,17 +274,17 @@ main_grow(int argc, char *argv[])
sdp->path_name = argv[optind++];
sdp->path_fd = open(sdp->path_name, O_RDONLY);
if (sdp->path_fd < 0)
- die("can't open root directory %s: %s\n",
+ die( _("can't open root directory %s: %s\n"),
sdp->path_name, strerror(errno));
check_for_gfs2(sdp);
sdp->device_fd = open(sdp->device_name,
(test ? O_RDONLY : O_RDWR));
if (sdp->device_fd < 0)
- die("can't open device %s: %s\n",
+ die( _("can't open device %s: %s\n"),
sdp->device_name, strerror(errno));
device_geometry(sdp);
- 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);
@@ -291,7 +293,7 @@ main_grow(int argc, char *argv[])
sdp->bsize = sdp->sd_sb.sb_bsize;
compute_constants(sdp);
if(read_sb(sdp) < 0)
- die("gfs: Error reading superblock.\n");
+ die( _("gfs: Error reading superblock.\n"));
fix_device_geometry(sdp);
mount_gfs2_meta(sdp);
@@ -300,7 +302,7 @@ main_grow(int argc, char *argv[])
rindex_fd = open(rindex_name, (test ? O_RDONLY : O_RDWR));
if (rindex_fd < 0) {
cleanup_metafs(sdp);
- die("GFS2 rindex not found. Please run gfs2_fsck.\n");
+ die( _("GFS2 rindex not found. Please run gfs2_fsck.\n"));
}
/* Get master dinode */
sdp->master_dir =
@@ -316,12 +318,12 @@ main_grow(int argc, char *argv[])
figure_out_rgsize(sdp, &rgsize);
fsgrowth = ((sdp->device.length - fssize) * sdp->bsize);
if (fsgrowth < rgsize * sdp->bsize) {
- log_err("Error: The device has grown by less than "
- "one Resource Group (RG).\n");
- log_err("The device grew by %" PRIu64 "MB. ",
- fsgrowth / MB);
- log_err("One RG is %uMB for this file system.\n",
- (rgsize * sdp->bsize) / MB);
+ log_err( _("Error: The device has grown by less than "
+ "one Resource Group (RG).\n"));
+ log_err( _("The device grew by %" PRIu64 "MB. "),
+ fsgrowth / MB);
+ log_err( _("One RG is %uMB for this file system.\n"),
+ (rgsize * sdp->bsize) / MB);
}
else {
int old_rg_count;
@@ -340,5 +342,5 @@ main_grow(int argc, char *argv[])
}
close(sdp->path_fd);
sync();
- log_notice("gfs2_grow complete.\n");
+ log_notice( _("gfs2_grow complete.\n"));
}
diff --git a/gfs2/mkfs/main_jadd.c b/gfs2/mkfs/main_jadd.c
index e2bea53..4b5eb74 100644
--- a/gfs2/mkfs/main_jadd.c
+++ b/gfs2/mkfs/main_jadd.c
@@ -27,6 +27,8 @@
#include <time.h>
#include <errno.h>
#include <stdarg.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include <linux/types.h>
#include "libgfs2.h"
@@ -42,14 +44,14 @@ make_jdata(int fd, char *value)
err = ioctl(fd, FS_IOC_GETFLAGS, &val);
if (err)
- die("error doing get flags (%d): %s\n", err, strerror(errno));
+ die( _("error doing get flags (%d): %s\n"), err, strerror(errno));
if (strcmp(value, "set") == 0)
val |= FS_JOURNAL_DATA_FL;
if (strcmp(value, "clear") == 0)
val &= ~FS_JOURNAL_DATA_FL;
err = ioctl(fd, FS_IOC_SETFLAGS, &val);
if (err)
- die("error doing set flags (%d): %s\n", err, strerror(errno));
+ die( _("error doing set flags (%d): %s\n"), err, strerror(errno));
}
int
@@ -60,12 +62,12 @@ rename2system(struct gfs2_sbd *sdp, char *new_dir, char *new_name)
error = snprintf(oldpath, PATH_MAX, "%s/new_inode",
sdp->metafs_path);
if (error >= PATH_MAX)
- die("rename2system (1)\n");
+ die( _("rename2system (1)\n"));
error = snprintf(newpath, PATH_MAX, "%s/%s/%s",
sdp->metafs_path, new_dir, new_name);
if (error >= PATH_MAX)
- die("rename2system (2)\n");
+ die( _("rename2system (2)\n"));
return rename(oldpath, newpath);
}
@@ -78,19 +80,16 @@ rename2system(struct gfs2_sbd *sdp, char *new_dir, char *new_name)
static void
print_usage(void)
{
- printf("Usage:\n");
- printf("\n");
- printf("%s [options] /path/to/filesystem\n", prog_name);
- printf("\n");
- printf("Options:\n");
- printf("\n");
- printf(" -c <MB> Size of quota change file\n");
- printf(" -D Enable debugging code\n");
- printf(" -h Print this help, then exit\n");
- printf(" -J <MB> Size of journals\n");
- printf(" -j <num> Number of journals\n");
- printf(" -q Don't print anything\n");
- printf(" -V Print program version information, then exit\n");
+ printf( _("Usage:\n\n"
+ "%s [options] /path/to/filesystem\n\n"
+ "Options:\n\n"
+ " -c <MB> Size of quota change file\n"
+ " -D Enable debugging code\n"
+ " -h Print this help, then exit\n"
+ " -J <MB> Size of journals\n"
+ " -j <num> Number of journals\n"
+ " -q Don't print anything\n"
+ " -V Print program version information, then exit\n"), prog_name);
}
/**
@@ -148,7 +147,7 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
cont = FALSE;
break;
default:
- die("unknown option: %c\n", optchar);
+ die( _("unknown option: %c\n"), optchar);
break;
};
}
@@ -157,13 +156,13 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
sdp->path_name = argv[optind];
optind++;
} else
- die("no path specified (try -h for help)\n");
+ die( _("no path specified (try -h for help)\n"));
if (optind < argc)
- die("Unrecognized option: %s\n", argv[optind]);
+ die( _("Unrecognized option: %s\n"), argv[optind]);
if (sdp->debug) {
- printf("Command Line Arguments:\n");
+ printf( _("Command Line Arguments:\n"));
printf(" qcsize = %u\n", sdp->qcsize);
printf(" jsize = %u\n", sdp->jsize);
printf(" journals = %u\n", sdp->md.journals);
@@ -176,11 +175,11 @@ static void
verify_arguments(struct gfs2_sbd *sdp)
{
if (!sdp->md.journals)
- die("no journals specified\n");
+ die( _("no journals specified\n"));
if (sdp->jsize < 32 || sdp->jsize > 1024)
- die("bad journal size\n");
+ die( _("bad journal size\n"));
if (!sdp->qcsize || sdp->qcsize > 64)
- die("bad quota change size\n");
+ die( _("bad quota change size\n"));
}
/**
@@ -200,9 +199,9 @@ print_results(struct gfs2_sbd *sdp)
if (sdp->expert)
printf("Expert mode: on\n");
- printf("Filesystem: %s\n", sdp->path_name);
- printf("Old Journals %u\n", sdp->orig_journals);
- printf("New Journals %u\n", sdp->md.journals);
+ printf( _("Filesystem: %s\n"), sdp->path_name);
+ printf( _("Old Journals %u\n"), sdp->orig_journals);
+ printf( _("New Journals %u\n"), sdp->md.journals);
}
@@ -224,10 +223,10 @@ create_new_inode(struct gfs2_sbd *sdp)
if (errno == EEXIST) {
error = unlink(name);
if (error)
- die("can't unlink %s: %s\n",
+ die( _("can't unlink %s: %s\n"),
name, strerror(errno));
} else
- die("can't create %s: %s\n", name, strerror(errno));
+ die( _("can't create %s: %s\n"), name, strerror(errno));
}
return fd;
@@ -254,7 +253,7 @@ add_ir(struct gfs2_sbd *sdp)
sprintf(new_name, "inum_range%u", sdp->md.journals);
error = rename2system(sdp, "per_node", new_name);
if (error < 0 && errno != EEXIST)
- die("can't rename2system %s (%d): %s\n",
+ die( _("can't rename2system %s (%d): %s\n"),
new_name, error, strerror(errno));
}
@@ -280,7 +279,7 @@ add_sc(struct gfs2_sbd *sdp)
sprintf(new_name, "statfs_change%u", sdp->md.journals);
error = rename2system(sdp, "per_node", new_name);
if (error < 0 && errno != EEXIST)
- die("can't rename2system %s (%d): %s\n",
+ die( _("can't rename2system %s (%d): %s\n"),
new_name, error, strerror(errno));
}
@@ -321,7 +320,7 @@ add_qc(struct gfs2_sbd *sdp)
error = fsync(fd);
if (error)
- die("can't fsync: %s\n",
+ die( _("can't fsync: %s\n"),
strerror(errno));
}
@@ -330,7 +329,7 @@ add_qc(struct gfs2_sbd *sdp)
sprintf(new_name, "quota_change%u", sdp->md.journals);
error = rename2system(sdp, "per_node", new_name);
if (error < 0 && errno != EEXIST)
- die("can't rename2system %s (%d): %s\n",
+ die( _("can't rename2system %s (%d): %s\n"),
new_name, error, strerror(errno));
}
@@ -370,7 +369,7 @@ gather_info(struct gfs2_sbd *sdp)
{
struct statfs statbuf;
if (statfs(sdp->path_name, &statbuf) < 0) {
- die("Could not statfs the filesystem %s: %s\n",
+ die( _("Could not statfs the filesystem %s: %s\n"),
sdp->path_name, strerror(errno));
}
sdp->bsize = statbuf.f_bsize;
@@ -388,8 +387,8 @@ find_current_journals(struct gfs2_sbd *sdp)
sprintf(jindex, "%s/jindex", sdp->metafs_path);
dirp = opendir(jindex);
if (!dirp) {
- die("Could not find the jindex directory "
- "in gfs2meta mount! error: %s\n", strerror(errno));
+ die( _("Could not find the jindex directory "
+ "in gfs2meta mount! error: %s\n"), strerror(errno));
}
while (dirp) {
if ((dp = readdir(dirp)) != NULL) {
@@ -401,8 +400,8 @@ find_current_journals(struct gfs2_sbd *sdp)
close:
closedir(dirp);
if (existing_journals <= 0) {
- die("There are no journals for this "
- "gfs2 fs! Did you mkfs.gfs2 correctly?\n");
+ die( _("There are no journals for this "
+ "gfs2 fs! Did you mkfs.gfs2 correctly?\n"));
}
sdp->orig_journals = existing_journals;
@@ -456,7 +455,7 @@ add_j(struct gfs2_sbd *sdp)
error = fsync(fd);
if (error)
- die("can't fsync: %s\n",
+ die( _("can't fsync: %s\n"),
strerror(errno));
}
@@ -465,7 +464,7 @@ add_j(struct gfs2_sbd *sdp)
sprintf(new_name, "journal%u", sdp->md.journals);
error = rename2system(sdp, "jindex", new_name);
if (error < 0 && errno != EEXIST)
- die("can't rename2system %s (%d): %s\n",
+ die( _("can't rename2system %s (%d): %s\n"),
new_name, error, strerror(errno));
}
@@ -492,7 +491,7 @@ main_jadd(int argc, char *argv[])
sdp->path_fd = open(sdp->path_name, O_RDONLY);
if (sdp->path_fd < 0)
- die("can't open root directory %s: %s\n",
+ die( _("can't open root directory %s: %s\n"),
sdp->path_name, strerror(errno));
check_for_gfs2(sdp);
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 615a17c..3456f6d 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -26,6 +26,9 @@
#include <mntent.h>
#include <ctype.h>
#include <sys/time.h>
+#include <libintl.h>
+#define _(String) gettext(String)
+
#include <linux/types.h>
#include "libgfs2.h"
@@ -55,25 +58,22 @@ void print_it(const char *label, const char *fmt, const char *fmt2, ...)
static void
print_usage(void)
{
- printf("Usage:\n");
- printf("\n");
- printf("%s [options] <device> [ block-count ]\n", prog_name);
- printf("\n");
- printf("Options:\n");
- printf("\n");
- printf(" -b <bytes> Filesystem block size\n");
- printf(" -c <MB> Size of quota change file\n");
- printf(" -D Enable debugging code\n");
- printf(" -h Print this help, then exit\n");
- printf(" -J <MB> Size of journals\n");
- printf(" -j <num> Number of journals\n");
- printf(" -O Don't ask for confirmation\n");
- printf(" -p <name> Name of the locking protocol\n");
- printf(" -q Don't print anything\n");
- printf(" -r <MB> Resource Group Size\n");
- printf(" -t <name> Name of the lock table\n");
- printf(" -u <MB> Size of unlinked file\n");
- printf(" -V Print program version information, then exit\n");
+ printf( _("Usage:\n\n"
+ "%s [options] <device> [ block-count ]\n\n"
+ "Options:\n\n"
+ " -b <bytes> Filesystem block size\n"
+ " -c <MB> Size of quota change file\n"
+ " -D Enable debugging code\n"
+ " -h Print this help, then exit\n"
+ " -J <MB> Size of journals\n"
+ " -j <num> Number of journals\n"
+ " -O Don't ask for confirmation\n"
+ " -p <name> Name of the locking protocol\n"
+ " -q Don't print anything\n"
+ " -r <MB> Resource Group Size\n"
+ " -t <name> Name of the lock table\n"
+ " -u <MB> Size of unlinked file\n"
+ " -V Print program version information, then exit\n"), prog_name);
}
/**
@@ -129,7 +129,7 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
case 'p':
if (strlen(optarg) >= GFS2_LOCKNAME_LEN)
- die("lock protocol name %s is too long\n",
+ die( _("lock protocol name %s is too long\n"),
optarg);
strcpy(sdp->lockproto, optarg);
break;
@@ -144,7 +144,7 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
case 't':
if (strlen(optarg) >= GFS2_LOCKNAME_LEN)
- die("lock table name %s is too long\n", optarg);
+ die( _("lock table name %s is too long\n"), optarg);
strcpy(sdp->locktable, optarg);
break;
@@ -165,7 +165,7 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
case ':':
case '?':
- fprintf(stderr, "Please use '-h' for usage.\n");
+ fprintf(stderr, _("Please use '-h' for usage.\n"));
exit(EXIT_FAILURE);
break;
@@ -182,11 +182,11 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
isdigit(optarg[0]))
sdp->orig_fssize = atol(optarg);
else
- die("More than one device specified (try -h for help)\n");
+ die( _("More than one device specified (try -h for help)\n"));
break;
default:
- die("unknown option: %c\n", optchar);
+ die( _("unknown option: %c\n"), optchar);
break;
};
}
@@ -195,16 +195,16 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
strcpy(sdp->device_name, argv[optind++]);
if (sdp->device_name[0] == '\0')
- die("no device specified (try -h for help)\n");
+ die( _("no device specified (try -h for help)\n"));
if (optind < argc)
sdp->orig_fssize = atol(argv[optind++]);
if (optind < argc)
- die("Unrecognized argument: %s\n", argv[optind]);
+ die( _("Unrecognized argument: %s\n"), argv[optind]);
if (sdp->debug) {
- printf("Command Line Arguments:\n");
+ printf( _("Command Line Arguments:\n"));
printf(" bsize = %u\n", sdp->bsize);
printf(" qcsize = %u\n", sdp->qcsize);
printf(" jsize = %u\n", sdp->jsize);
@@ -213,7 +213,7 @@ decode_arguments(int argc, char *argv[], struct gfs2_sbd *sdp)
printf(" proto = %s\n", sdp->lockproto);
printf(" quiet = %d\n", sdp->quiet);
if (sdp->rgsize==-1)
- printf(" rgsize = optimize for best performance\n");
+ printf( _(" rgsize = optimize for best performance\n"));
else
printf(" rgsize = %u\n", sdp->rgsize);
printf(" table = %s\n", sdp->locktable);
@@ -240,28 +240,28 @@ verify_arguments(struct gfs2_sbd *sdp)
break;
if (!x || sdp->bsize > 65536)
- die("block size must be a power of two between 512 and 65536\n");
+ die( _("block size must be a power of two between 512 and 65536\n"));
/* Look at this! Why can't we go bigger than 2GB? */
if (sdp->expert) {
if (1 > sdp->rgsize || sdp->rgsize > 2048)
- die("bad resource group size\n");
+ die( _("bad resource group size\n"));
} else {
if (32 > sdp->rgsize || sdp->rgsize > 2048)
- die("bad resource group size\n");
+ die( _("bad resource group size\n"));
}
if (!sdp->md.journals)
- die("no journals specified\n");
+ die( _("no journals specified\n"));
if (sdp->jsize < 8 || sdp->jsize > 1024)
- die("bad journal size\n");
+ die( _("bad journal size\n"));
if (!sdp->utsize || sdp->utsize > 64)
- die("bad unlinked size\n");
+ die( _("bad unlinked size\n"));
if (!sdp->qcsize || sdp->qcsize > 64)
- die("bad quota change size\n");
+ die( _("bad quota change size\n"));
}
/**
@@ -277,19 +277,19 @@ static void are_you_sure(struct gfs2_sbd *sdp)
vid = volume_id_open_node(sdp->device_name);
if (vid == NULL)
- die("error identifying the contents of %s: %s\n",
- sdp->device_name, strerror(errno));
+ die( _("error identifying the contents of %s: %s\n"),
+ sdp->device_name, strerror(errno));
- printf("This will destroy any data on %s.\n", sdp->device_name);
+ printf( _("This will destroy any data on %s.\n"), sdp->device_name);
if (volume_id_probe_all(vid, 0, sdp->device_size) == 0)
- printf(" It appears to contain a %s %s.\n", vid->type,
- vid->usage_id == VOLUME_ID_OTHER? "partition" : vid->usage);
+ printf( _(" It appears to contain a %s %s.\n"), vid->type,
+ vid->usage_id == VOLUME_ID_OTHER? "partition" : vid->usage);
volume_id_close(vid);
- printf("\nAre you sure you want to proceed? [y/n] ");
+ printf(_("\nAre you sure you want to proceed? [y/n] "));
fgets(input, 32, stdin);
if (input[0] != 'y')
- die("aborted\n");
+ die( _("aborted\n"));
else
printf("\n");
}
@@ -306,15 +306,15 @@ void check_mount(char *device)
int fd;
if (stat(device, &st_buf) < 0)
- die("could not stat device %s\n", device);
+ die( _("could not stat device %s\n"), device);
if (!S_ISBLK(st_buf.st_mode))
- die("%s is not a block device\n", device);
+ die( _("%s is not a block device\n"), device);
fd = open(device, O_RDONLY | O_NONBLOCK | O_EXCL);
if (fd < 0) {
if (errno == EBUSY) {
- die("device %s is busy\n", device);
+ die( _("device %s is busy\n"), device);
}
}
else {
@@ -384,30 +384,31 @@ print_results(struct gfs2_sbd *sdp, uint64_t real_device_size,
return;
if (sdp->expert)
- printf("Expert mode: on\n");
+ printf( _("Expert mode: on\n"));
- printf("Device: %s\n", sdp->device_name);
+ printf( _("Device: %s\n"), sdp->device_name);
- printf("Blocksize: %u\n", sdp->bsize);
- printf("Device Size %.2f GB (%"PRIu64" blocks)\n",
+ printf( _("Blocksize: %u\n"), sdp->bsize);
+ printf( _("Device Size %.2f GB (%"PRIu64" blocks)\n"),
real_device_size / ((float)(1 << 30)),
real_device_size / sdp->bsize);
- printf("Filesystem Size: %.2f GB (%"PRIu64" blocks)\n",
+ printf( _("Filesystem Size: %.2f GB (%"PRIu64" blocks)\n"),
sdp->fssize / ((float)(1 << 30)) * sdp->bsize, sdp->fssize);
- printf("Journals: %u\n", sdp->md.journals);
- printf("Resource Groups: %"PRIu64"\n", sdp->rgrps);
+ printf( _("Journals: %u\n"), sdp->md.journals);
+ printf( _("Resource Groups: %"PRIu64"\n"), sdp->rgrps);
- printf("Locking Protocol: \"%s\"\n", sdp->lockproto);
- printf("Lock Table: \"%s\"\n", sdp->locktable);
+ printf( _("Locking Protocol: \"%s\"\n"), sdp->lockproto);
+ printf( _("Lock Table: \"%s\"\n"), sdp->locktable);
if (sdp->debug) {
printf("\n");
- printf("Spills: %u\n",
+ printf( _("Spills: %u\n"),
sdp->buf_list.spills);
- printf("Writes: %u\n", sdp->writes);
+ printf( _("Writes: %u\n"), sdp->writes);
}
- printf("UUID: %s\n", str_uuid(uuid));
+
+ printf( _("UUID: %s\n"), str_uuid(uuid));
printf("\n");
}
@@ -451,7 +452,7 @@ main_mkfs(int argc, char *argv[])
sdp->device_fd = open(sdp->device_name, O_RDWR);
if (sdp->device_fd < 0)
- die("can't open device %s: %s\n",
+ die( _("can't open device %s: %s\n"),
sdp->device_name, strerror(errno));
if (!sdp->override)
@@ -468,9 +469,9 @@ main_mkfs(int argc, char *argv[])
sdp->orig_fssize *= sdp->bsize;
sdp->orig_fssize >>= GFS2_BASIC_BLOCK_SHIFT;
if (sdp->orig_fssize > sdp->device.length) {
- fprintf(stderr, "%s: Specified block count is bigger "
- "than the actual device.\n", prog_name);
- die("Device Size is %.2f GB (%"PRIu64" blocks)\n",
+ fprintf(stderr, _("%s: Specified block count is bigger "
+ "than the actual device.\n"), argv[0]);
+ die( _("Device Size is %.2f GB (%"PRIu64" blocks)\n"),
real_device_size / ((float)(1 << 30)),
real_device_size / sdp->bsize);
}
@@ -512,11 +513,11 @@ main_mkfs(int argc, char *argv[])
error = fsync(sdp->device_fd);
if (error)
- die("can't fsync device (%d): %s\n",
+ die( _("can't fsync device (%d): %s\n"),
error, strerror(errno));
error = close(sdp->device_fd);
if (error)
- die("error closing device (%d): %s\n",
+ die( _("error closing device (%d): %s\n"),
error, strerror(errno));
print_results(sdp, real_device_size, uuid);
diff --git a/gfs2/tool/main.c b/gfs2/tool/main.c
index 8a8afaf..a2529c2 100644
--- a/gfs2/tool/main.c
+++ b/gfs2/tool/main.c
@@ -24,6 +24,9 @@
#include <limits.h>
#include <errno.h>
#include <linux/types.h>
+#include <libintl.h>
+#include <locale.h>
+#define _(String) gettext(String)
#include "copyright.cf"
@@ -206,15 +209,16 @@ decode_arguments(int argc, char *argv[])
break;
default:
- die("unknown option: %c\n", optchar);
+ die( _("unknown option: %c\n"), optchar);
};
}
if (optind < argc) {
action = argv[optind];
optind++;
- } else
- die("no action specified\n");
+ } else {
+ die( _("no action specified\n"));
+ }
}
/**
diff --git a/gfs2/tool/misc.c b/gfs2/tool/misc.c
index 940c2b7..4176882 100644
--- a/gfs2/tool/misc.c
+++ b/gfs2/tool/misc.c
@@ -25,6 +25,8 @@
#include <limits.h>
#include <errno.h>
#include <dirent.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#define __user
#include <linux/gfs2_ondisk.h>
@@ -128,8 +130,7 @@ print_lockdump(int argc, char **argv)
sprintf(debugfs, "/tmp/debugfs.XXXXXX");
if (!mkdtemp(debugfs)) {
- fprintf(stderr,
- "Can't create %s mount point.\n",
+ fprintf(stderr,_("Can't create %s mount point.\n"),
debugfs);
free(debugfs);
exit(-1);
@@ -138,8 +139,8 @@ print_lockdump(int argc, char **argv)
rc = mount("none", debugfs, "debugfs", 0, NULL);
if (rc) {
fprintf(stderr,
- "Can't mount debugfs. "
- "Maybe your kernel doesn't support it.\n");
+ _("Can't mount debugfs. "
+ "Maybe your kernel doesn't support it.\n"));
free(debugfs);
exit(-1);
}
@@ -151,15 +152,15 @@ print_lockdump(int argc, char **argv)
file = fopen(path, "rt");
if (file) {
while (fgets(line, PATH_MAX, file)) {
- printf(line);
+ printf("%s", line);
}
fclose(file);
} else {
- fprintf(stderr, "Can't open %s: %s\n", path,
+ fprintf(stderr, _("Can't open %s: %s\n"), path,
strerror(errno));
}
} else {
- fprintf(stderr, "Unable to locate sysfs for mount point %s.\n",
+ fprintf(stderr, _("Unable to locate sysfs for mount point %s.\n"),
argv[optind]);
}
/* Check if we mounted the debugfs and if so, unmount it. */
@@ -193,7 +194,7 @@ static void
print_flags(struct gfs2_dinode *di)
{
if (di->di_flags) {
- printf("Flags:\n");
+ printf( _("Flags:\n"));
if (di->di_flags & GFS2_DIF_JDATA)
printf(" jdata\n");
if (di->di_flags & GFS2_DIF_EXHASH)
@@ -259,22 +260,22 @@ set_flag(int argc, char **argv)
set = (strcmp(argv[optind -1], "setflag") == 0) ? 1 : 0;
flstr = argv[optind++];
if (!(flag = get_flag_from_name(flstr)))
- die("unrecognized flag %s\n", argv[optind -1]);
+ die( _("unrecognized flag %s\n"), argv[optind -1]);
for (; optind < argc; optind++) {
fd = open(argv[optind], O_RDONLY);
if (fd < 0)
- die("can't open %s: %s\n", argv[optind], strerror(errno));
+ die( _("can't open %s: %s\n"), argv[optind], strerror(errno));
/* first get the existing flags on the file */
error = ioctl(fd, FS_IOC_GETFLAGS, &newflags);
if (error)
- die("can't get flags on %s: %s\n",
+ die( _("can't get flags on %s: %s\n"),
argv[optind], strerror(errno));
newflags = set ? newflags | flag : newflags & ~flag;
/* new flags */
error = ioctl(fd, FS_IOC_SETFLAGS, &newflags);
if (error)
- die("can't set flags on %s: %s\n",
+ die( _("can't set flags on %s: %s\n"),
argv[optind], strerror(errno));
close(fd);
}
@@ -441,14 +442,14 @@ print_journals(int argc, char **argv)
check_for_gfs2(&sbd);
sbd.device_fd = open(sbd.device_name, O_RDONLY);
if (sbd.device_fd < 0)
- die("can't open device %s: %s\n",
+ die( _("can't open device %s: %s\n"),
sbd.device_name, strerror(errno));
mount_gfs2_meta(&sbd);
sprintf(jindex_name, "%s/jindex", sbd.metafs_path);
jindex = opendir(jindex_name);
if (!jindex) {
- die("Can't open %s\n", jindex_name);
+ die( _("Can't open %s\n"), jindex_name);
} else {
jcount = 0;
while ((journal = readdir(jindex))) {
@@ -464,7 +465,7 @@ print_journals(int argc, char **argv)
(unsigned long long)statbuf.st_size / 1048576);
}
- printf("%d journal(s) found.\n", jcount);
+ printf( _("%d journal(s) found.\n"), jcount);
closedir(jindex);
}
cleanup_metafs(&sbd);
diff --git a/gfs2/tool/sb.c b/gfs2/tool/sb.c
index ccf4039..cf76d6e 100644
--- a/gfs2/tool/sb.c
+++ b/gfs2/tool/sb.c
@@ -26,6 +26,8 @@
#include <limits.h>
#include <errno.h>
#include <ctype.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#include <linux/gfs2_ondisk.h>
@@ -105,12 +107,13 @@ do_sb(int argc, char **argv)
die("can't open %s: %s\n", device, strerror(errno));
if (newval && !override) {
- printf("You shouldn't change any of these values if the filesystem is mounted.\n");
- printf("\nAre you sure? [y/n] ");
- fgets((char*)input, 255, stdin);
+ printf( _("You shouldn't change any of these values if the filesystem is mounted.\n"));
+ printf( _("\nAre you sure? [y/n] "));
+ if(!fgets((char*)input, 255, stdin))
+ die( _("unable to read from stdin\n"));
if (input[0] != 'y')
- die("aborted\n");
+ die( _("aborted\n"));
printf("\n");
}
@@ -122,84 +125,84 @@ do_sb(int argc, char **argv)
if (sb.sb_header.mh_magic != GFS2_MAGIC ||
sb.sb_header.mh_type != GFS2_METATYPE_SB)
- die("there isn't a GFS2 filesystem on %s\n", device);
+ die( _("there isn't a GFS2 filesystem on %s\n"), device);
if (strcmp(field, "proto") == 0) {
- printf("current lock protocol name = \"%s\"\n",
+ printf( _("current lock protocol name = \"%s\"\n"),
sb.sb_lockproto);
if (newval) {
if (strlen(newval) >= GFS2_LOCKNAME_LEN)
- die("new lockproto name is too long\n");
+ die( _("new lockproto name is too long\n"));
strcpy(sb.sb_lockproto, newval);
- printf("new lock protocol name = \"%s\"\n",
+ printf( _("new lock protocol name = \"%s\"\n"),
sb.sb_lockproto);
}
} else if (strcmp(field, "table") == 0) {
- printf("current lock table name = \"%s\"\n",
+ printf( _("current lock table name = \"%s\"\n"),
sb.sb_locktable);
if (newval) {
if (strlen(newval) >= GFS2_LOCKNAME_LEN)
- die("new locktable name is too long\n");
+ die( _("new locktable name is too long\n"));
strcpy(sb.sb_locktable, newval);
- printf("new lock table name = \"%s\"\n",
+ printf( _("new lock table name = \"%s\"\n"),
sb.sb_locktable);
}
} else if (strcmp(field, "ondisk") == 0) {
- printf("current ondisk format = %u\n",
+ printf( _("current ondisk format = %u\n"),
sb.sb_fs_format);
if (newval) {
sb.sb_fs_format = atoi(newval);
- printf("new ondisk format = %u\n",
+ printf( _("new ondisk format = %u\n"),
sb.sb_fs_format);
}
} else if (strcmp(field, "multihost") == 0) {
- printf("current multihost format = %u\n",
+ printf( _("current multihost format = %u\n"),
sb.sb_multihost_format);
if (newval) {
sb.sb_multihost_format = atoi(newval);
- printf("new multihost format = %u\n",
+ printf( _("new multihost format = %u\n"),
sb.sb_multihost_format);
}
#ifdef GFS2_HAS_UUID
} else if (strcmp(field, "uuid") == 0) {
- printf("current uuid = %s\n", str_uuid(sb.sb_uuid));
+ printf( _("current uuid = %s\n"), str_uuid(sb.sb_uuid));
if (newval) {
int i;
unsigned char uuid[16], *cp;
if (strlen(newval) != 36)
- die("uuid %s is the wrong length; must be 36 "
- "hex characters long.\n", newval);
+ die( _("uuid %s is the wrong length; must be 36 "
+ "hex characters long.\n"), newval);
cp = uuid;
for (i = 0; i < 36; i++) {
if ((i == 8) || (i == 13) ||
(i == 18) || (i == 23)) {
if (newval[i] == '-')
continue;
- die("uuid %s has an invalid format.",
+ die( _("uuid %s has an invalid format."),
newval);
}
if (!isxdigit(newval[i]))
- die("uuid %s has an invalid hex "
- "digit '%c' at offset %d.\n",
+ die( _("uuid %s has an invalid hex "
+ "digit '%c' at offset %d.\n"),
newval, newval[i], i + 1);
*cp = str_to_hexchar(&newval[i++]);
cp++;
}
memcpy(sb.sb_uuid, uuid, 16);
- printf("new uuid = %s\n", str_uuid(sb.sb_uuid));
+ printf( _("new uuid = %s\n"), str_uuid(sb.sb_uuid));
}
#endif
} else if (strcmp(field, "all") == 0) {
gfs2_sb_print(&sb);
newval = FALSE;
} else
- die("unknown field %s\n", field);
+ die( _("unknown field %s\n"), field);
if (newval) {
gfs2_sb_out(&sb,(char*) buf);
@@ -209,7 +212,7 @@ do_sb(int argc, char **argv)
fsync(fd);
- printf("Done\n");
+ printf( _("Done\n"));
}
close(fd);
diff --git a/gfs2/tool/tune.c b/gfs2/tool/tune.c
index 294ff54..13b51f3 100644
--- a/gfs2/tool/tune.c
+++ b/gfs2/tool/tune.c
@@ -25,6 +25,8 @@
#include <limits.h>
#include <errno.h>
#include <dirent.h>
+#include <libintl.h>
+#define _(String) gettext(String)
#define __user
@@ -52,7 +54,7 @@ get_tune(int argc, char **argv)
struct gfs2_sbd sbd;
if (optind == argc)
- die("Usage: gfs2_tool gettune <mountpoint>\n");
+ die( _("Usage: gfs2_tool gettune <mountpoint>\n"));
sbd.path_name = argv[optind];
check_for_gfs2(&sbd);
@@ -62,7 +64,7 @@ get_tune(int argc, char **argv)
d = opendir(path);
if (!d)
- die("can't open %s: %s\n", path, strerror(errno));
+ die( _("can't open %s: %s\n"), path, strerror(errno));
while((de = readdir(d))) {
if (de->d_name[0] == '.')
@@ -72,7 +74,7 @@ get_tune(int argc, char **argv)
sscanf(get_sysfs(fs, "tune/quota_scale"), "%u %u",
&num, &den);
ratio = (double)num / den;
- printf("quota_scale = %.4f (%u, %u)\n", ratio, num,
+ printf( _("quota_scale = %.4f (%u, %u)\n"), ratio, num,
den);
} else
printf("%s = %s\n", de->d_name, get_sysfs(fs, path));
@@ -97,13 +99,13 @@ set_tune(int argc, char **argv)
struct gfs2_sbd sbd;
if (optind == argc)
- die("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n");
+ die( _("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n"));
sbd.path_name = argv[optind++];
if (optind == argc)
- die("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n");
+ die( _("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n"));
param = argv[optind++];
if (optind == argc)
- die("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n");
+ die( _("Usage: gfs2_tool settune <mountpoint> <parameter> <value>\n"));
value = argv[optind++];
check_for_gfs2(&sbd);
distrib
>
Scientific%20Linux
>
5x
>
x86_64
>
by-pkgid
>
9383e745e23602bc45f9c92184feea59
>
files
>
1
