Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/e2fsprogs/old_e2fsprogs/e2fsck.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/e2fsprogs/old_e2fsprogs/e2fsck.c (modified) (88 diffs)

branches/2.2.9/mindi-busybox/e2fsprogs/old_e2fsprogs/e2fsck.c

@@ -27 +27 @@
  * part of the ext2fs journaling system.
  *
- * Licensed under GPLv2 or later, see file License in this tarball for details.
- */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1 /* get strnlen() */
-#endif
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
 
 #include "e2fsck.h" /*Put all of our defines here to clean things up*/
@@ -90 +86 @@
 struct problem_context {
     errcode_t       errcode;
-    ext2_ino_t ino, ino2, dir;
+    ext2_ino_t      ino, ino2, dir;
     struct ext2_inode *inode;
     struct ext2_dir_entry *dirent;
-    blk_t   blk, blk2;
+    blk_t           blk, blk2;
     e2_blkcnt_t     blkcount;
     int             group;
-    __u64   num;
-    const char *str;
+    __u64           num;
+    const char      *str;
 };
 
@@ -134 +130 @@
 
 typedef struct dnode_t {
-    struct dnode_t *dict_left;
-    struct dnode_t *dict_right;
-    struct dnode_t *dict_parent;
-    dnode_color_t dict_color;
-    const void *dict_key;
-    void *dict_data;
+    struct dnode_t *dict_left;
+    struct dnode_t *dict_right;
+    struct dnode_t *dict_parent;
+    dnode_color_t dict_color;
+    const void *dict_key;
+    void *dict_data;
 } dnode_t;
 
@@ -146 +142 @@
 
 typedef struct dict_t {
-    dnode_t dict_nilnode;
-    dictcount_t dict_nodecount;
-    dictcount_t dict_maxcount;
-    dict_comp_t dict_compare;
-    dnode_free_t dict_freenode;
-    int dict_dupes;
+    dnode_t dict_nilnode;
+    dictcount_t dict_nodecount;
+    dictcount_t dict_maxcount;
+    dict_comp_t dict_compare;
+    dnode_free_t dict_freenode;
+    int dict_dupes;
 } dict_t;
 
@@ -157 +153 @@
 
 typedef struct dict_load_t {
-    dict_t *dict_dictptr;
-    dnode_t dict_nilnode;
+    dict_t *dict_dictptr;
+    dnode_t dict_nilnode;
 } dict_load_t;
 
@@ -193 +189 @@
 #define K_DEV_JOURNAL   2
 
-#define lock_buffer(bh) do {} while(0)
-#define unlock_buffer(bh) do {} while(0)
+#define lock_buffer(bh) do {} while (0)
+#define unlock_buffer(bh) do {} while (0)
 #define buffer_req(bh) 1
-#define do_readahead(journal, start) do {} while(0)
+#define do_readahead(journal, start) do {} while (0)
 
 static e2fsck_t e2fsck_global_ctx;  /* Try your very best not to use this! */
@@ -215 +211 @@
     kmem_cache_t *new_cache;
 
-    new_cache = malloc(sizeof(*new_cache));
-    if (new_cache)
-        new_cache->object_length = len;
+    new_cache = xmalloc(sizeof(*new_cache));
+    new_cache->object_length = len;
     return new_cache;
 }
@@ -270 +265 @@
 static void rotate_left(dnode_t *upper)
 {
-    dnode_t *lower, *lowleft, *upparent;
-
-    lower = upper->right;
-    upper->right = lowleft = lower->left;
-    lowleft->parent = upper;
-
-    lower->parent = upparent = upper->parent;
-
-    /* don't need to check for root node here because root->parent is
-       the sentinel nil node, and root->parent->left points back to root */
-
-    if (upper == upparent->left) {
-    upparent->left = lower;
-    } else {
-    assert (upper == upparent->right);
-    upparent->right = lower;
-    }
-
-    lower->left = upper;
-    upper->parent = lower;
+    dnode_t *lower, *lowleft, *upparent;
+
+    lower = upper->right;
+    upper->right = lowleft = lower->left;
+    lowleft->parent = upper;
+
+    lower->parent = upparent = upper->parent;
+
+    /* don't need to check for root node here because root->parent is
+       the sentinel nil node, and root->parent->left points back to root */
+
+    if (upper == upparent->left) {
+        upparent->left = lower;
+    } else {
+        assert (upper == upparent->right);
+        upparent->right = lower;
+    }
+
+    lower->left = upper;
+    upper->parent = lower;
 }
 
@@ -299 +294 @@
 static void rotate_right(dnode_t *upper)
 {
-    dnode_t *lower, *lowright, *upparent;
-
-    lower = upper->left;
-    upper->left = lowright = lower->right;
-    lowright->parent = upper;
-
-    lower->parent = upparent = upper->parent;
-
-    if (upper == upparent->right) {
-    upparent->right = lower;
-    } else {
-    assert (upper == upparent->left);
-    upparent->left = lower;
-    }
-
-    lower->right = upper;
-    upper->parent = lower;
+    dnode_t *lower, *lowright, *upparent;
+
+    lower = upper->left;
+    upper->left = lowright = lower->right;
+    lowright->parent = upper;
+
+    lower->parent = upparent = upper->parent;
+
+    if (upper == upparent->right) {
+        upparent->right = lower;
+    } else {
+        assert (upper == upparent->left);
+        upparent->left = lower;
+    }
+
+    lower->right = upper;
+    upper->parent = lower;
 }
 
@@ -325 +320 @@
 static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil)
 {
-    if (node == nil)
-    return;
-    free_nodes(dict, node->left, nil);
-    free_nodes(dict, node->right, nil);
-    dict->dict_freenode(node);
+    if (node == nil)
+        return;
+    free_nodes(dict, node->left, nil);
+    free_nodes(dict, node->right, nil);
+    dict->dict_freenode(node);
 }
 
@@ -341 +336 @@
 static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node)
 {
-    if (root != nil) {
-    return root == node
-        || verify_dict_has_node(nil, root->left, node)
-        || verify_dict_has_node(nil, root->right, node);
-    }
-    return 0;
+    if (root != nil) {
+        return root == node
+            || verify_dict_has_node(nil, root->left, node)
+            || verify_dict_has_node(nil, root->right, node);
+    }
+    return 0;
 }
 
@@ -356 +351 @@
 static void dict_set_allocator(dict_t *dict, dnode_free_t fr)
 {
-    assert (dict_count(dict) == 0);
-    dict->dict_freenode = fr;
+    assert(dict_count(dict) == 0);
+    dict->dict_freenode = fr;
 }
 
@@ -367 +362 @@
 static void dict_free_nodes(dict_t *dict)
 {
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
-    free_nodes(dict, root, nil);
-    dict->dict_nodecount = 0;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
+    dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
+    free_nodes(dict, root, nil);
+    dict->dict_nodecount = 0;
+    dict->nilnode.left = &dict->nilnode;
+    dict->nilnode.right = &dict->nilnode;
 }
 
@@ -380 +375 @@
 static dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp)
 {
-    dict->compare = comp;
-    dict->dict_freenode = dnode_free;
-    dict->dict_nodecount = 0;
-    dict->maxcount = maxcount;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
-    dict->nilnode.parent = &dict->nilnode;
-    dict->nilnode.color = dnode_black;
-    dict->dupes = 0;
-    return dict;
+    dict->compare = comp;
+    dict->dict_freenode = dnode_free;
+    dict->dict_nodecount = 0;
+    dict->maxcount = maxcount;
+    dict->nilnode.left = &dict->nilnode;
+    dict->nilnode.right = &dict->nilnode;
+    dict->nilnode.parent = &dict->nilnode;
+    dict->nilnode.color = dnode_black;
+    dict->dupes = 0;
+    return dict;
 }
 
@@ -401 +396 @@
 static dnode_t *dict_lookup(dict_t *dict, const void *key)
 {
-    dnode_t *root = dict_root(dict);
-    dnode_t *nil = dict_nil(dict);
-    dnode_t *saved;
-    int result;
-
-    /* simple binary search adapted for trees that contain duplicate keys */
-
-    while (root != nil) {
-    result = dict->compare(key, root->key);
-    if (result < 0)
-        root = root->left;
-    else if (result > 0)
-        root = root->right;
-    else {
-        if (!dict->dupes) { /* no duplicates, return match          */
-        return root;
-        } else {            /* could be dupes, find leftmost one    */
-        do {
-            saved = root;
-            root = root->left;
-            while (root != nil && dict->compare(key, root->key))
+    dnode_t *root = dict_root(dict);
+    dnode_t *nil = dict_nil(dict);
+    dnode_t *saved;
+    int result;
+
+    /* simple binary search adapted for trees that contain duplicate keys */
+
+    while (root != nil) {
+        result = dict->compare(key, root->key);
+        if (result < 0)
+            root = root->left;
+        else if (result > 0)
             root = root->right;
-        } while (root != nil);
-        return saved;
-        }
-    }
-    }
-
-    return NULL;
+        else {
+            if (!dict->dupes) { /* no duplicates, return match          */
+                return root;
+            } else {            /* could be dupes, find leftmost one    */
+                do {
+                    saved = root;
+                    root = root->left;
+                    while (root != nil && dict->compare(key, root->key))
+                        root = root->right;
+                } while (root != nil);
+                return saved;
+            }
+        }
+    }
+
+    return NULL;
 }
 
@@ -442 +437 @@
 static void dict_insert(dict_t *dict, dnode_t *node, const void *key)
 {
-    dnode_t *where = dict_root(dict), *nil = dict_nil(dict);
-    dnode_t *parent = nil, *uncle, *grandpa;
-    int result = -1;
-
-    node->key = key;
-
-    /* basic binary tree insert */
-
-    while (where != nil) {
-    parent = where;
-    result = dict->compare(key, where->key);
-    /* trap attempts at duplicate key insertion unless it's explicitly allowed */
-    assert (dict->dupes || result != 0);
+    dnode_t *where = dict_root(dict), *nil = dict_nil(dict);
+    dnode_t *parent = nil, *uncle, *grandpa;
+    int result = -1;
+
+    node->key = key;
+
+    /* basic binary tree insert */
+
+    while (where != nil) {
+        parent = where;
+        result = dict->compare(key, where->key);
+        /* trap attempts at duplicate key insertion unless it's explicitly allowed */
+        assert(dict->dupes || result != 0);
+        if (result < 0)
+            where = where->left;
+        else
+            where = where->right;
+    }
+
+    assert(where == nil);
+
     if (result < 0)
-        where = where->left;
+        parent->left = node;
     else
-        where = where->right;
-    }
-
-    assert (where == nil);
-
-    if (result < 0)
-    parent->left = node;
-    else
-    parent->right = node;
-
-    node->parent = parent;
-    node->left = nil;
-    node->right = nil;
-
-    dict->dict_nodecount++;
-
-    /* red black adjustments */
-
-    node->color = dnode_red;
-
-    while (parent->color == dnode_red) {
-    grandpa = parent->parent;
-    if (parent == grandpa->left) {
-        uncle = grandpa->right;
-        if (uncle->color == dnode_red) {    /* red parent, red uncle */
-        parent->color = dnode_black;
-        uncle->color = dnode_black;
-        grandpa->color = dnode_red;
-        node = grandpa;
-        parent = grandpa->parent;
-        } else {                            /* red parent, black uncle */
-        if (node == parent->right) {
-            rotate_left(parent);
-            parent = node;
-            assert (grandpa == parent->parent);
-            /* rotation between parent and child preserves grandpa */
-        }
-        parent->color = dnode_black;
-        grandpa->color = dnode_red;
-        rotate_right(grandpa);
-        break;
-        }
-    } else {        /* symmetric cases: parent == parent->parent->right */
-        uncle = grandpa->left;
-        if (uncle->color == dnode_red) {
-        parent->color = dnode_black;
-        uncle->color = dnode_black;
-        grandpa->color = dnode_red;
-        node = grandpa;
-        parent = grandpa->parent;
-        } else {
-        if (node == parent->left) {
-            rotate_right(parent);
-            parent = node;
-            assert (grandpa == parent->parent);
-        }
-        parent->color = dnode_black;
-        grandpa->color = dnode_red;
-        rotate_left(grandpa);
-        break;
-        }
-    }
-    }
-
-    dict_root(dict)->color = dnode_black;
-
+        parent->right = node;
+
+    node->parent = parent;
+    node->left = nil;
+    node->right = nil;
+
+    dict->dict_nodecount++;
+
+    /* red black adjustments */
+
+    node->color = dnode_red;
+
+    while (parent->color == dnode_red) {
+        grandpa = parent->parent;
+        if (parent == grandpa->left) {
+            uncle = grandpa->right;
+            if (uncle->color == dnode_red) {    /* red parent, red uncle */
+                parent->color = dnode_black;
+                uncle->color = dnode_black;
+                grandpa->color = dnode_red;
+                node = grandpa;
+                parent = grandpa->parent;
+            } else {                            /* red parent, black uncle */
+                if (node == parent->right) {
+                    rotate_left(parent);
+                    parent = node;
+                    assert (grandpa == parent->parent);
+                    /* rotation between parent and child preserves grandpa */
+                }
+                parent->color = dnode_black;
+                grandpa->color = dnode_red;
+                rotate_right(grandpa);
+                break;
+            }
+        } else {        /* symmetric cases: parent == parent->parent->right */
+            uncle = grandpa->left;
+            if (uncle->color == dnode_red) {
+                parent->color = dnode_black;
+                uncle->color = dnode_black;
+                grandpa->color = dnode_red;
+                node = grandpa;
+                parent = grandpa->parent;
+            } else {
+                if (node == parent->left) {
+                    rotate_right(parent);
+                    parent = node;
+                    assert (grandpa == parent->parent);
+                }
+                parent->color = dnode_black;
+                grandpa->color = dnode_red;
+                rotate_left(grandpa);
+                break;
+            }
+        }
+    }
+
+    dict_root(dict)->color = dnode_black;
 }
 
@@ -533 +527 @@
 static dnode_t *dnode_init(dnode_t *dnode, void *data)
 {
-    dnode->data = data;
-    dnode->parent = NULL;
-    dnode->left = NULL;
-    dnode->right = NULL;
-    return dnode;
+    dnode->data = data;
+    dnode->parent = NULL;
+    dnode->left = NULL;
+    dnode->right = NULL;
+    return dnode;
 }
 
 static int dict_alloc_insert(dict_t *dict, const void *key, void *data)
 {
-    dnode_t *node = malloc(sizeof(dnode_t));
-
-    if (node) {
+    dnode_t *node = xmalloc(sizeof(dnode_t));
+
     dnode_init(node, data);
     dict_insert(dict, node, key);
     return 1;
-    }
-    return 0;
 }
 
@@ -559 +550 @@
 static dnode_t *dict_first(dict_t *dict)
 {
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left;
-
-    if (root != nil)
-    while ((left = root->left) != nil)
-        root = left;
-
-    return (root == nil) ? NULL : root;
+    dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left;
+
+    if (root != nil)
+        while ((left = root->left) != nil)
+            root = left;
+
+    return (root == nil) ? NULL : root;
 }
 
@@ -577 +568 @@
 static dnode_t *dict_next(dict_t *dict, dnode_t *curr)
 {
-    dnode_t *nil = dict_nil(dict), *parent, *left;
-
-    if (curr->right != nil) {
-    curr = curr->right;
-    while ((left = curr->left) != nil)
-        curr = left;
-    return curr;
-    }
-
-    parent = curr->parent;
-
-    while (parent != nil && curr == parent->right) {
-    curr = parent;
+    dnode_t *nil = dict_nil(dict), *parent, *left;
+
+    if (curr->right != nil) {
+        curr = curr->right;
+        while ((left = curr->left) != nil)
+            curr = left;
+        return curr;
+    }
+
     parent = curr->parent;
-    }
-
-    return (parent == nil) ? NULL : parent;
+
+    while (parent != nil && curr == parent->right) {
+        curr = parent;
+        parent = curr->parent;
+    }
+
+    return (parent == nil) ? NULL : parent;
 }
 
@@ -599 +590 @@
 static void dnode_free(dnode_t *node)
 {
-    free(node);
+    free(node);
 }
 
@@ -810 +801 @@
                        * sizeof (struct dx_dirblock_info),
                        "dx_block info array");
-
 }
 
@@ -1544 +1534 @@
     struct inode            *j_inode = NULL;
     struct kdev_s           *dev_fs = NULL, *dev_journal;
-    const char              *journal_name = 0;
+    const char              *journal_name = NULL;
     journal_t               *journal = NULL;
     errcode_t               retval = 0;
@@ -1733 +1723 @@
     ext2fs_free_mem(&journal);
     return retval;
-
 }
 
@@ -1887 +1876 @@
 
     /* Leave a valid existing V1 superblock signature alone.
-     * Anything unrecognisable we overwrite with a new V2
+     * Anything unrecognizable we overwrite with a new V2
      * signature. */
 
@@ -2271 +2260 @@
     fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
     inode.i_links_count = 0;
-    inode.i_dtime = time(0);
+    inode.i_dtime = time(NULL);
     if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0)
         goto err_out;
@@ -2393 +2382 @@
     N_("llost+found"),
     N_("Lis a link"),
-    N_("mmultiply-claimed"),
-    N_("ninvalid"),
+    N_("mmultiply-claimed"),
+    N_("ninvalid"),
     N_("oorphaned"),
     N_("pproblem in"),
@@ -2444 +2433 @@
         }
         if ((ch < 32) || (ch == 0x7f)) {
-            fputc('^', stdout);
+            bb_putchar('^');
             ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
         }
-        fputc(ch, stdout);
+        bb_putchar(ch);
     }
 }
@@ -2498 +2487 @@
         if (*first && islower(*str)) {
             *first = 0;
-            fputc(toupper(*str++), stdout);
+            bb_putchar(toupper(*str++));
         }
         print_e2fsck_message(ctx, str, pctx, *first);
@@ -2631 +2620 @@
     switch (ch) {
     case '%':
-        fputc('%', stdout);
+        bb_putchar('%');
         break;
     case 'b':
@@ -2655 +2644 @@
         break;
     case 'm':
-        printf("%s", error_message(ctx->errcode));
+        fputs(error_message(ctx->errcode), stdout);
         break;
     case 'N':
@@ -2677 +2666 @@
         break;
     case 's':
-        printf("%s", ctx->str ? ctx->str : "NULL");
+        fputs((ctx->str ? ctx->str : "NULL"), stdout);
         break;
     case 'X':
@@ -2743 +2732 @@
     region_t        region;
 
-    region = malloc(sizeof(struct region_struct));
-    if (!region)
-        return NULL;
-    memset(region, 0, sizeof(struct region_struct));
+    region = xzalloc(sizeof(struct region_struct));
     region->min = min;
     region->max = max;
@@ -2811 +2797 @@
      * Insert a new region element structure into the linked list
      */
-    new_region = malloc(sizeof(struct region_el));
-    if (!new_region)
-        return -1;
+    new_region = xmalloc(sizeof(struct region_el));
     new_region->start = start;
     new_region->end = start + n;
@@ -3382 +3366 @@
             if (!LINUX_S_ISDIR(inode->i_mode)) {
                 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) {
-                    inode->i_dtime = time(0);
+                    inode->i_dtime = time(NULL);
                     inode->i_links_count = 0;
                     ext2fs_icount_store(ctx->inode_link_info,
@@ -3389 +3373 @@
                                "pass1");
                 }
-
             }
             /*
@@ -3476 +3459 @@
             if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
                 inode->i_dtime = inode->i_links_count ?
-                    0 : time(0);
+                    0 : time(NULL);
                 e2fsck_write_inode(ctx, ino, inode,
                            "pass1");
@@ -3490 +3473 @@
                 if (fix_problem(ctx,
                         PR_1_ZERO_DTIME, &pctx)) {
-                    inode->i_dtime = time(0);
+                    inode->i_dtime = time(NULL);
                     e2fsck_write_inode(ctx, ino, inode,
                                "pass1");
@@ -3660 +3643 @@
         e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
                   "recreate inode");
-        inode->i_mtime = time(0);
+        inode->i_mtime = time(NULL);
         e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
                   "recreate inode");
@@ -3692 +3675 @@
     ext2fs_free_mem(&block_buf);
     ext2fs_free_mem(&inode);
-
 }
 
@@ -4170 +4152 @@
         inode->i_links_count = 0;
         ext2fs_icount_store(ctx->inode_link_info, ino, 0);
-        inode->i_dtime = time(0);
+        inode->i_dtime = time(NULL);
         dirty_inode++;
         ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
@@ -4203 +4185 @@
             inode->i_links_count = 0;
             ext2fs_icount_store(ctx->inode_link_info, ino, 0);
-            inode->i_dtime = time(0);
+            inode->i_dtime = time(NULL);
             dirty_inode++;
             ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
@@ -4465 +4447 @@
                     }
                 } else {
-                    ext2fs_mark_block_bitmap(ctx->block_found_map,
-                                 b);
+                    ext2fs_mark_block_bitmap(ctx->block_found_map, b);
                 }
             }
@@ -4483 +4464 @@
                 }
             } else {
-                ext2fs_mark_block_bitmap(ctx->block_found_map,
-                     fs->group_desc[i].bg_block_bitmap);
-            }
-
+                ext2fs_mark_block_bitmap(ctx->block_found_map,
+                    fs->group_desc[i].bg_block_bitmap);
+            }
         }
         /*
@@ -4500 +4480 @@
                 }
             } else {
-                ext2fs_mark_block_bitmap(ctx->block_found_map,
-                     fs->group_desc[i].bg_inode_bitmap);
+                ext2fs_mark_block_bitmap(ctx->block_found_map,
+                    fs->group_desc[i].bg_inode_bitmap);
             }
         }
@@ -5148 +5128 @@
     e2fsck_read_inode(ctx, ino, &inode, "delete_file");
     inode.i_links_count = 0;
-    inode.i_dtime = time(0);
+    inode.i_dtime = time(NULL);
     if (inode.i_file_acl &&
         (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
@@ -5602 +5582 @@
         }
     }
-
 }
 
@@ -6019 +5998 @@
     struct dx_dir_info      *dx_dir;
 #ifdef ENABLE_HTREE
-    struct dx_dirblock_info *dx_db = 0;
+    struct dx_dirblock_info *dx_db = NULL;
 #endif /* ENABLE_HTREE */
     struct ext2_dir_entry   *dirent, *prev;
@@ -6394 +6373 @@
     e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
     inode.i_links_count = 0;
-    inode.i_dtime = time(0);
+    inode.i_dtime = time(NULL);
     e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode");
     clear_problem_context(&pctx);
@@ -6891 +6870 @@
     inode.i_mode = 040755;
     inode.i_size = fs->blocksize;
-    inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
+    inode.i_atime = inode.i_ctime = inode.i_mtime = time(NULL);
     inode.i_links_count = 2;
     inode.i_blocks = fs->blocksize / 512;
@@ -7139 +7118 @@
     inode.i_mode = 040700;
     inode.i_size = fs->blocksize;
-    inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
+    inode.i_atime = inode.i_ctime = inode.i_mtime = time(NULL);
     inode.i_links_count = 2;
     inode.i_blocks = fs->blocksize / 512;
@@ -7493 +7472 @@
             ext2fs_icount_store(ctx->inode_link_info, i, 0);
             inode.i_links_count = 0;
-            inode.i_dtime = time(0);
+            inode.i_dtime = time(NULL);
             e2fsck_write_inode(ctx, i, &inode,
                        "disconnect_inode");
@@ -7534 +7513 @@
     struct problem_context  pctx;
     __u16   link_count, link_counted;
-    char    *buf = 0;
+    char    *buf = NULL;
     int     group, maxgroup;
 
@@ -9401 +9380 @@
     /* Cannot proceed without a root inode. */
     { PR_3_NO_ROOT_INODE_ABORT,
-      N_("Cannot proceed without a @r.\n"),
+      N_("can't proceed without a @r.\n"),
       PROMPT_NONE, PR_FATAL },
 
@@ -9680 +9659 @@
     ext2_filsys fs = ctx->fs;
     const struct e2fsck_problem *ptr;
-    struct latch_descr *ldesc = 0;
+    struct latch_descr *ldesc = NULL;
     const char *message;
     int             def_yn, answer, ans;
@@ -9762 +9741 @@
             printf("%s.\n", answer ?
                    _(preen_msg[(int) ptr->prompt]) : _("IGNORED"));
-
     }
 
@@ -10015 +9993 @@
          * to do with it?  That depends on the pass... */
 
-        switch(blocktype) {
+        switch (blocktype) {
         case JFS_DESCRIPTOR_BLOCK:
             /* If it is a valid descriptor block, replay it
@@ -10312 +10290 @@
         }
         if (fd->num_array >= fd->max_array) {
-            new_array = realloc(fd->harray,
+            new_array = xrealloc(fd->harray,
                 sizeof(struct hash_entry) * (fd->max_array+500));
-            if (!new_array) {
-                fd->err = ENOMEM;
-                return BLOCK_ABORT;
-            }
             fd->harray = new_array;
             fd->max_array += 500;
@@ -10392 +10366 @@
 
     if (outdir->max) {
-        new_mem = realloc(outdir->buf, blocks * fs->blocksize);
-        if (!new_mem)
-            return ENOMEM;
+        new_mem = xrealloc(outdir->buf, blocks * fs->blocksize);
         outdir->buf = new_mem;
-        new_mem = realloc(outdir->hashes,
+        new_mem = xrealloc(outdir->hashes,
                   blocks * sizeof(ext2_dirhash_t));
-        if (!new_mem)
-            return ENOMEM;
         outdir->hashes = new_mem;
     } else {
-        outdir->buf = malloc(blocks * fs->blocksize);
-        outdir->hashes = malloc(blocks * sizeof(ext2_dirhash_t));
+        outdir->buf = xmalloc(blocks * fs->blocksize);
+        outdir->hashes = xmalloc(blocks * sizeof(ext2_dirhash_t));
         outdir->num = 0;
     }
@@ -10687 +10657 @@
 {
     struct ext2_dx_root_info        *root_info;
-    struct ext2_dx_entry            *root, *dx_ent = 0;
+    struct ext2_dx_entry            *root, *dx_ent = NULL;
     struct ext2_dx_countlimit       *root_limit, *limit;
     errcode_t                       retval;
@@ -10839 +10809 @@
     errcode_t               retval;
     struct ext2_inode       inode;
-    char                    *dir_buf = 0;
+    char                    *dir_buf = NULL;
     struct fill_dir_struct  fd;
     struct out_dir          outdir;
@@ -10850 +10820 @@
     retval = ENOMEM;
     fd.harray = 0;
-    dir_buf = malloc(inode.i_size);
-    if (!dir_buf)
-        goto errout;
+    dir_buf = xmalloc(inode.i_size);
 
     fd.max_array = inode.i_size / 32;
     fd.num_array = 0;
-    fd.harray = malloc(fd.max_array * sizeof(struct hash_entry));
-    if (!fd.harray)
-        goto errout;
+    fd.harray = xmalloc(fd.max_array * sizeof(struct hash_entry));
 
     fd.ctx = ctx;
@@ -11159 +11125 @@
     shift = 0;
     tmp = hash_size;
-    while((tmp >>= 1UL) != 0UL)
+    while ((tmp >>= 1UL) != 0UL)
         shift++;
     journal->j_revoke->hash_shift = shift;
 
-    journal->j_revoke->hash_table = malloc(hash_size * sizeof(struct list_head));
-    if (!journal->j_revoke->hash_table) {
-        free(journal->j_revoke);
-        journal->j_revoke = NULL;
-        return -ENOMEM;
-    }
+    journal->j_revoke->hash_table = xmalloc(hash_size * sizeof(struct list_head));
 
     for (tmp = 0; tmp < hash_size; tmp++)
@@ -11355 +11316 @@
         (blk >= fs->super->s_blocks_count)) {
         fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
-    return_abort:
+ return_abort:
         pb->abort = 1;
         return BLOCK_ABORT;
@@ -11559 +11520 @@
             ext2fs_inode_alloc_stats2(fs, ino, -1,
                           LINUX_S_ISDIR(inode.i_mode));
-            inode.i_dtime = time(0);
+            inode.i_dtime = time(NULL);
         } else {
             inode.i_dtime = 0;
@@ -11568 +11529 @@
     ext2fs_free_mem(&block_buf);
     return 0;
-return_abort:
+ return_abort:
     ext2fs_free_mem(&block_buf);
     return 1;
@@ -11586 +11547 @@
     int             i, j, gdt_off, ind_off;
     blk_t           blk, pblk, expect;
-    __u32           *dind_buf = 0, *ind_buf;
+    __u32           *dind_buf = NULL, *ind_buf;
     errcode_t       retval;
 
@@ -11649 +11610 @@
         (blk < fs->super->s_first_data_block ||
          blk >= fs->super->s_blocks_count)) {
-    resize_inode_invalid:
+ resize_inode_invalid:
         if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
             memset(&inode, 0, sizeof(inode));
@@ -11691 +11652 @@
     }
 
-cleanup:
+ cleanup:
     ext2fs_free_mem(&dind_buf);
-
- }
+}
 
 static void check_super_block(e2fsck_t ctx)
@@ -11873 +11833 @@
             (gd->bg_used_dirs_count > sb->s_inodes_per_group))
             ext2fs_unmark_valid(fs);
-
     }
 
@@ -11933 +11892 @@
                 ~EXT2_FEATURE_INCOMPAT_FILETYPE;
             ext2fs_mark_super_dirty(fs);
-
         }
     }
@@ -12220 +12178 @@
     char buf[256];
 
-    ret = malloc(size);
-    if (!ret) {
-        sprintf(buf, "Can't allocate %s\n", description);
-        bb_error_msg_and_die(buf);
-    }
-    memset(ret, 0, size);
+    ret = xzalloc(size);
     return ret;
 }
@@ -12237 +12190 @@
     if (!len)
         len = strlen(str);
-    ret = malloc(len+1);
-    if (ret) {
-        strncpy(ret, str, len);
-        ret[len] = 0;
-    }
+    ret = xmalloc(len+1);
+    strncpy(ret, str, len);
+    ret[len] = 0;
     return ret;
 }
@@ -12252 +12203 @@
     int     fail = 0;
 
-    while(1) {
+    while (1) {
         if (e2fsck_global_ctx &&
             (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
@@ -12282 +12233 @@
     tmp.c_cc[VMIN] = 1;
     tmp.c_cc[VTIME] = 0;
-    tcsetattr (0, TCSANOW, &tmp);
+    tcsetattr_stdin_TCSANOW(&tmp);
 #endif
 
@@ -12298 +12249 @@
         if (c == 3) {
 #ifdef HAVE_TERMIOS_H
-            tcsetattr (0, TCSANOW, &termios);
+            tcsetattr_stdin_TCSANOW(&termios);
 #endif
             if (e2fsck_global_ctx &&
@@ -12324 +12275 @@
         puts ("no\n");
 #ifdef HAVE_TERMIOS_H
-    tcsetattr (0, TCSANOW, &termios);
+    tcsetattr_stdin_TCSANOW(&termios);
 #endif
     return def;
@@ -12633 +12584 @@
                      &ctx->mount_flags);
     if (retval) {
-        bb_error_msg(_("while determining whether %s is mounted."),
+        bb_error_msg(_("while determining whether %s is mounted"),
             ctx->filesystem_name);
         return;
@@ -12654 +12605 @@
     printf(_("%s is mounted.  "), ctx->filesystem_name);
     if (!ctx->interactive)
-        bb_error_msg_and_die(_("Cannot continue, aborting."));
+        bb_error_msg_and_die(_("can't continue, aborting"));
     printf(_("\n\n\007\007\007\007WARNING!!!  "
            "Running e2fsck on a mounted filesystem may cause\n"
@@ -12673 +12624 @@
     struct dirent*  de;
 
-    f = fopen("/proc/apm", "r");
+    f = fopen_for_read("/proc/apm");
     if (f) {
         if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4)
@@ -12687 +12638 @@
             snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state",
                  de->d_name);
-            f = fopen(fname, "r");
+            f = fopen_for_read(fname);
             if (!f)
                 continue;
@@ -12715 +12666 @@
     long next_check;
     int batt = is_on_batt();
-    time_t now = time(0);
+    time_t now = time(NULL);
 
     if ((ctx->options & E2F_OPT_FORCE) || cflag || swapfs)
@@ -12768 +12719 @@
             printf(_(" (check in %ld mounts)"), next_check);
     }
-    fputc('\n', stdout);
+    bb_putchar('\n');
     ext2fs_close(fs);
     ctx->fs = NULL;
@@ -12865 +12816 @@
            spaces + (sizeof(spaces) - (dpywidth - i + 1)));
     if (fixed_percent == 1000)
-        fputc('|', stdout);
+        bb_putchar('|');
     else
-        fputc(spinner[ctx->progress_pos & 3], stdout);
+        bb_putchar(spinner[ctx->progress_pos & 3]);
     printf(" %4.1f%%  ", percent);
     if (dpynum)
@@ -12893 +12844 @@
     if (ctx->progress_fd) {
         sprintf(buf, "%d %lu %lu\n", pass, cur, max);
-        write(ctx->progress_fd, buf, strlen(buf));
+        xwrite_str(ctx->progress_fd, buf);
     } else {
         percent = calc_percent(&e2fsck_tbl, pass, cur, max);
@@ -13009 +12960 @@
     errcode_t       retval;
     struct sigaction        sa;
-    char            *extended_opts = 0;
+    char            *extended_opts = NULL;
 
     retval = e2fsck_allocate_context(&ctx);
@@ -13061 +13012 @@
             if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) {
             conflict_opt:
-                bb_error_msg_and_die(_("Only one the options -p/-a, -n or -y may be specified."));
+                bb_error_msg_and_die(_("only one the options -p/-a, -n or -y may be specified"));
             }
             ctx->options |= E2F_OPT_PREEN;
@@ -13374 +13325 @@
                  * device driver is being bogus.
                  */
-                bb_error_msg(_("cannot set superblock flags on %s"), ctx->device_name);
+                bb_error_msg(_("can't set superblock flags on %s"), ctx->device_name);
                 bb_error_msg_and_die(0);
             }
@@ -13406 +13357 @@
     /* FIXME - do we support this at all? */
     if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
-        bb_error_msg(_("Warning: compression support is experimental."));
+        bb_error_msg(_("warning: compression support is experimental"));
 #endif
 #ifndef ENABLE_HTREE