diff options
Diffstat (limited to 'e2fsprogs/old_e2fsprogs/e2fsck.c')
| -rw-r--r-- | e2fsprogs/old_e2fsprogs/e2fsck.c | 13516 |
1 files changed, 0 insertions, 13516 deletions
diff --git a/e2fsprogs/old_e2fsprogs/e2fsck.c b/e2fsprogs/old_e2fsprogs/e2fsck.c deleted file mode 100644 index b816c62b0..000000000 --- a/e2fsprogs/old_e2fsprogs/e2fsck.c +++ /dev/null @@ -1,13516 +0,0 @@ -/* vi: set sw=4 ts=4: */ -/* - * e2fsck - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * Copyright (C) 2006 Garrett Kajmowicz - * - * Dictionary Abstract Data Type - * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net> - * Free Software License: - * All rights are reserved by the author, with the following exceptions: - * Permission is granted to freely reproduce and distribute this software, - * possibly in exchange for a fee, provided that this copyright notice appears - * intact. Permission is also granted to adapt this software to produce - * derivative works, as long as the modified versions carry this copyright - * notice and additional notices stating that the work has been modified. - * This source code may be translated into executable form and incorporated - * into proprietary software; there is no requirement for such software to - * contain a copyright notice related to this source. - * - * linux/fs/recovery and linux/fs/revoke - * Written by Stephen C. Tweedie <sct@redhat.com>, 1999 - * - * Copyright 1999-2000 Red Hat Software --- All Rights Reserved - * - * Journal recovery routines for the generic filesystem journaling code; - * part of the ext2fs journaling system. - * - * Licensed under GPLv2 or later, see file LICENSE in this source tree. - */ - -/* -//usage:#define e2fsck_trivial_usage -//usage: "[-panyrcdfvstDFSV] [-b superblock] [-B blocksize] " -//usage: "[-I inode_buffer_blocks] [-P process_inode_size] " -//usage: "[-l|-L bad_blocks_file] [-C fd] [-j external_journal] " -//usage: "[-E extended-options] device" -//usage:#define e2fsck_full_usage "\n\n" -//usage: "Check ext2/ext3 file system\n" -//usage: "\n -p Automatic repair (no questions)" -//usage: "\n -n Make no changes to the filesystem" -//usage: "\n -y Assume 'yes' to all questions" -//usage: "\n -c Check for bad blocks and add them to the badblock list" -//usage: "\n -f Force checking even if filesystem is marked clean" -//usage: "\n -v Verbose" -//usage: "\n -b superblock Use alternative superblock" -//usage: "\n -B blocksize Force blocksize when looking for superblock" -//usage: "\n -j journal Set location of the external journal" -//usage: "\n -l file Add to badblocks list" -//usage: "\n -L file Set badblocks list" -*/ - -#include "e2fsck.h" /*Put all of our defines here to clean things up*/ - -#define _(x) x -#define N_(x) x - -/* - * Procedure declarations - */ - -static void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf); - -/* pass1.c */ -static void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool); - -/* pass2.c */ -static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, - ext2_ino_t ino, char *buf); - -/* pass3.c */ -static int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t inode); -static errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, - int num, int gauranteed_size); -static ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix); -static errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, - int adj); - -/* rehash.c */ -static void e2fsck_rehash_directories(e2fsck_t ctx); - -/* util.c */ -static void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, - const char *description); -static int ask(e2fsck_t ctx, const char * string, int def); -static void e2fsck_read_bitmaps(e2fsck_t ctx); -static void preenhalt(e2fsck_t ctx); -static void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char * proc); -static void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char * proc); -static blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, - const char *name, io_manager manager); - -/* unix.c */ -static void e2fsck_clear_progbar(e2fsck_t ctx); -static int e2fsck_simple_progress(e2fsck_t ctx, const char *label, - float percent, unsigned int dpynum); - - -/* - * problem.h --- e2fsck problem error codes - */ - -typedef __u32 problem_t; - -struct problem_context { - errcode_t errcode; - ext2_ino_t ino, ino2, dir; - struct ext2_inode *inode; - struct ext2_dir_entry *dirent; - blk_t blk, blk2; - e2_blkcnt_t blkcount; - int group; - __u64 num; - const char *str; -}; - - -/* - * Function declarations - */ -static int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx); -static int end_problem_latch(e2fsck_t ctx, int mask); -static int set_latch_flags(int mask, int setflags, int clearflags); -static void clear_problem_context(struct problem_context *ctx); - -/* - * Dictionary Abstract Data Type - * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net> - * - * dict.h v 1.22.2.6 2000/11/13 01:36:44 kaz - * kazlib_1_20 - */ - -#ifndef DICT_H -#define DICT_H - -/* - * Blurb for inclusion into C++ translation units - */ - -typedef unsigned long dictcount_t; -#define DICTCOUNT_T_MAX ULONG_MAX - -/* - * The dictionary is implemented as a red-black tree - */ - -typedef enum { dnode_red, dnode_black } dnode_color_t; - -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; -} dnode_t; - -typedef int (*dict_comp_t)(const void *, const void *); -typedef void (*dnode_free_t)(dnode_t *); - -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; -} dict_t; - -typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *); - -typedef struct dict_load_t { - dict_t *dict_dictptr; - dnode_t dict_nilnode; -} dict_load_t; - -#define dict_count(D) ((D)->dict_nodecount) -#define dnode_get(N) ((N)->dict_data) -#define dnode_getkey(N) ((N)->dict_key) - -#endif - -/* - * Compatibility header file for e2fsck which should be included - * instead of linux/jfs.h - * - * Copyright (C) 2000 Stephen C. Tweedie - */ - -/* - * Pull in the definition of the e2fsck context structure - */ - -struct buffer_head { - char b_data[8192]; - e2fsck_t b_ctx; - io_channel b_io; - int b_size; - blk_t b_blocknr; - int b_dirty; - int b_uptodate; - int b_err; -}; - - -#define K_DEV_FS 1 -#define K_DEV_JOURNAL 2 - -#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) - -static e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ - -typedef struct { - int object_length; -} kmem_cache_t; - -#define kmem_cache_alloc(cache,flags) malloc((cache)->object_length) - -/* - * We use the standard libext2fs portability tricks for inline - * functions. - */ - -static kmem_cache_t * do_cache_create(int len) -{ - kmem_cache_t *new_cache; - - new_cache = xmalloc(sizeof(*new_cache)); - new_cache->object_length = len; - return new_cache; -} - -static void do_cache_destroy(kmem_cache_t *cache) -{ - free(cache); -} - - -/* - * Dictionary Abstract Data Type - */ - - -/* - * These macros provide short convenient names for structure members, - * which are embellished with dict_ prefixes so that they are - * properly confined to the documented namespace. It's legal for a - * program which uses dict to define, for instance, a macro called ``parent''. - * Such a macro would interfere with the dnode_t struct definition. - * In general, highly portable and reusable C modules which expose their - * structures need to confine structure member names to well-defined spaces. - * The resulting identifiers aren't necessarily convenient to use, nor - * readable, in the implementation, however! - */ - -#define left dict_left -#define right dict_right -#define parent dict_parent -#define color dict_color -#define key dict_key -#define data dict_data - -#define nilnode dict_nilnode -#define maxcount dict_maxcount -#define compare dict_compare -#define dupes dict_dupes - -#define dict_root(D) ((D)->nilnode.left) -#define dict_nil(D) (&(D)->nilnode) - -static void dnode_free(dnode_t *node); - -/* - * Perform a ``left rotation'' adjustment on the tree. The given node P and - * its right child C are rearranged so that the P instead becomes the left - * child of C. The left subtree of C is inherited as the new right subtree - * for P. The ordering of the keys within the tree is thus preserved. - */ - -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; -} - -/* - * This operation is the ``mirror'' image of rotate_left. It is - * the same procedure, but with left and right interchanged. - */ - -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; -} - -/* - * Do a postorder traversal of the tree rooted at the specified - * node and free everything under it. Used by dict_free(). - */ - -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); -} - -/* - * Verify that the tree contains the given node. This is done by - * traversing all of the nodes and comparing their pointers to the - * given pointer. Returns 1 if the node is found, otherwise - * returns zero. It is intended for debugging purposes. - */ - -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; -} - - -/* - * Select a different set of node allocator routines. - */ - -static void dict_set_allocator(dict_t *dict, dnode_free_t fr) -{ - assert(dict_count(dict) == 0); - dict->dict_freenode = fr; -} - -/* - * Free all the nodes in the dictionary by using the dictionary's - * installed free routine. The dictionary is emptied. - */ - -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; -} - -/* - * Initialize a user-supplied dictionary object. - */ - -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; -} - -/* - * Locate a node in the dictionary having the given key. - * If the node is not found, a null a pointer is returned (rather than - * a pointer that dictionary's nil sentinel node), otherwise a pointer to the - * located node is returned. - */ - -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)) - root = root->right; - } while (root != nil); - return saved; - } - } - } - - return NULL; -} - -/* - * Insert a node into the dictionary. The node should have been - * initialized with a data field. All other fields are ignored. - * The behavior is undefined if the user attempts to insert into - * a dictionary that is already full (for which the dict_isfull() - * function returns true). - */ - -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); - if (result < 0) - where = where->left; - 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; -} - -/* - * Allocate a node using the dictionary's allocator routine, give it - * the data item. - */ - -static dnode_t *dnode_init(dnode_t *dnode, void *data) -{ - 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 = xmalloc(sizeof(dnode_t)); - - dnode_init(node, data); - dict_insert(dict, node, key); - return 1; -} - -/* - * Return the node with the lowest (leftmost) key. If the dictionary is empty - * (that is, dict_isempty(dict) returns 1) a null pointer is returned. - */ - -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; -} - -/* - * Return the given node's successor node---the node which has the - * next key in the left to right ordering. If the node has - * no successor, a null pointer is returned rather than a pointer to - * the nil node. - */ - -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; - parent = curr->parent; - } - - return (parent == nil) ? NULL : parent; -} - - -static void dnode_free(dnode_t *node) -{ - free(node); -} - - -#undef left -#undef right -#undef parent -#undef color -#undef key -#undef data - -#undef nilnode -#undef maxcount -#undef compare -#undef dupes - - -/* - * dirinfo.c --- maintains the directory information table for e2fsck. - */ - -/* - * This subroutine is called during pass1 to create a directory info - * entry. During pass1, the passed-in parent is 0; it will get filled - * in during pass2. - */ -static void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) -{ - struct dir_info *dir; - int i, j; - ext2_ino_t num_dirs; - errcode_t retval; - unsigned long old_size; - - if (!ctx->dir_info) { - ctx->dir_info_count = 0; - retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); - if (retval) - num_dirs = 1024; /* Guess */ - ctx->dir_info_size = num_dirs + 10; - ctx->dir_info = (struct dir_info *) - e2fsck_allocate_memory(ctx, ctx->dir_info_size - * sizeof (struct dir_info), - "directory map"); - } - - if (ctx->dir_info_count >= ctx->dir_info_size) { - old_size = ctx->dir_info_size * sizeof(struct dir_info); - ctx->dir_info_size += 10; - retval = ext2fs_resize_mem(old_size, ctx->dir_info_size * - sizeof(struct dir_info), - &ctx->dir_info); - if (retval) { - ctx->dir_info_size -= 10; - return; - } - } - - /* - * Normally, add_dir_info is called with each inode in - * sequential order; but once in a while (like when pass 3 - * needs to recreate the root directory or lost+found - * directory) it is called out of order. In those cases, we - * need to move the dir_info entries down to make room, since - * the dir_info array needs to be sorted by inode number for - * get_dir_info()'s sake. - */ - if (ctx->dir_info_count && - ctx->dir_info[ctx->dir_info_count-1].ino >= ino) { - for (i = ctx->dir_info_count-1; i > 0; i--) - if (ctx->dir_info[i-1].ino < ino) - break; - dir = &ctx->dir_info[i]; - if (dir->ino != ino) - for (j = ctx->dir_info_count++; j > i; j--) - ctx->dir_info[j] = ctx->dir_info[j-1]; - } else - dir = &ctx->dir_info[ctx->dir_info_count++]; - - dir->ino = ino; - dir->dotdot = parent; - dir->parent = parent; -} - -/* - * get_dir_info() --- given an inode number, try to find the directory - * information entry for it. - */ -static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) -{ - int low, high, mid; - - low = 0; - high = ctx->dir_info_count-1; - if (!ctx->dir_info) - return 0; - if (ino == ctx->dir_info[low].ino) - return &ctx->dir_info[low]; - if (ino == ctx->dir_info[high].ino) - return &ctx->dir_info[high]; - - while (low < high) { - mid = (low+high)/2; - if (mid == low || mid == high) - break; - if (ino == ctx->dir_info[mid].ino) - return &ctx->dir_info[mid]; - if (ino < ctx->dir_info[mid].ino) - high = mid; - else - low = mid; - } - return 0; -} - -/* - * Free the dir_info structure when it isn't needed any more. - */ -static void e2fsck_free_dir_info(e2fsck_t ctx) -{ - ext2fs_free_mem(&ctx->dir_info); - ctx->dir_info_size = 0; - ctx->dir_info_count = 0; -} - -/* - * Return the count of number of directories in the dir_info structure - */ -static int e2fsck_get_num_dirinfo(e2fsck_t ctx) -{ - return ctx->dir_info_count; -} - -/* - * A simple interator function - */ -static struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control) -{ - if (*control >= ctx->dir_info_count) - return 0; - - return ctx->dir_info + (*control)++; -} - -/* - * dirinfo.c --- maintains the directory information table for e2fsck. - * - */ - -#ifdef ENABLE_HTREE - -/* - * This subroutine is called during pass1 to create a directory info - * entry. During pass1, the passed-in parent is 0; it will get filled - * in during pass2. - */ -static void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks) -{ - struct dx_dir_info *dir; - int i, j; - errcode_t retval; - unsigned long old_size; - - if (!ctx->dx_dir_info) { - ctx->dx_dir_info_count = 0; - ctx->dx_dir_info_size = 100; /* Guess */ - ctx->dx_dir_info = (struct dx_dir_info *) - e2fsck_allocate_memory(ctx, ctx->dx_dir_info_size - * sizeof (struct dx_dir_info), - "directory map"); - } - - if (ctx->dx_dir_info_count >= ctx->dx_dir_info_size) { - old_size = ctx->dx_dir_info_size * sizeof(struct dx_dir_info); - ctx->dx_dir_info_size += 10; - retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size * - sizeof(struct dx_dir_info), - &ctx->dx_dir_info); - if (retval) { - ctx->dx_dir_info_size -= 10; - return; - } - } - - /* - * Normally, add_dx_dir_info is called with each inode in - * sequential order; but once in a while (like when pass 3 - * needs to recreate the root directory or lost+found - * directory) it is called out of order. In those cases, we - * need to move the dx_dir_info entries down to make room, since - * the dx_dir_info array needs to be sorted by inode number for - * get_dx_dir_info()'s sake. - */ - if (ctx->dx_dir_info_count && - ctx->dx_dir_info[ctx->dx_dir_info_count-1].ino >= ino) { - for (i = ctx->dx_dir_info_count-1; i > 0; i--) - if (ctx->dx_dir_info[i-1].ino < ino) - break; - dir = &ctx->dx_dir_info[i]; - if (dir->ino != ino) - for (j = ctx->dx_dir_info_count++; j > i; j--) - ctx->dx_dir_info[j] = ctx->dx_dir_info[j-1]; - } else - dir = &ctx->dx_dir_info[ctx->dx_dir_info_count++]; - - dir->ino = ino; - dir->numblocks = num_blocks; - dir->hashversion = 0; - dir->dx_block = e2fsck_allocate_memory(ctx, num_blocks - * sizeof (struct dx_dirblock_info), - "dx_block info array"); -} - -/* - * get_dx_dir_info() --- given an inode number, try to find the directory - * information entry for it. - */ -static struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino) -{ - int low, high, mid; - - low = 0; - high = ctx->dx_dir_info_count-1; - if (!ctx->dx_dir_info) - return 0; - if (ino == ctx->dx_dir_info[low].ino) - return &ctx->dx_dir_info[low]; - if (ino == ctx->dx_dir_info[high].ino) - return &ctx->dx_dir_info[high]; - - while (low < high) { - mid = (low+high)/2; - if (mid == low || mid == high) - break; - if (ino == ctx->dx_dir_info[mid].ino) - return &ctx->dx_dir_info[mid]; - if (ino < ctx->dx_dir_info[mid].ino) - high = mid; - else - low = mid; - } - return 0; -} - -/* - * Free the dx_dir_info structure when it isn't needed any more. - */ -static void e2fsck_free_dx_dir_info(e2fsck_t ctx) -{ - int i; - struct dx_dir_info *dir; - - if (ctx->dx_dir_info) { - dir = ctx->dx_dir_info; - for (i=0; i < ctx->dx_dir_info_count; i++) { - ext2fs_free_mem(&dir->dx_block); - } - ext2fs_free_mem(&ctx->dx_dir_info); - } - ctx->dx_dir_info_size = 0; - ctx->dx_dir_info_count = 0; -} - -/* - * A simple interator function - */ -static struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control) -{ - if (*control >= ctx->dx_dir_info_count) - return 0; - - return ctx->dx_dir_info + (*control)++; -} - -#endif /* ENABLE_HTREE */ -/* - * e2fsck.c - a consistency checker for the new extended file system. - * - */ - -/* - * This function allocates an e2fsck context - */ -static errcode_t e2fsck_allocate_context(e2fsck_t *ret) -{ - e2fsck_t context; - errcode_t retval; - - retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &context); - if (retval) - return retval; - - memset(context, 0, sizeof(struct e2fsck_struct)); - - context->process_inode_size = 256; - context->ext_attr_ver = 2; - - *ret = context; - return 0; -} - -struct ea_refcount_el { - blk_t ea_blk; - int ea_count; -}; - -struct ea_refcount { - blk_t count; - blk_t size; - blk_t cursor; - struct ea_refcount_el *list; -}; - -static void ea_refcount_free(ext2_refcount_t refcount) -{ - if (!refcount) - return; - - ext2fs_free_mem(&refcount->list); - ext2fs_free_mem(&refcount); -} - -/* - * This function resets an e2fsck context; it is called when e2fsck - * needs to be restarted. - */ -static errcode_t e2fsck_reset_context(e2fsck_t ctx) -{ - ctx->flags = 0; - ctx->lost_and_found = 0; - ctx->bad_lost_and_found = 0; - ext2fs_free_inode_bitmap(ctx->inode_used_map); - ctx->inode_used_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_dir_map); - ctx->inode_dir_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_reg_map); - ctx->inode_reg_map = 0; - ext2fs_free_block_bitmap(ctx->block_found_map); - ctx->block_found_map = 0; - ext2fs_free_icount(ctx->inode_link_info); - ctx->inode_link_info = 0; - if (ctx->journal_io) { - if (ctx->fs && ctx->fs->io != ctx->journal_io) - io_channel_close(ctx->journal_io); - ctx->journal_io = 0; - } - if (ctx->fs) { - ext2fs_free_dblist(ctx->fs->dblist); - ctx->fs->dblist = 0; - } - e2fsck_free_dir_info(ctx); -#ifdef ENABLE_HTREE - e2fsck_free_dx_dir_info(ctx); -#endif - ea_refcount_free(ctx->refcount); - ctx->refcount = 0; - ea_refcount_free(ctx->refcount_extra); - ctx->refcount_extra = 0; - ext2fs_free_block_bitmap(ctx->block_dup_map); - ctx->block_dup_map = 0; - ext2fs_free_block_bitmap(ctx->block_ea_map); - ctx->block_ea_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_bad_map); - ctx->inode_bad_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_imagic_map); - ctx->inode_imagic_map = 0; - ext2fs_u32_list_free(ctx->dirs_to_hash); - ctx->dirs_to_hash = 0; - - /* - * Clear the array of invalid meta-data flags - */ - ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag); - ext2fs_free_mem(&ctx->invalid_block_bitmap_flag); - ext2fs_free_mem(&ctx->invalid_inode_table_flag); - - /* Clear statistic counters */ - ctx->fs_directory_count = 0; - ctx->fs_regular_count = 0; - ctx->fs_blockdev_count = 0; - ctx->fs_chardev_count = 0; - ctx->fs_links_count = 0; - ctx->fs_symlinks_count = 0; - ctx->fs_fast_symlinks_count = 0; - ctx->fs_fifo_count = 0; - ctx->fs_total_count = 0; - ctx->fs_sockets_count = 0; - ctx->fs_ind_count = 0; - ctx->fs_dind_count = 0; - ctx->fs_tind_count = 0; - ctx->fs_fragmented = 0; - ctx->large_files = 0; - - /* Reset the superblock to the user's requested value */ - ctx->superblock = ctx->use_superblock; - - return 0; -} - -static void e2fsck_free_context(e2fsck_t ctx) -{ - if (!ctx) - return; - - e2fsck_reset_context(ctx); - if (ctx->blkid) - blkid_put_cache(ctx->blkid); - - ext2fs_free_mem(&ctx); -} - -/* - * ea_refcount.c - */ - -/* - * The strategy we use for keeping track of EA refcounts is as - * follows. We keep a sorted array of first EA blocks and its - * reference counts. Once the refcount has dropped to zero, it is - * removed from the array to save memory space. Once the EA block is - * checked, its bit is set in the block_ea_map bitmap. - */ - - -static errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) -{ - ext2_refcount_t refcount; - errcode_t retval; - size_t bytes; - - retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount); - if (retval) - return retval; - memset(refcount, 0, sizeof(struct ea_refcount)); - - if (!size) - size = 500; - refcount->size = size; - bytes = (size_t) (size * sizeof(struct ea_refcount_el)); -#ifdef DEBUG - printf("Refcount allocated %d entries, %lu bytes.\n", - refcount->size, bytes); -#endif - retval = ext2fs_get_mem(bytes, &refcount->list); - if (retval) - goto errout; - memset(refcount->list, 0, bytes); - - refcount->count = 0; - refcount->cursor = 0; - - *ret = refcount; - return 0; - -errout: - ea_refcount_free(refcount); - return retval; -} - -/* - * collapse_refcount() --- go through the refcount array, and get rid - * of any count == zero entries - */ -static void refcount_collapse(ext2_refcount_t refcount) -{ - unsigned int i, j; - struct ea_refcount_el *list; - - list = refcount->list; - for (i = 0, j = 0; i < refcount->count; i++) { - if (list[i].ea_count) { - if (i != j) - list[j] = list[i]; - j++; - } - } -#if defined(DEBUG) || defined(TEST_PROGRAM) - printf("Refcount_collapse: size was %d, now %d\n", - refcount->count, j); -#endif - refcount->count = j; -} - - -/* - * insert_refcount_el() --- Insert a new entry into the sorted list at a - * specified position. - */ -static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount, - blk_t blk, int pos) -{ - struct ea_refcount_el *el; - errcode_t retval; - blk_t new_size = 0; - int num; - - if (refcount->count >= refcount->size) { - new_size = refcount->size + 100; -#ifdef DEBUG - printf("Reallocating refcount %d entries...\n", new_size); -#endif - retval = ext2fs_resize_mem((size_t) refcount->size * - sizeof(struct ea_refcount_el), - (size_t) new_size * - sizeof(struct ea_refcount_el), - &refcount->list); - if (retval) - return 0; - refcount->size = new_size; - } - num = (int) refcount->count - pos; - if (num < 0) - return 0; /* should never happen */ - if (num) { - memmove(&refcount->list[pos+1], &refcount->list[pos], - sizeof(struct ea_refcount_el) * num); - } - refcount->count++; - el = &refcount->list[pos]; - el->ea_count = 0; - el->ea_blk = blk; - return el; -} - - -/* - * get_refcount_el() --- given an block number, try to find refcount - * information in the sorted list. If the create flag is set, - * and we can't find an entry, create one in the sorted list. - */ -static struct ea_refcount_el *get_refcount_el(ext2_refcount_t refcount, - blk_t blk, int create) -{ - float range; - int low, high, mid; - blk_t lowval, highval; - - if (!refcount || !refcount->list) - return 0; -retry: - low = 0; - high = (int) refcount->count-1; - if (create && ((refcount->count == 0) || - (blk > refcount->list[high].ea_blk))) { - if (refcount->count >= refcount->size) - refcount_collapse(refcount); - - return insert_refcount_el(refcount, blk, - (unsigned) refcount->count); - } - if (refcount->count == 0) - return 0; - - if (refcount->cursor >= refcount->count) - refcount->cursor = 0; - if (blk == refcount->list[refcount->cursor].ea_blk) - return &refcount->list[refcount->cursor++]; -#ifdef DEBUG - printf("Non-cursor get_refcount_el: %u\n", blk); -#endif - while (low <= high) { - if (low == high) - mid = low; - else { - /* Interpolate for efficiency */ - lowval = refcount->list[low].ea_blk; - highval = refcount->list[high].ea_blk; - - if (blk < lowval) - range = 0; - else if (blk > highval) - range = 1; - else - range = ((float) (blk - lowval)) / - (highval - lowval); - mid = low + ((int) (range * (high-low))); - } - - if (blk == refcount->list[mid].ea_blk) { - refcount->cursor = mid+1; - return &refcount->list[mid]; - } - if (blk < refcount->list[mid].ea_blk) - high = mid-1; - else - low = mid+1; - } - /* - * If we need to create a new entry, it should be right at - * low (where high will be left at low-1). - */ - if (create) { - if (refcount->count >= refcount->size) { - refcount_collapse(refcount); - if (refcount->count < refcount->size) - goto retry; - } - return insert_refcount_el(refcount, blk, low); - } - return 0; -} - -static errcode_t -ea_refcount_increment(ext2_refcount_t refcount, blk_t blk, int *ret) -{ - struct ea_refcount_el *el; - - el = get_refcount_el(refcount, blk, 1); - if (!el) - return EXT2_ET_NO_MEMORY; - el->ea_count++; - - if (ret) - *ret = el->ea_count; - return 0; -} - -static errcode_t -ea_refcount_decrement(ext2_refcount_t refcount, blk_t blk, int *ret) -{ - struct ea_refcount_el *el; - - el = get_refcount_el(refcount, blk, 0); - if (!el || el->ea_count == 0) - return EXT2_ET_INVALID_ARGUMENT; - - el->ea_count--; - - if (ret) - *ret = el->ea_count; - return 0; -} - -static errcode_t -ea_refcount_store(ext2_refcount_t refcount, blk_t blk, int count) -{ - struct ea_refcount_el *el; - - /* - * Get the refcount element - */ - el = get_refcount_el(refcount, blk, count ? 1 : 0); - if (!el) - return count ? EXT2_ET_NO_MEMORY : 0; - el->ea_count = count; - return 0; -} - -static inline void ea_refcount_intr_begin(ext2_refcount_t refcount) -{ - refcount->cursor = 0; -} - - -static blk_t ea_refcount_intr_next(ext2_refcount_t refcount, int *ret) -{ - struct ea_refcount_el *list; - - while (1) { - if (refcount->cursor >= refcount->count) - return 0; - list = refcount->list; - if (list[refcount->cursor].ea_count) { - if (ret) - *ret = list[refcount->cursor].ea_count; - return list[refcount->cursor++].ea_blk; - } - refcount->cursor++; - } -} - - -/* - * ehandler.c --- handle bad block errors which come up during the - * course of an e2fsck session. - */ - - -static const char *operation; - -static errcode_t -e2fsck_handle_read_error(io_channel channel, unsigned long block, int count, - void *data, size_t size FSCK_ATTR((unused)), - int actual FSCK_ATTR((unused)), errcode_t error) -{ - int i; - char *p; - ext2_filsys fs = (ext2_filsys) channel->app_data; - e2fsck_t ctx; - - ctx = (e2fsck_t) fs->priv_data; - - /* - * If more than one block was read, try reading each block - * separately. We could use the actual bytes read to figure - * out where to start, but we don't bother. - */ - if (count > 1) { - p = (char *) data; - for (i=0; i < count; i++, p += channel->block_size, block++) { - error = io_channel_read_blk(channel, block, - 1, p); - if (error) - return error; - } - return 0; - } - if (operation) - printf(_("Error reading block %lu (%s) while %s. "), block, - error_message(error), operation); - else - printf(_("Error reading block %lu (%s). "), block, - error_message(error)); - preenhalt(ctx); - if (ask(ctx, _("Ignore error"), 1)) { - if (ask(ctx, _("Force rewrite"), 1)) - io_channel_write_blk(channel, block, 1, data); - return 0; - } - - return error; -} - -static errcode_t -e2fsck_handle_write_error(io_channel channel, unsigned long block, int count, - const void *data, size_t size FSCK_ATTR((unused)), - int actual FSCK_ATTR((unused)), errcode_t error) -{ - int i; - const char *p; - ext2_filsys fs = (ext2_filsys) channel->app_data; - e2fsck_t ctx; - - ctx = (e2fsck_t) fs->priv_data; - - /* - * If more than one block was written, try writing each block - * separately. We could use the actual bytes read to figure - * out where to start, but we don't bother. - */ - if (count > 1) { - p = (const char *) data; - for (i=0; i < count; i++, p += channel->block_size, block++) { - error = io_channel_write_blk(channel, block, - 1, p); - if (error) - return error; - } - return 0; - } - - if (operation) - printf(_("Error writing block %lu (%s) while %s. "), block, - error_message(error), operation); - else - printf(_("Error writing block %lu (%s). "), block, - error_message(error)); - preenhalt(ctx); - if (ask(ctx, _("Ignore error"), 1)) - return 0; - - return error; -} - -static const char *ehandler_operation(const char *op) -{ - const char *ret = operation; - - operation = op; - return ret; -} - -static void ehandler_init(io_channel channel) -{ - channel->read_error = e2fsck_handle_read_error; - channel->write_error = e2fsck_handle_write_error; -} - -/* - * journal.c --- code for handling the "ext3" journal - * - * Copyright (C) 2000 Andreas Dilger - * Copyright (C) 2000 Theodore Ts'o - * - * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie - * Copyright (C) 1999 Red Hat Software - * - * This file may be redistributed under the terms of the - * GNU General Public License version 2 or at your discretion - * any later version. - */ - -/* - * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths. - * This creates a larger static binary, and a smaller binary using - * shared libraries. It's also probably slightly less CPU-efficient, - * which is why it's not on by default. But, it's a good way of - * testing the functions in inode_io.c and fileio.c. - */ -#undef USE_INODE_IO - -/* Kernel compatibility functions for handling the journal. These allow us - * to use the recovery.c file virtually unchanged from the kernel, so we - * don't have to do much to keep kernel and user recovery in sync. - */ -static int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys) -{ -#ifdef USE_INODE_IO - *phys = block; - return 0; -#else - struct inode *inode = journal->j_inode; - errcode_t retval; - blk_t pblk; - - if (!inode) { - *phys = block; - return 0; - } - - retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino, - &inode->i_ext2, NULL, 0, block, &pblk); - *phys = pblk; - return retval; -#endif -} - -static struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize) -{ - struct buffer_head *bh; - - bh = e2fsck_allocate_memory(kdev->k_ctx, sizeof(*bh), "block buffer"); - if (!bh) - return NULL; - - bh->b_ctx = kdev->k_ctx; - if (kdev->k_dev == K_DEV_FS) - bh->b_io = kdev->k_ctx->fs->io; - else - bh->b_io = kdev->k_ctx->journal_io; - bh->b_size = blocksize; - bh->b_blocknr = blocknr; - - return bh; -} - -static void sync_blockdev(kdev_t kdev) -{ - io_channel io; - - if (kdev->k_dev == K_DEV_FS) - io = kdev->k_ctx->fs->io; - else - io = kdev->k_ctx->journal_io; - - io_channel_flush(io); -} - -static void ll_rw_block(int rw, int nr, struct buffer_head *bhp[]) -{ - int retval; - struct buffer_head *bh; - - for (; nr > 0; --nr) { - bh = *bhp++; - if (rw == READ && !bh->b_uptodate) { - retval = io_channel_read_blk(bh->b_io, - bh->b_blocknr, - 1, bh->b_data); - if (retval) { - bb_error_msg("while reading block %lu", - (unsigned long) bh->b_blocknr); - bh->b_err = retval; - continue; - } - bh->b_uptodate = 1; - } else if (rw == WRITE && bh->b_dirty) { - retval = io_channel_write_blk(bh->b_io, - bh->b_blocknr, - 1, bh->b_data); - if (retval) { - bb_error_msg("while writing block %lu", - (unsigned long) bh->b_blocknr); - bh->b_err = retval; - continue; - } - bh->b_dirty = 0; - bh->b_uptodate = 1; - } - } -} - -static void mark_buffer_dirty(struct buffer_head *bh) -{ - bh->b_dirty = 1; -} - -static inline void mark_buffer_clean(struct buffer_head * bh) -{ - bh->b_dirty = 0; -} - -static void brelse(struct buffer_head *bh) -{ - if (bh->b_dirty) - ll_rw_block(WRITE, 1, &bh); - ext2fs_free_mem(&bh); -} - -static int buffer_uptodate(struct buffer_head *bh) -{ - return bh->b_uptodate; -} - -static inline void mark_buffer_uptodate(struct buffer_head *bh, int val) -{ - bh->b_uptodate = val; -} - -static void wait_on_buffer(struct buffer_head *bh) -{ - if (!bh->b_uptodate) - ll_rw_block(READ, 1, &bh); -} - - -static void e2fsck_clear_recover(e2fsck_t ctx, int error) -{ - ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; - - /* if we had an error doing journal recovery, we need a full fsck */ - if (error) - ctx->fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(ctx->fs); -} - -static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_super_block jsuper; - struct problem_context pctx; - struct buffer_head *bh; - struct inode *j_inode = NULL; - struct kdev_s *dev_fs = NULL, *dev_journal; - const char *journal_name = NULL; - journal_t *journal = NULL; - errcode_t retval = 0; - io_manager io_ptr = 0; - unsigned long start = 0; - blk_t blk; - int ext_journal = 0; - int tried_backup_jnl = 0; - int i; - - clear_problem_context(&pctx); - - journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal"); - if (!journal) { - return EXT2_ET_NO_MEMORY; - } - - dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev"); - if (!dev_fs) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - dev_journal = dev_fs+1; - - dev_fs->k_ctx = dev_journal->k_ctx = ctx; - dev_fs->k_dev = K_DEV_FS; - dev_journal->k_dev = K_DEV_JOURNAL; - - journal->j_dev = dev_journal; - journal->j_fs_dev = dev_fs; - journal->j_inode = NULL; - journal->j_blocksize = ctx->fs->blocksize; - - if (uuid_is_null(sb->s_journal_uuid)) { - if (!sb->s_journal_inum) - return EXT2_ET_BAD_INODE_NUM; - j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode), - "journal inode"); - if (!j_inode) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - - j_inode->i_ctx = ctx; - j_inode->i_ino = sb->s_journal_inum; - - if ((retval = ext2fs_read_inode(ctx->fs, - sb->s_journal_inum, - &j_inode->i_ext2))) { - try_backup_journal: - if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS || - tried_backup_jnl) - goto errout; - memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode)); - memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks, - EXT2_N_BLOCKS*4); - j_inode->i_ext2.i_size = sb->s_jnl_blocks[16]; - j_inode->i_ext2.i_links_count = 1; - j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600; - tried_backup_jnl++; - } - if (!j_inode->i_ext2.i_links_count || - !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) { - retval = EXT2_ET_NO_JOURNAL; - goto try_backup_journal; - } - if (j_inode->i_ext2.i_size / journal->j_blocksize < - JFS_MIN_JOURNAL_BLOCKS) { - retval = EXT2_ET_JOURNAL_TOO_SMALL; - goto try_backup_journal; - } - for (i=0; i < EXT2_N_BLOCKS; i++) { - blk = j_inode->i_ext2.i_block[i]; - if (!blk) { - if (i < EXT2_NDIR_BLOCKS) { - retval = EXT2_ET_JOURNAL_TOO_SMALL; - goto try_backup_journal; - } - continue; - } - if (blk < sb->s_first_data_block || - blk >= sb->s_blocks_count) { - retval = EXT2_ET_BAD_BLOCK_NUM; - goto try_backup_journal; - } - } - journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize; - -#ifdef USE_INODE_IO - retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum, - &j_inode->i_ext2, - &journal_name); - if (retval) - goto errout; - - io_ptr = inode_io_manager; -#else - journal->j_inode = j_inode; - ctx->journal_io = ctx->fs->io; - if ((retval = journal_bmap(journal, 0, &start)) != 0) - goto errout; -#endif - } else { - ext_journal = 1; - if (!ctx->journal_name) { - char uuid[37]; - - uuid_unparse(sb->s_journal_uuid, uuid); - ctx->journal_name = blkid_get_devname(ctx->blkid, - "UUID", uuid); - if (!ctx->journal_name) - ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev); - } - journal_name = ctx->journal_name; - - if (!journal_name) { - fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx); - return EXT2_ET_LOAD_EXT_JOURNAL; - } - - io_ptr = unix_io_manager; - } - -#ifndef USE_INODE_IO - if (ext_journal) -#endif - retval = io_ptr->open(journal_name, IO_FLAG_RW, - &ctx->journal_io); - if (retval) - goto errout; - - io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize); - - if (ext_journal) { - if (ctx->fs->blocksize == 1024) - start = 1; - bh = getblk(dev_journal, start, ctx->fs->blocksize); - if (!bh) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - ll_rw_block(READ, 1, &bh); - if ((retval = bh->b_err) != 0) - goto errout; - memcpy(&jsuper, start ? bh->b_data : bh->b_data + 1024, - sizeof(jsuper)); - brelse(bh); -#if BB_BIG_ENDIAN - if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) - ext2fs_swap_super(&jsuper); -#endif - if (jsuper.s_magic != EXT2_SUPER_MAGIC || - !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) { - fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx); - retval = EXT2_ET_LOAD_EXT_JOURNAL; - goto errout; - } - /* Make sure the journal UUID is correct */ - if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid, - sizeof(jsuper.s_uuid))) { - fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx); - retval = EXT2_ET_LOAD_EXT_JOURNAL; - goto errout; - } - - journal->j_maxlen = jsuper.s_blocks_count; - start++; - } - - if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - - journal->j_sb_buffer = bh; - journal->j_superblock = (journal_superblock_t *)bh->b_data; - -#ifdef USE_INODE_IO - ext2fs_free_mem(&j_inode); -#endif - - *ret_journal = journal; - return 0; - -errout: - ext2fs_free_mem(&dev_fs); - ext2fs_free_mem(&j_inode); - ext2fs_free_mem(&journal); - return retval; -} - -static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx, - struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - int has_journal = ctx->fs->super->s_feature_compat & - EXT3_FEATURE_COMPAT_HAS_JOURNAL; - - if (has_journal || sb->s_journal_inum) { - /* The journal inode is bogus, remove and force full fsck */ - pctx->ino = sb->s_journal_inum; - if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) { - if (has_journal && sb->s_journal_inum) - printf("*** ext3 journal has been deleted - " - "filesystem is now ext2 only ***\n\n"); - sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; - sb->s_journal_inum = 0; - ctx->flags |= E2F_FLAG_JOURNAL_INODE; /* FIXME: todo */ - e2fsck_clear_recover(ctx, 1); - return 0; - } - return EXT2_ET_BAD_INODE_NUM; - } else if (recover) { - if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) { - e2fsck_clear_recover(ctx, 1); - return 0; - } - return EXT2_ET_UNSUPP_FEATURE; - } - return 0; -} - -#define V1_SB_SIZE 0x0024 -static void clear_v2_journal_fields(journal_t *journal) -{ - e2fsck_t ctx = journal->j_dev->k_ctx; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx)) - return; - - memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0, - ctx->fs->blocksize-V1_SB_SIZE); - mark_buffer_dirty(journal->j_sb_buffer); -} - - -static errcode_t e2fsck_journal_load(journal_t *journal) -{ - e2fsck_t ctx = journal->j_dev->k_ctx; - journal_superblock_t *jsb; - struct buffer_head *jbh = journal->j_sb_buffer; - struct problem_context pctx; - - clear_problem_context(&pctx); - - ll_rw_block(READ, 1, &jbh); - if (jbh->b_err) { - bb_error_msg(_("reading journal superblock")); - return jbh->b_err; - } - - jsb = journal->j_superblock; - /* If we don't even have JFS_MAGIC, we probably have a wrong inode */ - if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER)) - return e2fsck_journal_fix_bad_inode(ctx, &pctx); - - switch (ntohl(jsb->s_header.h_blocktype)) { - case JFS_SUPERBLOCK_V1: - journal->j_format_version = 1; - if (jsb->s_feature_compat || - jsb->s_feature_incompat || - jsb->s_feature_ro_compat || - jsb->s_nr_users) - clear_v2_journal_fields(journal); - break; - - case JFS_SUPERBLOCK_V2: - journal->j_format_version = 2; - if (ntohl(jsb->s_nr_users) > 1 && - uuid_is_null(ctx->fs->super->s_journal_uuid)) - clear_v2_journal_fields(journal); - if (ntohl(jsb->s_nr_users) > 1) { - fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx); - return EXT2_ET_JOURNAL_UNSUPP_VERSION; - } - break; - - /* - * These should never appear in a journal super block, so if - * they do, the journal is badly corrupted. - */ - case JFS_DESCRIPTOR_BLOCK: - case JFS_COMMIT_BLOCK: - case JFS_REVOKE_BLOCK: - return EXT2_ET_CORRUPT_SUPERBLOCK; - - /* If we don't understand the superblock major type, but there - * is a magic number, then it is likely to be a new format we - * just don't understand, so leave it alone. */ - default: - return EXT2_ET_JOURNAL_UNSUPP_VERSION; - } - - if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES)) - return EXT2_ET_UNSUPP_FEATURE; - - if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES)) - return EXT2_ET_RO_UNSUPP_FEATURE; - - /* We have now checked whether we know enough about the journal - * format to be able to proceed safely, so any other checks that - * fail we should attempt to recover from. */ - if (jsb->s_blocksize != htonl(journal->j_blocksize)) { - bb_error_msg(_("%s: no valid journal superblock found"), - ctx->device_name); - return EXT2_ET_CORRUPT_SUPERBLOCK; - } - - if (ntohl(jsb->s_maxlen) < journal->j_maxlen) - journal->j_maxlen = ntohl(jsb->s_maxlen); - else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) { - bb_error_msg(_("%s: journal too short"), - ctx->device_name); - return EXT2_ET_CORRUPT_SUPERBLOCK; - } - - journal->j_tail_sequence = ntohl(jsb->s_sequence); - journal->j_transaction_sequence = journal->j_tail_sequence; - journal->j_tail = ntohl(jsb->s_start); - journal->j_first = ntohl(jsb->s_first); - journal->j_last = ntohl(jsb->s_maxlen); - - return 0; -} - -static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb, - journal_t *journal) -{ - char *p; - union { - uuid_t uuid; - __u32 val[4]; - } u; - __u32 new_seq = 0; - int i; - - /* Leave a valid existing V1 superblock signature alone. - * Anything unrecognizable we overwrite with a new V2 - * signature. */ - - if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) || - jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) { - jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER); - jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2); - } - - /* Zero out everything else beyond the superblock header */ - - p = ((char *) jsb) + sizeof(journal_header_t); - memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t)); - - jsb->s_blocksize = htonl(ctx->fs->blocksize); - jsb->s_maxlen = htonl(journal->j_maxlen); - jsb->s_first = htonl(1); - - /* Initialize the journal sequence number so that there is "no" - * chance we will find old "valid" transactions in the journal. - * This avoids the need to zero the whole journal (slow to do, - * and risky when we are just recovering the filesystem). - */ - uuid_generate(u.uuid); - for (i = 0; i < 4; i ++) - new_seq ^= u.val[i]; - jsb->s_sequence = htonl(new_seq); - - mark_buffer_dirty(journal->j_sb_buffer); - ll_rw_block(WRITE, 1, &journal->j_sb_buffer); -} - -static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx, - journal_t *journal, - struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - - if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) { - if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) { - e2fsck_journal_reset_super(ctx, journal->j_superblock, - journal); - journal->j_transaction_sequence = 1; - e2fsck_clear_recover(ctx, recover); - return 0; - } - return EXT2_ET_CORRUPT_SUPERBLOCK; - } else if (e2fsck_journal_fix_bad_inode(ctx, pctx)) - return EXT2_ET_CORRUPT_SUPERBLOCK; - - return 0; -} - -static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal, - int reset, int drop) -{ - journal_superblock_t *jsb; - - if (drop) - mark_buffer_clean(journal->j_sb_buffer); - else if (!(ctx->options & E2F_OPT_READONLY)) { - jsb = journal->j_superblock; - jsb->s_sequence = htonl(journal->j_transaction_sequence); - if (reset) - jsb->s_start = 0; /* this marks the journal as empty */ - mark_buffer_dirty(journal->j_sb_buffer); - } - brelse(journal->j_sb_buffer); - - if (ctx->journal_io) { - if (ctx->fs && ctx->fs->io != ctx->journal_io) - io_channel_close(ctx->journal_io); - ctx->journal_io = 0; - } - -#ifndef USE_INODE_IO - ext2fs_free_mem(&journal->j_inode); -#endif - ext2fs_free_mem(&journal->j_fs_dev); - ext2fs_free_mem(&journal); -} - -/* - * This function makes sure that the superblock fields regarding the - * journal are consistent. - */ -static int e2fsck_check_ext3_journal(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - journal_t *journal; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - struct problem_context pctx; - problem_t problem; - int reset = 0, force_fsck = 0; - int retval; - - /* If we don't have any journal features, don't do anything more */ - if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && - !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 && - uuid_is_null(sb->s_journal_uuid)) - return 0; - - clear_problem_context(&pctx); - pctx.num = sb->s_journal_inum; - - retval = e2fsck_get_journal(ctx, &journal); - if (retval) { - if ((retval == EXT2_ET_BAD_INODE_NUM) || - (retval == EXT2_ET_BAD_BLOCK_NUM) || - (retval == EXT2_ET_JOURNAL_TOO_SMALL) || - (retval == EXT2_ET_NO_JOURNAL)) - return e2fsck_journal_fix_bad_inode(ctx, &pctx); - return retval; - } - - retval = e2fsck_journal_load(journal); - if (retval) { - if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) || - ((retval == EXT2_ET_UNSUPP_FEATURE) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT, - &pctx))) || - ((retval == EXT2_ET_RO_UNSUPP_FEATURE) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT, - &pctx))) || - ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx)))) - retval = e2fsck_journal_fix_corrupt_super(ctx, journal, - &pctx); - e2fsck_journal_release(ctx, journal, 0, 1); - return retval; - } - - /* - * We want to make the flags consistent here. We will not leave with - * needs_recovery set but has_journal clear. We can't get in a loop - * with -y, -n, or -p, only if a user isn't making up their mind. - */ -no_has_journal: - if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) { - recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER; - pctx.str = "inode"; - if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) { - if (recover && - !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx)) - goto no_has_journal; - /* - * Need a full fsck if we are releasing a - * journal stored on a reserved inode. - */ - force_fsck = recover || - (sb->s_journal_inum < EXT2_FIRST_INODE(sb)); - /* Clear all of the journal fields */ - sb->s_journal_inum = 0; - sb->s_journal_dev = 0; - memset(sb->s_journal_uuid, 0, - sizeof(sb->s_journal_uuid)); - e2fsck_clear_recover(ctx, force_fsck); - } else if (!(ctx->options & E2F_OPT_READONLY)) { - sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL; - ext2fs_mark_super_dirty(ctx->fs); - } - } - - if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL && - !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) && - journal->j_superblock->s_start != 0) { - /* Print status information */ - fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx); - if (ctx->superblock) - problem = PR_0_JOURNAL_RUN_DEFAULT; - else - problem = PR_0_JOURNAL_RUN; - if (fix_problem(ctx, problem, &pctx)) { - ctx->options |= E2F_OPT_FORCE; - sb->s_feature_incompat |= - EXT3_FEATURE_INCOMPAT_RECOVER; - ext2fs_mark_super_dirty(ctx->fs); - } else if (fix_problem(ctx, - PR_0_JOURNAL_RESET_JOURNAL, &pctx)) { - reset = 1; - sb->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(ctx->fs); - } - /* - * If the user answers no to the above question, we - * ignore the fact that journal apparently has data; - * accidentally replaying over valid data would be far - * worse than skipping a questionable recovery. - * - * XXX should we abort with a fatal error here? What - * will the ext3 kernel code do if a filesystem with - * !NEEDS_RECOVERY but with a non-zero - * journal->j_superblock->s_start is mounted? - */ - } - - e2fsck_journal_release(ctx, journal, reset, 0); - return retval; -} - -static errcode_t recover_ext3_journal(e2fsck_t ctx) -{ - journal_t *journal; - int retval; - - journal_init_revoke_caches(); - retval = e2fsck_get_journal(ctx, &journal); - if (retval) - return retval; - - retval = e2fsck_journal_load(journal); - if (retval) - goto errout; - - retval = journal_init_revoke(journal, 1024); - if (retval) - goto errout; - - retval = -journal_recover(journal); - if (retval) - goto errout; - - if (journal->j_superblock->s_errno) { - ctx->fs->super->s_state |= EXT2_ERROR_FS; - ext2fs_mark_super_dirty(ctx->fs); - journal->j_superblock->s_errno = 0; - mark_buffer_dirty(journal->j_sb_buffer); - } - -errout: - journal_destroy_revoke(journal); - journal_destroy_revoke_caches(); - e2fsck_journal_release(ctx, journal, 1, 0); - return retval; -} - -static int e2fsck_run_ext3_journal(e2fsck_t ctx) -{ - io_manager io_ptr = ctx->fs->io->manager; - int blocksize = ctx->fs->blocksize; - errcode_t retval, recover_retval; - - printf(_("%s: recovering journal\n"), ctx->device_name); - if (ctx->options & E2F_OPT_READONLY) { - printf(_("%s: won't do journal recovery while read-only\n"), - ctx->device_name); - return EXT2_ET_FILE_RO; - } - - if (ctx->fs->flags & EXT2_FLAG_DIRTY) - ext2fs_flush(ctx->fs); /* Force out any modifications */ - - recover_retval = recover_ext3_journal(ctx); - - /* - * Reload the filesystem context to get up-to-date data from disk - * because journal recovery will change the filesystem under us. - */ - ext2fs_close(ctx->fs); - retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW, - ctx->superblock, blocksize, io_ptr, - &ctx->fs); - - if (retval) { - bb_error_msg(_("while trying to re-open %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - ctx->fs->priv_data = ctx; - - /* Set the superblock flags */ - e2fsck_clear_recover(ctx, recover_retval); - return recover_retval; -} - -/* - * This function will move the journal inode from a visible file in - * the filesystem directory hierarchy to the reserved inode if necessary. - */ -static const char *const journal_names[] = { - ".journal", "journal", ".journal.dat", "journal.dat", 0 }; - -static void e2fsck_move_ext3_journal(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct problem_context pctx; - struct ext2_inode inode; - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - errcode_t retval; - const char *const * cpp; - int group, mount_flags; - - clear_problem_context(&pctx); - - /* - * If the filesystem is opened read-only, or there is no - * journal, then do nothing. - */ - if ((ctx->options & E2F_OPT_READONLY) || - (sb->s_journal_inum == 0) || - !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) - return; - - /* - * Read in the journal inode - */ - if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0) - return; - - /* - * If it's necessary to backup the journal inode, do so. - */ - if ((sb->s_jnl_backup_type == 0) || - ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) && - memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) { - if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) { - memcpy(sb->s_jnl_blocks, inode.i_block, - EXT2_N_BLOCKS*4); - sb->s_jnl_blocks[16] = inode.i_size; - sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - } - } - - /* - * If the journal is already the hidden inode, then do nothing - */ - if (sb->s_journal_inum == EXT2_JOURNAL_INO) - return; - - /* - * The journal inode had better have only one link and not be readable. - */ - if (inode.i_links_count != 1) - return; - - /* - * If the filesystem is mounted, or we can't tell whether - * or not it's mounted, do nothing. - */ - retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags); - if (retval || (mount_flags & EXT2_MF_MOUNTED)) - return; - - /* - * If we can't find the name of the journal inode, then do - * nothing. - */ - for (cpp = journal_names; *cpp; cpp++) { - retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp, - strlen(*cpp), 0, &ino); - if ((retval == 0) && (ino == sb->s_journal_inum)) - break; - } - if (*cpp == 0) - return; - - /* We need the inode bitmap to be loaded */ - retval = ext2fs_read_bitmaps(fs); - if (retval) - return; - - pctx.str = *cpp; - if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx)) - return; - - /* - * OK, we've done all the checks, let's actually move the - * journal inode. Errors at this point mean we need to force - * an ext2 filesystem check. - */ - if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0) - goto err_out; - if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0) - goto err_out; - sb->s_journal_inum = EXT2_JOURNAL_INO; - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - inode.i_links_count = 0; - inode.i_dtime = time(NULL); - if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0) - goto err_out; - - group = ext2fs_group_of_ino(fs, ino); - ext2fs_unmark_inode_bitmap(fs->inode_map, ino); - ext2fs_mark_ib_dirty(fs); - fs->group_desc[group].bg_free_inodes_count++; - fs->super->s_free_inodes_count++; - return; - -err_out: - pctx.errcode = retval; - fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx); - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); -} - -/* - * message.c --- print e2fsck messages (with compression) - * - * print_e2fsck_message() prints a message to the user, using - * compression techniques and expansions of abbreviations. - * - * The following % expansions are supported: - * - * %b <blk> block number - * %B <blkcount> integer - * %c <blk2> block number - * %Di <dirent>->ino inode number - * %Dn <dirent>->name string - * %Dr <dirent>->rec_len - * %Dl <dirent>->name_len - * %Dt <dirent>->filetype - * %d <dir> inode number - * %g <group> integer - * %i <ino> inode number - * %Is <inode> -> i_size - * %IS <inode> -> i_extra_isize - * %Ib <inode> -> i_blocks - * %Il <inode> -> i_links_count - * %Im <inode> -> i_mode - * %IM <inode> -> i_mtime - * %IF <inode> -> i_faddr - * %If <inode> -> i_file_acl - * %Id <inode> -> i_dir_acl - * %Iu <inode> -> i_uid - * %Ig <inode> -> i_gid - * %j <ino2> inode number - * %m <com_err error message> - * %N <num> - * %p ext2fs_get_pathname of directory <ino> - * %P ext2fs_get_pathname of <dirent>->ino with <ino2> as - * the containing directory. (If dirent is NULL - * then return the pathname of directory <ino2>) - * %q ext2fs_get_pathname of directory <dir> - * %Q ext2fs_get_pathname of directory <ino> with <dir> as - * the containing directory. - * %s <str> miscellaneous string - * %S backup superblock - * %X <num> hexadecimal format - * - * The following '@' expansions are supported: - * - * @a extended attribute - * @A error allocating - * @b block - * @B bitmap - * @c compress - * @C conflicts with some other fs block - * @D deleted - * @d directory - * @e entry - * @E Entry '%Dn' in %p (%i) - * @f filesystem - * @F for @i %i (%Q) is - * @g group - * @h HTREE directory inode - * @i inode - * @I illegal - * @j journal - * @l lost+found - * @L is a link - * @m multiply-claimed - * @n invalid - * @o orphaned - * @p problem in - * @r root inode - * @s should be - * @S superblock - * @u unattached - * @v device - * @z zero-length - */ - - -/* - * This structure defines the abbreviations used by the text strings - * below. The first character in the string is the index letter. An - * abbreviation of the form '@<i>' is expanded by looking up the index - * letter <i> in the table below. - */ -static const char *const abbrevs[] = { - N_("aextended attribute"), - N_("Aerror allocating"), - N_("bblock"), - N_("Bbitmap"), - N_("ccompress"), - N_("Cconflicts with some other fs @b"), - N_("iinode"), - N_("Iillegal"), - N_("jjournal"), - N_("Ddeleted"), - N_("ddirectory"), - N_("eentry"), - N_("E@e '%Dn' in %p (%i)"), - N_("ffilesystem"), - N_("Ffor @i %i (%Q) is"), - N_("ggroup"), - N_("hHTREE @d @i"), - N_("llost+found"), - N_("Lis a link"), - N_("mmultiply-claimed"), - N_("ninvalid"), - N_("oorphaned"), - N_("pproblem in"), - N_("rroot @i"), - N_("sshould be"), - N_("Ssuper@b"), - N_("uunattached"), - N_("vdevice"), - N_("zzero-length"), - "@@", - 0 - }; - -/* - * Give more user friendly names to the "special" inodes. - */ -#define num_special_inodes 11 -static const char *const special_inode_name[] = -{ - N_("<The NULL inode>"), /* 0 */ - N_("<The bad blocks inode>"), /* 1 */ - "/", /* 2 */ - N_("<The ACL index inode>"), /* 3 */ - N_("<The ACL data inode>"), /* 4 */ - N_("<The boot loader inode>"), /* 5 */ - N_("<The undelete directory inode>"), /* 6 */ - N_("<The group descriptor inode>"), /* 7 */ - N_("<The journal inode>"), /* 8 */ - N_("<Reserved inode 9>"), /* 9 */ - N_("<Reserved inode 10>"), /* 10 */ -}; - -/* - * This function does "safe" printing. It will convert non-printable - * ASCII characters using '^' and M- notation. - */ -static void safe_print(const char *cp, int len) -{ - unsigned char ch; - - if (len < 0) - len = strlen(cp); - - while (len--) { - ch = *cp++; - if (ch > 128) { - fputs("M-", stdout); - ch -= 128; - } - if ((ch < 32) || (ch == 0x7f)) { - bb_putchar('^'); - ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ - } - bb_putchar(ch); - } -} - - -/* - * This function prints a pathname, using the ext2fs_get_pathname - * function - */ -static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino) -{ - errcode_t retval; - char *path; - - if (!dir && (ino < num_special_inodes)) { - fputs(_(special_inode_name[ino]), stdout); - return; - } - - retval = ext2fs_get_pathname(fs, dir, ino, &path); - if (retval) - fputs("???", stdout); - else { - safe_print(path, -1); - ext2fs_free_mem(&path); - } -} - -static void print_e2fsck_message(e2fsck_t ctx, const char *msg, - struct problem_context *pctx, int first); -/* - * This function handles the '@' expansion. We allow recursive - * expansion; an @ expression can contain further '@' and '%' - * expressions. - */ -static void expand_at_expression(e2fsck_t ctx, char ch, - struct problem_context *pctx, - int *first) -{ - const char *const *cpp; - const char *str; - - /* Search for the abbreviation */ - for (cpp = abbrevs; *cpp; cpp++) { - if (ch == *cpp[0]) - break; - } - if (*cpp) { - str = _(*cpp) + 1; - if (*first && islower(*str)) { - *first = 0; - bb_putchar(toupper(*str++)); - } - print_e2fsck_message(ctx, str, pctx, *first); - } else - printf("@%c", ch); -} - -/* - * This function expands '%IX' expressions - */ -static void expand_inode_expression(char ch, - struct problem_context *ctx) -{ - struct ext2_inode *inode; - struct ext2_inode_large *large_inode; - char * time_str; - time_t t; - int do_gmt = -1; - - if (!ctx || !ctx->inode) - goto no_inode; - - inode = ctx->inode; - large_inode = (struct ext2_inode_large *) inode; - - switch (ch) { - case 's': - if (LINUX_S_ISDIR(inode->i_mode)) - printf("%u", inode->i_size); - else { - printf("%"PRIu64, (inode->i_size | - ((uint64_t) inode->i_size_high << 32))); - } - break; - case 'S': - printf("%u", large_inode->i_extra_isize); - break; - case 'b': - printf("%u", inode->i_blocks); - break; - case 'l': - printf("%d", inode->i_links_count); - break; - case 'm': - printf("0%o", inode->i_mode); - break; - case 'M': - /* The diet libc doesn't respect the TZ environemnt variable */ - if (do_gmt == -1) { - time_str = getenv("TZ"); - if (!time_str) - time_str = ""; - do_gmt = !strcmp(time_str, "GMT"); - } - t = inode->i_mtime; - time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t)); - printf("%.24s", time_str); - break; - case 'F': - printf("%u", inode->i_faddr); - break; - case 'f': - printf("%u", inode->i_file_acl); - break; - case 'd': - printf("%u", (LINUX_S_ISDIR(inode->i_mode) ? - inode->i_dir_acl : 0)); - break; - case 'u': - printf("%d", (inode->i_uid | - (inode->osd2.linux2.l_i_uid_high << 16))); - break; - case 'g': - printf("%d", (inode->i_gid | - (inode->osd2.linux2.l_i_gid_high << 16))); - break; - default: - no_inode: - printf("%%I%c", ch); - break; - } -} - -/* - * This function expands '%dX' expressions - */ -static void expand_dirent_expression(char ch, - struct problem_context *ctx) -{ - struct ext2_dir_entry *dirent; - int len; - - if (!ctx || !ctx->dirent) - goto no_dirent; - - dirent = ctx->dirent; - - switch (ch) { - case 'i': - printf("%u", dirent->inode); - break; - case 'n': - len = dirent->name_len & 0xFF; - if (len > EXT2_NAME_LEN) - len = EXT2_NAME_LEN; - if (len > dirent->rec_len) - len = dirent->rec_len; - safe_print(dirent->name, len); - break; - case 'r': - printf("%u", dirent->rec_len); - break; - case 'l': - printf("%u", dirent->name_len & 0xFF); - break; - case 't': - printf("%u", dirent->name_len >> 8); - break; - default: - no_dirent: - printf("%%D%c", ch); - break; - } -} - -static void expand_percent_expression(ext2_filsys fs, char ch, - struct problem_context *ctx) -{ - if (!ctx) - goto no_context; - - switch (ch) { - case '%': - bb_putchar('%'); - break; - case 'b': - printf("%u", ctx->blk); - break; - case 'B': - printf("%"PRIi64, ctx->blkcount); - break; - case 'c': - printf("%u", ctx->blk2); - break; - case 'd': - printf("%u", ctx->dir); - break; - case 'g': - printf("%d", ctx->group); - break; - case 'i': - printf("%u", ctx->ino); - break; - case 'j': - printf("%u", ctx->ino2); - break; - case 'm': - fputs(error_message(ctx->errcode), stdout); - break; - case 'N': - printf("%"PRIi64, ctx->num); - break; - case 'p': - print_pathname(fs, ctx->ino, 0); - break; - case 'P': - print_pathname(fs, ctx->ino2, - ctx->dirent ? ctx->dirent->inode : 0); - break; - case 'q': - print_pathname(fs, ctx->dir, 0); - break; - case 'Q': - print_pathname(fs, ctx->dir, ctx->ino); - break; - case 'S': - printf("%d", get_backup_sb(NULL, fs, NULL, NULL)); - break; - case 's': - fputs((ctx->str ? ctx->str : "NULL"), stdout); - break; - case 'X': - printf("0x%"PRIi64, ctx->num); - break; - default: - no_context: - printf("%%%c", ch); - break; - } -} - - -static void print_e2fsck_message(e2fsck_t ctx, const char *msg, - struct problem_context *pctx, int first) -{ - ext2_filsys fs = ctx->fs; - const char * cp; - int i; - - e2fsck_clear_progbar(ctx); - for (cp = msg; *cp; cp++) { - if (cp[0] == '@') { - cp++; - expand_at_expression(ctx, *cp, pctx, &first); - } else if (cp[0] == '%' && cp[1] == 'I') { - cp += 2; - expand_inode_expression(*cp, pctx); - } else if (cp[0] == '%' && cp[1] == 'D') { - cp += 2; - expand_dirent_expression(*cp, pctx); - } else if ((cp[0] == '%')) { - cp++; - expand_percent_expression(fs, *cp, pctx); - } else { - for (i=0; cp[i]; i++) - if ((cp[i] == '@') || cp[i] == '%') - break; - printf("%.*s", i, cp); - cp += i-1; - } - first = 0; - } -} - - -/* - * region.c --- code which manages allocations within a region. - */ - -struct region_el { - region_addr_t start; - region_addr_t end; - struct region_el *next; -}; - -struct region_struct { - region_addr_t min; - region_addr_t max; - struct region_el *allocated; -}; - -static region_t region_create(region_addr_t min, region_addr_t max) -{ - region_t region; - - region = xzalloc(sizeof(struct region_struct)); - region->min = min; - region->max = max; - return region; -} - -static void region_free(region_t region) -{ - struct region_el *r, *next; - - for (r = region->allocated; r; r = next) { - next = r->next; - free(r); - } - memset(region, 0, sizeof(struct region_struct)); - free(region); -} - -static int region_allocate(region_t region, region_addr_t start, int n) -{ - struct region_el *r, *new_region, *prev, *next; - region_addr_t end; - - end = start+n; - if ((start < region->min) || (end > region->max)) - return -1; - if (n == 0) - return 1; - - /* - * Search through the linked list. If we find that it - * conflicts witih something that's already allocated, return - * 1; if we can find an existing region which we can grow, do - * so. Otherwise, stop when we find the appropriate place - * insert a new region element into the linked list. - */ - for (r = region->allocated, prev=NULL; r; prev = r, r = r->next) { - if (((start >= r->start) && (start < r->end)) || - ((end > r->start) && (end <= r->end)) || - ((start <= r->start) && (end >= r->end))) - return 1; - if (end == r->start) { - r->start = start; - return 0; - } - if (start == r->end) { - if ((next = r->next)) { - if (end > next->start) - return 1; - if (end == next->start) { - r->end = next->end; - r->next = next->next; - free(next); - return 0; - } - } - r->end = end; - return 0; - } - if (start < r->start) - break; - } - /* - * Insert a new region element structure into the linked list - */ - new_region = xmalloc(sizeof(struct region_el)); - new_region->start = start; - new_region->end = start + n; - new_region->next = r; - if (prev) - prev->next = new_region; - else - region->allocated = new_region; - return 0; -} - -/* - * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table - * - * Pass 1 of e2fsck iterates over all the inodes in the filesystems, - * and applies the following tests to each inode: - * - * - The mode field of the inode must be legal. - * - The size and block count fields of the inode are correct. - * - A data block must not be used by another inode - * - * Pass 1 also gathers the collects the following information: - * - * - A bitmap of which inodes are in use. (inode_used_map) - * - A bitmap of which inodes are directories. (inode_dir_map) - * - A bitmap of which inodes are regular files. (inode_reg_map) - * - A bitmap of which inodes have bad fields. (inode_bad_map) - * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) - * - A bitmap of which blocks are in use. (block_found_map) - * - A bitmap of which blocks are in use by two inodes (block_dup_map) - * - The data blocks of the directory inodes. (dir_map) - * - * Pass 1 is designed to stash away enough information so that the - * other passes should not need to read in the inode information - * during the normal course of a filesystem check. (Althogh if an - * inconsistency is detected, other passes may need to read in an - * inode to fix it.) - * - * Note that pass 1B will be invoked if there are any duplicate blocks - * found. - */ - - -static int process_block(ext2_filsys fs, blk_t *blocknr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static int process_bad_block(ext2_filsys fs, blk_t *block_nr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf); -static void mark_table_blocks(e2fsck_t ctx); -static void alloc_imagic_map(e2fsck_t ctx); -static void mark_inode_bad(e2fsck_t ctx, ino_t ino); -static void handle_fs_bad_blocks(e2fsck_t ctx); -static void process_inodes(e2fsck_t ctx, char *block_buf); -static int process_inode_cmp(const void *a, const void *b); -static errcode_t scan_callback(ext2_filsys fs, - dgrp_t group, void * priv_data); -static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, - char *block_buf, int adjust_sign); -/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */ - -static void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, int bufsize, - const char *proc); - -struct process_block_struct_1 { - ext2_ino_t ino; - unsigned is_dir:1, is_reg:1, clear:1, suppress:1, - fragmented:1, compressed:1, bbcheck:1; - blk_t num_blocks; - blk_t max_blocks; - e2_blkcnt_t last_block; - int num_illegal_blocks; - blk_t previous_block; - struct ext2_inode *inode; - struct problem_context *pctx; - ext2fs_block_bitmap fs_meta_blocks; - e2fsck_t ctx; -}; - -struct process_inode_block { - ext2_ino_t ino; - struct ext2_inode inode; -}; - -struct scan_callback_struct { - e2fsck_t ctx; - char *block_buf; -}; - -/* - * For the inodes to process list. - */ -static struct process_inode_block *inodes_to_process; -static int process_inode_count; - -static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - - EXT2_MIN_BLOCK_LOG_SIZE + 1]; - -/* - * Free all memory allocated by pass1 in preparation for restarting - * things. - */ -static void unwind_pass1(void) -{ - ext2fs_free_mem(&inodes_to_process); -} - -/* - * Check to make sure a device inode is real. Returns 1 if the device - * checks out, 0 if not. - * - * Note: this routine is now also used to check FIFO's and Sockets, - * since they have the same requirement; the i_block fields should be - * zero. - */ -static int -e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode) -{ - int i; - - /* - * If i_blocks is non-zero, or the index flag is set, then - * this is a bogus device/fifo/socket - */ - if ((ext2fs_inode_data_blocks(fs, inode) != 0) || - (inode->i_flags & EXT2_INDEX_FL)) - return 0; - - /* - * We should be able to do the test below all the time, but - * because the kernel doesn't forcibly clear the device - * inode's additional i_block fields, there are some rare - * occasions when a legitimate device inode will have non-zero - * additional i_block fields. So for now, we only complain - * when the immutable flag is set, which should never happen - * for devices. (And that's when the problem is caused, since - * you can't set or clear immutable flags for devices.) Once - * the kernel has been fixed we can change this... - */ - if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { - for (i=4; i < EXT2_N_BLOCKS; i++) - if (inode->i_block[i]) - return 0; - } - return 1; -} - -/* - * Check to make sure a symlink inode is real. Returns 1 if the symlink - * checks out, 0 if not. - */ -static int -e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode, char *buf) -{ - unsigned int len; - int i; - blk_t blocks; - - if ((inode->i_size_high || inode->i_size == 0) || - (inode->i_flags & EXT2_INDEX_FL)) - return 0; - - blocks = ext2fs_inode_data_blocks(fs, inode); - if (blocks) { - if ((inode->i_size >= fs->blocksize) || - (blocks != fs->blocksize >> 9) || - (inode->i_block[0] < fs->super->s_first_data_block) || - (inode->i_block[0] >= fs->super->s_blocks_count)) - return 0; - - for (i = 1; i < EXT2_N_BLOCKS; i++) - if (inode->i_block[i]) - return 0; - - if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf)) - return 0; - - len = strnlen(buf, fs->blocksize); - if (len == fs->blocksize) - return 0; - } else { - if (inode->i_size >= sizeof(inode->i_block)) - return 0; - - len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); - if (len == sizeof(inode->i_block)) - return 0; - } - if (len != inode->i_size) - return 0; - return 1; -} - -/* - * If the immutable (or append-only) flag is set on the inode, offer - * to clear it. - */ -#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) -static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) -{ - if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) - return; - - if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) - return; - - pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; - e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); -} - -/* - * If device, fifo or socket, check size is zero -- if not offer to - * clear it - */ -static void check_size(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_inode *inode = pctx->inode; - - if ((inode->i_size == 0) && (inode->i_size_high == 0)) - return; - - if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) - return; - - inode->i_size = 0; - inode->i_size_high = 0; - e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); -} - -static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_inode_large *inode; - struct ext2_ext_attr_entry *entry; - char *start, *end; - int storage_size, remain, offs; - int problem = 0; - - inode = (struct ext2_inode_large *) pctx->inode; - storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - - inode->i_extra_isize; - start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + - inode->i_extra_isize + sizeof(__u32); - end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super); - entry = (struct ext2_ext_attr_entry *) start; - - /* scan all entry's headers first */ - - /* take finish entry 0UL into account */ - remain = storage_size - sizeof(__u32); - offs = end - start; - - while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { - - /* header eats this space */ - remain -= sizeof(struct ext2_ext_attr_entry); - - /* is attribute name valid? */ - if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { - pctx->num = entry->e_name_len; - problem = PR_1_ATTR_NAME_LEN; - goto fix; - } - - /* attribute len eats this space */ - remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); - - /* check value size */ - if (entry->e_value_size == 0 || entry->e_value_size > remain) { - pctx->num = entry->e_value_size; - problem = PR_1_ATTR_VALUE_SIZE; - goto fix; - } - - /* check value placement */ - if (entry->e_value_offs + - EXT2_XATTR_SIZE(entry->e_value_size) != offs) { - printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs); - pctx->num = entry->e_value_offs; - problem = PR_1_ATTR_VALUE_OFFSET; - goto fix; - } - - /* e_value_block must be 0 in inode's ea */ - if (entry->e_value_block != 0) { - pctx->num = entry->e_value_block; - problem = PR_1_ATTR_VALUE_BLOCK; - goto fix; - } - - /* e_hash must be 0 in inode's ea */ - if (entry->e_hash != 0) { - pctx->num = entry->e_hash; - problem = PR_1_ATTR_HASH; - goto fix; - } - - remain -= entry->e_value_size; - offs -= EXT2_XATTR_SIZE(entry->e_value_size); - - entry = EXT2_EXT_ATTR_NEXT(entry); - } -fix: - /* - * it seems like a corruption. it's very unlikely we could repair - * EA(s) in automatic fashion -bzzz - */ - if (problem == 0 || !fix_problem(ctx, problem, pctx)) - return; - - /* simple remove all possible EA(s) */ - *((__u32 *)start) = 0UL; - e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *)inode, - EXT2_INODE_SIZE(sb), "pass1"); -} - -static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_inode_large *inode; - __u32 *eamagic; - int min, max; - - inode = (struct ext2_inode_large *) pctx->inode; - if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { - /* this isn't large inode. so, nothing to check */ - return; - } - - /* i_extra_isize must cover i_extra_isize + i_pad1 at least */ - min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1); - max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; - /* - * For now we will allow i_extra_isize to be 0, but really - * implementations should never allow i_extra_isize to be 0 - */ - if (inode->i_extra_isize && - (inode->i_extra_isize < min || inode->i_extra_isize > max)) { - if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) - return; - inode->i_extra_isize = min; - e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, - EXT2_INODE_SIZE(sb), "pass1"); - return; - } - - eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + - inode->i_extra_isize); - if (*eamagic == EXT2_EXT_ATTR_MAGIC) { - /* it seems inode has an extended attribute(s) in body */ - check_ea_in_inode(ctx, pctx); - } -} - -static void e2fsck_pass1(e2fsck_t ctx) -{ - int i; - __u64 max_sizes; - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - struct ext2_inode *inode; - ext2_inode_scan scan; - char *block_buf; - unsigned char frag, fsize; - struct problem_context pctx; - struct scan_callback_struct scan_struct; - struct ext2_super_block *sb = ctx->fs->super; - int imagic_fs; - int busted_fs_time = 0; - int inode_size; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1_PASS_HEADER, &pctx); - - if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && - !(ctx->options & E2F_OPT_NO)) { - if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) - ctx->dirs_to_hash = 0; - } - - /* Pass 1 */ - -#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) - - for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { - max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); - max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); - max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); - max_sizes = (max_sizes * (1UL << i)) - 1; - ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; - } -#undef EXT2_BPP - - imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); - - /* - * Allocate bitmaps structures - */ - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"), - &ctx->inode_used_map); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("directory inode map"), &ctx->inode_dir_map); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("regular file inode map"), &ctx->inode_reg_map); - if (pctx.errcode) { - pctx.num = 6; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"), - &ctx->block_found_map); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, - &ctx->inode_link_info); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - inode_size = EXT2_INODE_SIZE(fs->super); - inode = (struct ext2_inode *) - e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); - - inodes_to_process = (struct process_inode_block *) - e2fsck_allocate_memory(ctx, - (ctx->process_inode_size * - sizeof(struct process_inode_block)), - "array of inodes to process"); - process_inode_count = 0; - - pctx.errcode = ext2fs_init_dblist(fs, 0); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - /* - * If the last orphan field is set, clear it, since the pass1 - * processing will automatically find and clear the orphans. - * In the future, we may want to try using the last_orphan - * linked list ourselves, but for now, we clear it so that the - * ext3 mount code won't get confused. - */ - if (!(ctx->options & E2F_OPT_READONLY)) { - if (fs->super->s_last_orphan) { - fs->super->s_last_orphan = 0; - ext2fs_mark_super_dirty(fs); - } - } - - mark_table_blocks(ctx); - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, - "block interate buffer"); - e2fsck_use_inode_shortcuts(ctx, 1); - ehandler_operation(_("doing inode scan")); - pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, - &scan); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); - ctx->stashed_inode = inode; - scan_struct.ctx = ctx; - scan_struct.block_buf = block_buf; - ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); - if (ctx->progress) - if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) - return; - if ((fs->super->s_wtime < fs->super->s_inodes_count) || - (fs->super->s_mtime < fs->super->s_inodes_count)) - busted_fs_time = 1; - - while (1) { - pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, - inode, inode_size); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { - continue; - } - if (pctx.errcode) { - fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (!ino) - break; - pctx.ino = ino; - pctx.inode = inode; - ctx->stashed_ino = ino; - if (inode->i_links_count) { - pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, - ino, inode->i_links_count); - if (pctx.errcode) { - pctx.num = inode->i_links_count; - fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - if (ino == EXT2_BAD_INO) { - struct process_block_struct_1 pb; - - pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, - &pb.fs_meta_blocks); - if (pctx.errcode) { - pctx.num = 4; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pb.ino = EXT2_BAD_INO; - pb.num_blocks = pb.last_block = 0; - pb.num_illegal_blocks = 0; - pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; - pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; - pb.inode = inode; - pb.pctx = &pctx; - pb.ctx = ctx; - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, - block_buf, process_bad_block, &pb); - ext2fs_free_block_bitmap(pb.fs_meta_blocks); - if (pctx.errcode) { - fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (pb.bbcheck) - if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - clear_problem_context(&pctx); - continue; - } else if (ino == EXT2_ROOT_INO) { - /* - * Make sure the root inode is a directory; if - * not, offer to clear it. It will be - * regnerated in pass #3. - */ - if (!LINUX_S_ISDIR(inode->i_mode)) { - if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) { - inode->i_dtime = time(NULL); - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, - ino, 0); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - /* - * If dtime is set, offer to clear it. mke2fs - * version 0.2b created filesystems with the - * dtime field set for the root and lost+found - * directories. We won't worry about - * /lost+found, since that can be regenerated - * easily. But we will fix the root directory - * as a special case. - */ - if (inode->i_dtime && inode->i_links_count) { - if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { - inode->i_dtime = 0; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - } else if (ino == EXT2_JOURNAL_INO) { - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { - if (!LINUX_S_ISREG(inode->i_mode) && - fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, - &pctx)) { - inode->i_mode = LINUX_S_IFREG; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - check_blocks(ctx, &pctx, block_buf); - continue; - } - if ((inode->i_links_count || inode->i_blocks || - inode->i_block[0]) && - fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, - &pctx)) { - memset(inode, 0, inode_size); - ext2fs_icount_store(ctx->inode_link_info, - ino, 0); - e2fsck_write_inode_full(ctx, ino, inode, - inode_size, "pass1"); - } - } else if (ino < EXT2_FIRST_INODE(fs->super)) { - int problem = 0; - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - if (ino == EXT2_BOOT_LOADER_INO) { - if (LINUX_S_ISDIR(inode->i_mode)) - problem = PR_1_RESERVED_BAD_MODE; - } else if (ino == EXT2_RESIZE_INO) { - if (inode->i_mode && - !LINUX_S_ISREG(inode->i_mode)) - problem = PR_1_RESERVED_BAD_MODE; - } else { - if (inode->i_mode != 0) - problem = PR_1_RESERVED_BAD_MODE; - } - if (problem) { - if (fix_problem(ctx, problem, &pctx)) { - inode->i_mode = 0; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - check_blocks(ctx, &pctx, block_buf); - continue; - } - /* - * Check for inodes who might have been part of the - * orphaned list linked list. They should have gotten - * dealt with by now, unless the list had somehow been - * corrupted. - * - * FIXME: In the future, inodes which are still in use - * (and which are therefore) pending truncation should - * be handled specially. Right now we just clear the - * dtime field, and the normal e2fsck handling of - * inodes where i_size and the inode blocks are - * inconsistent is to fix i_size, instead of releasing - * the extra blocks. This won't catch the inodes that - * was at the end of the orphan list, but it's better - * than nothing. The right answer is that there - * shouldn't be any bugs in the orphan list handling. :-) - */ - if (inode->i_dtime && !busted_fs_time && - inode->i_dtime < ctx->fs->super->s_inodes_count) { - if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { - inode->i_dtime = inode->i_links_count ? - 0 : time(NULL); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - - /* - * This code assumes that deleted inodes have - * i_links_count set to 0. - */ - if (!inode->i_links_count) { - if (!inode->i_dtime && inode->i_mode) { - if (fix_problem(ctx, - PR_1_ZERO_DTIME, &pctx)) { - inode->i_dtime = time(NULL); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - continue; - } - /* - * n.b. 0.3c ext2fs code didn't clear i_links_count for - * deleted files. Oops. - * - * Since all new ext2 implementations get this right, - * we now assume that the case of non-zero - * i_links_count and non-zero dtime means that we - * should keep the file, not delete it. - * - */ - if (inode->i_dtime) { - if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { - inode->i_dtime = 0; - e2fsck_write_inode(ctx, ino, inode, "pass1"); - } - } - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - switch (fs->super->s_creator_os) { - case EXT2_OS_LINUX: - frag = inode->osd2.linux2.l_i_frag; - fsize = inode->osd2.linux2.l_i_fsize; - break; - case EXT2_OS_HURD: - frag = inode->osd2.hurd2.h_i_frag; - fsize = inode->osd2.hurd2.h_i_fsize; - break; - case EXT2_OS_MASIX: - frag = inode->osd2.masix2.m_i_frag; - fsize = inode->osd2.masix2.m_i_fsize; - break; - default: - frag = fsize = 0; - } - - if (inode->i_faddr || frag || fsize || - (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) - mark_inode_bad(ctx, ino); - if (inode->i_flags & EXT2_IMAGIC_FL) { - if (imagic_fs) { - if (!ctx->inode_imagic_map) - alloc_imagic_map(ctx); - ext2fs_mark_inode_bitmap(ctx->inode_imagic_map, - ino); - } else { - if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { - inode->i_flags &= ~EXT2_IMAGIC_FL; - e2fsck_write_inode(ctx, ino, - inode, "pass1"); - } - } - } - - check_inode_extra_space(ctx, &pctx); - - if (LINUX_S_ISDIR(inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); - e2fsck_add_dir_info(ctx, ino, 0); - ctx->fs_directory_count++; - } else if (LINUX_S_ISREG (inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino); - ctx->fs_regular_count++; - } else if (LINUX_S_ISCHR (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_chardev_count++; - } else if (LINUX_S_ISBLK (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_blockdev_count++; - } else if (LINUX_S_ISLNK (inode->i_mode) && - e2fsck_pass1_check_symlink(fs, inode, block_buf)) { - check_immutable(ctx, &pctx); - ctx->fs_symlinks_count++; - if (ext2fs_inode_data_blocks(fs, inode) == 0) { - ctx->fs_fast_symlinks_count++; - check_blocks(ctx, &pctx, block_buf); - continue; - } - } - else if (LINUX_S_ISFIFO (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_fifo_count++; - } else if ((LINUX_S_ISSOCK (inode->i_mode)) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_sockets_count++; - } else - mark_inode_bad(ctx, ino); - if (inode->i_block[EXT2_IND_BLOCK]) - ctx->fs_ind_count++; - if (inode->i_block[EXT2_DIND_BLOCK]) - ctx->fs_dind_count++; - if (inode->i_block[EXT2_TIND_BLOCK]) - ctx->fs_tind_count++; - if (inode->i_block[EXT2_IND_BLOCK] || - inode->i_block[EXT2_DIND_BLOCK] || - inode->i_block[EXT2_TIND_BLOCK] || - inode->i_file_acl) { - inodes_to_process[process_inode_count].ino = ino; - inodes_to_process[process_inode_count].inode = *inode; - process_inode_count++; - } else - check_blocks(ctx, &pctx, block_buf); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - if (process_inode_count >= ctx->process_inode_size) { - process_inodes(ctx, block_buf); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - } - } - process_inodes(ctx, block_buf); - ext2fs_close_inode_scan(scan); - ehandler_operation(0); - - /* - * If any extended attribute blocks' reference counts need to - * be adjusted, either up (ctx->refcount_extra), or down - * (ctx->refcount), then fix them. - */ - if (ctx->refcount) { - adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); - ea_refcount_free(ctx->refcount); - ctx->refcount = 0; - } - if (ctx->refcount_extra) { - adjust_extattr_refcount(ctx, ctx->refcount_extra, - block_buf, +1); - ea_refcount_free(ctx->refcount_extra); - ctx->refcount_extra = 0; - } - - if (ctx->invalid_bitmaps) - handle_fs_bad_blocks(ctx); - - /* We don't need the block_ea_map any more */ - ext2fs_free_block_bitmap(ctx->block_ea_map); - ctx->block_ea_map = 0; - - if (ctx->flags & E2F_FLAG_RESIZE_INODE) { - ext2fs_block_bitmap save_bmap; - - save_bmap = fs->block_map; - fs->block_map = ctx->block_found_map; - clear_problem_context(&pctx); - pctx.errcode = ext2fs_create_resize_inode(fs); - if (pctx.errcode) { - fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, - "recreate inode"); - inode->i_mtime = time(NULL); - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, - "recreate inode"); - fs->block_map = save_bmap; - ctx->flags &= ~E2F_FLAG_RESIZE_INODE; - } - - if (ctx->flags & E2F_FLAG_RESTART) { - /* - * Only the master copy of the superblock and block - * group descriptors are going to be written during a - * restart, so set the superblock to be used to be the - * master superblock. - */ - ctx->use_superblock = 0; - unwind_pass1(); - goto endit; - } - - if (ctx->block_dup_map) { - if (ctx->options & E2F_OPT_PREEN) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); - } - e2fsck_pass1_dupblocks(ctx, block_buf); - } - ext2fs_free_mem(&inodes_to_process); -endit: - e2fsck_use_inode_shortcuts(ctx, 0); - - ext2fs_free_mem(&block_buf); - ext2fs_free_mem(&inode); -} - -/* - * When the inode_scan routines call this callback at the end of the - * glock group, call process_inodes. - */ -static errcode_t scan_callback(ext2_filsys fs, - dgrp_t group, void * priv_data) -{ - struct scan_callback_struct *scan_struct; - e2fsck_t ctx; - - scan_struct = (struct scan_callback_struct *) priv_data; - ctx = scan_struct->ctx; - - process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); - - if (ctx->progress) - if ((ctx->progress)(ctx, 1, group+1, - ctx->fs->group_desc_count)) - return EXT2_ET_CANCEL_REQUESTED; - - return 0; -} - -/* - * Process the inodes in the "inodes to process" list. - */ -static void process_inodes(e2fsck_t ctx, char *block_buf) -{ - int i; - struct ext2_inode *old_stashed_inode; - ext2_ino_t old_stashed_ino; - const char *old_operation; - char buf[80]; - struct problem_context pctx; - - /* begin process_inodes */ - if (process_inode_count == 0) - return; - old_operation = ehandler_operation(0); - old_stashed_inode = ctx->stashed_inode; - old_stashed_ino = ctx->stashed_ino; - qsort(inodes_to_process, process_inode_count, - sizeof(struct process_inode_block), process_inode_cmp); - clear_problem_context(&pctx); - for (i=0; i < process_inode_count; i++) { - pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; - pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; - sprintf(buf, _("reading indirect blocks of inode %u"), - pctx.ino); - ehandler_operation(buf); - check_blocks(ctx, &pctx, block_buf); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - break; - } - ctx->stashed_inode = old_stashed_inode; - ctx->stashed_ino = old_stashed_ino; - process_inode_count = 0; - /* end process inodes */ - - ehandler_operation(old_operation); -} - -static int process_inode_cmp(const void *a, const void *b) -{ - const struct process_inode_block *ib_a = - (const struct process_inode_block *) a; - const struct process_inode_block *ib_b = - (const struct process_inode_block *) b; - int ret; - - ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - - ib_b->inode.i_block[EXT2_IND_BLOCK]); - if (ret == 0) - ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl; - return ret; -} - -/* - * Mark an inode as being bad in some what - */ -static void mark_inode_bad(e2fsck_t ctx, ino_t ino) -{ - struct problem_context pctx; - - if (!ctx->inode_bad_map) { - clear_problem_context(&pctx); - - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("bad inode map"), &ctx->inode_bad_map); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino); -} - - -/* - * This procedure will allocate the inode imagic table - */ -static void alloc_imagic_map(e2fsck_t ctx) -{ - struct problem_context pctx; - - clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("imagic inode map"), - &ctx->inode_imagic_map); - if (pctx.errcode) { - pctx.num = 5; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -/* - * Marks a block as in use, setting the dup_map if it's been set - * already. Called by process_block and process_bad_block. - * - * WARNING: Assumes checks have already been done to make sure block - * is valid. This is true in both process_block and process_bad_block. - */ -static void mark_block_used(e2fsck_t ctx, blk_t block) -{ - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) { - if (!ctx->block_dup_map) { - pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs, - _("multiply claimed block map"), - &ctx->block_dup_map); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, - &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block); - } else { - ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block); - } -} - -/* - * Adjust the extended attribute block's reference counts at the end - * of pass 1, either by subtracting out references for EA blocks that - * are still referenced in ctx->refcount, or by adding references for - * EA blocks that had extra references as accounted for in - * ctx->refcount_extra. - */ -static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, - char *block_buf, int adjust_sign) -{ - struct ext2_ext_attr_header *header; - struct problem_context pctx; - ext2_filsys fs = ctx->fs; - blk_t blk; - __u32 should_be; - int count; - - clear_problem_context(&pctx); - - ea_refcount_intr_begin(refcount); - while (1) { - if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) - break; - pctx.blk = blk; - pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf); - if (pctx.errcode) { - fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); - return; - } - header = (struct ext2_ext_attr_header *) block_buf; - pctx.blkcount = header->h_refcount; - should_be = header->h_refcount + adjust_sign * count; - pctx.num = should_be; - if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { - header->h_refcount = should_be; - pctx.errcode = ext2fs_write_ext_attr(fs, blk, - block_buf); - if (pctx.errcode) { - fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx); - continue; - } - } - } -} - -/* - * Handle processing the extended attribute blocks - */ -static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino = pctx->ino; - struct ext2_inode *inode = pctx->inode; - blk_t blk; - char * end; - struct ext2_ext_attr_header *header; - struct ext2_ext_attr_entry *entry; - int count; - region_t region; - - blk = inode->i_file_acl; - if (blk == 0) - return 0; - - /* - * If the Extended attribute flag isn't set, then a non-zero - * file acl means that the inode is corrupted. - * - * Or if the extended attribute block is an invalid block, - * then the inode is also corrupted. - */ - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || - (blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { - mark_inode_bad(ctx, ino); - return 0; - } - - /* If ea bitmap hasn't been allocated, create it */ - if (!ctx->block_ea_map) { - pctx->errcode = ext2fs_allocate_block_bitmap(fs, - _("ext attr block map"), - &ctx->block_ea_map); - if (pctx->errcode) { - pctx->num = 2; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - - /* Create the EA refcount structure if necessary */ - if (!ctx->refcount) { - pctx->errcode = ea_refcount_create(0, &ctx->refcount); - if (pctx->errcode) { - pctx->num = 1; - fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - - /* Have we seen this EA block before? */ - if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) { - if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) - return 1; - /* Ooops, this EA was referenced more than it stated */ - if (!ctx->refcount_extra) { - pctx->errcode = ea_refcount_create(0, - &ctx->refcount_extra); - if (pctx->errcode) { - pctx->num = 2; - fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - ea_refcount_increment(ctx->refcount_extra, blk, 0); - return 1; - } - - /* - * OK, we haven't seen this EA block yet. So we need to - * validate it - */ - pctx->blk = blk; - pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf); - if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) - goto clear_extattr; - header = (struct ext2_ext_attr_header *) block_buf; - pctx->blk = inode->i_file_acl; - if (((ctx->ext_attr_ver == 1) && - (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || - ((ctx->ext_attr_ver == 2) && - (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { - if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) - goto clear_extattr; - } - - if (header->h_blocks != 1) { - if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) - goto clear_extattr; - } - - region = region_create(0, fs->blocksize); - if (!region) { - fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - - entry = (struct ext2_ext_attr_entry *)(header+1); - end = block_buf + fs->blocksize; - while ((char *)entry < end && *(__u32 *)entry) { - if (region_allocate(region, (char *)entry - (char *)header, - EXT2_EXT_ATTR_LEN(entry->e_name_len))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - if ((ctx->ext_attr_ver == 1 && - (entry->e_name_len == 0 || entry->e_name_index != 0)) || - (ctx->ext_attr_ver == 2 && - entry->e_name_index == 0)) { - if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) - goto clear_extattr; - } - if (entry->e_value_block != 0) { - if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) - goto clear_extattr; - } - if (entry->e_value_size && - region_allocate(region, entry->e_value_offs, - EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - entry = EXT2_EXT_ATTR_NEXT(entry); - } - if (region_allocate(region, (char *)entry - (char *)header, 4)) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - region_free(region); - - count = header->h_refcount - 1; - if (count) - ea_refcount_store(ctx->refcount, blk, count); - mark_block_used(ctx, blk); - ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk); - - return 1; - -clear_extattr: - inode->i_file_acl = 0; - e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); - return 0; -} - -/* Returns 1 if bad htree, 0 if OK */ -static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, - ext2_ino_t ino FSCK_ATTR((unused)), - struct ext2_inode *inode, - char *block_buf) -{ - struct ext2_dx_root_info *root; - ext2_filsys fs = ctx->fs; - errcode_t retval; - blk_t blk; - - if ((!LINUX_S_ISDIR(inode->i_mode) && - fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || - (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && - fix_problem(ctx, PR_1_HTREE_SET, pctx))) - return 1; - - blk = inode->i_block[0]; - if (((blk == 0) || - (blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) && - fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - retval = io_channel_read_blk(fs->io, blk, 1, block_buf); - if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - /* XXX should check that beginning matches a directory */ - root = (struct ext2_dx_root_info *) (block_buf + 24); - - if ((root->reserved_zero || root->info_length < 8) && - fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - pctx->num = root->hash_version; - if ((root->hash_version != EXT2_HASH_LEGACY) && - (root->hash_version != EXT2_HASH_HALF_MD4) && - (root->hash_version != EXT2_HASH_TEA) && - fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) - return 1; - - if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && - fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) - return 1; - - pctx->num = root->indirect_levels; - if ((root->indirect_levels > 1) && - fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) - return 1; - - return 0; -} - -/* - * This subroutine is called on each inode to account for all of the - * blocks used by that inode. - */ -static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct process_block_struct_1 pb; - ext2_ino_t ino = pctx->ino; - struct ext2_inode *inode = pctx->inode; - int bad_size = 0; - int dirty_inode = 0; - __u64 size; - - pb.ino = ino; - pb.num_blocks = 0; - pb.last_block = -1; - pb.num_illegal_blocks = 0; - pb.suppress = 0; pb.clear = 0; - pb.fragmented = 0; - pb.compressed = 0; - pb.previous_block = 0; - pb.is_dir = LINUX_S_ISDIR(inode->i_mode); - pb.is_reg = LINUX_S_ISREG(inode->i_mode); - pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); - pb.inode = inode; - pb.pctx = pctx; - pb.ctx = ctx; - pctx->ino = ino; - pctx->errcode = 0; - - if (inode->i_flags & EXT2_COMPRBLK_FL) { - if (fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_COMPRESSION) - pb.compressed = 1; - else { - if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { - inode->i_flags &= ~EXT2_COMPRBLK_FL; - dirty_inode++; - } - } - } - - if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) - pb.num_blocks++; - - if (ext2fs_inode_has_valid_blocks(inode)) - pctx->errcode = ext2fs_block_iterate2(fs, ino, - pb.is_dir ? BLOCK_FLAG_HOLE : 0, - block_buf, process_block, &pb); - end_problem_latch(ctx, PR_LATCH_BLOCK); - end_problem_latch(ctx, PR_LATCH_TOOBIG); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto out; - if (pctx->errcode) - fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); - - if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) - ctx->fs_fragmented++; - - if (pb.clear) { - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - inode->i_dtime = time(NULL); - dirty_inode++; - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - /* - * The inode was probably partially accounted for - * before processing was aborted, so we need to - * restart the pass 1 scan. - */ - ctx->flags |= E2F_FLAG_RESTART; - goto out; - } - - if (inode->i_flags & EXT2_INDEX_FL) { - if (handle_htree(ctx, pctx, ino, inode, block_buf)) { - inode->i_flags &= ~EXT2_INDEX_FL; - dirty_inode++; - } else { -#ifdef ENABLE_HTREE - e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); -#endif - } - } - if (ctx->dirs_to_hash && pb.is_dir && - !(inode->i_flags & EXT2_INDEX_FL) && - ((inode->i_size / fs->blocksize) >= 3)) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); - - if (!pb.num_blocks && pb.is_dir) { - if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - inode->i_dtime = time(NULL); - dirty_inode++; - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ctx->fs_directory_count--; - goto out; - } - } - - pb.num_blocks *= (fs->blocksize / 512); - - if (pb.is_dir) { - int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); - if (nblock > (pb.last_block + 1)) - bad_size = 1; - else if (nblock < (pb.last_block + 1)) { - if (((pb.last_block + 1) - nblock) > - fs->super->s_prealloc_dir_blocks) - bad_size = 2; - } - } else { - size = EXT2_I_SIZE(inode); - if ((pb.last_block >= 0) && - (size < (__u64) pb.last_block * fs->blocksize)) - bad_size = 3; - else if (size > ext2_max_sizes[fs->super->s_log_block_size]) - bad_size = 4; - } - /* i_size for symlinks is checked elsewhere */ - if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { - pctx->num = (pb.last_block+1) * fs->blocksize; - if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { - inode->i_size = pctx->num; - if (!LINUX_S_ISDIR(inode->i_mode)) - inode->i_size_high = pctx->num >> 32; - dirty_inode++; - } - pctx->num = 0; - } - if (LINUX_S_ISREG(inode->i_mode) && - (inode->i_size_high || inode->i_size & 0x80000000UL)) - ctx->large_files++; - if (pb.num_blocks != inode->i_blocks) { - pctx->num = pb.num_blocks; - if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { - inode->i_blocks = pb.num_blocks; - dirty_inode++; - } - pctx->num = 0; - } -out: - if (dirty_inode) - e2fsck_write_inode(ctx, ino, inode, "check_blocks"); -} - - -/* - * This is a helper function for check_blocks(). - */ -static int process_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct_1 *p; - struct problem_context *pctx; - blk_t blk = *block_nr; - int ret_code = 0; - int problem = 0; - e2fsck_t ctx; - - p = (struct process_block_struct_1 *) priv_data; - pctx = p->pctx; - ctx = p->ctx; - - if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { - /* todo: Check that the comprblk_fl is high, that the - blkaddr pattern looks right (all non-holes up to - first EXT2FS_COMPRESSED_BLKADDR, then all - EXT2FS_COMPRESSED_BLKADDR up to end of cluster), - that the feature_incompat bit is high, and that the - inode is a regular file. If we're doing a "full - check" (a concept introduced to e2fsck by e2compr, - meaning that we look at data blocks as well as - metadata) then call some library routine that - checks the compressed data. I'll have to think - about this, because one particularly important - problem to be able to fix is to recalculate the - cluster size if necessary. I think that perhaps - we'd better do most/all e2compr-specific checks - separately, after the non-e2compr checks. If not - doing a full check, it may be useful to test that - the personality is linux; e.g. if it isn't then - perhaps this really is just an illegal block. */ - return 0; - } - - if (blk == 0) { - if (p->is_dir == 0) { - /* - * Should never happen, since only directories - * get called with BLOCK_FLAG_HOLE - */ -#ifdef DEBUG_E2FSCK - printf("process_block() called with blk == 0, " - "blockcnt=%d, inode %lu???\n", - blockcnt, p->ino); -#endif - return 0; - } - if (blockcnt < 0) - return 0; - if (blockcnt * fs->blocksize < p->inode->i_size) { - goto mark_dir; - } - return 0; - } - - /* - * Simplistic fragmentation check. We merely require that the - * file be contiguous. (Which can never be true for really - * big files that are greater than a block group.) - */ - if (!HOLE_BLKADDR(p->previous_block)) { - if (p->previous_block+1 != blk) - p->fragmented = 1; - } - p->previous_block = blk; - - if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) - problem = PR_1_TOOBIG_DIR; - if (p->is_reg && p->num_blocks+1 >= p->max_blocks) - problem = PR_1_TOOBIG_REG; - if (!p->is_dir && !p->is_reg && blockcnt > 0) - problem = PR_1_TOOBIG_SYMLINK; - - if (blk < fs->super->s_first_data_block || - blk >= fs->super->s_blocks_count) - problem = PR_1_ILLEGAL_BLOCK_NUM; - - if (problem) { - p->num_illegal_blocks++; - if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { - if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { - p->clear = 1; - return BLOCK_ABORT; - } - if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { - p->suppress = 1; - set_latch_flags(PR_LATCH_BLOCK, - PRL_SUPPRESS, 0); - } - } - pctx->blk = blk; - pctx->blkcount = blockcnt; - if (fix_problem(ctx, problem, pctx)) { - blk = *block_nr = 0; - ret_code = BLOCK_CHANGED; - goto mark_dir; - } else - return 0; - } - - if (p->ino == EXT2_RESIZE_INO) { - /* - * The resize inode has already be sanity checked - * during pass #0 (the superblock checks). All we - * have to do is mark the double indirect block as - * being in use; all of the other blocks are handled - * by mark_table_blocks()). - */ - if (blockcnt == BLOCK_COUNT_DIND) - mark_block_used(ctx, blk); - } else - mark_block_used(ctx, blk); - p->num_blocks++; - if (blockcnt >= 0) - p->last_block = blockcnt; -mark_dir: - if (p->is_dir && (blockcnt >= 0)) { - pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino, - blk, blockcnt); - if (pctx->errcode) { - pctx->blk = blk; - pctx->num = blockcnt; - fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return BLOCK_ABORT; - } - } - return ret_code; -} - -static int process_bad_block(ext2_filsys fs FSCK_ATTR((unused)), - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data EXT2FS_ATTR((unused))) -{ - /* - * Note: This function processes blocks for the bad blocks - * inode, which is never compressed. So we don't use HOLE_BLKADDR(). - */ - - printf("Unrecoverable Error: Found %"PRIi64" bad blocks starting at block number: %u\n", blockcnt, *block_nr); - return BLOCK_ERROR; -} - -/* - * This routine gets called at the end of pass 1 if bad blocks are - * detected in the superblock, group descriptors, inode_bitmaps, or - * block bitmaps. At this point, all of the blocks have been mapped - * out, so we can try to allocate new block(s) to replace the bad - * blocks. - */ -static void handle_fs_bad_blocks(e2fsck_t ctx) -{ - printf("Bad blocks detected on your filesystem\n" - "You should get your data off as the device will soon die\n"); -} - -/* - * This routine marks all blocks which are used by the superblock, - * group descriptors, inode bitmaps, and block bitmaps. - */ -static void mark_table_blocks(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t block, b; - dgrp_t i; - int j; - struct problem_context pctx; - - clear_problem_context(&pctx); - - block = fs->super->s_first_data_block; - for (i = 0; i < fs->group_desc_count; i++) { - pctx.group = i; - - ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); - - /* - * Mark the blocks used for the inode table - */ - if (fs->group_desc[i].bg_inode_table) { - for (j = 0, b = fs->group_desc[i].bg_inode_table; - j < fs->inode_blocks_per_group; - j++, b++) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - b)) { - pctx.blk = b; - if (fix_problem(ctx, - PR_1_ITABLE_CONFLICT, &pctx)) { - ctx->invalid_inode_table_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, b); - } - } - } - - /* - * Mark block used for the block bitmap - */ - if (fs->group_desc[i].bg_block_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap)) { - pctx.blk = fs->group_desc[i].bg_block_bitmap; - if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { - ctx->invalid_block_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap); - } - } - /* - * Mark block used for the inode bitmap - */ - if (fs->group_desc[i].bg_inode_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap)) { - pctx.blk = fs->group_desc[i].bg_inode_bitmap; - if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { - ctx->invalid_inode_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap); - } - } - block += fs->super->s_blocks_per_group; - } -} - -/* - * Thes subroutines short circuits ext2fs_get_blocks and - * ext2fs_check_directory; we use them since we already have the inode - * structure, so there's no point in letting the ext2fs library read - * the inode again. - */ -static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, - blk_t *blocks) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - int i; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - - for (i=0; i < EXT2_N_BLOCKS; i++) - blocks[i] = ctx->stashed_inode->i_block[i]; - return 0; -} - -static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - *inode = *ctx->stashed_inode; - return 0; -} - -static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino == ctx->stashed_ino) && ctx->stashed_inode) - *ctx->stashed_inode = *inode; - return EXT2_ET_CALLBACK_NOTHANDLED; -} - -static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - - if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) - return EXT2_ET_NO_DIRECTORY; - return 0; -} - -void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool) -{ - ext2_filsys fs = ctx->fs; - - if (bool) { - fs->get_blocks = pass1_get_blocks; - fs->check_directory = pass1_check_directory; - fs->read_inode = pass1_read_inode; - fs->write_inode = pass1_write_inode; - ctx->stashed_ino = 0; - } else { - fs->get_blocks = 0; - fs->check_directory = 0; - fs->read_inode = 0; - fs->write_inode = 0; - } -} - -/* - * pass1b.c --- Pass #1b of e2fsck - * - * This file contains pass1B, pass1C, and pass1D of e2fsck. They are - * only invoked if pass 1 discovered blocks which are in use by more - * than one inode. - * - * Pass1B scans the data blocks of all the inodes again, generating a - * complete list of duplicate blocks and which inodes have claimed - * them. - * - * Pass1C does a tree-traversal of the filesystem, to determine the - * parent directories of these inodes. This step is necessary so that - * e2fsck can print out the pathnames of affected inodes. - * - * Pass1D is a reconciliation pass. For each inode with duplicate - * blocks, the user is prompted if s/he would like to clone the file - * (so that the file gets a fresh copy of the duplicated blocks) or - * simply to delete the file. - * - */ - - -/* Needed for architectures where sizeof(int) != sizeof(void *) */ -#define INT_TO_VOIDPTR(val) ((void *)(intptr_t)(val)) -#define VOIDPTR_TO_INT(ptr) ((int)(intptr_t)(ptr)) - -/* Define an extension to the ext2 library's block count information */ -#define BLOCK_COUNT_EXTATTR (-5) - -struct block_el { - blk_t block; - struct block_el *next; -}; - -struct inode_el { - ext2_ino_t inode; - struct inode_el *next; -}; - -struct dup_block { - int num_bad; - struct inode_el *inode_list; -}; - -/* - * This structure stores information about a particular inode which - * is sharing blocks with other inodes. This information is collected - * to display to the user, so that the user knows what files he or she - * is dealing with, when trying to decide how to resolve the conflict - * of multiply-claimed blocks. - */ -struct dup_inode { - ext2_ino_t dir; - int num_dupblocks; - struct ext2_inode inode; - struct block_el *block_list; -}; - -static int process_pass1b_block(ext2_filsys fs, blk_t *blocknr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static void delete_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char *block_buf); -static int clone_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf); -static int check_if_fs_block(e2fsck_t ctx, blk_t test_blk); - -static void pass1b(e2fsck_t ctx, char *block_buf); -static void pass1c(e2fsck_t ctx, char *block_buf); -static void pass1d(e2fsck_t ctx, char *block_buf); - -static int dup_inode_count = 0; - -static dict_t blk_dict, ino_dict; - -static ext2fs_inode_bitmap inode_dup_map; - -static int dict_int_cmp(const void *a, const void *b) -{ - intptr_t ia, ib; - - ia = (intptr_t)a; - ib = (intptr_t)b; - - return (ia-ib); -} - -/* - * Add a duplicate block record - */ -static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk_t blk, - struct ext2_inode *inode) -{ - dnode_t *n; - struct dup_block *db; - struct dup_inode *di; - struct block_el *blk_el; - struct inode_el *ino_el; - - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); - if (n) - db = (struct dup_block *) dnode_get(n); - else { - db = (struct dup_block *) e2fsck_allocate_memory(ctx, - sizeof(struct dup_block), "duplicate block header"); - db->num_bad = 0; - db->inode_list = 0; - dict_alloc_insert(&blk_dict, INT_TO_VOIDPTR(blk), db); - } - ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx, - sizeof(struct inode_el), "inode element"); - ino_el->inode = ino; - ino_el->next = db->inode_list; - db->inode_list = ino_el; - db->num_bad++; - - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino)); - if (n) - di = (struct dup_inode *) dnode_get(n); - else { - di = (struct dup_inode *) e2fsck_allocate_memory(ctx, - sizeof(struct dup_inode), "duplicate inode header"); - di->dir = (ino == EXT2_ROOT_INO) ? EXT2_ROOT_INO : 0; - di->num_dupblocks = 0; - di->block_list = 0; - di->inode = *inode; - dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di); - } - blk_el = (struct block_el *) e2fsck_allocate_memory(ctx, - sizeof(struct block_el), "block element"); - blk_el->block = blk; - blk_el->next = di->block_list; - di->block_list = blk_el; - di->num_dupblocks++; -} - -/* - * Free a duplicate inode record - */ -static void inode_dnode_free(dnode_t *node) -{ - struct dup_inode *di; - struct block_el *p, *next; - - di = (struct dup_inode *) dnode_get(node); - for (p = di->block_list; p; p = next) { - next = p->next; - free(p); - } - free(node); -} - -/* - * Free a duplicate block record - */ -static void block_dnode_free(dnode_t *node) -{ - struct dup_block *db; - struct inode_el *p, *next; - - db = (struct dup_block *) dnode_get(node); - for (p = db->inode_list; p; p = next) { - next = p->next; - free(p); - } - free(node); -} - - -/* - * Main procedure for handling duplicate blocks - */ -void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct problem_context pctx; - - clear_problem_context(&pctx); - - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("multiply claimed inode map"), &inode_dup_map); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - dict_init(&ino_dict, DICTCOUNT_T_MAX, dict_int_cmp); - dict_init(&blk_dict, DICTCOUNT_T_MAX, dict_int_cmp); - dict_set_allocator(&ino_dict, inode_dnode_free); - dict_set_allocator(&blk_dict, block_dnode_free); - - pass1b(ctx, block_buf); - pass1c(ctx, block_buf); - pass1d(ctx, block_buf); - - /* - * Time to free all of the accumulated data structures that we - * don't need anymore. - */ - dict_free_nodes(&ino_dict); - dict_free_nodes(&blk_dict); -} - -/* - * Scan the inodes looking for inodes that contain duplicate blocks. - */ -struct process_block_struct_1b { - e2fsck_t ctx; - ext2_ino_t ino; - int dup_blocks; - struct ext2_inode *inode; - struct problem_context *pctx; -}; - -static void pass1b(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - struct ext2_inode inode; - ext2_inode_scan scan; - struct process_block_struct_1b pb; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1B_PASS_HEADER, &pctx); - pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, - &scan); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ctx->stashed_inode = &inode; - pb.ctx = ctx; - pb.pctx = &pctx; - pctx.str = "pass1b"; - while (1) { - pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode); - if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) - continue; - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (!ino) - break; - pctx.ino = ctx->stashed_ino = ino; - if ((ino != EXT2_BAD_INO) && - !ext2fs_test_inode_bitmap(ctx->inode_used_map, ino)) - continue; - - pb.ino = ino; - pb.dup_blocks = 0; - pb.inode = &inode; - - if (ext2fs_inode_has_valid_blocks(&inode) || - (ino == EXT2_BAD_INO)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, - 0, block_buf, process_pass1b_block, &pb); - if (inode.i_file_acl) - process_pass1b_block(fs, &inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &pb); - if (pb.dup_blocks) { - end_problem_latch(ctx, PR_LATCH_DBLOCK); - if (ino >= EXT2_FIRST_INODE(fs->super) || - ino == EXT2_ROOT_INO) - dup_inode_count++; - } - if (pctx.errcode) - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - } - ext2fs_close_inode_scan(scan); - e2fsck_use_inode_shortcuts(ctx, 0); -} - -static int process_pass1b_block(ext2_filsys fs FSCK_ATTR((unused)), - blk_t *block_nr, - e2_blkcnt_t blockcnt FSCK_ATTR((unused)), - blk_t ref_blk FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct_1b *p; - e2fsck_t ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - p = (struct process_block_struct_1b *) priv_data; - ctx = p->ctx; - - if (!ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) - return 0; - - /* OK, this is a duplicate block */ - if (p->ino != EXT2_BAD_INO) { - p->pctx->blk = *block_nr; - fix_problem(ctx, PR_1B_DUP_BLOCK, p->pctx); - } - p->dup_blocks++; - ext2fs_mark_inode_bitmap(inode_dup_map, p->ino); - - add_dupe(ctx, p->ino, *block_nr, p->inode); - - return 0; -} - -/* - * Pass 1c: Scan directories for inodes with duplicate blocks. This - * is used so that we can print pathnames when prompting the user for - * what to do. - */ -struct search_dir_struct { - int count; - ext2_ino_t first_inode; - ext2_ino_t max_inode; -}; - -static int search_dirent_proc(ext2_ino_t dir, int entry, - struct ext2_dir_entry *dirent, - int offset FSCK_ATTR((unused)), - int blocksize FSCK_ATTR((unused)), - char *buf FSCK_ATTR((unused)), - void *priv_data) -{ - struct search_dir_struct *sd; - struct dup_inode *p; - dnode_t *n; - - sd = (struct search_dir_struct *) priv_data; - - if (dirent->inode > sd->max_inode) - /* Should abort this inode, but not everything */ - return 0; - - if ((dirent->inode < sd->first_inode) || (entry < DIRENT_OTHER_FILE) || - !ext2fs_test_inode_bitmap(inode_dup_map, dirent->inode)) - return 0; - - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(dirent->inode)); - if (!n) - return 0; - p = (struct dup_inode *) dnode_get(n); - p->dir = dir; - sd->count--; - - return sd->count ? 0 : DIRENT_ABORT; -} - - -static void pass1c(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct search_dir_struct sd; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1C_PASS_HEADER, &pctx); - - /* - * Search through all directories to translate inodes to names - * (by searching for the containing directory for that inode.) - */ - sd.count = dup_inode_count; - sd.first_inode = EXT2_FIRST_INODE(fs->super); - sd.max_inode = fs->super->s_inodes_count; - ext2fs_dblist_dir_iterate(fs->dblist, 0, block_buf, - search_dirent_proc, &sd); -} - -static void pass1d(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct dup_inode *p, *t; - struct dup_block *q; - ext2_ino_t *shared, ino; - int shared_len; - int i; - int file_ok; - int meta_data = 0; - struct problem_context pctx; - dnode_t *n, *m; - struct block_el *s; - struct inode_el *r; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1D_PASS_HEADER, &pctx); - e2fsck_read_bitmaps(ctx); - - pctx.num = dup_inode_count; /* dict_count(&ino_dict); */ - fix_problem(ctx, PR_1D_NUM_DUP_INODES, &pctx); - shared = (ext2_ino_t *) e2fsck_allocate_memory(ctx, - sizeof(ext2_ino_t) * dict_count(&ino_dict), - "Shared inode list"); - for (n = dict_first(&ino_dict); n; n = dict_next(&ino_dict, n)) { - p = (struct dup_inode *) dnode_get(n); - shared_len = 0; - file_ok = 1; - ino = (ext2_ino_t)VOIDPTR_TO_INT(dnode_getkey(n)); - if (ino == EXT2_BAD_INO || ino == EXT2_RESIZE_INO) - continue; - - /* - * Find all of the inodes which share blocks with this - * one. First we find all of the duplicate blocks - * belonging to this inode, and then search each block - * get the list of inodes, and merge them together. - */ - for (s = p->block_list; s; s = s->next) { - m = dict_lookup(&blk_dict, INT_TO_VOIDPTR(s->block)); - if (!m) - continue; /* Should never happen... */ - q = (struct dup_block *) dnode_get(m); - if (q->num_bad > 1) - file_ok = 0; - if (check_if_fs_block(ctx, s->block)) { - file_ok = 0; - meta_data = 1; - } - - /* - * Add all inodes used by this block to the - * shared[] --- which is a unique list, so - * if an inode is already in shared[], don't - * add it again. - */ - for (r = q->inode_list; r; r = r->next) { - if (r->inode == ino) - continue; - for (i = 0; i < shared_len; i++) - if (shared[i] == r->inode) - break; - if (i == shared_len) { - shared[shared_len++] = r->inode; - } - } - } - - /* - * Report the inode that we are working on - */ - pctx.inode = &p->inode; - pctx.ino = ino; - pctx.dir = p->dir; - pctx.blkcount = p->num_dupblocks; - pctx.num = meta_data ? shared_len+1 : shared_len; - fix_problem(ctx, PR_1D_DUP_FILE, &pctx); - pctx.blkcount = 0; - pctx.num = 0; - - if (meta_data) - fix_problem(ctx, PR_1D_SHARE_METADATA, &pctx); - - for (i = 0; i < shared_len; i++) { - m = dict_lookup(&ino_dict, INT_TO_VOIDPTR(shared[i])); - if (!m) - continue; /* should never happen */ - t = (struct dup_inode *) dnode_get(m); - /* - * Report the inode that we are sharing with - */ - pctx.inode = &t->inode; - pctx.ino = shared[i]; - pctx.dir = t->dir; - fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx); - } - if (file_ok) { - fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx); - continue; - } - if (fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) { - pctx.errcode = clone_file(ctx, ino, p, block_buf); - if (pctx.errcode) - fix_problem(ctx, PR_1D_CLONE_ERROR, &pctx); - else - continue; - } - if (fix_problem(ctx, PR_1D_DELETE_QUESTION, &pctx)) - delete_file(ctx, ino, p, block_buf); - else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&shared); -} - -/* - * Drop the refcount on the dup_block structure, and clear the entry - * in the block_dup_map if appropriate. - */ -static void decrement_badcount(e2fsck_t ctx, blk_t block, struct dup_block *p) -{ - p->num_bad--; - if (p->num_bad <= 0 || - (p->num_bad == 1 && !check_if_fs_block(ctx, block))) - ext2fs_unmark_block_bitmap(ctx->block_dup_map, block); -} - -static int delete_file_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt FSCK_ATTR((unused)), - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct_1b *pb; - struct dup_block *p; - dnode_t *n; - e2fsck_t ctx; - - pb = (struct process_block_struct_1b *) priv_data; - ctx = pb->ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - - if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); - if (n) { - p = (struct dup_block *) dnode_get(n); - decrement_badcount(ctx, *block_nr, p); - } else - bb_error_msg(_("internal error; can't find dup_blk for %d"), - *block_nr); - } else { - ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); - ext2fs_block_alloc_stats(fs, *block_nr, -1); - } - - return 0; -} - -static void delete_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - struct process_block_struct_1b pb; - struct ext2_inode inode; - struct problem_context pctx; - unsigned int count; - - clear_problem_context(&pctx); - pctx.ino = pb.ino = ino; - pb.dup_blocks = dp->num_dupblocks; - pb.ctx = ctx; - pctx.str = "delete_file"; - - e2fsck_read_inode(ctx, ino, &inode, "delete_file"); - if (ext2fs_inode_has_valid_blocks(&inode)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - delete_file_block, &pb); - if (pctx.errcode) - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); - - /* Inode may have changed by block_iterate, so reread it */ - e2fsck_read_inode(ctx, ino, &inode, "delete_file"); - inode.i_links_count = 0; - inode.i_dtime = time(NULL); - if (inode.i_file_acl && - (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { - count = 1; - pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, - block_buf, -1, &count); - if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { - pctx.errcode = 0; - count = 1; - } - if (pctx.errcode) { - pctx.blk = inode.i_file_acl; - fix_problem(ctx, PR_1B_ADJ_EA_REFCOUNT, &pctx); - } - /* - * If the count is zero, then arrange to have the - * block deleted. If the block is in the block_dup_map, - * also call delete_file_block since it will take care - * of keeping the accounting straight. - */ - if ((count == 0) || - ext2fs_test_block_bitmap(ctx->block_dup_map, - inode.i_file_acl)) - delete_file_block(fs, &inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &pb); - } - e2fsck_write_inode(ctx, ino, &inode, "delete_file"); -} - -struct clone_struct { - errcode_t errcode; - ext2_ino_t dir; - char *buf; - e2fsck_t ctx; -}; - -static int clone_file_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct dup_block *p; - blk_t new_block; - errcode_t retval; - struct clone_struct *cs = (struct clone_struct *) priv_data; - dnode_t *n; - e2fsck_t ctx; - - ctx = cs->ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - - if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); - if (n) { - p = (struct dup_block *) dnode_get(n); - retval = ext2fs_new_block(fs, 0, ctx->block_found_map, - &new_block); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - if (cs->dir && (blockcnt >= 0)) { - retval = ext2fs_set_dir_block(fs->dblist, - cs->dir, new_block, blockcnt); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - } - - retval = io_channel_read_blk(fs->io, *block_nr, 1, - cs->buf); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - retval = io_channel_write_blk(fs->io, new_block, 1, - cs->buf); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - decrement_badcount(ctx, *block_nr, p); - *block_nr = new_block; - ext2fs_mark_block_bitmap(ctx->block_found_map, - new_block); - ext2fs_mark_block_bitmap(fs->block_map, new_block); - return BLOCK_CHANGED; - } else - bb_error_msg(_("internal error; can't find dup_blk for %d"), - *block_nr); - } - return 0; -} - -static int clone_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct clone_struct cs; - struct problem_context pctx; - blk_t blk; - dnode_t *n; - struct inode_el *ino_el; - struct dup_block *db; - struct dup_inode *di; - - clear_problem_context(&pctx); - cs.errcode = 0; - cs.dir = 0; - cs.ctx = ctx; - retval = ext2fs_get_mem(fs->blocksize, &cs.buf); - if (retval) - return retval; - - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) - cs.dir = ino; - - pctx.ino = ino; - pctx.str = "clone_file"; - if (ext2fs_inode_has_valid_blocks(&dp->inode)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - clone_file_block, &cs); - ext2fs_mark_bb_dirty(fs); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - retval = pctx.errcode; - goto errout; - } - if (cs.errcode) { - bb_error_msg(_("returned from clone_file_block")); - retval = cs.errcode; - goto errout; - } - /* The inode may have changed on disk, so we have to re-read it */ - e2fsck_read_inode(ctx, ino, &dp->inode, "clone file EA"); - blk = dp->inode.i_file_acl; - if (blk && (clone_file_block(fs, &dp->inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &cs) == - BLOCK_CHANGED)) { - e2fsck_write_inode(ctx, ino, &dp->inode, "clone file EA"); - /* - * If we cloned the EA block, find all other inodes - * which refered to that EA block, and modify - * them to point to the new EA block. - */ - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); - db = (struct dup_block *) dnode_get(n); - for (ino_el = db->inode_list; ino_el; ino_el = ino_el->next) { - if (ino_el->inode == ino) - continue; - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino_el->inode)); - di = (struct dup_inode *) dnode_get(n); - if (di->inode.i_file_acl == blk) { - di->inode.i_file_acl = dp->inode.i_file_acl; - e2fsck_write_inode(ctx, ino_el->inode, - &di->inode, "clone file EA"); - decrement_badcount(ctx, blk, db); - } - } - } - retval = 0; -errout: - ext2fs_free_mem(&cs.buf); - return retval; -} - -/* - * This routine returns 1 if a block overlaps with one of the superblocks, - * group descriptors, inode bitmaps, or block bitmaps. - */ -static int check_if_fs_block(e2fsck_t ctx, blk_t test_block) -{ - ext2_filsys fs = ctx->fs; - blk_t block; - dgrp_t i; - - block = fs->super->s_first_data_block; - for (i = 0; i < fs->group_desc_count; i++) { - - /* Check superblocks/block group descriptros */ - if (ext2fs_bg_has_super(fs, i)) { - if (test_block >= block && - (test_block <= block + fs->desc_blocks)) - return 1; - } - - /* Check the inode table */ - if ((fs->group_desc[i].bg_inode_table) && - (test_block >= fs->group_desc[i].bg_inode_table) && - (test_block < (fs->group_desc[i].bg_inode_table + - fs->inode_blocks_per_group))) - return 1; - - /* Check the bitmap blocks */ - if ((test_block == fs->group_desc[i].bg_block_bitmap) || - (test_block == fs->group_desc[i].bg_inode_bitmap)) - return 1; - - block += fs->super->s_blocks_per_group; - } - return 0; -} -/* - * pass2.c --- check directory structure - * - * Pass 2 of e2fsck iterates through all active directory inodes, and - * applies to following tests to each directory entry in the directory - * blocks in the inodes: - * - * - The length of the directory entry (rec_len) should be at - * least 8 bytes, and no more than the remaining space - * left in the directory block. - * - The length of the name in the directory entry (name_len) - * should be less than (rec_len - 8). - * - The inode number in the directory entry should be within - * legal bounds. - * - The inode number should refer to a in-use inode. - * - The first entry should be '.', and its inode should be - * the inode of the directory. - * - The second entry should be '..'. - * - * To minimize disk seek time, the directory blocks are processed in - * sorted order of block numbers. - * - * Pass 2 also collects the following information: - * - The inode numbers of the subdirectories for each directory. - * - * Pass 2 relies on the following information from previous passes: - * - The directory information collected in pass 1. - * - The inode_used_map bitmap - * - The inode_bad_map bitmap - * - The inode_dir_map bitmap - * - * Pass 2 frees the following data structures - * - The inode_bad_map bitmap - * - The inode_reg_map bitmap - */ - -/* - * Keeps track of how many times an inode is referenced. - */ -static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf); -static int check_dir_block(ext2_filsys fs, - struct ext2_db_entry *dir_blocks_info, - void *priv_data); -static int allocate_dir_block(e2fsck_t ctx, struct ext2_db_entry *dir_blocks_info, - struct problem_context *pctx); -static int update_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block, - int ref_offset, - void *priv_data); -static void clear_htree(e2fsck_t ctx, ext2_ino_t ino); -static int htree_depth(struct dx_dir_info *dx_dir, - struct dx_dirblock_info *dx_db); -static int special_dir_block_cmp(const void *a, const void *b); - -struct check_dir_struct { - char *buf; - struct problem_context pctx; - int count, max; - e2fsck_t ctx; -}; - -static void e2fsck_pass2(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct problem_context pctx; - ext2_filsys fs = ctx->fs; - char *buf; - struct dir_info *dir; - struct check_dir_struct cd; - struct dx_dir_info *dx_dir; - struct dx_dirblock_info *dx_db, *dx_parent; - int b; - int i, depth; - problem_t code; - int bad_dir; - - clear_problem_context(&cd.pctx); - - /* Pass 2 */ - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx); - - cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT, - 0, ctx->inode_link_info, - &ctx->inode_count); - if (cd.pctx.errcode) { - fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize, - "directory scan buffer"); - - /* - * Set up the parent pointer for the root directory, if - * present. (If the root directory is not present, we will - * create it in pass 3.) - */ - dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO); - if (dir) - dir->parent = EXT2_ROOT_INO; - - cd.buf = buf; - cd.ctx = ctx; - cd.count = 1; - cd.max = ext2fs_dblist_count(fs->dblist); - - if (ctx->progress) - (void) (ctx->progress)(ctx, 2, 0, cd.max); - - if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) - ext2fs_dblist_sort(fs->dblist, special_dir_block_cmp); - - cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block, - &cd); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (cd.pctx.errcode) { - fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - -#ifdef ENABLE_HTREE - for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (dx_dir->numblocks == 0) - continue; - clear_problem_context(&pctx); - bad_dir = 0; - pctx.dir = dx_dir->ino; - dx_db = dx_dir->dx_block; - if (dx_db->flags & DX_FLAG_REFERENCED) - dx_db->flags |= DX_FLAG_DUP_REF; - else - dx_db->flags |= DX_FLAG_REFERENCED; - /* - * Find all of the first and last leaf blocks, and - * update their parent's min and max hash values - */ - for (b=0, dx_db = dx_dir->dx_block; - b < dx_dir->numblocks; - b++, dx_db++) { - if ((dx_db->type != DX_DIRBLOCK_LEAF) || - !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST))) - continue; - dx_parent = &dx_dir->dx_block[dx_db->parent]; - /* - * XXX Make sure dx_parent->min_hash > dx_db->min_hash - */ - if (dx_db->flags & DX_FLAG_FIRST) - dx_parent->min_hash = dx_db->min_hash; - /* - * XXX Make sure dx_parent->max_hash < dx_db->max_hash - */ - if (dx_db->flags & DX_FLAG_LAST) - dx_parent->max_hash = dx_db->max_hash; - } - - for (b=0, dx_db = dx_dir->dx_block; - b < dx_dir->numblocks; - b++, dx_db++) { - pctx.blkcount = b; - pctx.group = dx_db->parent; - code = 0; - if (!(dx_db->flags & DX_FLAG_FIRST) && - (dx_db->min_hash < dx_db->node_min_hash)) { - pctx.blk = dx_db->min_hash; - pctx.blk2 = dx_db->node_min_hash; - code = PR_2_HTREE_MIN_HASH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (dx_db->type == DX_DIRBLOCK_LEAF) { - depth = htree_depth(dx_dir, dx_db); - if (depth != dx_dir->depth) { - code = PR_2_HTREE_BAD_DEPTH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - } - /* - * This test doesn't apply for the root block - * at block #0 - */ - if (b && - (dx_db->max_hash > dx_db->node_max_hash)) { - pctx.blk = dx_db->max_hash; - pctx.blk2 = dx_db->node_max_hash; - code = PR_2_HTREE_MAX_HASH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (!(dx_db->flags & DX_FLAG_REFERENCED)) { - code = PR_2_HTREE_NOTREF; - fix_problem(ctx, code, &pctx); - bad_dir++; - } else if (dx_db->flags & DX_FLAG_DUP_REF) { - code = PR_2_HTREE_DUPREF; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (code == 0) - continue; - } - if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) { - clear_htree(ctx, dx_dir->ino); - dx_dir->numblocks = 0; - } - } -#endif - ext2fs_free_mem(&buf); - ext2fs_free_dblist(fs->dblist); - - ext2fs_free_inode_bitmap(ctx->inode_bad_map); - ctx->inode_bad_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_reg_map); - ctx->inode_reg_map = 0; - - clear_problem_context(&pctx); - if (ctx->large_files) { - if (!(sb->s_feature_ro_compat & - EXT2_FEATURE_RO_COMPAT_LARGE_FILE) && - fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) { - sb->s_feature_ro_compat |= - EXT2_FEATURE_RO_COMPAT_LARGE_FILE; - ext2fs_mark_super_dirty(fs); - } - if (sb->s_rev_level == EXT2_GOOD_OLD_REV && - fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) { - ext2fs_update_dynamic_rev(fs); - ext2fs_mark_super_dirty(fs); - } - } else if (!ctx->large_files && - (sb->s_feature_ro_compat & - EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) { - if (fs->flags & EXT2_FLAG_RW) { - sb->s_feature_ro_compat &= - ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE; - ext2fs_mark_super_dirty(fs); - } - } -} - -#define MAX_DEPTH 32000 -static int htree_depth(struct dx_dir_info *dx_dir, - struct dx_dirblock_info *dx_db) -{ - int depth = 0; - - while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) { - dx_db = &dx_dir->dx_block[dx_db->parent]; - depth++; - } - return depth; -} - -static int dict_de_cmp(const void *a, const void *b) -{ - const struct ext2_dir_entry *de_a, *de_b; - int a_len, b_len; - - de_a = (const struct ext2_dir_entry *) a; - a_len = de_a->name_len & 0xFF; - de_b = (const struct ext2_dir_entry *) b; - b_len = de_b->name_len & 0xFF; - - if (a_len != b_len) - return (a_len - b_len); - - return strncmp(de_a->name, de_b->name, a_len); -} - -/* - * This is special sort function that makes sure that directory blocks - * with a dirblock of zero are sorted to the beginning of the list. - * This guarantees that the root node of the htree directories are - * processed first, so we know what hash version to use. - */ -static int special_dir_block_cmp(const void *a, const void *b) -{ - const struct ext2_db_entry *db_a = - (const struct ext2_db_entry *) a; - const struct ext2_db_entry *db_b = - (const struct ext2_db_entry *) b; - - if (db_a->blockcnt && !db_b->blockcnt) - return 1; - - if (!db_a->blockcnt && db_b->blockcnt) - return -1; - - if (db_a->blk != db_b->blk) - return (int) (db_a->blk - db_b->blk); - - if (db_a->ino != db_b->ino) - return (int) (db_a->ino - db_b->ino); - - return (int) (db_a->blockcnt - db_b->blockcnt); -} - - -/* - * Make sure the first entry in the directory is '.', and that the - * directory entry is sane. - */ -static int check_dot(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - ext2_ino_t ino, struct problem_context *pctx) -{ - struct ext2_dir_entry *nextdir; - int status = 0; - int created = 0; - int new_len; - int problem = 0; - - if (!dirent->inode) - problem = PR_2_MISSING_DOT; - else if (((dirent->name_len & 0xFF) != 1) || - (dirent->name[0] != '.')) - problem = PR_2_1ST_NOT_DOT; - else if (dirent->name[1] != '\0') - problem = PR_2_DOT_NULL_TERM; - - if (problem) { - if (fix_problem(ctx, problem, pctx)) { - if (dirent->rec_len < 12) - dirent->rec_len = 12; - dirent->inode = ino; - dirent->name_len = 1; - dirent->name[0] = '.'; - dirent->name[1] = '\0'; - status = 1; - created = 1; - } - } - if (dirent->inode != ino) { - if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) { - dirent->inode = ino; - status = 1; - } - } - if (dirent->rec_len > 12) { - new_len = dirent->rec_len - 12; - if (new_len > 12) { - if (created || - fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) { - nextdir = (struct ext2_dir_entry *) - ((char *) dirent + 12); - dirent->rec_len = 12; - nextdir->rec_len = new_len; - nextdir->inode = 0; - nextdir->name_len = 0; - status = 1; - } - } - } - return status; -} - -/* - * Make sure the second entry in the directory is '..', and that the - * directory entry is sane. We do not check the inode number of '..' - * here; this gets done in pass 3. - */ -static int check_dotdot(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - struct dir_info *dir, struct problem_context *pctx) -{ - int problem = 0; - - if (!dirent->inode) - problem = PR_2_MISSING_DOT_DOT; - else if (((dirent->name_len & 0xFF) != 2) || - (dirent->name[0] != '.') || - (dirent->name[1] != '.')) - problem = PR_2_2ND_NOT_DOT_DOT; - else if (dirent->name[2] != '\0') - problem = PR_2_DOT_DOT_NULL_TERM; - - if (problem) { - if (fix_problem(ctx, problem, pctx)) { - if (dirent->rec_len < 12) - dirent->rec_len = 12; - /* - * Note: we don't have the parent inode just - * yet, so we will fill it in with the root - * inode. This will get fixed in pass 3. - */ - dirent->inode = EXT2_ROOT_INO; - dirent->name_len = 2; - dirent->name[0] = '.'; - dirent->name[1] = '.'; - dirent->name[2] = '\0'; - return 1; - } - return 0; - } - dir->dotdot = dirent->inode; - return 0; -} - -/* - * Check to make sure a directory entry doesn't contain any illegal - * characters. - */ -static int check_name(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - struct problem_context *pctx) -{ - int i; - int fixup = -1; - int ret = 0; - - for ( i = 0; i < (dirent->name_len & 0xFF); i++) { - if (dirent->name[i] == '/' || dirent->name[i] == '\0') { - if (fixup < 0) { - fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx); - } - if (fixup) { - dirent->name[i] = '.'; - ret = 1; - } - } - } - return ret; -} - -/* - * Check the directory filetype (if present) - */ - -/* - * Given a mode, return the ext2 file type - */ -static int ext2_file_type(unsigned int mode) -{ - if (LINUX_S_ISREG(mode)) - return EXT2_FT_REG_FILE; - - if (LINUX_S_ISDIR(mode)) - return EXT2_FT_DIR; - - if (LINUX_S_ISCHR(mode)) - return EXT2_FT_CHRDEV; - - if (LINUX_S_ISBLK(mode)) - return EXT2_FT_BLKDEV; - - if (LINUX_S_ISLNK(mode)) - return EXT2_FT_SYMLINK; - - if (LINUX_S_ISFIFO(mode)) - return EXT2_FT_FIFO; - - if (LINUX_S_ISSOCK(mode)) - return EXT2_FT_SOCK; - - return 0; -} - -static int check_filetype(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - struct problem_context *pctx) -{ - int filetype = dirent->name_len >> 8; - int should_be = EXT2_FT_UNKNOWN; - struct ext2_inode inode; - - if (!(ctx->fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_FILETYPE)) { - if (filetype == 0 || - !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx)) - return 0; - dirent->name_len = dirent->name_len & 0xFF; - return 1; - } - - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dirent->inode)) { - should_be = EXT2_FT_DIR; - } else if (ext2fs_test_inode_bitmap(ctx->inode_reg_map, - dirent->inode)) { - should_be = EXT2_FT_REG_FILE; - } else if (ctx->inode_bad_map && - ext2fs_test_inode_bitmap(ctx->inode_bad_map, - dirent->inode)) - should_be = 0; - else { - e2fsck_read_inode(ctx, dirent->inode, &inode, - "check_filetype"); - should_be = ext2_file_type(inode.i_mode); - } - if (filetype == should_be) - return 0; - pctx->num = should_be; - - if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE, - pctx) == 0) - return 0; - - dirent->name_len = (dirent->name_len & 0xFF) | should_be << 8; - return 1; -} - -#ifdef ENABLE_HTREE -static void parse_int_node(ext2_filsys fs, - struct ext2_db_entry *db, - struct check_dir_struct *cd, - struct dx_dir_info *dx_dir, - char *block_buf) -{ - struct ext2_dx_root_info *root; - struct ext2_dx_entry *ent; - struct ext2_dx_countlimit *limit; - struct dx_dirblock_info *dx_db; - int i, expect_limit, count; - blk_t blk; - ext2_dirhash_t min_hash = 0xffffffff; - ext2_dirhash_t max_hash = 0; - ext2_dirhash_t hash = 0, prev_hash; - - if (db->blockcnt == 0) { - root = (struct ext2_dx_root_info *) (block_buf + 24); - ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length); - } else { - ent = (struct ext2_dx_entry *) (block_buf+8); - } - limit = (struct ext2_dx_countlimit *) ent; - - count = ext2fs_le16_to_cpu(limit->count); - expect_limit = (fs->blocksize - ((char *) ent - block_buf)) / - sizeof(struct ext2_dx_entry); - if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) { - cd->pctx.num = ext2fs_le16_to_cpu(limit->limit); - if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx)) - goto clear_and_exit; - } - if (count > expect_limit) { - cd->pctx.num = count; - if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx)) - goto clear_and_exit; - count = expect_limit; - } - - for (i=0; i < count; i++) { - prev_hash = hash; - hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0; - blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff; - /* Check to make sure the block is valid */ - if (blk > (blk_t) dx_dir->numblocks) { - cd->pctx.blk = blk; - if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK, - &cd->pctx)) - goto clear_and_exit; - } - if (hash < prev_hash && - fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx)) - goto clear_and_exit; - dx_db = &dx_dir->dx_block[blk]; - if (dx_db->flags & DX_FLAG_REFERENCED) { - dx_db->flags |= DX_FLAG_DUP_REF; - } else { - dx_db->flags |= DX_FLAG_REFERENCED; - dx_db->parent = db->blockcnt; - } - if (hash < min_hash) - min_hash = hash; - if (hash > max_hash) - max_hash = hash; - dx_db->node_min_hash = hash; - if ((i+1) < count) - dx_db->node_max_hash = - ext2fs_le32_to_cpu(ent[i+1].hash) & ~1; - else { - dx_db->node_max_hash = 0xfffffffe; - dx_db->flags |= DX_FLAG_LAST; - } - if (i == 0) - dx_db->flags |= DX_FLAG_FIRST; - } - dx_db = &dx_dir->dx_block[db->blockcnt]; - dx_db->min_hash = min_hash; - dx_db->max_hash = max_hash; - return; - -clear_and_exit: - clear_htree(cd->ctx, cd->pctx.ino); - dx_dir->numblocks = 0; -} -#endif /* ENABLE_HTREE */ - -/* - * Given a busted directory, try to salvage it somehow. - * - */ -static void salvage_directory(ext2_filsys fs, - struct ext2_dir_entry *dirent, - struct ext2_dir_entry *prev, - unsigned int *offset) -{ - char *cp = (char *) dirent; - int left = fs->blocksize - *offset - dirent->rec_len; - int name_len = dirent->name_len & 0xFF; - - /* - * Special case of directory entry of size 8: copy what's left - * of the directory block up to cover up the invalid hole. - */ - if ((left >= 12) && (dirent->rec_len == 8)) { - memmove(cp, cp+8, left); - memset(cp + left, 0, 8); - return; - } - /* - * If the directory entry overruns the end of the directory - * block, and the name is small enough to fit, then adjust the - * record length. - */ - if ((left < 0) && - (name_len + 8 <= dirent->rec_len + left) && - dirent->inode <= fs->super->s_inodes_count && - strnlen(dirent->name, name_len) == name_len) { - dirent->rec_len += left; - return; - } - /* - * If the directory entry is a multiple of four, so it is - * valid, let the previous directory entry absorb the invalid - * one. - */ - if (prev && dirent->rec_len && (dirent->rec_len % 4) == 0) { - prev->rec_len += dirent->rec_len; - *offset += dirent->rec_len; - return; - } - /* - * Default salvage method --- kill all of the directory - * entries for the rest of the block. We will either try to - * absorb it into the previous directory entry, or create a - * new empty directory entry the rest of the directory block. - */ - if (prev) { - prev->rec_len += fs->blocksize - *offset; - *offset = fs->blocksize; - } else { - dirent->rec_len = fs->blocksize - *offset; - dirent->name_len = 0; - dirent->inode = 0; - } -} - -static int check_dir_block(ext2_filsys fs, - struct ext2_db_entry *db, - void *priv_data) -{ - struct dir_info *subdir, *dir; - struct dx_dir_info *dx_dir; -#ifdef ENABLE_HTREE - struct dx_dirblock_info *dx_db = NULL; -#endif /* ENABLE_HTREE */ - struct ext2_dir_entry *dirent, *prev; - ext2_dirhash_t hash; - unsigned int offset = 0; - int dir_modified = 0; - int dot_state; - blk_t block_nr = db->blk; - ext2_ino_t ino = db->ino; - __u16 links; - struct check_dir_struct *cd; - char *buf; - e2fsck_t ctx; - int problem; - struct ext2_dx_root_info *root; - struct ext2_dx_countlimit *limit; - static dict_t de_dict; - struct problem_context pctx; - int dups_found = 0; - - cd = (struct check_dir_struct *) priv_data; - buf = cd->buf; - ctx = cd->ctx; - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return DIRENT_ABORT; - - if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max)) - return DIRENT_ABORT; - - /* - * Make sure the inode is still in use (could have been - * deleted in the duplicate/bad blocks pass. - */ - if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))) - return 0; - - cd->pctx.ino = ino; - cd->pctx.blk = block_nr; - cd->pctx.blkcount = db->blockcnt; - cd->pctx.ino2 = 0; - cd->pctx.dirent = 0; - cd->pctx.num = 0; - - if (db->blk == 0) { - if (allocate_dir_block(ctx, db, &cd->pctx)) - return 0; - block_nr = db->blk; - } - - if (db->blockcnt) - dot_state = 2; - else - dot_state = 0; - - if (ctx->dirs_to_hash && - ext2fs_u32_list_test(ctx->dirs_to_hash, ino)) - dups_found++; - - cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf); - if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED) - cd->pctx.errcode = 0; /* We'll handle this ourselves */ - if (cd->pctx.errcode) { - if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return DIRENT_ABORT; - } - memset(buf, 0, fs->blocksize); - } -#ifdef ENABLE_HTREE - dx_dir = e2fsck_get_dx_dir_info(ctx, ino); - if (dx_dir && dx_dir->numblocks) { - if (db->blockcnt >= dx_dir->numblocks) { - printf("XXX should never happen!!!\n"); - abort(); - } - dx_db = &dx_dir->dx_block[db->blockcnt]; - dx_db->type = DX_DIRBLOCK_LEAF; - dx_db->phys = block_nr; - dx_db->min_hash = ~0; - dx_db->max_hash = 0; - - dirent = (struct ext2_dir_entry *) buf; - limit = (struct ext2_dx_countlimit *) (buf+8); - if (db->blockcnt == 0) { - root = (struct ext2_dx_root_info *) (buf + 24); - dx_db->type = DX_DIRBLOCK_ROOT; - dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST; - if ((root->reserved_zero || - root->info_length < 8 || - root->indirect_levels > 1) && - fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) { - clear_htree(ctx, ino); - dx_dir->numblocks = 0; - dx_db = 0; - } - dx_dir->hashversion = root->hash_version; - dx_dir->depth = root->indirect_levels + 1; - } else if ((dirent->inode == 0) && - (dirent->rec_len == fs->blocksize) && - (dirent->name_len == 0) && - (ext2fs_le16_to_cpu(limit->limit) == - ((fs->blocksize-8) / - sizeof(struct ext2_dx_entry)))) - dx_db->type = DX_DIRBLOCK_NODE; - } -#endif /* ENABLE_HTREE */ - - dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp); - prev = 0; - do { - problem = 0; - dirent = (struct ext2_dir_entry *) (buf + offset); - cd->pctx.dirent = dirent; - cd->pctx.num = offset; - if (((offset + dirent->rec_len) > fs->blocksize) || - (dirent->rec_len < 12) || - ((dirent->rec_len % 4) != 0) || - (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { - if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) { - salvage_directory(fs, dirent, prev, &offset); - dir_modified++; - continue; - } else - goto abort_free_dict; - } - if ((dirent->name_len & 0xFF) > EXT2_NAME_LEN) { - if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) { - dirent->name_len = EXT2_NAME_LEN; - dir_modified++; - } - } - - if (dot_state == 0) { - if (check_dot(ctx, dirent, ino, &cd->pctx)) - dir_modified++; - } else if (dot_state == 1) { - dir = e2fsck_get_dir_info(ctx, ino); - if (!dir) { - fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); - goto abort_free_dict; - } - if (check_dotdot(ctx, dirent, dir, &cd->pctx)) - dir_modified++; - } else if (dirent->inode == ino) { - problem = PR_2_LINK_DOT; - if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - } - if (!dirent->inode) - goto next; - - /* - * Make sure the inode listed is a legal one. - */ - if (((dirent->inode != EXT2_ROOT_INO) && - (dirent->inode < EXT2_FIRST_INODE(fs->super))) || - (dirent->inode > fs->super->s_inodes_count)) { - problem = PR_2_BAD_INO; - } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, - dirent->inode))) { - /* - * If the inode is unused, offer to clear it. - */ - problem = PR_2_UNUSED_INODE; - } else if ((dot_state > 1) && - ((dirent->name_len & 0xFF) == 1) && - (dirent->name[0] == '.')) { - /* - * If there's a '.' entry in anything other - * than the first directory entry, it's a - * duplicate entry that should be removed. - */ - problem = PR_2_DUP_DOT; - } else if ((dot_state > 1) && - ((dirent->name_len & 0xFF) == 2) && - (dirent->name[0] == '.') && - (dirent->name[1] == '.')) { - /* - * If there's a '..' entry in anything other - * than the second directory entry, it's a - * duplicate entry that should be removed. - */ - problem = PR_2_DUP_DOT_DOT; - } else if ((dot_state > 1) && - (dirent->inode == EXT2_ROOT_INO)) { - /* - * Don't allow links to the root directory. - * We check this specially to make sure we - * catch this error case even if the root - * directory hasn't been created yet. - */ - problem = PR_2_LINK_ROOT; - } else if ((dot_state > 1) && - (dirent->name_len & 0xFF) == 0) { - /* - * Don't allow zero-length directory names. - */ - problem = PR_2_NULL_NAME; - } - - if (problem) { - if (fix_problem(ctx, problem, &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } else { - ext2fs_unmark_valid(fs); - if (problem == PR_2_BAD_INO) - goto next; - } - } - - /* - * If the inode was marked as having bad fields in - * pass1, process it and offer to fix/clear it. - * (We wait until now so that we can display the - * pathname to the user.) - */ - if (ctx->inode_bad_map && - ext2fs_test_inode_bitmap(ctx->inode_bad_map, - dirent->inode)) { - if (e2fsck_process_bad_inode(ctx, ino, - dirent->inode, - buf + fs->blocksize)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return DIRENT_ABORT; - } - - if (check_name(ctx, dirent, &cd->pctx)) - dir_modified++; - - if (check_filetype(ctx, dirent, &cd->pctx)) - dir_modified++; - -#ifdef ENABLE_HTREE - if (dx_db) { - ext2fs_dirhash(dx_dir->hashversion, dirent->name, - (dirent->name_len & 0xFF), - fs->super->s_hash_seed, &hash, 0); - if (hash < dx_db->min_hash) - dx_db->min_hash = hash; - if (hash > dx_db->max_hash) - dx_db->max_hash = hash; - } -#endif - - /* - * If this is a directory, then mark its parent in its - * dir_info structure. If the parent field is already - * filled in, then this directory has more than one - * hard link. We assume the first link is correct, - * and ask the user if he/she wants to clear this one. - */ - if ((dot_state > 1) && - (ext2fs_test_inode_bitmap(ctx->inode_dir_map, - dirent->inode))) { - subdir = e2fsck_get_dir_info(ctx, dirent->inode); - if (!subdir) { - cd->pctx.ino = dirent->inode; - fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); - goto abort_free_dict; - } - if (subdir->parent) { - cd->pctx.ino2 = subdir->parent; - if (fix_problem(ctx, PR_2_LINK_DIR, - &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - cd->pctx.ino2 = 0; - } else - subdir->parent = ino; - } - - if (dups_found) { - ; - } else if (dict_lookup(&de_dict, dirent)) { - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.dirent = dirent; - fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx); - if (!ctx->dirs_to_hash) - ext2fs_u32_list_create(&ctx->dirs_to_hash, 50); - if (ctx->dirs_to_hash) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); - dups_found++; - } else - dict_alloc_insert(&de_dict, dirent, dirent); - - ext2fs_icount_increment(ctx->inode_count, dirent->inode, - &links); - if (links > 1) - ctx->fs_links_count++; - ctx->fs_total_count++; - next: - prev = dirent; - offset += dirent->rec_len; - dot_state++; - } while (offset < fs->blocksize); -#ifdef ENABLE_HTREE - if (dx_db) { - cd->pctx.dir = cd->pctx.ino; - if ((dx_db->type == DX_DIRBLOCK_ROOT) || - (dx_db->type == DX_DIRBLOCK_NODE)) - parse_int_node(fs, db, cd, dx_dir, buf); - } -#endif /* ENABLE_HTREE */ - if (offset != fs->blocksize) { - cd->pctx.num = dirent->rec_len - fs->blocksize + offset; - if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) { - dirent->rec_len = cd->pctx.num; - dir_modified++; - } - } - if (dir_modified) { - cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf); - if (cd->pctx.errcode) { - if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK, - &cd->pctx)) - goto abort_free_dict; - } - ext2fs_mark_changed(fs); - } - dict_free_nodes(&de_dict); - return 0; -abort_free_dict: - dict_free_nodes(&de_dict); - ctx->flags |= E2F_FLAG_ABORT; - return DIRENT_ABORT; -} - -/* - * This function is called to deallocate a block, and is an interator - * functioned called by deallocate inode via ext2fs_iterate_block(). - */ -static int deallocate_inode_block(ext2_filsys fs, blk_t *block_nr, - e2_blkcnt_t blockcnt FSCK_ATTR((unused)), - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - e2fsck_t ctx = (e2fsck_t) priv_data; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - if ((*block_nr < fs->super->s_first_data_block) || - (*block_nr >= fs->super->s_blocks_count)) - return 0; - ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); - ext2fs_block_alloc_stats(fs, *block_nr, -1); - return 0; -} - -/* - * This function deallocates an inode - */ -static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - __u32 count; - - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); - inode.i_links_count = 0; - inode.i_dtime = time(NULL); - e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode"); - clear_problem_context(&pctx); - pctx.ino = ino; - - /* - * Fix up the bitmaps... - */ - e2fsck_read_bitmaps(ctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); - - if (inode.i_file_acl && - (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { - pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, - block_buf, -1, &count); - if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { - pctx.errcode = 0; - count = 1; - } - if (pctx.errcode) { - pctx.blk = inode.i_file_acl; - fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (count == 0) { - ext2fs_unmark_block_bitmap(ctx->block_found_map, - inode.i_file_acl); - ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1); - } - inode.i_file_acl = 0; - } - - if (!ext2fs_inode_has_valid_blocks(&inode)) - return; - - if (LINUX_S_ISREG(inode.i_mode) && - (inode.i_size_high || inode.i_size & 0x80000000UL)) - ctx->large_files--; - - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - deallocate_inode_block, ctx); - if (pctx.errcode) { - fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -/* - * This function clears the htree flag on an inode - */ -static void clear_htree(e2fsck_t ctx, ext2_ino_t ino) -{ - struct ext2_inode inode; - - e2fsck_read_inode(ctx, ino, &inode, "clear_htree"); - inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL; - e2fsck_write_inode(ctx, ino, &inode, "clear_htree"); - if (ctx->dirs_to_hash) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); -} - - -static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, - ext2_ino_t ino, char *buf) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - int inode_modified = 0; - int not_fixed = 0; - unsigned char *frag, *fsize; - struct problem_context pctx; - int problem = 0; - - e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode"); - - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.dir = dir; - pctx.inode = &inode; - - if (inode.i_file_acl && - !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) && - fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) { - inode.i_file_acl = 0; -#if BB_BIG_ENDIAN - /* - * This is a special kludge to deal with long symlinks - * on big endian systems. i_blocks had already been - * decremented earlier in pass 1, but since i_file_acl - * hadn't yet been cleared, ext2fs_read_inode() - * assumed that the file was short symlink and would - * not have byte swapped i_block[0]. Hence, we have - * to byte-swap it here. - */ - if (LINUX_S_ISLNK(inode.i_mode) && - (fs->flags & EXT2_FLAG_SWAP_BYTES) && - (inode.i_blocks == fs->blocksize >> 9)) - inode.i_block[0] = ext2fs_swab32(inode.i_block[0]); -#endif - inode_modified++; - } else - not_fixed++; - - if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) && - !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) && - !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) && - !(LINUX_S_ISSOCK(inode.i_mode))) - problem = PR_2_BAD_MODE; - else if (LINUX_S_ISCHR(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_CHAR_DEV; - else if (LINUX_S_ISBLK(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_BLOCK_DEV; - else if (LINUX_S_ISFIFO(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_FIFO; - else if (LINUX_S_ISSOCK(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_SOCKET; - else if (LINUX_S_ISLNK(inode.i_mode) - && !e2fsck_pass1_check_symlink(fs, &inode, buf)) { - problem = PR_2_INVALID_SYMLINK; - } - - if (problem) { - if (fix_problem(ctx, problem, &pctx)) { - deallocate_inode(ctx, ino, 0); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return 0; - return 1; - } else - not_fixed++; - problem = 0; - } - - if (inode.i_faddr) { - if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) { - inode.i_faddr = 0; - inode_modified++; - } else - not_fixed++; - } - - switch (fs->super->s_creator_os) { - case EXT2_OS_LINUX: - frag = &inode.osd2.linux2.l_i_frag; - fsize = &inode.osd2.linux2.l_i_fsize; - break; - case EXT2_OS_HURD: - frag = &inode.osd2.hurd2.h_i_frag; - fsize = &inode.osd2.hurd2.h_i_fsize; - break; - case EXT2_OS_MASIX: - frag = &inode.osd2.masix2.m_i_frag; - fsize = &inode.osd2.masix2.m_i_fsize; - break; - default: - frag = fsize = 0; - } - if (frag && *frag) { - pctx.num = *frag; - if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) { - *frag = 0; - inode_modified++; - } else - not_fixed++; - pctx.num = 0; - } - if (fsize && *fsize) { - pctx.num = *fsize; - if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) { - *fsize = 0; - inode_modified++; - } else - not_fixed++; - pctx.num = 0; - } - - if (inode.i_file_acl && - ((inode.i_file_acl < fs->super->s_first_data_block) || - (inode.i_file_acl >= fs->super->s_blocks_count))) { - if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) { - inode.i_file_acl = 0; - inode_modified++; - } else - not_fixed++; - } - if (inode.i_dir_acl && - LINUX_S_ISDIR(inode.i_mode)) { - if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) { - inode.i_dir_acl = 0; - inode_modified++; - } else - not_fixed++; - } - - if (inode_modified) - e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode"); - if (!not_fixed) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - return 0; -} - - -/* - * allocate_dir_block --- this function allocates a new directory - * block for a particular inode; this is done if a directory has - * a "hole" in it, or if a directory has a illegal block number - * that was zeroed out and now needs to be replaced. - */ -static int allocate_dir_block(e2fsck_t ctx, struct ext2_db_entry *db, - struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - blk_t blk; - char *block; - struct ext2_inode inode; - - if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0) - return 1; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (pctx->errcode) { - pctx->str = "ext2fs_new_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_mark_block_bitmap(fs->block_map, blk); - ext2fs_mark_bb_dirty(fs); - - /* - * Now let's create the actual data block for the inode - */ - if (db->blockcnt) - pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block); - else - pctx->errcode = ext2fs_new_dir_block(fs, db->ino, - EXT2_ROOT_INO, &block); - - if (pctx->errcode) { - pctx->str = "ext2fs_new_dir_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - pctx->errcode = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem(&block); - if (pctx->errcode) { - pctx->str = "ext2fs_write_dir_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - /* - * Update the inode block count - */ - e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block"); - inode.i_blocks += fs->blocksize / 512; - if (inode.i_size < (db->blockcnt+1) * fs->blocksize) - inode.i_size = (db->blockcnt+1) * fs->blocksize; - e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block"); - - /* - * Finally, update the block pointers for the inode - */ - db->blk = blk; - pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE, - 0, update_dir_block, db); - if (pctx->errcode) { - pctx->str = "ext2fs_block_iterate"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - return 0; -} - -/* - * This is a helper function for allocate_dir_block(). - */ -static int update_dir_block(ext2_filsys fs FSCK_ATTR((unused)), - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct ext2_db_entry *db; - - db = (struct ext2_db_entry *) priv_data; - if (db->blockcnt == (int) blockcnt) { - *block_nr = db->blk; - return BLOCK_CHANGED; - } - return 0; -} - -/* - * pass3.c -- pass #3 of e2fsck: Check for directory connectivity - * - * Pass #3 assures that all directories are connected to the - * filesystem tree, using the following algorithm: - * - * First, the root directory is checked to make sure it exists; if - * not, e2fsck will offer to create a new one. It is then marked as - * "done". - * - * Then, pass3 interates over all directory inodes; for each directory - * it attempts to trace up the filesystem tree, using dirinfo.parent - * until it reaches a directory which has been marked "done". If it - * cannot do so, then the directory must be disconnected, and e2fsck - * will offer to reconnect it to /lost+found. While it is chasing - * parent pointers up the filesystem tree, if pass3 sees a directory - * twice, then it has detected a filesystem loop, and it will again - * offer to reconnect the directory to /lost+found in to break the - * filesystem loop. - * - * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to - * reconnect inodes to /lost+found; this subroutine is also used by - * pass 4. e2fsck_reconnect_file() calls get_lost_and_found(), which - * is responsible for creating /lost+found if it does not exist. - * - * Pass 3 frees the following data structures: - * - The dirinfo directory information cache. - */ - -static void check_root(e2fsck_t ctx); -static int check_directory(e2fsck_t ctx, struct dir_info *dir, - struct problem_context *pctx); -static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent); - -static ext2fs_inode_bitmap inode_loop_detect; -static ext2fs_inode_bitmap inode_done_map; - -static void e2fsck_pass3(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - int i; - struct problem_context pctx; - struct dir_info *dir; - unsigned long maxdirs, count; - - clear_problem_context(&pctx); - - /* Pass 3 */ - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_3_PASS_HEADER, &pctx); - - /* - * Allocate some bitmaps to do loop detection. - */ - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"), - &inode_done_map); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - goto abort_exit; - } - check_root(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto abort_exit; - - ext2fs_mark_inode_bitmap(inode_done_map, EXT2_ROOT_INO); - - maxdirs = e2fsck_get_num_dirinfo(ctx); - count = 1; - - if (ctx->progress) - if ((ctx->progress)(ctx, 3, 0, maxdirs)) - goto abort_exit; - - for (i=0; (dir = e2fsck_dir_info_iter(ctx, &i)) != 0;) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto abort_exit; - if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs)) - goto abort_exit; - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dir->ino)) - if (check_directory(ctx, dir, &pctx)) - goto abort_exit; - } - - /* - * Force the creation of /lost+found if not present - */ - if ((ctx->flags & E2F_OPT_READONLY) == 0) - e2fsck_get_lost_and_found(ctx, 1); - - /* - * If there are any directories that need to be indexed or - * optimized, do it here. - */ - e2fsck_rehash_directories(ctx); - -abort_exit: - e2fsck_free_dir_info(ctx); - ext2fs_free_inode_bitmap(inode_loop_detect); - inode_loop_detect = 0; - ext2fs_free_inode_bitmap(inode_done_map); - inode_done_map = 0; -} - -/* - * This makes sure the root inode is present; if not, we ask if the - * user wants us to create it. Not creating it is a fatal error. - */ -static void check_root(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t blk; - struct ext2_inode inode; - char * block; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) { - /* - * If the root inode is not a directory, die here. The - * user must have answered 'no' in pass1 when we - * offered to clear it. - */ - if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map, - EXT2_ROOT_INO))) { - fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - } - return; - } - - if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) { - fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (pctx.errcode) { - pctx.str = "ext2fs_new_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_mark_block_bitmap(fs->block_map, blk); - ext2fs_mark_bb_dirty(fs); - - /* - * Now let's create the actual data block for the inode - */ - pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, - &block); - if (pctx.errcode) { - pctx.str = "ext2fs_new_dir_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - pctx.errcode = ext2fs_write_dir_block(fs, blk, block); - if (pctx.errcode) { - pctx.str = "ext2fs_write_dir_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_free_mem(&block); - - /* - * Set up the inode structure - */ - memset(&inode, 0, sizeof(inode)); - inode.i_mode = 040755; - inode.i_size = fs->blocksize; - inode.i_atime = inode.i_ctime = inode.i_mtime = time(NULL); - inode.i_links_count = 2; - inode.i_blocks = fs->blocksize / 512; - inode.i_block[0] = blk; - - /* - * Write out the inode. - */ - pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode); - if (pctx.errcode) { - pctx.str = "ext2fs_write_inode"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - /* - * Miscellaneous bookkeeping... - */ - e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO); - ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2); - ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2); - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO); - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO); - ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO); - ext2fs_mark_ib_dirty(fs); -} - -/* - * This subroutine is responsible for making sure that a particular - * directory is connected to the root; if it isn't we trace it up as - * far as we can go, and then offer to connect the resulting parent to - * the lost+found. We have to do loop detection; if we ever discover - * a loop, we treat that as a disconnected directory and offer to - * reparent it to lost+found. - * - * However, loop detection is expensive, because for very large - * filesystems, the inode_loop_detect bitmap is huge, and clearing it - * is non-trivial. Loops in filesystems are also a rare error case, - * and we shouldn't optimize for error cases. So we try two passes of - * the algorithm. The first time, we ignore loop detection and merely - * increment a counter; if the counter exceeds some extreme threshold, - * then we try again with the loop detection bitmap enabled. - */ -static int check_directory(e2fsck_t ctx, struct dir_info *dir, - struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - struct dir_info *p = dir; - int loop_pass = 0, parent_count = 0; - - if (!p) - return 0; - - while (1) { - /* - * Mark this inode as being "done"; by the time we - * return from this function, the inode we either be - * verified as being connected to the directory tree, - * or we will have offered to reconnect this to - * lost+found. - * - * If it was marked done already, then we've reached a - * parent we've already checked. - */ - if (ext2fs_mark_inode_bitmap(inode_done_map, p->ino)) - break; - - /* - * If this directory doesn't have a parent, or we've - * seen the parent once already, then offer to - * reparent it to lost+found - */ - if (!p->parent || - (loop_pass && - (ext2fs_test_inode_bitmap(inode_loop_detect, - p->parent)))) { - pctx->ino = p->ino; - if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) { - if (e2fsck_reconnect_file(ctx, pctx->ino)) - ext2fs_unmark_valid(fs); - else { - p = e2fsck_get_dir_info(ctx, pctx->ino); - p->parent = ctx->lost_and_found; - fix_dotdot(ctx, p, ctx->lost_and_found); - } - } - break; - } - p = e2fsck_get_dir_info(ctx, p->parent); - if (!p) { - fix_problem(ctx, PR_3_NO_DIRINFO, pctx); - return 0; - } - if (loop_pass) { - ext2fs_mark_inode_bitmap(inode_loop_detect, - p->ino); - } else if (parent_count++ > 2048) { - /* - * If we've run into a path depth that's - * greater than 2048, try again with the inode - * loop bitmap turned on and start from the - * top. - */ - loop_pass = 1; - if (inode_loop_detect) - ext2fs_clear_inode_bitmap(inode_loop_detect); - else { - pctx->errcode = ext2fs_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), &inode_loop_detect); - if (pctx->errcode) { - pctx->num = 1; - fix_problem(ctx, - PR_3_ALLOCATE_IBITMAP_ERROR, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return -1; - } - } - p = dir; - } - } - - /* - * Make sure that .. and the parent directory are the same; - * offer to fix it if not. - */ - if (dir->parent != dir->dotdot) { - pctx->ino = dir->ino; - pctx->ino2 = dir->dotdot; - pctx->dir = dir->parent; - if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx)) - fix_dotdot(ctx, dir, dir->parent); - } - return 0; -} - -/* - * This routine gets the lost_and_found inode, making it a directory - * if necessary - */ -ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - blk_t blk; - errcode_t retval; - struct ext2_inode inode; - char * block; - static const char name[] = "lost+found"; - struct problem_context pctx; - struct dir_info *dirinfo; - - if (ctx->lost_and_found) - return ctx->lost_and_found; - - clear_problem_context(&pctx); - - retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name, - sizeof(name)-1, 0, &ino); - if (retval && !fix) - return 0; - if (!retval) { - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) { - ctx->lost_and_found = ino; - return ino; - } - - /* Lost+found isn't a directory! */ - if (!fix) - return 0; - pctx.ino = ino; - if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx)) - return 0; - - /* OK, unlink the old /lost+found file. */ - pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0); - if (pctx.errcode) { - pctx.str = "ext2fs_unlink"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - dirinfo = e2fsck_get_dir_info(ctx, ino); - if (dirinfo) - dirinfo->parent = 0; - e2fsck_adjust_inode_count(ctx, ino, -1); - } else if (retval != EXT2_ET_FILE_NOT_FOUND) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx); - } - if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0)) - return 0; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx); - return 0; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_block_alloc_stats(fs, blk, +1); - - /* - * Next find a free inode. - */ - retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700, - ctx->inode_used_map, &ino); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx); - return 0; - } - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, +1, 1); - - /* - * Now let's create the actual data block for the inode - */ - retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx); - return 0; - } - - retval = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem(&block); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx); - return 0; - } - - /* - * Set up the inode structure - */ - memset(&inode, 0, sizeof(inode)); - inode.i_mode = 040700; - inode.i_size = fs->blocksize; - inode.i_atime = inode.i_ctime = inode.i_mtime = time(NULL); - inode.i_links_count = 2; - inode.i_blocks = fs->blocksize / 512; - inode.i_block[0] = blk; - - /* - * Next, write out the inode. - */ - pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode); - if (pctx.errcode) { - pctx.str = "ext2fs_write_inode"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - /* - * Finally, create the directory link - */ - pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR); - if (pctx.errcode) { - pctx.str = "ext2fs_link"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - - /* - * Miscellaneous bookkeeping that needs to be kept straight. - */ - e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO); - e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1); - ext2fs_icount_store(ctx->inode_count, ino, 2); - ext2fs_icount_store(ctx->inode_link_info, ino, 2); - ctx->lost_and_found = ino; - return ino; -} - -/* - * This routine will connect a file to lost+found - */ -int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t ino) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - char name[80]; - struct problem_context pctx; - struct ext2_inode inode; - int file_type = 0; - - clear_problem_context(&pctx); - pctx.ino = ino; - - if (!ctx->bad_lost_and_found && !ctx->lost_and_found) { - if (e2fsck_get_lost_and_found(ctx, 1) == 0) - ctx->bad_lost_and_found++; - } - if (ctx->bad_lost_and_found) { - fix_problem(ctx, PR_3_NO_LPF, &pctx); - return 1; - } - - sprintf(name, "#%u", ino); - if (ext2fs_read_inode(fs, ino, &inode) == 0) - file_type = ext2_file_type(inode.i_mode); - retval = ext2fs_link(fs, ctx->lost_and_found, name, ino, file_type); - if (retval == EXT2_ET_DIR_NO_SPACE) { - if (!fix_problem(ctx, PR_3_EXPAND_LF_DIR, &pctx)) - return 1; - retval = e2fsck_expand_directory(ctx, ctx->lost_and_found, - 1, 0); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_CANT_EXPAND_LPF, &pctx); - return 1; - } - retval = ext2fs_link(fs, ctx->lost_and_found, name, - ino, file_type); - } - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_CANT_RECONNECT, &pctx); - return 1; - } - e2fsck_adjust_inode_count(ctx, ino, 1); - - return 0; -} - -/* - * Utility routine to adjust the inode counts on an inode. - */ -errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, int adj) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct ext2_inode inode; - - if (!ino) - return 0; - - retval = ext2fs_read_inode(fs, ino, &inode); - if (retval) - return retval; - - if (adj == 1) { - ext2fs_icount_increment(ctx->inode_count, ino, 0); - if (inode.i_links_count == (__u16) ~0) - return 0; - ext2fs_icount_increment(ctx->inode_link_info, ino, 0); - inode.i_links_count++; - } else if (adj == -1) { - ext2fs_icount_decrement(ctx->inode_count, ino, 0); - if (inode.i_links_count == 0) - return 0; - ext2fs_icount_decrement(ctx->inode_link_info, ino, 0); - inode.i_links_count--; - } - - retval = ext2fs_write_inode(fs, ino, &inode); - if (retval) - return retval; - - return 0; -} - -/* - * Fix parent --- this routine fixes up the parent of a directory. - */ -struct fix_dotdot_struct { - ext2_filsys fs; - ext2_ino_t parent; - int done; - e2fsck_t ctx; -}; - -static int fix_dotdot_proc(struct ext2_dir_entry *dirent, - int offset FSCK_ATTR((unused)), - int blocksize FSCK_ATTR((unused)), - char *buf FSCK_ATTR((unused)), - void *priv_data) -{ - struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data; - errcode_t retval; - struct problem_context pctx; - - if ((dirent->name_len & 0xFF) != 2) - return 0; - if (strncmp(dirent->name, "..", 2)) - return 0; - - clear_problem_context(&pctx); - - retval = e2fsck_adjust_inode_count(fp->ctx, dirent->inode, -1); - if (retval) { - pctx.errcode = retval; - fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); - } - retval = e2fsck_adjust_inode_count(fp->ctx, fp->parent, 1); - if (retval) { - pctx.errcode = retval; - fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); - } - dirent->inode = fp->parent; - - fp->done++; - return DIRENT_ABORT | DIRENT_CHANGED; -} - -static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct fix_dotdot_struct fp; - struct problem_context pctx; - - fp.fs = fs; - fp.parent = parent; - fp.done = 0; - fp.ctx = ctx; - - retval = ext2fs_dir_iterate(fs, dir->ino, DIRENT_FLAG_INCLUDE_EMPTY, - 0, fix_dotdot_proc, &fp); - if (retval || !fp.done) { - clear_problem_context(&pctx); - pctx.ino = dir->ino; - pctx.errcode = retval; - fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR : - PR_3_FIX_PARENT_NOFIND, &pctx); - ext2fs_unmark_valid(fs); - } - dir->dotdot = parent; -} - -/* - * These routines are responsible for expanding a /lost+found if it is - * too small. - */ - -struct expand_dir_struct { - int num; - int guaranteed_size; - int newblocks; - int last_block; - errcode_t err; - e2fsck_t ctx; -}; - -static int expand_dir_proc(ext2_filsys fs, - blk_t *blocknr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data; - blk_t new_blk; - static blk_t last_blk = 0; - char *block; - errcode_t retval; - e2fsck_t ctx; - - ctx = es->ctx; - - if (es->guaranteed_size && blockcnt >= es->guaranteed_size) - return BLOCK_ABORT; - - if (blockcnt > 0) - es->last_block = blockcnt; - if (*blocknr) { - last_blk = *blocknr; - return 0; - } - retval = ext2fs_new_block(fs, last_blk, ctx->block_found_map, - &new_blk); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - if (blockcnt > 0) { - retval = ext2fs_new_dir_block(fs, 0, 0, &block); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - es->num--; - retval = ext2fs_write_dir_block(fs, new_blk, block); - } else { - retval = ext2fs_get_mem(fs->blocksize, &block); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - memset(block, 0, fs->blocksize); - retval = io_channel_write_blk(fs->io, new_blk, 1, block); - } - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - ext2fs_free_mem(&block); - *blocknr = new_blk; - ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk); - ext2fs_block_alloc_stats(fs, new_blk, +1); - es->newblocks++; - - if (es->num == 0) - return (BLOCK_CHANGED | BLOCK_ABORT); - else - return BLOCK_CHANGED; -} - -errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, - int num, int guaranteed_size) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct expand_dir_struct es; - struct ext2_inode inode; - - if (!(fs->flags & EXT2_FLAG_RW)) - return EXT2_ET_RO_FILSYS; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - retval = ext2fs_check_directory(fs, dir); - if (retval) - return retval; - - es.num = num; - es.guaranteed_size = guaranteed_size; - es.last_block = 0; - es.err = 0; - es.newblocks = 0; - es.ctx = ctx; - - retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND, - 0, expand_dir_proc, &es); - - if (es.err) - return es.err; - - /* - * Update the size and block count fields in the inode. - */ - retval = ext2fs_read_inode(fs, dir, &inode); - if (retval) - return retval; - - inode.i_size = (es.last_block + 1) * fs->blocksize; - inode.i_blocks += (fs->blocksize / 512) * es.newblocks; - - e2fsck_write_inode(ctx, dir, &inode, "expand_directory"); - - return 0; -} - -/* - * pass4.c -- pass #4 of e2fsck: Check reference counts - * - * Pass 4 frees the following data structures: - * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) - */ - -/* - * This routine is called when an inode is not connected to the - * directory tree. - * - * This subroutine returns 1 then the caller shouldn't bother with the - * rest of the pass 4 tests. - */ -static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - - e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode"); - clear_problem_context(&pctx); - pctx.ino = i; - pctx.inode = &inode; - - /* - * Offer to delete any zero-length files that does not have - * blocks. If there is an EA block, it might have useful - * information, so we won't prompt to delete it, but let it be - * reconnected to lost+found. - */ - if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) || - LINUX_S_ISDIR(inode.i_mode))) { - if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) { - ext2fs_icount_store(ctx->inode_link_info, i, 0); - inode.i_links_count = 0; - inode.i_dtime = time(NULL); - e2fsck_write_inode(ctx, i, &inode, - "disconnect_inode"); - /* - * Fix up the bitmaps... - */ - e2fsck_read_bitmaps(ctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i); - ext2fs_inode_alloc_stats2(fs, i, -1, - LINUX_S_ISDIR(inode.i_mode)); - return 0; - } - } - - /* - * Prompt to reconnect. - */ - if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) { - if (e2fsck_reconnect_file(ctx, i)) - ext2fs_unmark_valid(fs); - } else { - /* - * If we don't attach the inode, then skip the - * i_links_test since there's no point in trying to - * force i_links_count to zero. - */ - ext2fs_unmark_valid(fs); - return 1; - } - return 0; -} - - -static void e2fsck_pass4(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t i; - struct ext2_inode inode; - struct problem_context pctx; - __u16 link_count, link_counted; - char *buf = NULL; - int group, maxgroup; - - /* Pass 4 */ - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_4_PASS_HEADER, &pctx); - - group = 0; - maxgroup = fs->group_desc_count; - if (ctx->progress) - if ((ctx->progress)(ctx, 4, 0, maxgroup)) - return; - - for (i=1; i <= fs->super->s_inodes_count; i++) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if ((i % fs->super->s_inodes_per_group) == 0) { - group++; - if (ctx->progress) - if ((ctx->progress)(ctx, 4, group, maxgroup)) - return; - } - if (i == EXT2_BAD_INO || - (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super))) - continue; - if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) || - (ctx->inode_imagic_map && - ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i))) - continue; - ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count); - ext2fs_icount_fetch(ctx->inode_count, i, &link_counted); - if (link_counted == 0) { - if (!buf) - buf = e2fsck_allocate_memory(ctx, - fs->blocksize, "bad_inode buffer"); - if (e2fsck_process_bad_inode(ctx, 0, i, buf)) - continue; - if (disconnect_inode(ctx, i)) - continue; - ext2fs_icount_fetch(ctx->inode_link_info, i, - &link_count); - ext2fs_icount_fetch(ctx->inode_count, i, - &link_counted); - } - if (link_counted != link_count) { - e2fsck_read_inode(ctx, i, &inode, "pass4"); - pctx.ino = i; - pctx.inode = &inode; - if (link_count != inode.i_links_count) { - pctx.num = link_count; - fix_problem(ctx, - PR_4_INCONSISTENT_COUNT, &pctx); - } - pctx.num = link_counted; - if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) { - inode.i_links_count = link_counted; - e2fsck_write_inode(ctx, i, &inode, "pass4"); - } - } - } - ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0; - ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0; - ext2fs_free_inode_bitmap(ctx->inode_imagic_map); - ctx->inode_imagic_map = 0; - ext2fs_free_mem(&buf); -} - -/* - * pass5.c --- check block and inode bitmaps against on-disk bitmaps - */ - -#define NO_BLK ((blk_t) -1) - -static void print_bitmap_problem(e2fsck_t ctx, int problem, - struct problem_context *pctx) -{ - switch (problem) { - case PR_5_BLOCK_UNUSED: - if (pctx->blk == pctx->blk2) - pctx->blk2 = 0; - else - problem = PR_5_BLOCK_RANGE_UNUSED; - break; - case PR_5_BLOCK_USED: - if (pctx->blk == pctx->blk2) - pctx->blk2 = 0; - else - problem = PR_5_BLOCK_RANGE_USED; - break; - case PR_5_INODE_UNUSED: - if (pctx->ino == pctx->ino2) - pctx->ino2 = 0; - else - problem = PR_5_INODE_RANGE_UNUSED; - break; - case PR_5_INODE_USED: - if (pctx->ino == pctx->ino2) - pctx->ino2 = 0; - else - problem = PR_5_INODE_RANGE_USED; - break; - } - fix_problem(ctx, problem, pctx); - pctx->blk = pctx->blk2 = NO_BLK; - pctx->ino = pctx->ino2 = 0; -} - -static void check_block_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t i; - int *free_array; - int group = 0; - unsigned int blocks = 0; - unsigned int free_blocks = 0; - int group_free = 0; - int actual, bitmap; - struct problem_context pctx; - int problem, save_problem, fixit, had_problem; - errcode_t retval; - - clear_problem_context(&pctx); - free_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "free block count array"); - - if ((fs->super->s_first_data_block < - ext2fs_get_block_bitmap_start(ctx->block_found_map)) || - (fs->super->s_blocks_count-1 > - ext2fs_get_block_bitmap_end(ctx->block_found_map))) { - pctx.num = 1; - pctx.blk = fs->super->s_first_data_block; - pctx.blk2 = fs->super->s_blocks_count -1; - pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map); - pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - - if ((fs->super->s_first_data_block < - ext2fs_get_block_bitmap_start(fs->block_map)) || - (fs->super->s_blocks_count-1 > - ext2fs_get_block_bitmap_end(fs->block_map))) { - pctx.num = 2; - pctx.blk = fs->super->s_first_data_block; - pctx.blk2 = fs->super->s_blocks_count -1; - pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map); - pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - -redo_counts: - had_problem = 0; - save_problem = 0; - pctx.blk = pctx.blk2 = NO_BLK; - for (i = fs->super->s_first_data_block; - i < fs->super->s_blocks_count; - i++) { - actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i); - bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); - - if (actual == bitmap) - goto do_counts; - - if (!actual && bitmap) { - /* - * Block not used, but marked in use in the bitmap. - */ - problem = PR_5_BLOCK_UNUSED; - } else { - /* - * Block used, but not marked in use in the bitmap. - */ - problem = PR_5_BLOCK_USED; - } - if (pctx.blk == NO_BLK) { - pctx.blk = pctx.blk2 = i; - save_problem = problem; - } else { - if ((problem == save_problem) && - (pctx.blk2 == i-1)) - pctx.blk2++; - else { - print_bitmap_problem(ctx, save_problem, &pctx); - pctx.blk = pctx.blk2 = i; - save_problem = problem; - } - } - ctx->flags |= E2F_FLAG_PROG_SUPPRESS; - had_problem++; - - do_counts: - if (!bitmap) { - group_free++; - free_blocks++; - } - blocks ++; - if ((blocks == fs->super->s_blocks_per_group) || - (i == fs->super->s_blocks_count-1)) { - free_array[group] = group_free; - group ++; - blocks = 0; - group_free = 0; - if (ctx->progress) - if ((ctx->progress)(ctx, 5, group, - fs->group_desc_count*2)) - return; - } - } - if (pctx.blk != NO_BLK) - print_bitmap_problem(ctx, save_problem, &pctx); - if (had_problem) - fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP); - else - fixit = -1; - ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; - - if (fixit == 1) { - ext2fs_free_block_bitmap(fs->block_map); - retval = ext2fs_copy_bitmap(ctx->block_found_map, - &fs->block_map); - if (retval) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_set_bitmap_padding(fs->block_map); - ext2fs_mark_bb_dirty(fs); - - /* Redo the counts */ - blocks = 0; free_blocks = 0; group_free = 0; group = 0; - memset(free_array, 0, fs->group_desc_count * sizeof(int)); - goto redo_counts; - } else if (fixit == 0) - ext2fs_unmark_valid(fs); - - for (i = 0; i < fs->group_desc_count; i++) { - if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) { - pctx.group = i; - pctx.blk = fs->group_desc[i].bg_free_blocks_count; - pctx.blk2 = free_array[i]; - - if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_free_blocks_count = - free_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - } - if (free_blocks != fs->super->s_free_blocks_count) { - pctx.group = 0; - pctx.blk = fs->super->s_free_blocks_count; - pctx.blk2 = free_blocks; - - if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) { - fs->super->s_free_blocks_count = free_blocks; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&free_array); -} - -static void check_inode_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t i; - unsigned int free_inodes = 0; - int group_free = 0; - int dirs_count = 0; - int group = 0; - unsigned int inodes = 0; - int *free_array; - int *dir_array; - int actual, bitmap; - errcode_t retval; - struct problem_context pctx; - int problem, save_problem, fixit, had_problem; - - clear_problem_context(&pctx); - free_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "free inode count array"); - - dir_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "directory count array"); - - if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) || - (fs->super->s_inodes_count > - ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) { - pctx.num = 3; - pctx.blk = 1; - pctx.blk2 = fs->super->s_inodes_count; - pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map); - pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) || - (fs->super->s_inodes_count > - ext2fs_get_inode_bitmap_end(fs->inode_map))) { - pctx.num = 4; - pctx.blk = 1; - pctx.blk2 = fs->super->s_inodes_count; - pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map); - pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - -redo_counts: - had_problem = 0; - save_problem = 0; - pctx.ino = pctx.ino2 = 0; - for (i = 1; i <= fs->super->s_inodes_count; i++) { - actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i); - bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); - - if (actual == bitmap) - goto do_counts; - - if (!actual && bitmap) { - /* - * Inode wasn't used, but marked in bitmap - */ - problem = PR_5_INODE_UNUSED; - } else /* if (actual && !bitmap) */ { - /* - * Inode used, but not in bitmap - */ - problem = PR_5_INODE_USED; - } - if (pctx.ino == 0) { - pctx.ino = pctx.ino2 = i; - save_problem = problem; - } else { - if ((problem == save_problem) && - (pctx.ino2 == i-1)) - pctx.ino2++; - else { - print_bitmap_problem(ctx, save_problem, &pctx); - pctx.ino = pctx.ino2 = i; - save_problem = problem; - } - } - ctx->flags |= E2F_FLAG_PROG_SUPPRESS; - had_problem++; - -do_counts: - if (!bitmap) { - group_free++; - free_inodes++; - } else { - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i)) - dirs_count++; - } - inodes++; - if ((inodes == fs->super->s_inodes_per_group) || - (i == fs->super->s_inodes_count)) { - free_array[group] = group_free; - dir_array[group] = dirs_count; - group ++; - inodes = 0; - group_free = 0; - dirs_count = 0; - if (ctx->progress) - if ((ctx->progress)(ctx, 5, - group + fs->group_desc_count, - fs->group_desc_count*2)) - return; - } - } - if (pctx.ino) - print_bitmap_problem(ctx, save_problem, &pctx); - - if (had_problem) - fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP); - else - fixit = -1; - ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; - - if (fixit == 1) { - ext2fs_free_inode_bitmap(fs->inode_map); - retval = ext2fs_copy_bitmap(ctx->inode_used_map, - &fs->inode_map); - if (retval) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_set_bitmap_padding(fs->inode_map); - ext2fs_mark_ib_dirty(fs); - - /* redo counts */ - inodes = 0; free_inodes = 0; group_free = 0; - dirs_count = 0; group = 0; - memset(free_array, 0, fs->group_desc_count * sizeof(int)); - memset(dir_array, 0, fs->group_desc_count * sizeof(int)); - goto redo_counts; - } else if (fixit == 0) - ext2fs_unmark_valid(fs); - - for (i = 0; i < fs->group_desc_count; i++) { - if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) { - pctx.group = i; - pctx.ino = fs->group_desc[i].bg_free_inodes_count; - pctx.ino2 = free_array[i]; - if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_free_inodes_count = - free_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) { - pctx.group = i; - pctx.ino = fs->group_desc[i].bg_used_dirs_count; - pctx.ino2 = dir_array[i]; - - if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_used_dirs_count = - dir_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - } - if (free_inodes != fs->super->s_free_inodes_count) { - pctx.group = -1; - pctx.ino = fs->super->s_free_inodes_count; - pctx.ino2 = free_inodes; - - if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) { - fs->super->s_free_inodes_count = free_inodes; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&free_array); - ext2fs_free_mem(&dir_array); -} - -static void check_inode_end(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t end, save_inodes_count, i; - struct problem_context pctx; - - clear_problem_context(&pctx); - - end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count; - pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, - &save_inodes_count); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if (save_inodes_count == end) - return; - - for (i = save_inodes_count + 1; i <= end; i++) { - if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { - if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { - for (i = save_inodes_count + 1; i <= end; i++) - ext2fs_mark_inode_bitmap(fs->inode_map, - i); - ext2fs_mark_ib_dirty(fs); - } else - ext2fs_unmark_valid(fs); - break; - } - } - - pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, - save_inodes_count, 0); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } -} - -static void check_block_end(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t end, save_blocks_count, i; - struct problem_context pctx; - - clear_problem_context(&pctx); - - end = fs->block_map->start + - (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1; - pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end, - &save_blocks_count); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if (save_blocks_count == end) - return; - - for (i = save_blocks_count + 1; i <= end; i++) { - if (!ext2fs_test_block_bitmap(fs->block_map, i)) { - if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { - for (i = save_blocks_count + 1; i <= end; i++) - ext2fs_mark_block_bitmap(fs->block_map, - i); - ext2fs_mark_bb_dirty(fs); - } else - ext2fs_unmark_valid(fs); - break; - } - } - - pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, - save_blocks_count, 0); - if (pctx.errcode) { - pctx.num = 4; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } -} - -static void e2fsck_pass5(e2fsck_t ctx) -{ - struct problem_context pctx; - - /* Pass 5 */ - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_5_PASS_HEADER, &pctx); - - if (ctx->progress) - if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) - return; - - e2fsck_read_bitmaps(ctx); - - check_block_bitmaps(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_inode_bitmaps(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_inode_end(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_block_end(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - ext2fs_free_inode_bitmap(ctx->inode_used_map); - ctx->inode_used_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_dir_map); - ctx->inode_dir_map = 0; - ext2fs_free_block_bitmap(ctx->block_found_map); - ctx->block_found_map = 0; -} - -/* - * problem.c --- report filesystem problems to the user - */ - -#define PR_PREEN_OK 0x000001 /* Don't need to do preenhalt */ -#define PR_NO_OK 0x000002 /* If user answers no, don't make fs invalid */ -#define PR_NO_DEFAULT 0x000004 /* Default to no */ -#define PR_MSG_ONLY 0x000008 /* Print message only */ - -/* Bit positions 0x000ff0 are reserved for the PR_LATCH flags */ - -#define PR_FATAL 0x001000 /* Fatal error */ -#define PR_AFTER_CODE 0x002000 /* After asking the first question, */ - /* ask another */ -#define PR_PREEN_NOMSG 0x004000 /* Don't print a message if we're preening */ -#define PR_NOCOLLATE 0x008000 /* Don't collate answers for this latch */ -#define PR_NO_NOMSG 0x010000 /* Don't print a message if e2fsck -n */ -#define PR_PREEN_NO 0x020000 /* Use No as an answer if preening */ -#define PR_PREEN_NOHDR 0x040000 /* Don't print the preen header */ - - -#define PROMPT_NONE 0 -#define PROMPT_FIX 1 -#define PROMPT_CLEAR 2 -#define PROMPT_RELOCATE 3 -#define PROMPT_ALLOCATE 4 -#define PROMPT_EXPAND 5 -#define PROMPT_CONNECT 6 -#define PROMPT_CREATE 7 -#define PROMPT_SALVAGE 8 -#define PROMPT_TRUNCATE 9 -#define PROMPT_CLEAR_INODE 10 -#define PROMPT_ABORT 11 -#define PROMPT_SPLIT 12 -#define PROMPT_CONTINUE 13 -#define PROMPT_CLONE 14 -#define PROMPT_DELETE 15 -#define PROMPT_SUPPRESS 16 -#define PROMPT_UNLINK 17 -#define PROMPT_CLEAR_HTREE 18 -#define PROMPT_RECREATE 19 -#define PROMPT_NULL 20 - -struct e2fsck_problem { - problem_t e2p_code; - const char * e2p_description; - char prompt; - int flags; - problem_t second_code; -}; - -struct latch_descr { - int latch_code; - problem_t question; - problem_t end_message; - int flags; -}; - -/* - * These are the prompts which are used to ask the user if they want - * to fix a problem. - */ -static const char *const prompt[] = { - N_("(no prompt)"), /* 0 */ - N_("Fix"), /* 1 */ - N_("Clear"), /* 2 */ - N_("Relocate"), /* 3 */ - N_("Allocate"), /* 4 */ - N_("Expand"), /* 5 */ - N_("Connect to /lost+found"), /* 6 */ - N_("Create"), /* 7 */ - N_("Salvage"), /* 8 */ - N_("Truncate"), /* 9 */ - N_("Clear inode"), /* 10 */ - N_("Abort"), /* 11 */ - N_("Split"), /* 12 */ - N_("Continue"), /* 13 */ - N_("Clone multiply-claimed blocks"), /* 14 */ - N_("Delete file"), /* 15 */ - N_("Suppress messages"),/* 16 */ - N_("Unlink"), /* 17 */ - N_("Clear HTree index"),/* 18 */ - N_("Recreate"), /* 19 */ - "", /* 20 */ -}; - -/* - * These messages are printed when we are preen mode and we will be - * automatically fixing the problem. - */ -static const char *const preen_msg[] = { - N_("(NONE)"), /* 0 */ - N_("FIXED"), /* 1 */ - N_("CLEARED"), /* 2 */ - N_("RELOCATED"), /* 3 */ - N_("ALLOCATED"), /* 4 */ - N_("EXPANDED"), /* 5 */ - N_("RECONNECTED"), /* 6 */ - N_("CREATED"), /* 7 */ - N_("SALVAGED"), /* 8 */ - N_("TRUNCATED"), /* 9 */ - N_("INODE CLEARED"), /* 10 */ - N_("ABORTED"), /* 11 */ - N_("SPLIT"), /* 12 */ - N_("CONTINUING"), /* 13 */ - N_("MULTIPLY-CLAIMED BLOCKS CLONED"), /* 14 */ - N_("FILE DELETED"), /* 15 */ - N_("SUPPRESSED"), /* 16 */ - N_("UNLINKED"), /* 17 */ - N_("HTREE INDEX CLEARED"),/* 18 */ - N_("WILL RECREATE"), /* 19 */ - "", /* 20 */ -}; - -static const struct e2fsck_problem problem_table[] = { - - /* Pre-Pass 1 errors */ - - /* Block bitmap not in group */ - { PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g. (@b %b)\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Inode bitmap not in group */ - { PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g. (@b %b)\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Inode table not in group */ - { PR_0_ITABLE_NOT_GROUP, - N_("@i table for @g %g is not in @g. (@b %b)\n" - "WARNING: SEVERE DATA LOSS POSSIBLE.\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Superblock corrupt */ - { PR_0_SB_CORRUPT, - N_("\nThe @S could not be read or does not describe a correct ext2\n" - "@f. If the @v is valid and it really contains an ext2\n" - "@f (and not swap or ufs or something else), then the @S\n" - "is corrupt, and you might try running e2fsck with an alternate @S:\n" - " e2fsck -b %S <@v>\n\n"), - PROMPT_NONE, PR_FATAL }, - - /* Filesystem size is wrong */ - { PR_0_FS_SIZE_WRONG, - N_("The @f size (according to the @S) is %b @bs\n" - "The physical size of the @v is %c @bs\n" - "Either the @S or the partition table is likely to be corrupt!\n"), - PROMPT_ABORT, 0 }, - - /* Fragments not supported */ - { PR_0_NO_FRAGMENTS, - N_("@S @b_size = %b, fragsize = %c.\n" - "This version of e2fsck does not support fragment sizes different\n" - "from the @b size.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Bad blocks_per_group */ - { PR_0_BLOCKS_PER_GROUP, - N_("@S @bs_per_group = %b, should have been %c\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Bad first_data_block */ - { PR_0_FIRST_DATA_BLOCK, - N_("@S first_data_@b = %b, should have been %c\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Adding UUID to filesystem */ - { PR_0_ADD_UUID, - N_("@f did not have a UUID; generating one.\n\n"), - PROMPT_NONE, 0 }, - - /* Relocate hint */ - { PR_0_RELOCATE_HINT, - N_("Note: if several inode or block bitmap blocks or part\n" - "of the inode table require relocation, you may wish to try\n" - "running e2fsck with the '-b %S' option first. The problem\n" - "may lie only with the primary block group descriptors, and\n" - "the backup block group descriptors may be OK.\n\n"), - PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE }, - - /* Miscellaneous superblock corruption */ - { PR_0_MISC_CORRUPT_SUPER, - N_("Corruption found in @S. (%s = %N).\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Error determing physical device size of filesystem */ - { PR_0_GETSIZE_ERROR, - N_("Error determining size of the physical @v: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Inode count in superblock is incorrect */ - { PR_0_INODE_COUNT_WRONG, - N_("@i count in @S is %i, @s %j.\n"), - PROMPT_FIX, 0 }, - - { PR_0_HURD_CLEAR_FILETYPE, - N_("The Hurd does not support the filetype feature.\n"), - PROMPT_CLEAR, 0 }, - - /* Journal inode is invalid */ - { PR_0_JOURNAL_BAD_INODE, - N_("@S has an @n ext3 @j (@i %i).\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* The external journal has (unsupported) multiple filesystems */ - { PR_0_JOURNAL_UNSUPP_MULTIFS, - N_("External @j has multiple @f users (unsupported).\n"), - PROMPT_NONE, PR_FATAL }, - - /* Can't find external journal */ - { PR_0_CANT_FIND_JOURNAL, - N_("Can't find external @j\n"), - PROMPT_NONE, PR_FATAL }, - - /* External journal has bad superblock */ - { PR_0_EXT_JOURNAL_BAD_SUPER, - N_("External @j has bad @S\n"), - PROMPT_NONE, PR_FATAL }, - - /* Superblock has a bad journal UUID */ - { PR_0_JOURNAL_BAD_UUID, - N_("External @j does not support this @f\n"), - PROMPT_NONE, PR_FATAL }, - - /* Journal has an unknown superblock type */ - { PR_0_JOURNAL_UNSUPP_SUPER, - N_("Ext3 @j @S is unknown type %N (unsupported).\n" - "It is likely that your copy of e2fsck is old and/or doesn't " - "support this @j format.\n" - "It is also possible the @j @S is corrupt.\n"), - PROMPT_ABORT, PR_NO_OK | PR_AFTER_CODE, PR_0_JOURNAL_BAD_SUPER }, - - /* Journal superblock is corrupt */ - { PR_0_JOURNAL_BAD_SUPER, - N_("Ext3 @j @S is corrupt.\n"), - PROMPT_FIX, PR_PREEN_OK }, - - /* Superblock flag should be cleared */ - { PR_0_JOURNAL_HAS_JOURNAL, - N_("@S doesn't have has_@j flag, but has ext3 @j %s.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Superblock flag is incorrect */ - { PR_0_JOURNAL_RECOVER_SET, - N_("@S has ext3 needs_recovery flag set, but no @j.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Journal has data, but recovery flag is clear */ - { PR_0_JOURNAL_RECOVERY_CLEAR, - N_("ext3 recovery flag is clear, but @j has data.\n"), - PROMPT_NONE, 0 }, - - /* Ask if we should clear the journal */ - { PR_0_JOURNAL_RESET_JOURNAL, - N_("Clear @j"), - PROMPT_NULL, PR_PREEN_NOMSG }, - - /* Ask if we should run the journal anyway */ - { PR_0_JOURNAL_RUN, - N_("Run @j anyway"), - PROMPT_NULL, 0 }, - - /* Run the journal by default */ - { PR_0_JOURNAL_RUN_DEFAULT, - N_("Recovery flag not set in backup @S, so running @j anyway.\n"), - PROMPT_NONE, 0 }, - - /* Clearing orphan inode */ - { PR_0_ORPHAN_CLEAR_INODE, - N_("%s @o @i %i (uid=%Iu, gid=%Ig, mode=%Im, size=%Is)\n"), - PROMPT_NONE, 0 }, - - /* Illegal block found in orphaned inode */ - { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) found in @o @i %i.\n"), - PROMPT_NONE, 0 }, - - /* Already cleared block found in orphaned inode */ - { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, - N_("Already cleared @b #%B (%b) found in @o @i %i.\n"), - PROMPT_NONE, 0 }, - - /* Illegal orphan inode in superblock */ - { PR_0_ORPHAN_ILLEGAL_HEAD_INODE, - N_("@I @o @i %i in @S.\n"), - PROMPT_NONE, 0 }, - - /* Illegal inode in orphaned inode list */ - { PR_0_ORPHAN_ILLEGAL_INODE, - N_("@I @i %i in @o @i list.\n"), - PROMPT_NONE, 0 }, - - /* Filesystem revision is 0, but feature flags are set */ - { PR_0_FS_REV_LEVEL, - N_("@f has feature flag(s) set, but is a revision 0 @f. "), - PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, - - /* Journal superblock has an unknown read-only feature flag set */ - { PR_0_JOURNAL_UNSUPP_ROCOMPAT, - N_("Ext3 @j @S has an unknown read-only feature flag set.\n"), - PROMPT_ABORT, 0 }, - - /* Journal superblock has an unknown incompatible feature flag set */ - { PR_0_JOURNAL_UNSUPP_INCOMPAT, - N_("Ext3 @j @S has an unknown incompatible feature flag set.\n"), - PROMPT_ABORT, 0 }, - - /* Journal has unsupported version number */ - { PR_0_JOURNAL_UNSUPP_VERSION, - N_("@j version not supported by this e2fsck.\n"), - PROMPT_ABORT, 0 }, - - /* Moving journal to hidden file */ - { PR_0_MOVE_JOURNAL, - N_("Moving @j from /%s to hidden @i.\n\n"), - PROMPT_NONE, 0 }, - - /* Error moving journal to hidden file */ - { PR_0_ERR_MOVE_JOURNAL, - N_("Error moving @j: %m\n\n"), - PROMPT_NONE, 0 }, - - /* Clearing V2 journal superblock */ - { PR_0_CLEAR_V2_JOURNAL, - N_("Found @n V2 @j @S fields (from V1 @j).\n" - "Clearing fields beyond the V1 @j @S...\n\n"), - PROMPT_NONE, 0 }, - - /* Backup journal inode blocks */ - { PR_0_BACKUP_JNL, - N_("Backing up @j @i @b information.\n\n"), - PROMPT_NONE, 0 }, - - /* Reserved blocks w/o resize_inode */ - { PR_0_NONZERO_RESERVED_GDT_BLOCKS, - N_("@f does not have resize_@i enabled, but s_reserved_gdt_@bs\n" - "is %N; @s zero. "), - PROMPT_FIX, 0 }, - - /* Resize_inode not enabled, but resize inode is non-zero */ - { PR_0_CLEAR_RESIZE_INODE, - N_("Resize_@i not enabled, but the resize @i is non-zero. "), - PROMPT_CLEAR, 0 }, - - /* Resize inode invalid */ - { PR_0_RESIZE_INODE_INVALID, - N_("Resize @i not valid. "), - PROMPT_RECREATE, 0 }, - - /* Pass 1 errors */ - - /* Pass 1: Checking inodes, blocks, and sizes */ - { PR_1_PASS_HEADER, - N_("Pass 1: Checking @is, @bs, and sizes\n"), - PROMPT_NONE, 0 }, - - /* Root directory is not an inode */ - { PR_1_ROOT_NO_DIR, N_("@r is not a @d. "), - PROMPT_CLEAR, 0 }, - - /* Root directory has dtime set */ - { PR_1_ROOT_DTIME, - N_("@r has dtime set (probably due to old mke2fs). "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Reserved inode has bad mode */ - { PR_1_RESERVED_BAD_MODE, - N_("Reserved @i %i (%Q) has @n mode. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Deleted inode has zero dtime */ - { PR_1_ZERO_DTIME, - N_("@D @i %i has zero dtime. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Inode in use, but dtime set */ - { PR_1_SET_DTIME, - N_("@i %i is in use, but has dtime set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Zero-length directory */ - { PR_1_ZERO_LENGTH_DIR, - N_("@i %i is a @z @d. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Block bitmap conflicts with some other fs block */ - { PR_1_BB_CONFLICT, - N_("@g %g's @b @B at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Inode bitmap conflicts with some other fs block */ - { PR_1_IB_CONFLICT, - N_("@g %g's @i @B at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Inode table conflicts with some other fs block */ - { PR_1_ITABLE_CONFLICT, - N_("@g %g's @i table at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Block bitmap is on a bad block */ - { PR_1_BB_BAD_BLOCK, - N_("@g %g's @b @B (%b) is bad. "), - PROMPT_RELOCATE, 0 }, - - /* Inode bitmap is on a bad block */ - { PR_1_IB_BAD_BLOCK, - N_("@g %g's @i @B (%b) is bad. "), - PROMPT_RELOCATE, 0 }, - - /* Inode has incorrect i_size */ - { PR_1_BAD_I_SIZE, - N_("@i %i, i_size is %Is, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Inode has incorrect i_blocks */ - { PR_1_BAD_I_BLOCKS, - N_("@i %i, i_@bs is %Ib, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Illegal blocknumber in inode */ - { PR_1_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) in @i %i. "), - PROMPT_CLEAR, PR_LATCH_BLOCK }, - - /* Block number overlaps fs metadata */ - { PR_1_BLOCK_OVERLAPS_METADATA, - N_("@b #%B (%b) overlaps @f metadata in @i %i. "), - PROMPT_CLEAR, PR_LATCH_BLOCK }, - - /* Inode has illegal blocks (latch question) */ - { PR_1_INODE_BLOCK_LATCH, - N_("@i %i has illegal @b(s). "), - PROMPT_CLEAR, 0 }, - - /* Too many bad blocks in inode */ - { PR_1_TOO_MANY_BAD_BLOCKS, - N_("Too many illegal @bs in @i %i.\n"), - PROMPT_CLEAR_INODE, PR_NO_OK }, - - /* Illegal block number in bad block inode */ - { PR_1_BB_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) in bad @b @i. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Bad block inode has illegal blocks (latch question) */ - { PR_1_INODE_BBLOCK_LATCH, - N_("Bad @b @i has illegal @b(s). "), - PROMPT_CLEAR, 0 }, - - /* Duplicate or bad blocks in use! */ - { PR_1_DUP_BLOCKS_PREENSTOP, - N_("Duplicate or bad @b in use!\n"), - PROMPT_NONE, 0 }, - - /* Bad block used as bad block indirect block */ - { PR_1_BBINODE_BAD_METABLOCK, - N_("Bad @b %b used as bad @b @i indirect @b. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Inconsistency can't be fixed prompt */ - { PR_1_BBINODE_BAD_METABLOCK_PROMPT, - N_("\nThe bad @b @i has probably been corrupted. You probably\n" - "should stop now and run ""e2fsck -c"" to scan for bad blocks\n" - "in the @f.\n"), - PROMPT_CONTINUE, PR_PREEN_NOMSG }, - - /* Bad primary block */ - { PR_1_BAD_PRIMARY_BLOCK, - N_("\nIf the @b is really bad, the @f cannot be fixed.\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT }, - - /* Bad primary block prompt */ - { PR_1_BAD_PRIMARY_BLOCK_PROMPT, - N_("You can remove this @b from the bad @b list and hope\n" - "that the @b is really OK. But there are no guarantees.\n\n"), - PROMPT_CLEAR, PR_PREEN_NOMSG }, - - /* Bad primary superblock */ - { PR_1_BAD_PRIMARY_SUPERBLOCK, - N_("The primary @S (%b) is on the bad @b list.\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, - - /* Bad primary block group descriptors */ - { PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, - N_("Block %b in the primary @g descriptors " - "is on the bad @b list\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, - - /* Bad superblock in group */ - { PR_1_BAD_SUPERBLOCK, - N_("Warning: Group %g's @S (%b) is bad.\n"), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Bad block group descriptors in group */ - { PR_1_BAD_GROUP_DESCRIPTORS, - N_("Warning: Group %g's copy of the @g descriptors has a bad " - "@b (%b).\n"), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block claimed for no reason */ - { PR_1_PROGERR_CLAIMED_BLOCK, - N_("Programming error? @b #%b claimed for no reason in " - "process_bad_@b.\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating blocks for relocating metadata */ - { PR_1_RELOC_BLOCK_ALLOCATE, - N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating block buffer during relocation process */ - { PR_1_RELOC_MEMORY_ALLOCATE, - N_("@A @b buffer for relocating %s\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Relocating metadata group information from X to Y */ - { PR_1_RELOC_FROM_TO, - N_("Relocating @g %g's %s from %b to %c...\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Relocating metatdata group information to X */ - { PR_1_RELOC_TO, - N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */ - PROMPT_NONE, PR_PREEN_OK }, - - /* Block read error during relocation process */ - { PR_1_RELOC_READ_ERR, - N_("Warning: could not read @b %b of %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Block write error during relocation process */ - { PR_1_RELOC_WRITE_ERR, - N_("Warning: could not write @b %b for %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating inode bitmap */ - { PR_1_ALLOCATE_IBITMAP_ERROR, - N_("@A @i @B (%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating block bitmap */ - { PR_1_ALLOCATE_BBITMAP_ERROR, - N_("@A @b @B (%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating icount structure */ - { PR_1_ALLOCATE_ICOUNT, - N_("@A icount link information: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating dbcount */ - { PR_1_ALLOCATE_DBCOUNT, - N_("@A @d @b array: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while scanning inodes */ - { PR_1_ISCAN_ERROR, - N_("Error while scanning @is (%i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while iterating over blocks */ - { PR_1_BLOCK_ITERATE, - N_("Error while iterating over @bs in @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while storing inode count information */ - { PR_1_ICOUNT_STORE, - N_("Error storing @i count information (@i=%i, count=%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while storing directory block information */ - { PR_1_ADD_DBLOCK, - N_("Error storing @d @b information " - "(@i=%i, @b=%b, num=%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while reading inode (for clearing) */ - { PR_1_READ_INODE, - N_("Error reading @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Suppress messages prompt */ - { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK }, - - /* Imagic flag set on an inode when filesystem doesn't support it */ - { PR_1_SET_IMAGIC, - N_("@i %i has imagic flag set. "), - PROMPT_CLEAR, 0 }, - - /* Immutable flag set on a device or socket inode */ - { PR_1_SET_IMMUTABLE, - N_("Special (@v/socket/fifo/symlink) file (@i %i) has immutable\n" - "or append-only flag set. "), - PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK }, - - /* Compression flag set on an inode when filesystem doesn't support it */ - { PR_1_COMPR_SET, - N_("@i %i has @cion flag set on @f without @cion support. "), - PROMPT_CLEAR, 0 }, - - /* Non-zero size for device, fifo or socket inode */ - { PR_1_SET_NONZSIZE, - N_("Special (@v/socket/fifo) @i %i has non-zero size. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Filesystem revision is 0, but feature flags are set */ - { PR_1_FS_REV_LEVEL, - N_("@f has feature flag(s) set, but is a revision 0 @f. "), - PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, - - /* Journal inode is not in use, but contains data */ - { PR_1_JOURNAL_INODE_NOT_CLEAR, - N_("@j @i is not in use, but contains data. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Journal has bad mode */ - { PR_1_JOURNAL_BAD_MODE, - N_("@j is not regular file. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Deal with inodes that were part of orphan linked list */ - { PR_1_LOW_DTIME, - N_("@i %i was part of the @o @i list. "), - PROMPT_FIX, PR_LATCH_LOW_DTIME, 0 }, - - /* Deal with inodes that were part of corrupted orphan linked - list (latch question) */ - { PR_1_ORPHAN_LIST_REFUGEES, - N_("@is that were part of a corrupted orphan linked list found. "), - PROMPT_FIX, 0 }, - - /* Error allocating refcount structure */ - { PR_1_ALLOCATE_REFCOUNT, - N_("@A refcount structure (%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error reading extended attribute block */ - { PR_1_READ_EA_BLOCK, - N_("Error reading @a @b %b for @i %i. "), - PROMPT_CLEAR, 0 }, - - /* Invalid extended attribute block */ - { PR_1_BAD_EA_BLOCK, - N_("@i %i has a bad @a @b %b. "), - PROMPT_CLEAR, 0 }, - - /* Error reading Extended Attribute block while fixing refcount */ - { PR_1_EXTATTR_READ_ABORT, - N_("Error reading @a @b %b (%m). "), - PROMPT_ABORT, 0 }, - - /* Extended attribute reference count incorrect */ - { PR_1_EXTATTR_REFCOUNT, - N_("@a @b %b has reference count %B, @s %N. "), - PROMPT_FIX, 0 }, - - /* Error writing Extended Attribute block while fixing refcount */ - { PR_1_EXTATTR_WRITE, - N_("Error writing @a @b %b (%m). "), - PROMPT_ABORT, 0 }, - - /* Multiple EA blocks not supported */ - { PR_1_EA_MULTI_BLOCK, - N_("@a @b %b has h_@bs > 1. "), - PROMPT_CLEAR, 0}, - - /* Error allocating EA region allocation structure */ - { PR_1_EA_ALLOC_REGION, - N_("@A @a @b %b. "), - PROMPT_ABORT, 0}, - - /* Error EA allocation collision */ - { PR_1_EA_ALLOC_COLLISION, - N_("@a @b %b is corrupt (allocation collision). "), - PROMPT_CLEAR, 0}, - - /* Bad extended attribute name */ - { PR_1_EA_BAD_NAME, - N_("@a @b %b is corrupt (@n name). "), - PROMPT_CLEAR, 0}, - - /* Bad extended attribute value */ - { PR_1_EA_BAD_VALUE, - N_("@a @b %b is corrupt (@n value). "), - PROMPT_CLEAR, 0}, - - /* Inode too big (latch question) */ - { PR_1_INODE_TOOBIG, - N_("@i %i is too big. "), PROMPT_TRUNCATE, 0 }, - - /* Directory too big */ - { PR_1_TOOBIG_DIR, - N_("@b #%B (%b) causes @d to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* Regular file too big */ - { PR_1_TOOBIG_REG, - N_("@b #%B (%b) causes file to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* Symlink too big */ - { PR_1_TOOBIG_SYMLINK, - N_("@b #%B (%b) causes symlink to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* INDEX_FL flag set on a non-HTREE filesystem */ - { PR_1_HTREE_SET, - N_("@i %i has INDEX_FL flag set on @f without htree support.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* INDEX_FL flag set on a non-directory */ - { PR_1_HTREE_NODIR, - N_("@i %i has INDEX_FL flag set but is not a @d.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid root node in HTREE directory */ - { PR_1_HTREE_BADROOT, - N_("@h %i has an @n root node.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Unsupported hash version in HTREE directory */ - { PR_1_HTREE_HASHV, - N_("@h %i has an unsupported hash version (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Incompatible flag in HTREE root node */ - { PR_1_HTREE_INCOMPAT, - N_("@h %i uses an incompatible htree root node flag.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* HTREE too deep */ - { PR_1_HTREE_DEPTH, - N_("@h %i has a tree depth (%N) which is too big\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Bad block has indirect block that conflicts with filesystem block */ - { PR_1_BB_FS_BLOCK, - N_("Bad @b @i has an indirect @b (%b) that conflicts with\n" - "@f metadata. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Resize inode failed */ - { PR_1_RESIZE_INODE_CREATE, - N_("Resize @i (re)creation failed: %m."), - PROMPT_ABORT, 0 }, - - /* invalid inode->i_extra_isize */ - { PR_1_EXTRA_ISIZE, - N_("@i %i has a extra size (%IS) which is @n\n"), - PROMPT_FIX, PR_PREEN_OK }, - - /* invalid ea entry->e_name_len */ - { PR_1_ATTR_NAME_LEN, - N_("@a in @i %i has a namelen (%N) which is @n\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_size */ - { PR_1_ATTR_VALUE_SIZE, - N_("@a in @i %i has a value size (%N) which is @n\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_offs */ - { PR_1_ATTR_VALUE_OFFSET, - N_("@a in @i %i has a value offset (%N) which is @n\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_block */ - { PR_1_ATTR_VALUE_BLOCK, - N_("@a in @i %i has a value @b (%N) which is @n (must be 0)\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_hash */ - { PR_1_ATTR_HASH, - N_("@a in @i %i has a hash (%N) which is @n (must be 0)\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Pass 1b errors */ - - /* Pass 1B: Rescan for duplicate/bad blocks */ - { PR_1B_PASS_HEADER, - N_("\nRunning additional passes to resolve @bs claimed by more than one @i...\n" - "Pass 1B: Rescanning for @m @bs\n"), - PROMPT_NONE, 0 }, - - /* Duplicate/bad block(s) header */ - { PR_1B_DUP_BLOCK_HEADER, - N_("@m @b(s) in @i %i:"), - PROMPT_NONE, 0 }, - - /* Duplicate/bad block(s) in inode */ - { PR_1B_DUP_BLOCK, - " %b", - PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR }, - - /* Duplicate/bad block(s) end */ - { PR_1B_DUP_BLOCK_END, - "\n", - PROMPT_NONE, PR_PREEN_NOHDR }, - - /* Error while scanning inodes */ - { PR_1B_ISCAN_ERROR, - N_("Error while scanning inodes (%i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating inode bitmap */ - { PR_1B_ALLOCATE_IBITMAP_ERROR, - N_("@A @i @B (@i_dup_map): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while iterating over blocks */ - { PR_1B_BLOCK_ITERATE, - N_("Error while iterating over @bs in @i %i (%s): %m\n"), - PROMPT_NONE, 0 }, - - /* Error adjusting EA refcount */ - { PR_1B_ADJ_EA_REFCOUNT, - N_("Error adjusting refcount for @a @b %b (@i %i): %m\n"), - PROMPT_NONE, 0 }, - - - /* Pass 1C: Scan directories for inodes with multiply-claimed blocks. */ - { PR_1C_PASS_HEADER, - N_("Pass 1C: Scanning directories for @is with @m @bs.\n"), - PROMPT_NONE, 0 }, - - - /* Pass 1D: Reconciling multiply-claimed blocks */ - { PR_1D_PASS_HEADER, - N_("Pass 1D: Reconciling @m @bs\n"), - PROMPT_NONE, 0 }, - - /* File has duplicate blocks */ - { PR_1D_DUP_FILE, - N_("File %Q (@i #%i, mod time %IM)\n" - " has %B @m @b(s), shared with %N file(s):\n"), - PROMPT_NONE, 0 }, - - /* List of files sharing duplicate blocks */ - { PR_1D_DUP_FILE_LIST, - N_("\t%Q (@i #%i, mod time %IM)\n"), - PROMPT_NONE, 0 }, - - /* File sharing blocks with filesystem metadata */ - { PR_1D_SHARE_METADATA, - N_("\t<@f metadata>\n"), - PROMPT_NONE, 0 }, - - /* Report of how many duplicate/bad inodes */ - { PR_1D_NUM_DUP_INODES, - N_("(There are %N @is containing @m @bs.)\n\n"), - PROMPT_NONE, 0 }, - - /* Duplicated blocks already reassigned or cloned. */ - { PR_1D_DUP_BLOCKS_DEALT, - N_("@m @bs already reassigned or cloned.\n\n"), - PROMPT_NONE, 0 }, - - /* Clone duplicate/bad blocks? */ - { PR_1D_CLONE_QUESTION, - "", PROMPT_CLONE, PR_NO_OK }, - - /* Delete file? */ - { PR_1D_DELETE_QUESTION, - "", PROMPT_DELETE, 0 }, - - /* Couldn't clone file (error) */ - { PR_1D_CLONE_ERROR, - N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 }, - - /* Pass 2 errors */ - - /* Pass 2: Checking directory structure */ - { PR_2_PASS_HEADER, - N_("Pass 2: Checking @d structure\n"), - PROMPT_NONE, 0 }, - - /* Bad inode number for '.' */ - { PR_2_BAD_INODE_DOT, - N_("@n @i number for '.' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* Directory entry has bad inode number */ - { PR_2_BAD_INO, - N_("@E has @n @i #: %Di.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry has deleted or unused inode */ - { PR_2_UNUSED_INODE, - N_("@E has @D/unused @i %Di. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Directry entry is link to '.' */ - { PR_2_LINK_DOT, - N_("@E @L to '.' "), - PROMPT_CLEAR, 0 }, - - /* Directory entry points to inode now located in a bad block */ - { PR_2_BB_INODE, - N_("@E points to @i (%Di) located in a bad @b.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry contains a link to a directory */ - { PR_2_LINK_DIR, - N_("@E @L to @d %P (%Di).\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry contains a link to the root directry */ - { PR_2_LINK_ROOT, - N_("@E @L to the @r.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry has illegal characters in its name */ - { PR_2_BAD_NAME, - N_("@E has illegal characters in its name.\n"), - PROMPT_FIX, 0 }, - - /* Missing '.' in directory inode */ - { PR_2_MISSING_DOT, - N_("Missing '.' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* Missing '..' in directory inode */ - { PR_2_MISSING_DOT_DOT, - N_("Missing '..' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* First entry in directory inode doesn't contain '.' */ - { PR_2_1ST_NOT_DOT, - N_("First @e '%Dn' (@i=%Di) in @d @i %i (%p) @s '.'\n"), - PROMPT_FIX, 0 }, - - /* Second entry in directory inode doesn't contain '..' */ - { PR_2_2ND_NOT_DOT_DOT, - N_("Second @e '%Dn' (@i=%Di) in @d @i %i @s '..'\n"), - PROMPT_FIX, 0 }, - - /* i_faddr should be zero */ - { PR_2_FADDR_ZERO, - N_("i_faddr @F %IF, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_file_acl should be zero */ - { PR_2_FILE_ACL_ZERO, - N_("i_file_acl @F %If, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_dir_acl should be zero */ - { PR_2_DIR_ACL_ZERO, - N_("i_dir_acl @F %Id, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_frag should be zero */ - { PR_2_FRAG_ZERO, - N_("i_frag @F %N, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_fsize should be zero */ - { PR_2_FSIZE_ZERO, - N_("i_fsize @F %N, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* inode has bad mode */ - { PR_2_BAD_MODE, - N_("@i %i (%Q) has @n mode (%Im).\n"), - PROMPT_CLEAR, 0 }, - - /* directory corrupted */ - { PR_2_DIR_CORRUPTED, - N_("@d @i %i, @b %B, offset %N: @d corrupted\n"), - PROMPT_SALVAGE, 0 }, - - /* filename too long */ - { PR_2_FILENAME_LONG, - N_("@d @i %i, @b %B, offset %N: filename too long\n"), - PROMPT_TRUNCATE, 0 }, - - /* Directory inode has a missing block (hole) */ - { PR_2_DIRECTORY_HOLE, - N_("@d @i %i has an unallocated @b #%B. "), - PROMPT_ALLOCATE, 0 }, - - /* '.' is not NULL terminated */ - { PR_2_DOT_NULL_TERM, - N_("'.' @d @e in @d @i %i is not NULL terminated\n"), - PROMPT_FIX, 0 }, - - /* '..' is not NULL terminated */ - { PR_2_DOT_DOT_NULL_TERM, - N_("'..' @d @e in @d @i %i is not NULL terminated\n"), - PROMPT_FIX, 0 }, - - /* Illegal character device inode */ - { PR_2_BAD_CHAR_DEV, - N_("@i %i (%Q) is an @I character @v.\n"), - PROMPT_CLEAR, 0 }, - - /* Illegal block device inode */ - { PR_2_BAD_BLOCK_DEV, - N_("@i %i (%Q) is an @I @b @v.\n"), - PROMPT_CLEAR, 0 }, - - /* Duplicate '.' entry */ - { PR_2_DUP_DOT, - N_("@E is duplicate '.' @e.\n"), - PROMPT_FIX, 0 }, - - /* Duplicate '..' entry */ - { PR_2_DUP_DOT_DOT, - N_("@E is duplicate '..' @e.\n"), - PROMPT_FIX, 0 }, - - /* Internal error: couldn't find dir_info */ - { PR_2_NO_DIRINFO, - N_("Internal error: cannot find dir_info for %i.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Final rec_len is wrong */ - { PR_2_FINAL_RECLEN, - N_("@E has rec_len of %Dr, @s %N.\n"), - PROMPT_FIX, 0 }, - - /* Error allocating icount structure */ - { PR_2_ALLOCATE_ICOUNT, - N_("@A icount structure: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error iterating over directory blocks */ - { PR_2_DBLIST_ITERATE, - N_("Error iterating over @d @bs: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error reading directory block */ - { PR_2_READ_DIRBLOCK, - N_("Error reading @d @b %b (@i %i): %m\n"), - PROMPT_CONTINUE, 0 }, - - /* Error writing directory block */ - { PR_2_WRITE_DIRBLOCK, - N_("Error writing @d @b %b (@i %i): %m\n"), - PROMPT_CONTINUE, 0 }, - - /* Error allocating new directory block */ - { PR_2_ALLOC_DIRBOCK, - N_("@A new @d @b for @i %i (%s): %m\n"), - PROMPT_NONE, 0 }, - - /* Error deallocating inode */ - { PR_2_DEALLOC_INODE, - N_("Error deallocating @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Directory entry for '.' is big. Split? */ - { PR_2_SPLIT_DOT, - N_("@d @e for '.' is big. "), - PROMPT_SPLIT, PR_NO_OK }, - - /* Illegal FIFO inode */ - { PR_2_BAD_FIFO, - N_("@i %i (%Q) is an @I FIFO.\n"), - PROMPT_CLEAR, 0 }, - - /* Illegal socket inode */ - { PR_2_BAD_SOCKET, - N_("@i %i (%Q) is an @I socket.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory filetype not set */ - { PR_2_SET_FILETYPE, - N_("Setting filetype for @E to %N.\n"), - PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG }, - - /* Directory filetype incorrect */ - { PR_2_BAD_FILETYPE, - N_("@E has an incorrect filetype (was %Dt, @s %N).\n"), - PROMPT_FIX, 0 }, - - /* Directory filetype set on filesystem */ - { PR_2_CLEAR_FILETYPE, - N_("@E has filetype set.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Directory filename is null */ - { PR_2_NULL_NAME, - N_("@E has a @z name.\n"), - PROMPT_CLEAR, 0 }, - - /* Invalid symlink */ - { PR_2_INVALID_SYMLINK, - N_("Symlink %Q (@i #%i) is @n.\n"), - PROMPT_CLEAR, 0 }, - - /* i_file_acl (extended attribute block) is bad */ - { PR_2_FILE_ACL_BAD, - N_("@a @b @F @n (%If).\n"), - PROMPT_CLEAR, 0 }, - - /* Filesystem contains large files, but has no such flag in sb */ - { PR_2_FEATURE_LARGE_FILES, - N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"), - PROMPT_FIX, 0 }, - - /* Node in HTREE directory not referenced */ - { PR_2_HTREE_NOTREF, - N_("@p @h %d: node (%B) not referenced\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory referenced twice */ - { PR_2_HTREE_DUPREF, - N_("@p @h %d: node (%B) referenced twice\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory has bad min hash */ - { PR_2_HTREE_MIN_HASH, - N_("@p @h %d: node (%B) has bad min hash\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory has bad max hash */ - { PR_2_HTREE_MAX_HASH, - N_("@p @h %d: node (%B) has bad max hash\n"), - PROMPT_NONE, 0 }, - - /* Clear invalid HTREE directory */ - { PR_2_HTREE_CLEAR, - N_("@n @h %d (%q). "), PROMPT_CLEAR, 0 }, - - /* Bad block in htree interior node */ - { PR_2_HTREE_BADBLK, - N_("@p @h %d (%q): bad @b number %b.\n"), - PROMPT_CLEAR_HTREE, 0 }, - - /* Error adjusting EA refcount */ - { PR_2_ADJ_EA_REFCOUNT, - N_("Error adjusting refcount for @a @b %b (@i %i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Invalid HTREE root node */ - { PR_2_HTREE_BAD_ROOT, - N_("@p @h %d: root node is @n\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid HTREE limit */ - { PR_2_HTREE_BAD_LIMIT, - N_("@p @h %d: node (%B) has @n limit (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid HTREE count */ - { PR_2_HTREE_BAD_COUNT, - N_("@p @h %d: node (%B) has @n count (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* HTREE interior node has out-of-order hashes in table */ - { PR_2_HTREE_HASH_ORDER, - N_("@p @h %d: node (%B) has an unordered hash table\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Node in HTREE directory has invalid depth */ - { PR_2_HTREE_BAD_DEPTH, - N_("@p @h %d: node (%B) has @n depth\n"), - PROMPT_NONE, 0 }, - - /* Duplicate directory entry found */ - { PR_2_DUPLICATE_DIRENT, - N_("Duplicate @E found. "), - PROMPT_CLEAR, 0 }, - - /* Non-unique filename found */ - { PR_2_NON_UNIQUE_FILE, /* xgettext: no-c-format */ - N_("@E has a non-unique filename.\nRename to %s"), - PROMPT_NULL, 0 }, - - /* Duplicate directory entry found */ - { PR_2_REPORT_DUP_DIRENT, - N_("Duplicate @e '%Dn' found.\n\tMarking %p (%i) to be rebuilt.\n\n"), - PROMPT_NONE, 0 }, - - /* Pass 3 errors */ - - /* Pass 3: Checking directory connectivity */ - { PR_3_PASS_HEADER, - N_("Pass 3: Checking @d connectivity\n"), - PROMPT_NONE, 0 }, - - /* Root inode not allocated */ - { PR_3_NO_ROOT_INODE, - N_("@r not allocated. "), - PROMPT_ALLOCATE, 0 }, - - /* No room in lost+found */ - { PR_3_EXPAND_LF_DIR, - N_("No room in @l @d. "), - PROMPT_EXPAND, 0 }, - - /* Unconnected directory inode */ - { PR_3_UNCONNECTED_DIR, - N_("Unconnected @d @i %i (%p)\n"), - PROMPT_CONNECT, 0 }, - - /* /lost+found not found */ - { PR_3_NO_LF_DIR, - N_("/@l not found. "), - PROMPT_CREATE, PR_PREEN_OK }, - - /* .. entry is incorrect */ - { PR_3_BAD_DOT_DOT, - N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"), - PROMPT_FIX, 0 }, - - /* Bad or non-existent /lost+found. Cannot reconnect */ - { PR_3_NO_LPF, - N_("Bad or non-existent /@l. Cannot reconnect.\n"), - PROMPT_NONE, 0 }, - - /* Could not expand /lost+found */ - { PR_3_CANT_EXPAND_LPF, - N_("Could not expand /@l: %m\n"), - PROMPT_NONE, 0 }, - - /* Could not reconnect inode */ - { PR_3_CANT_RECONNECT, - N_("Could not reconnect %i: %m\n"), - PROMPT_NONE, 0 }, - - /* Error while trying to find /lost+found */ - { PR_3_ERR_FIND_LPF, - N_("Error while trying to find /@l: %m\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_block while creating /lost+found */ - { PR_3_ERR_LPF_NEW_BLOCK, - N_("ext2fs_new_@b: %m while trying to create /@l @d\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_inode while creating /lost+found */ - { PR_3_ERR_LPF_NEW_INODE, - N_("ext2fs_new_@i: %m while trying to create /@l @d\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_dir_block while creating /lost+found */ - { PR_3_ERR_LPF_NEW_DIR_BLOCK, - N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"), - PROMPT_NONE, 0 }, - - /* Error while writing directory block for /lost+found */ - { PR_3_ERR_LPF_WRITE_BLOCK, - N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"), - PROMPT_NONE, 0 }, - - /* Error while adjusting inode count */ - { PR_3_ADJUST_INODE, - N_("Error while adjusting @i count on @i %i\n"), - PROMPT_NONE, 0 }, - - /* Couldn't fix parent directory -- error */ - { PR_3_FIX_PARENT_ERR, - N_("Couldn't fix parent of @i %i: %m\n\n"), - PROMPT_NONE, 0 }, - - /* Couldn't fix parent directory -- couldn't find it */ - { PR_3_FIX_PARENT_NOFIND, - N_("Couldn't fix parent of @i %i: Couldn't find parent @d @e\n\n"), - PROMPT_NONE, 0 }, - - /* Error allocating inode bitmap */ - { PR_3_ALLOCATE_IBITMAP_ERROR, - N_("@A @i @B (%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error creating root directory */ - { PR_3_CREATE_ROOT_ERROR, - N_("Error creating root @d (%s): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error creating lost and found directory */ - { PR_3_CREATE_LPF_ERROR, - N_("Error creating /@l @d (%s): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Root inode is not directory; aborting */ - { PR_3_ROOT_NOT_DIR_ABORT, - N_("@r is not a @d; aborting.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Cannot proceed without a root inode. */ - { PR_3_NO_ROOT_INODE_ABORT, - N_("can't proceed without a @r.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Internal error: couldn't find dir_info */ - { PR_3_NO_DIRINFO, - N_("Internal error: cannot find dir_info for %i.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Lost+found not a directory */ - { PR_3_LPF_NOTDIR, - N_("/@l is not a @d (ino=%i)\n"), - PROMPT_UNLINK, 0 }, - - /* Pass 3A Directory Optimization */ - - /* Pass 3A: Optimizing directories */ - { PR_3A_PASS_HEADER, - N_("Pass 3A: Optimizing directories\n"), - PROMPT_NONE, PR_PREEN_NOMSG }, - - /* Error iterating over directories */ - { PR_3A_OPTIMIZE_ITER, - N_("Failed to create dirs_to_hash iterator: %m"), - PROMPT_NONE, 0 }, - - /* Error rehash directory */ - { PR_3A_OPTIMIZE_DIR_ERR, - N_("Failed to optimize directory %q (%d): %m"), - PROMPT_NONE, 0 }, - - /* Rehashing dir header */ - { PR_3A_OPTIMIZE_DIR_HEADER, - N_("Optimizing directories: "), - PROMPT_NONE, PR_MSG_ONLY }, - - /* Rehashing directory %d */ - { PR_3A_OPTIMIZE_DIR, - " %d", - PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR}, - - /* Rehashing dir end */ - { PR_3A_OPTIMIZE_DIR_END, - "\n", - PROMPT_NONE, PR_PREEN_NOHDR }, - - /* Pass 4 errors */ - - /* Pass 4: Checking reference counts */ - { PR_4_PASS_HEADER, - N_("Pass 4: Checking reference counts\n"), - PROMPT_NONE, 0 }, - - /* Unattached zero-length inode */ - { PR_4_ZERO_LEN_INODE, - N_("@u @z @i %i. "), - PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK }, - - /* Unattached inode */ - { PR_4_UNATTACHED_INODE, - N_("@u @i %i\n"), - PROMPT_CONNECT, 0 }, - - /* Inode ref count wrong */ - { PR_4_BAD_REF_COUNT, - N_("@i %i ref count is %Il, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - { PR_4_INCONSISTENT_COUNT, - N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n" - "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n" - "@i_link_info[%i] is %N, @i.i_links_count is %Il. " - "They @s the same!\n"), - PROMPT_NONE, 0 }, - - /* Pass 5 errors */ - - /* Pass 5: Checking group summary information */ - { PR_5_PASS_HEADER, - N_("Pass 5: Checking @g summary information\n"), - PROMPT_NONE, 0 }, - - /* Padding at end of inode bitmap is not set. */ - { PR_5_INODE_BMAP_PADDING, - N_("Padding at end of @i @B is not set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Padding at end of block bitmap is not set. */ - { PR_5_BLOCK_BMAP_PADDING, - N_("Padding at end of @b @B is not set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Block bitmap differences header */ - { PR_5_BLOCK_BITMAP_HEADER, - N_("@b @B differences: "), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG}, - - /* Block not used, but marked in bitmap */ - { PR_5_BLOCK_UNUSED, - " -%b", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block used, but not marked used in bitmap */ - { PR_5_BLOCK_USED, - " +%b", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block bitmap differences end */ - { PR_5_BLOCK_BITMAP_END, - "\n", - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode bitmap differences header */ - { PR_5_INODE_BITMAP_HEADER, - N_("@i @B differences: "), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode not used, but marked in bitmap */ - { PR_5_INODE_UNUSED, - " -%i", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode used, but not marked used in bitmap */ - { PR_5_INODE_USED, - " +%i", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode bitmap differences end */ - { PR_5_INODE_BITMAP_END, - "\n", - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free inodes count for group wrong */ - { PR_5_FREE_INODE_COUNT_GROUP, - N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Directories count for group wrong */ - { PR_5_FREE_DIR_COUNT_GROUP, - N_("Directories count wrong for @g #%g (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free inodes count wrong */ - { PR_5_FREE_INODE_COUNT, - N_("Free @is count wrong (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free blocks count for group wrong */ - { PR_5_FREE_BLOCK_COUNT_GROUP, - N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free blocks count wrong */ - { PR_5_FREE_BLOCK_COUNT, - N_("Free @bs count wrong (%b, counted=%c).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Programming error: bitmap endpoints don't match */ - { PR_5_BMAP_ENDPOINTS, - N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't " - "match calculated @B endpoints (%i, %j)\n"), - PROMPT_NONE, PR_FATAL }, - - /* Internal error: fudging end of bitmap */ - { PR_5_FUDGE_BITMAP_ERROR, - N_("Internal error: fudging end of bitmap (%N)\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error copying in replacement inode bitmap */ - { PR_5_COPY_IBITMAP_ERROR, - N_("Error copying in replacement @i @B: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error copying in replacement block bitmap */ - { PR_5_COPY_BBITMAP_ERROR, - N_("Error copying in replacement @b @B: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Block range not used, but marked in bitmap */ - { PR_5_BLOCK_RANGE_UNUSED, - " -(%b--%c)", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block range used, but not marked used in bitmap */ - { PR_5_BLOCK_RANGE_USED, - " +(%b--%c)", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode range not used, but marked in bitmap */ - { PR_5_INODE_RANGE_UNUSED, - " -(%i--%j)", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode range used, but not marked used in bitmap */ - { PR_5_INODE_RANGE_USED, - " +(%i--%j)", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - { 0 } -}; - -/* - * This is the latch flags register. It allows several problems to be - * "latched" together. This means that the user has to answer but one - * question for the set of problems, and all of the associated - * problems will be either fixed or not fixed. - */ -static struct latch_descr pr_latch_info[] = { - { PR_LATCH_BLOCK, PR_1_INODE_BLOCK_LATCH, 0 }, - { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0 }, - { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END }, - { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END }, - { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0 }, - { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END }, - { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0 }, - { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0 }, - { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END }, - { -1, 0, 0 }, -}; - -static const struct e2fsck_problem *find_problem(problem_t code) -{ - int i; - - for (i=0; problem_table[i].e2p_code; i++) { - if (problem_table[i].e2p_code == code) - return &problem_table[i]; - } - return 0; -} - -static struct latch_descr *find_latch(int code) -{ - int i; - - for (i=0; pr_latch_info[i].latch_code >= 0; i++) { - if (pr_latch_info[i].latch_code == code) - return &pr_latch_info[i]; - } - return 0; -} - -int end_problem_latch(e2fsck_t ctx, int mask) -{ - struct latch_descr *ldesc; - struct problem_context pctx; - int answer = -1; - - ldesc = find_latch(mask); - if (ldesc->end_message && (ldesc->flags & PRL_LATCHED)) { - clear_problem_context(&pctx); - answer = fix_problem(ctx, ldesc->end_message, &pctx); - } - ldesc->flags &= ~(PRL_VARIABLE); - return answer; -} - -int set_latch_flags(int mask, int setflags, int clearflags) -{ - struct latch_descr *ldesc; - - ldesc = find_latch(mask); - if (!ldesc) - return -1; - ldesc->flags |= setflags; - ldesc->flags &= ~clearflags; - return 0; -} - -void clear_problem_context(struct problem_context *ctx) -{ - memset(ctx, 0, sizeof(struct problem_context)); - ctx->blkcount = -1; - ctx->group = -1; -} - -int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - const struct e2fsck_problem *ptr; - struct latch_descr *ldesc = NULL; - const char *message; - int def_yn, answer, ans; - int print_answer = 0; - int suppress = 0; - - ptr = find_problem(code); - if (!ptr) { - printf(_("Unhandled error code (0x%x)!\n"), code); - return 0; - } - def_yn = 1; - if ((ptr->flags & PR_NO_DEFAULT) || - ((ptr->flags & PR_PREEN_NO) && (ctx->options & E2F_OPT_PREEN)) || - (ctx->options & E2F_OPT_NO)) - def_yn= 0; - - /* - * Do special latch processing. This is where we ask the - * latch question, if it exists - */ - if (ptr->flags & PR_LATCH_MASK) { - ldesc = find_latch(ptr->flags & PR_LATCH_MASK); - if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) { - ans = fix_problem(ctx, ldesc->question, pctx); - if (ans == 1) - ldesc->flags |= PRL_YES; - if (ans == 0) - ldesc->flags |= PRL_NO; - ldesc->flags |= PRL_LATCHED; - } - if (ldesc->flags & PRL_SUPPRESS) - suppress++; - } - if ((ptr->flags & PR_PREEN_NOMSG) && - (ctx->options & E2F_OPT_PREEN)) - suppress++; - if ((ptr->flags & PR_NO_NOMSG) && - (ctx->options & E2F_OPT_NO)) - suppress++; - if (!suppress) { - message = ptr->e2p_description; - if ((ctx->options & E2F_OPT_PREEN) && - !(ptr->flags & PR_PREEN_NOHDR)) { - printf("%s: ", ctx->device_name ? - ctx->device_name : ctx->filesystem_name); - } - if (*message) - print_e2fsck_message(ctx, _(message), pctx, 1); - } - if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE)) - preenhalt(ctx); - - if (ptr->flags & PR_FATAL) - bb_error_msg_and_die(0); - - if (ptr->prompt == PROMPT_NONE) { - if (ptr->flags & PR_NOCOLLATE) - answer = -1; - else - answer = def_yn; - } else { - if (ctx->options & E2F_OPT_PREEN) { - answer = def_yn; - if (!(ptr->flags & PR_PREEN_NOMSG)) - print_answer = 1; - } else if ((ptr->flags & PR_LATCH_MASK) && - (ldesc->flags & (PRL_YES | PRL_NO))) { - if (!suppress) - print_answer = 1; - if (ldesc->flags & PRL_YES) - answer = 1; - else - answer = 0; - } else - answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn); - if (!answer && !(ptr->flags & PR_NO_OK)) - ext2fs_unmark_valid(fs); - - if (print_answer) - printf("%s.\n", answer ? - _(preen_msg[(int) ptr->prompt]) : _("IGNORED")); - } - - if ((ptr->prompt == PROMPT_ABORT) && answer) - bb_error_msg_and_die(0); - - if (ptr->flags & PR_AFTER_CODE) - answer = fix_problem(ctx, ptr->second_code, pctx); - - return answer; -} - -/* - * linux/fs/recovery.c - * - * Written by Stephen C. Tweedie <sct@redhat.com>, 1999 - */ - -/* - * Maintain information about the progress of the recovery job, so that - * the different passes can carry information between them. - */ -struct recovery_info -{ - tid_t start_transaction; - tid_t end_transaction; - - int nr_replays; - int nr_revokes; - int nr_revoke_hits; -}; - -enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY}; -static int do_one_pass(journal_t *journal, - struct recovery_info *info, enum passtype pass); -static int scan_revoke_records(journal_t *, struct buffer_head *, - tid_t, struct recovery_info *); - -/* - * Read a block from the journal - */ - -static int jread(struct buffer_head **bhp, journal_t *journal, - unsigned int offset) -{ - int err; - unsigned long blocknr; - struct buffer_head *bh; - - *bhp = NULL; - - err = journal_bmap(journal, offset, &blocknr); - - if (err) { - printf("JBD: bad block at offset %u\n", offset); - return err; - } - - bh = getblk(journal->j_dev, blocknr, journal->j_blocksize); - if (!bh) - return -ENOMEM; - - if (!buffer_uptodate(bh)) { - /* If this is a brand new buffer, start readahead. - Otherwise, we assume we are already reading it. */ - if (!buffer_req(bh)) - do_readahead(journal, offset); - wait_on_buffer(bh); - } - - if (!buffer_uptodate(bh)) { - printf("JBD: Failed to read block at offset %u\n", offset); - brelse(bh); - return -EIO; - } - - *bhp = bh; - return 0; -} - - -/* - * Count the number of in-use tags in a journal descriptor block. - */ - -static int count_tags(struct buffer_head *bh, int size) -{ - char * tagp; - journal_block_tag_t * tag; - int nr = 0; - - tagp = &bh->b_data[sizeof(journal_header_t)]; - - while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) { - tag = (journal_block_tag_t *) tagp; - - nr++; - tagp += sizeof(journal_block_tag_t); - if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID))) - tagp += 16; - - if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG)) - break; - } - - return nr; -} - - -/* Make sure we wrap around the log correctly! */ -#define wrap(journal, var) \ -do { \ - if (var >= (journal)->j_last) \ - var -= ((journal)->j_last - (journal)->j_first); \ -} while (0) - -/** - * int journal_recover(journal_t *journal) - recovers a on-disk journal - * @journal: the journal to recover - * - * The primary function for recovering the log contents when mounting a - * journaled device. - * - * Recovery is done in three passes. In the first pass, we look for the - * end of the log. In the second, we assemble the list of revoke - * blocks. In the third and final pass, we replay any un-revoked blocks - * in the log. - */ -int journal_recover(journal_t *journal) -{ - int err; - journal_superblock_t * sb; - - struct recovery_info info; - - memset(&info, 0, sizeof(info)); - sb = journal->j_superblock; - - /* - * The journal superblock's s_start field (the current log head) - * is always zero if, and only if, the journal was cleanly - * unmounted. - */ - - if (!sb->s_start) { - journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1; - return 0; - } - - err = do_one_pass(journal, &info, PASS_SCAN); - if (!err) - err = do_one_pass(journal, &info, PASS_REVOKE); - if (!err) - err = do_one_pass(journal, &info, PASS_REPLAY); - - /* Restart the log at the next transaction ID, thus invalidating - * any existing commit records in the log. */ - journal->j_transaction_sequence = ++info.end_transaction; - - journal_clear_revoke(journal); - sync_blockdev(journal->j_fs_dev); - return err; -} - -static int do_one_pass(journal_t *journal, - struct recovery_info *info, enum passtype pass) -{ - unsigned int first_commit_ID, next_commit_ID; - unsigned long next_log_block; - int err, success = 0; - journal_superblock_t * sb; - journal_header_t * tmp; - struct buffer_head * bh; - unsigned int sequence; - int blocktype; - - /* Precompute the maximum metadata descriptors in a descriptor block */ - int MAX_BLOCKS_PER_DESC; - MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t)) - / sizeof(journal_block_tag_t)); - - /* - * First thing is to establish what we expect to find in the log - * (in terms of transaction IDs), and where (in terms of log - * block offsets): query the superblock. - */ - - sb = journal->j_superblock; - next_commit_ID = ntohl(sb->s_sequence); - next_log_block = ntohl(sb->s_start); - - first_commit_ID = next_commit_ID; - if (pass == PASS_SCAN) - info->start_transaction = first_commit_ID; - - /* - * Now we walk through the log, transaction by transaction, - * making sure that each transaction has a commit block in the - * expected place. Each complete transaction gets replayed back - * into the main filesystem. - */ - - while (1) { - int flags; - char * tagp; - journal_block_tag_t * tag; - struct buffer_head * obh; - struct buffer_head * nbh; - - /* If we already know where to stop the log traversal, - * check right now that we haven't gone past the end of - * the log. */ - - if (pass != PASS_SCAN) - if (tid_geq(next_commit_ID, info->end_transaction)) - break; - - /* Skip over each chunk of the transaction looking - * either the next descriptor block or the final commit - * record. */ - - err = jread(&bh, journal, next_log_block); - if (err) - goto failed; - - next_log_block++; - wrap(journal, next_log_block); - - /* What kind of buffer is it? - * - * If it is a descriptor block, check that it has the - * expected sequence number. Otherwise, we're all done - * here. */ - - tmp = (journal_header_t *)bh->b_data; - - if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) { - brelse(bh); - break; - } - - blocktype = ntohl(tmp->h_blocktype); - sequence = ntohl(tmp->h_sequence); - - if (sequence != next_commit_ID) { - brelse(bh); - break; - } - - /* OK, we have a valid descriptor block which matches - * all of the sequence number checks. What are we going - * to do with it? That depends on the pass... */ - - switch (blocktype) { - case JFS_DESCRIPTOR_BLOCK: - /* If it is a valid descriptor block, replay it - * in pass REPLAY; otherwise, just skip over the - * blocks it describes. */ - if (pass != PASS_REPLAY) { - next_log_block += - count_tags(bh, journal->j_blocksize); - wrap(journal, next_log_block); - brelse(bh); - continue; - } - - /* A descriptor block: we can now write all of - * the data blocks. Yay, useful work is finally - * getting done here! */ - - tagp = &bh->b_data[sizeof(journal_header_t)]; - while ((tagp - bh->b_data +sizeof(journal_block_tag_t)) - <= journal->j_blocksize) { - unsigned long io_block; - - tag = (journal_block_tag_t *) tagp; - flags = ntohl(tag->t_flags); - - io_block = next_log_block++; - wrap(journal, next_log_block); - err = jread(&obh, journal, io_block); - if (err) { - /* Recover what we can, but - * report failure at the end. */ - success = err; - printf("JBD: IO error %d recovering " - "block %ld in log\n", - err, io_block); - } else { - unsigned long blocknr; - - blocknr = ntohl(tag->t_blocknr); - - /* If the block has been - * revoked, then we're all done - * here. */ - if (journal_test_revoke - (journal, blocknr, - next_commit_ID)) { - brelse(obh); - ++info->nr_revoke_hits; - goto skip_write; - } - - /* Find a buffer for the new - * data being restored */ - nbh = getblk(journal->j_fs_dev, - blocknr, - journal->j_blocksize); - if (nbh == NULL) { - printf("JBD: Out of memory " - "during recovery.\n"); - err = -ENOMEM; - brelse(bh); - brelse(obh); - goto failed; - } - - lock_buffer(nbh); - memcpy(nbh->b_data, obh->b_data, - journal->j_blocksize); - if (flags & JFS_FLAG_ESCAPE) { - *((unsigned int *)bh->b_data) = - htonl(JFS_MAGIC_NUMBER); - } - - mark_buffer_uptodate(nbh, 1); - mark_buffer_dirty(nbh); - ++info->nr_replays; - /* ll_rw_block(WRITE, 1, &nbh); */ - unlock_buffer(nbh); - brelse(obh); - brelse(nbh); - } - - skip_write: - tagp += sizeof(journal_block_tag_t); - if (!(flags & JFS_FLAG_SAME_UUID)) - tagp += 16; - - if (flags & JFS_FLAG_LAST_TAG) - break; - } - - brelse(bh); - continue; - - case JFS_COMMIT_BLOCK: - /* Found an expected commit block: not much to - * do other than move on to the next sequence - * number. */ - brelse(bh); - next_commit_ID++; - continue; - - case JFS_REVOKE_BLOCK: - /* If we aren't in the REVOKE pass, then we can - * just skip over this block. */ - if (pass != PASS_REVOKE) { - brelse(bh); - continue; - } - - err = scan_revoke_records(journal, bh, - next_commit_ID, info); - brelse(bh); - if (err) - goto failed; - continue; - - default: - goto done; - } - } - - done: - /* - * We broke out of the log scan loop: either we came to the - * known end of the log or we found an unexpected block in the - * log. If the latter happened, then we know that the "current" - * transaction marks the end of the valid log. - */ - - if (pass == PASS_SCAN) - info->end_transaction = next_commit_ID; - else { - /* It's really bad news if different passes end up at - * different places (but possible due to IO errors). */ - if (info->end_transaction != next_commit_ID) { - printf("JBD: recovery pass %d ended at " - "transaction %u, expected %u\n", - pass, next_commit_ID, info->end_transaction); - if (!success) - success = -EIO; - } - } - - return success; - - failed: - return err; -} - - -/* Scan a revoke record, marking all blocks mentioned as revoked. */ - -static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, - tid_t sequence, struct recovery_info *info) -{ - journal_revoke_header_t *header; - int offset, max; - - header = (journal_revoke_header_t *) bh->b_data; - offset = sizeof(journal_revoke_header_t); - max = ntohl(header->r_count); - - while (offset < max) { - unsigned long blocknr; - int err; - - blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset))); - offset += 4; - err = journal_set_revoke(journal, blocknr, sequence); - if (err) - return err; - ++info->nr_revokes; - } - return 0; -} - - -/* - * rehash.c --- rebuild hash tree directories - * - * This algorithm is designed for simplicity of implementation and to - * pack the directory as much as possible. It however requires twice - * as much memory as the size of the directory. The maximum size - * directory supported using a 4k blocksize is roughly a gigabyte, and - * so there may very well be problems with machines that don't have - * virtual memory, and obscenely large directories. - * - * An alternate algorithm which is much more disk intensive could be - * written, and probably will need to be written in the future. The - * design goals of such an algorithm are: (a) use (roughly) constant - * amounts of memory, no matter how large the directory, (b) the - * directory must be safe at all times, even if e2fsck is interrupted - * in the middle, (c) we must use minimal amounts of extra disk - * blocks. This pretty much requires an incremental approach, where - * we are reading from one part of the directory, and inserting into - * the front half. So the algorithm will have to keep track of a - * moving block boundary between the new tree and the old tree, and - * files will need to be moved from the old directory and inserted - * into the new tree. If the new directory requires space which isn't - * yet available, blocks from the beginning part of the old directory - * may need to be moved to the end of the directory to make room for - * the new tree: - * - * -------------------------------------------------------- - * | new tree | | old tree | - * -------------------------------------------------------- - * ^ ptr ^ptr - * tail new head old - * - * This is going to be a pain in the tuckus to implement, and will - * require a lot more disk accesses. So I'm going to skip it for now; - * it's only really going to be an issue for really, really big - * filesystems (when we reach the level of tens of millions of files - * in a single directory). It will probably be easier to simply - * require that e2fsck use VM first. - */ - -struct fill_dir_struct { - char *buf; - struct ext2_inode *inode; - int err; - e2fsck_t ctx; - struct hash_entry *harray; - int max_array, num_array; - int dir_size; - int compress; - ino_t parent; -}; - -struct hash_entry { - ext2_dirhash_t hash; - ext2_dirhash_t minor_hash; - struct ext2_dir_entry *dir; -}; - -struct out_dir { - int num; - int max; - char *buf; - ext2_dirhash_t *hashes; -}; - -static int fill_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct fill_dir_struct *fd = (struct fill_dir_struct *) priv_data; - struct hash_entry *new_array, *ent; - struct ext2_dir_entry *dirent; - char *dir; - unsigned int offset, dir_offset; - - if (blockcnt < 0) - return 0; - - offset = blockcnt * fs->blocksize; - if (offset + fs->blocksize > fd->inode->i_size) { - fd->err = EXT2_ET_DIR_CORRUPTED; - return BLOCK_ABORT; - } - dir = (fd->buf+offset); - if (HOLE_BLKADDR(*block_nr)) { - memset(dir, 0, fs->blocksize); - dirent = (struct ext2_dir_entry *) dir; - dirent->rec_len = fs->blocksize; - } else { - fd->err = ext2fs_read_dir_block(fs, *block_nr, dir); - if (fd->err) - return BLOCK_ABORT; - } - /* While the directory block is "hot", index it. */ - dir_offset = 0; - while (dir_offset < fs->blocksize) { - dirent = (struct ext2_dir_entry *) (dir + dir_offset); - if (((dir_offset + dirent->rec_len) > fs->blocksize) || - (dirent->rec_len < 8) || - ((dirent->rec_len % 4) != 0) || - (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { - fd->err = EXT2_ET_DIR_CORRUPTED; - return BLOCK_ABORT; - } - dir_offset += dirent->rec_len; - if (dirent->inode == 0) - continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 1) && - (dirent->name[0] == '.')) - continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 2) && - (dirent->name[0] == '.') && (dirent->name[1] == '.')) { - fd->parent = dirent->inode; - continue; - } - if (fd->num_array >= fd->max_array) { - new_array = xrealloc(fd->harray, - sizeof(struct hash_entry) * (fd->max_array+500)); - fd->harray = new_array; - fd->max_array += 500; - } - ent = fd->harray + fd->num_array++; - ent->dir = dirent; - fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF); - if (fd->compress) - ent->hash = ent->minor_hash = 0; - else { - fd->err = ext2fs_dirhash(fs->super->s_def_hash_version, - dirent->name, - dirent->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); - if (fd->err) - return BLOCK_ABORT; - } - } - - return 0; -} - -/* Used for sorting the hash entry */ -static int name_cmp(const void *a, const void *b) -{ - const struct hash_entry *he_a = (const struct hash_entry *) a; - const struct hash_entry *he_b = (const struct hash_entry *) b; - int ret; - int min_len; - - min_len = he_a->dir->name_len; - if (min_len > he_b->dir->name_len) - min_len = he_b->dir->name_len; - - ret = strncmp(he_a->dir->name, he_b->dir->name, min_len); - if (ret == 0) { - if (he_a->dir->name_len > he_b->dir->name_len) - ret = 1; - else if (he_a->dir->name_len < he_b->dir->name_len) - ret = -1; - else - ret = he_b->dir->inode - he_a->dir->inode; - } - return ret; -} - -/* Used for sorting the hash entry */ -static int hash_cmp(const void *a, const void *b) -{ - const struct hash_entry *he_a = (const struct hash_entry *) a; - const struct hash_entry *he_b = (const struct hash_entry *) b; - int ret; - - if (he_a->hash > he_b->hash) - ret = 1; - else if (he_a->hash < he_b->hash) - ret = -1; - else { - if (he_a->minor_hash > he_b->minor_hash) - ret = 1; - else if (he_a->minor_hash < he_b->minor_hash) - ret = -1; - else - ret = name_cmp(a, b); - } - return ret; -} - -static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir, - int blocks) -{ - void *new_mem; - - if (outdir->max) { - new_mem = xrealloc(outdir->buf, blocks * fs->blocksize); - outdir->buf = new_mem; - new_mem = xrealloc(outdir->hashes, - blocks * sizeof(ext2_dirhash_t)); - outdir->hashes = new_mem; - } else { - outdir->buf = xmalloc(blocks * fs->blocksize); - outdir->hashes = xmalloc(blocks * sizeof(ext2_dirhash_t)); - outdir->num = 0; - } - outdir->max = blocks; - return 0; -} - -static void free_out_dir(struct out_dir *outdir) -{ - free(outdir->buf); - free(outdir->hashes); - outdir->max = 0; - outdir->num =0; -} - -static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir, - char ** ret) -{ - errcode_t retval; - - if (outdir->num >= outdir->max) { - retval = alloc_size_dir(fs, outdir, outdir->max + 50); - if (retval) - return retval; - } - *ret = outdir->buf + (outdir->num++ * fs->blocksize); - memset(*ret, 0, fs->blocksize); - return 0; -} - -/* - * This function is used to make a unique filename. We do this by - * appending ~0, and then incrementing the number. However, we cannot - * expand the length of the filename beyond the padding available in - * the directory entry. - */ -static void mutate_name(char *str, __u16 *len) -{ - int i; - __u16 l = *len & 0xFF, h = *len & 0xff00; - - /* - * First check to see if it looks the name has been mutated - * already - */ - for (i = l-1; i > 0; i--) { - if (!isdigit(str[i])) - break; - } - if ((i == l-1) || (str[i] != '~')) { - if (((l-1) & 3) < 2) - l += 2; - else - l = (l+3) & ~3; - str[l-2] = '~'; - str[l-1] = '0'; - *len = l | h; - return; - } - for (i = l-1; i >= 0; i--) { - if (isdigit(str[i])) { - if (str[i] == '9') - str[i] = '0'; - else { - str[i]++; - return; - } - continue; - } - if (i == 1) { - if (str[0] == 'z') - str[0] = 'A'; - else if (str[0] == 'Z') { - str[0] = '~'; - str[1] = '0'; - } else - str[0]++; - } else if (i > 0) { - str[i] = '1'; - str[i-1] = '~'; - } else { - if (str[0] == '~') - str[0] = 'a'; - else - str[0]++; - } - break; - } -} - -static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, - ext2_ino_t ino, - struct fill_dir_struct *fd) -{ - struct problem_context pctx; - struct hash_entry *ent, *prev; - int i, j; - int fixed = 0; - char new_name[256]; - __u16 new_len; - - clear_problem_context(&pctx); - pctx.ino = ino; - - for (i=1; i < fd->num_array; i++) { - ent = fd->harray + i; - prev = ent - 1; - if (!ent->dir->inode || - ((ent->dir->name_len & 0xFF) != - (prev->dir->name_len & 0xFF)) || - (strncmp(ent->dir->name, prev->dir->name, - ent->dir->name_len & 0xFF))) - continue; - pctx.dirent = ent->dir; - if ((ent->dir->inode == prev->dir->inode) && - fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) { - e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1); - ent->dir->inode = 0; - fixed++; - continue; - } - memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF); - new_len = ent->dir->name_len; - mutate_name(new_name, &new_len); - for (j=0; j < fd->num_array; j++) { - if ((i==j) || - ((ent->dir->name_len & 0xFF) != - (fd->harray[j].dir->name_len & 0xFF)) || - (strncmp(new_name, fd->harray[j].dir->name, - new_len & 0xFF))) - continue; - mutate_name(new_name, &new_len); - - j = -1; - } - new_name[new_len & 0xFF] = 0; - pctx.str = new_name; - if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) { - memcpy(ent->dir->name, new_name, new_len & 0xFF); - ent->dir->name_len = new_len; - ext2fs_dirhash(fs->super->s_def_hash_version, - ent->dir->name, - ent->dir->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); - fixed++; - } - } - return fixed; -} - - -static errcode_t copy_dir_entries(ext2_filsys fs, - struct fill_dir_struct *fd, - struct out_dir *outdir) -{ - errcode_t retval; - char *block_start; - struct hash_entry *ent; - struct ext2_dir_entry *dirent; - int i, rec_len, left; - ext2_dirhash_t prev_hash; - int offset; - - outdir->max = 0; - retval = alloc_size_dir(fs, outdir, - (fd->dir_size / fs->blocksize) + 2); - if (retval) - return retval; - outdir->num = fd->compress ? 0 : 1; - offset = 0; - outdir->hashes[0] = 0; - prev_hash = 1; - if ((retval = get_next_block(fs, outdir, &block_start))) - return retval; - dirent = (struct ext2_dir_entry *) block_start; - left = fs->blocksize; - for (i=0; i < fd->num_array; i++) { - ent = fd->harray + i; - if (ent->dir->inode == 0) - continue; - rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF); - if (rec_len > left) { - if (left) - dirent->rec_len += left; - if ((retval = get_next_block(fs, outdir, - &block_start))) - return retval; - offset = 0; - } - left = fs->blocksize - offset; - dirent = (struct ext2_dir_entry *) (block_start + offset); - if (offset == 0) { - if (ent->hash == prev_hash) - outdir->hashes[outdir->num-1] = ent->hash | 1; - else - outdir->hashes[outdir->num-1] = ent->hash; - } - dirent->inode = ent->dir->inode; - dirent->name_len = ent->dir->name_len; - dirent->rec_len = rec_len; - memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF); - offset += rec_len; - left -= rec_len; - if (left < 12) { - dirent->rec_len += left; - offset += left; - left = 0; - } - prev_hash = ent->hash; - } - if (left) - dirent->rec_len += left; - - return 0; -} - - -static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, - ext2_ino_t ino, ext2_ino_t parent) -{ - struct ext2_dir_entry *dir; - struct ext2_dx_root_info *root; - struct ext2_dx_countlimit *limits; - int filetype = 0; - - if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE) - filetype = EXT2_FT_DIR << 8; - - memset(buf, 0, fs->blocksize); - dir = (struct ext2_dir_entry *) buf; - dir->inode = ino; - dir->name[0] = '.'; - dir->name_len = 1 | filetype; - dir->rec_len = 12; - dir = (struct ext2_dir_entry *) (buf + 12); - dir->inode = parent; - dir->name[0] = '.'; - dir->name[1] = '.'; - dir->name_len = 2 | filetype; - dir->rec_len = fs->blocksize - 12; - - root = (struct ext2_dx_root_info *) (buf+24); - root->reserved_zero = 0; - root->hash_version = fs->super->s_def_hash_version; - root->info_length = 8; - root->indirect_levels = 0; - root->unused_flags = 0; - - limits = (struct ext2_dx_countlimit *) (buf+32); - limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry); - limits->count = 0; - - return root; -} - - -static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf) -{ - struct ext2_dir_entry *dir; - struct ext2_dx_countlimit *limits; - - memset(buf, 0, fs->blocksize); - dir = (struct ext2_dir_entry *) buf; - dir->inode = 0; - dir->rec_len = fs->blocksize; - - limits = (struct ext2_dx_countlimit *) (buf+8); - limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry); - limits->count = 0; - - return (struct ext2_dx_entry *) limits; -} - -/* - * This function takes the leaf nodes which have been written in - * outdir, and populates the root node and any necessary interior nodes. - */ -static errcode_t calculate_tree(ext2_filsys fs, - struct out_dir *outdir, - ext2_ino_t ino, - ext2_ino_t parent) -{ - struct ext2_dx_root_info *root_info; - struct ext2_dx_entry *root, *dx_ent = NULL; - struct ext2_dx_countlimit *root_limit, *limit; - errcode_t retval; - char * block_start; - int i, c1, c2, nblks; - int limit_offset, root_offset; - - root_info = set_root_node(fs, outdir->buf, ino, parent); - root_offset = limit_offset = ((char *) root_info - outdir->buf) + - root_info->info_length; - root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); - c1 = root_limit->limit; - nblks = outdir->num; - - /* Write out the pointer blocks */ - if (nblks-1 <= c1) { - /* Just write out the root block, and we're done */ - root = (struct ext2_dx_entry *) (outdir->buf + root_offset); - for (i=1; i < nblks; i++) { - root->block = ext2fs_cpu_to_le32(i); - if (i != 1) - root->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - root++; - c1--; - } - } else { - c2 = 0; - limit = 0; - root_info->indirect_levels = 1; - for (i=1; i < nblks; i++) { - if (c1 == 0) - return ENOSPC; - if (c2 == 0) { - if (limit) - limit->limit = limit->count = - ext2fs_cpu_to_le16(limit->limit); - root = (struct ext2_dx_entry *) - (outdir->buf + root_offset); - root->block = ext2fs_cpu_to_le32(outdir->num); - if (i != 1) - root->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - if ((retval = get_next_block(fs, outdir, - &block_start))) - return retval; - dx_ent = set_int_node(fs, block_start); - limit = (struct ext2_dx_countlimit *) dx_ent; - c2 = limit->limit; - root_offset += sizeof(struct ext2_dx_entry); - c1--; - } - dx_ent->block = ext2fs_cpu_to_le32(i); - if (c2 != limit->limit) - dx_ent->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - dx_ent++; - c2--; - } - limit->count = ext2fs_cpu_to_le16(limit->limit - c2); - limit->limit = ext2fs_cpu_to_le16(limit->limit); - } - root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); - root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1); - root_limit->limit = ext2fs_cpu_to_le16(root_limit->limit); - - return 0; -} - -struct write_dir_struct { - struct out_dir *outdir; - errcode_t err; - e2fsck_t ctx; - int cleared; -}; - -/* - * Helper function which writes out a directory block. - */ -static int write_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct write_dir_struct *wd = (struct write_dir_struct *) priv_data; - blk_t blk; - char *dir; - - if (*block_nr == 0) - return 0; - if (blockcnt >= wd->outdir->num) { - e2fsck_read_bitmaps(wd->ctx); - blk = *block_nr; - ext2fs_unmark_block_bitmap(wd->ctx->block_found_map, blk); - ext2fs_block_alloc_stats(fs, blk, -1); - *block_nr = 0; - wd->cleared++; - return BLOCK_CHANGED; - } - if (blockcnt < 0) - return 0; - - dir = wd->outdir->buf + (blockcnt * fs->blocksize); - wd->err = ext2fs_write_dir_block(fs, *block_nr, dir); - if (wd->err) - return BLOCK_ABORT; - return 0; -} - -static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs, - struct out_dir *outdir, - ext2_ino_t ino, int compress) -{ - struct write_dir_struct wd; - errcode_t retval; - struct ext2_inode inode; - - retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num); - if (retval) - return retval; - - wd.outdir = outdir; - wd.err = 0; - wd.ctx = ctx; - wd.cleared = 0; - - retval = ext2fs_block_iterate2(fs, ino, 0, 0, - write_dir_block, &wd); - if (retval) - return retval; - if (wd.err) - return wd.err; - - e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); - if (compress) - inode.i_flags &= ~EXT2_INDEX_FL; - else - inode.i_flags |= EXT2_INDEX_FL; - inode.i_size = outdir->num * fs->blocksize; - inode.i_blocks -= (fs->blocksize / 512) * wd.cleared; - e2fsck_write_inode(ctx, ino, &inode, "rehash_dir"); - - return 0; -} - -static errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct ext2_inode inode; - char *dir_buf = NULL; - struct fill_dir_struct fd; - struct out_dir outdir; - - outdir.max = outdir.num = 0; - outdir.buf = 0; - outdir.hashes = 0; - e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); - - retval = ENOMEM; - fd.harray = 0; - dir_buf = xmalloc(inode.i_size); - - fd.max_array = inode.i_size / 32; - fd.num_array = 0; - fd.harray = xmalloc(fd.max_array * sizeof(struct hash_entry)); - - fd.ctx = ctx; - fd.buf = dir_buf; - fd.inode = &inode; - fd.err = 0; - fd.dir_size = 0; - fd.compress = 0; - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) || - (inode.i_size / fs->blocksize) < 2) - fd.compress = 1; - fd.parent = 0; - - /* Read in the entire directory into memory */ - retval = ext2fs_block_iterate2(fs, ino, 0, 0, - fill_dir_block, &fd); - if (fd.err) { - retval = fd.err; - goto errout; - } - - /* Sort the list */ -resort: - if (fd.compress) - qsort(fd.harray+2, fd.num_array-2, - sizeof(struct hash_entry), name_cmp); - else - qsort(fd.harray, fd.num_array, - sizeof(struct hash_entry), hash_cmp); - - /* - * Look for duplicates - */ - if (duplicate_search_and_fix(ctx, fs, ino, &fd)) - goto resort; - - if (ctx->options & E2F_OPT_NO) { - retval = 0; - goto errout; - } - - /* - * Copy the directory entries. In a htree directory these - * will become the leaf nodes. - */ - retval = copy_dir_entries(fs, &fd, &outdir); - if (retval) - goto errout; - - free(dir_buf); dir_buf = 0; - - if (!fd.compress) { - /* Calculate the interior nodes */ - retval = calculate_tree(fs, &outdir, ino, fd.parent); - if (retval) - goto errout; - } - - retval = write_directory(ctx, fs, &outdir, ino, fd.compress); - -errout: - free(dir_buf); - free(fd.harray); - - free_out_dir(&outdir); - return retval; -} - -void e2fsck_rehash_directories(e2fsck_t ctx) -{ - struct problem_context pctx; - struct dir_info *dir; - ext2_u32_iterate iter; - ext2_ino_t ino; - errcode_t retval; - int i, cur, max, all_dirs, dir_index, first = 1; - - all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS; - - if (!ctx->dirs_to_hash && !all_dirs) - return; - - e2fsck_get_lost_and_found(ctx, 0); - - clear_problem_context(&pctx); - - dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX; - cur = 0; - if (all_dirs) { - i = 0; - max = e2fsck_get_num_dirinfo(ctx); - } else { - retval = ext2fs_u32_list_iterate_begin(ctx->dirs_to_hash, - &iter); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3A_OPTIMIZE_ITER, &pctx); - return; - } - max = ext2fs_u32_list_count(ctx->dirs_to_hash); - } - while (1) { - if (all_dirs) { - if ((dir = e2fsck_dir_info_iter(ctx, &i)) == 0) - break; - ino = dir->ino; - } else { - if (!ext2fs_u32_list_iterate(iter, &ino)) - break; - } - if (ino == ctx->lost_and_found) - continue; - pctx.dir = ino; - if (first) { - fix_problem(ctx, PR_3A_PASS_HEADER, &pctx); - first = 0; - } - pctx.errcode = e2fsck_rehash_dir(ctx, ino); - if (pctx.errcode) { - end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); - fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx); - } - if (ctx->progress && !ctx->progress_fd) - e2fsck_simple_progress(ctx, "Rebuilding directory", - 100.0 * (float) (++cur) / (float) max, ino); - } - end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); - if (!all_dirs) - ext2fs_u32_list_iterate_end(iter); - - ext2fs_u32_list_free(ctx->dirs_to_hash); - ctx->dirs_to_hash = 0; -} - -/* - * linux/fs/revoke.c - * - * Journal revoke routines for the generic filesystem journaling code; - * part of the ext2fs journaling system. - * - * Revoke is the mechanism used to prevent old log records for deleted - * metadata from being replayed on top of newer data using the same - * blocks. The revoke mechanism is used in two separate places: - * - * + Commit: during commit we write the entire list of the current - * transaction's revoked blocks to the journal - * - * + Recovery: during recovery we record the transaction ID of all - * revoked blocks. If there are multiple revoke records in the log - * for a single block, only the last one counts, and if there is a log - * entry for a block beyond the last revoke, then that log entry still - * gets replayed. - * - * We can get interactions between revokes and new log data within a - * single transaction: - * - * Block is revoked and then journaled: - * The desired end result is the journaling of the new block, so we - * cancel the revoke before the transaction commits. - * - * Block is journaled and then revoked: - * The revoke must take precedence over the write of the block, so we - * need either to cancel the journal entry or to write the revoke - * later in the log than the log block. In this case, we choose the - * latter: journaling a block cancels any revoke record for that block - * in the current transaction, so any revoke for that block in the - * transaction must have happened after the block was journaled and so - * the revoke must take precedence. - * - * Block is revoked and then written as data: - * The data write is allowed to succeed, but the revoke is _not_ - * cancelled. We still need to prevent old log records from - * overwriting the new data. We don't even need to clear the revoke - * bit here. - * - * Revoke information on buffers is a tri-state value: - * - * RevokeValid clear: no cached revoke status, need to look it up - * RevokeValid set, Revoked clear: - * buffer has not been revoked, and cancel_revoke - * need do nothing. - * RevokeValid set, Revoked set: - * buffer has been revoked. - */ - -static kmem_cache_t *revoke_record_cache; -static kmem_cache_t *revoke_table_cache; - -/* Each revoke record represents one single revoked block. During - journal replay, this involves recording the transaction ID of the - last transaction to revoke this block. */ - -struct jbd_revoke_record_s -{ - struct list_head hash; - tid_t sequence; /* Used for recovery only */ - unsigned long blocknr; -}; - - -/* The revoke table is just a simple hash table of revoke records. */ -struct jbd_revoke_table_s -{ - /* It is conceivable that we might want a larger hash table - * for recovery. Must be a power of two. */ - int hash_size; - int hash_shift; - struct list_head *hash_table; -}; - - -/* Utility functions to maintain the revoke table */ - -/* Borrowed from buffer.c: this is a tried and tested block hash function */ -static int hash(journal_t *journal, unsigned long block) -{ - struct jbd_revoke_table_s *table = journal->j_revoke; - int hash_shift = table->hash_shift; - - return ((block << (hash_shift - 6)) ^ - (block >> 13) ^ - (block << (hash_shift - 12))) & (table->hash_size - 1); -} - -static int insert_revoke_hash(journal_t *journal, unsigned long blocknr, - tid_t seq) -{ - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - - record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS); - if (!record) - goto oom; - - record->sequence = seq; - record->blocknr = blocknr; - hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; - list_add(&record->hash, hash_list); - return 0; - -oom: - return -ENOMEM; -} - -/* Find a revoke record in the journal's hash table. */ - -static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal, - unsigned long blocknr) -{ - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - - hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; - - record = (struct jbd_revoke_record_s *) hash_list->next; - while (&(record->hash) != hash_list) { - if (record->blocknr == blocknr) - return record; - record = (struct jbd_revoke_record_s *) record->hash.next; - } - return NULL; -} - -int journal_init_revoke_caches(void) -{ - revoke_record_cache = do_cache_create(sizeof(struct jbd_revoke_record_s)); - if (revoke_record_cache == 0) - return -ENOMEM; - - revoke_table_cache = do_cache_create(sizeof(struct jbd_revoke_table_s)); - if (revoke_table_cache == 0) { - do_cache_destroy(revoke_record_cache); - revoke_record_cache = NULL; - return -ENOMEM; - } - return 0; -} - -void journal_destroy_revoke_caches(void) -{ - do_cache_destroy(revoke_record_cache); - revoke_record_cache = 0; - do_cache_destroy(revoke_table_cache); - revoke_table_cache = 0; -} - -/* Initialise the revoke table for a given journal to a given size. */ - -int journal_init_revoke(journal_t *journal, int hash_size) -{ - int shift, tmp; - - journal->j_revoke = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL); - if (!journal->j_revoke) - return -ENOMEM; - - /* Check that the hash_size is a power of two */ - journal->j_revoke->hash_size = hash_size; - - shift = 0; - tmp = hash_size; - while ((tmp >>= 1UL) != 0UL) - shift++; - journal->j_revoke->hash_shift = shift; - - journal->j_revoke->hash_table = xmalloc(hash_size * sizeof(struct list_head)); - - for (tmp = 0; tmp < hash_size; tmp++) - INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]); - - return 0; -} - -/* Destoy a journal's revoke table. The table must already be empty! */ - -void journal_destroy_revoke(journal_t *journal) -{ - struct jbd_revoke_table_s *table; - struct list_head *hash_list; - int i; - - table = journal->j_revoke; - if (!table) - return; - - for (i=0; i<table->hash_size; i++) { - hash_list = &table->hash_table[i]; - } - - free(table->hash_table); - free(table); - journal->j_revoke = NULL; -} - -/* - * Revoke support for recovery. - * - * Recovery needs to be able to: - * - * record all revoke records, including the tid of the latest instance - * of each revoke in the journal - * - * check whether a given block in a given transaction should be replayed - * (ie. has not been revoked by a revoke record in that or a subsequent - * transaction) - * - * empty the revoke table after recovery. - */ - -/* - * First, setting revoke records. We create a new revoke record for - * every block ever revoked in the log as we scan it for recovery, and - * we update the existing records if we find multiple revokes for a - * single block. - */ - -int journal_set_revoke(journal_t *journal, unsigned long blocknr, - tid_t sequence) -{ - struct jbd_revoke_record_s *record; - - record = find_revoke_record(journal, blocknr); - if (record) { - /* If we have multiple occurences, only record the - * latest sequence number in the hashed record */ - if (tid_gt(sequence, record->sequence)) - record->sequence = sequence; - return 0; - } - return insert_revoke_hash(journal, blocknr, sequence); -} - -/* - * Test revoke records. For a given block referenced in the log, has - * that block been revoked? A revoke record with a given transaction - * sequence number revokes all blocks in that transaction and earlier - * ones, but later transactions still need replayed. - */ - -int journal_test_revoke(journal_t *journal, unsigned long blocknr, - tid_t sequence) -{ - struct jbd_revoke_record_s *record; - - record = find_revoke_record(journal, blocknr); - if (!record) - return 0; - if (tid_gt(sequence, record->sequence)) - return 0; - return 1; -} - -/* - * Finally, once recovery is over, we need to clear the revoke table so - * that it can be reused by the running filesystem. - */ - -void journal_clear_revoke(journal_t *journal) -{ - int i; - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - struct jbd_revoke_table_s *revoke_var; - - revoke_var = journal->j_revoke; - - for (i = 0; i < revoke_var->hash_size; i++) { - hash_list = &revoke_var->hash_table[i]; - while (!list_empty(hash_list)) { - record = (struct jbd_revoke_record_s*) hash_list->next; - list_del(&record->hash); - free(record); - } - } -} - -/* - * e2fsck.c - superblock checks - */ - -#define MIN_CHECK 1 -#define MAX_CHECK 2 - -static void check_super_value(e2fsck_t ctx, const char *descr, - unsigned long value, int flags, - unsigned long min_val, unsigned long max_val) -{ - struct problem_context pctx; - - if (((flags & MIN_CHECK) && (value < min_val)) || - ((flags & MAX_CHECK) && (value > max_val))) { - clear_problem_context(&pctx); - pctx.num = value; - pctx.str = descr; - fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ - } -} - -/* - * This routine may get stubbed out in special compilations of the - * e2fsck code.. - */ -#ifndef EXT2_SPECIAL_DEVICE_SIZE -static errcode_t e2fsck_get_device_size(e2fsck_t ctx) -{ - return (ext2fs_get_device_size(ctx->filesystem_name, - EXT2_BLOCK_SIZE(ctx->fs->super), - &ctx->num_blocks)); -} -#endif - -/* - * helper function to release an inode - */ -struct process_block_struct { - e2fsck_t ctx; - char *buf; - struct problem_context *pctx; - int truncating; - int truncate_offset; - e2_blkcnt_t truncate_block; - int truncated_blocks; - int abort; - errcode_t errcode; -}; - -static int release_inode_block(ext2_filsys fs, blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_blk FSCK_ATTR((unused)), - int ref_offset FSCK_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *pb; - e2fsck_t ctx; - struct problem_context *pctx; - blk_t blk = *block_nr; - int retval = 0; - - pb = (struct process_block_struct *) priv_data; - ctx = pb->ctx; - pctx = pb->pctx; - - pctx->blk = blk; - pctx->blkcount = blockcnt; - - if (HOLE_BLKADDR(blk)) - return 0; - - if ((blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx); - return_abort: - pb->abort = 1; - return BLOCK_ABORT; - } - - if (!ext2fs_test_block_bitmap(fs->block_map, blk)) { - fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx); - goto return_abort; - } - - /* - * If we are deleting an orphan, then we leave the fields alone. - * If we are truncating an orphan, then update the inode fields - * and clean up any partial block data. - */ - if (pb->truncating) { - /* - * We only remove indirect blocks if they are - * completely empty. - */ - if (blockcnt < 0) { - int i, limit; - blk_t *bp; - - pb->errcode = io_channel_read_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - - limit = fs->blocksize >> 2; - for (i = 0, bp = (blk_t *) pb->buf; - i < limit; i++, bp++) - if (*bp) - return 0; - } - /* - * We don't remove direct blocks until we've reached - * the truncation block. - */ - if (blockcnt >= 0 && blockcnt < pb->truncate_block) - return 0; - /* - * If part of the last block needs truncating, we do - * it here. - */ - if ((blockcnt == pb->truncate_block) && pb->truncate_offset) { - pb->errcode = io_channel_read_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - memset(pb->buf + pb->truncate_offset, 0, - fs->blocksize - pb->truncate_offset); - pb->errcode = io_channel_write_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - } - pb->truncated_blocks++; - *block_nr = 0; - retval |= BLOCK_CHANGED; - } - - ext2fs_block_alloc_stats(fs, blk, -1); - return retval; -} - -/* - * This function releases an inode. Returns 1 if an inconsistency was - * found. If the inode has a link count, then it is being truncated and - * not deleted. - */ -static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, - struct ext2_inode *inode, char *block_buf, - struct problem_context *pctx) -{ - struct process_block_struct pb; - ext2_filsys fs = ctx->fs; - errcode_t retval; - __u32 count; - - if (!ext2fs_inode_has_valid_blocks(inode)) - return 0; - - pb.buf = block_buf + 3 * ctx->fs->blocksize; - pb.ctx = ctx; - pb.abort = 0; - pb.errcode = 0; - pb.pctx = pctx; - if (inode->i_links_count) { - pb.truncating = 1; - pb.truncate_block = (e2_blkcnt_t) - ((((long long)inode->i_size_high << 32) + - inode->i_size + fs->blocksize - 1) / - fs->blocksize); - pb.truncate_offset = inode->i_size % fs->blocksize; - } else { - pb.truncating = 0; - pb.truncate_block = 0; - pb.truncate_offset = 0; - } - pb.truncated_blocks = 0; - retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE, - block_buf, release_inode_block, &pb); - if (retval) { - bb_error_msg(_("while calling ext2fs_block_iterate for inode %d"), - ino); - return 1; - } - if (pb.abort) - return 1; - - /* Refresh the inode since ext2fs_block_iterate may have changed it */ - e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks"); - - if (pb.truncated_blocks) - inode->i_blocks -= pb.truncated_blocks * - (fs->blocksize / 512); - - if (inode->i_file_acl) { - retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl, - block_buf, -1, &count); - if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) { - retval = 0; - count = 1; - } - if (retval) { - bb_error_msg(_("while calling ext2fs_adjust_ea_refcount for inode %d"), - ino); - return 1; - } - if (count == 0) - ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1); - inode->i_file_acl = 0; - } - return 0; -} - -/* - * This function releases all of the orphan inodes. It returns 1 if - * it hit some error, and 0 on success. - */ -static int release_orphan_inodes(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino, next_ino; - struct ext2_inode inode; - struct problem_context pctx; - char *block_buf; - - if ((ino = fs->super->s_last_orphan) == 0) - return 0; - - /* - * Win or lose, we won't be using the head of the orphan inode - * list again. - */ - fs->super->s_last_orphan = 0; - ext2fs_mark_super_dirty(fs); - - /* - * If the filesystem contains errors, don't run the orphan - * list, since the orphan list can't be trusted; and we're - * going to be running a full e2fsck run anyway... - */ - if (fs->super->s_state & EXT2_ERROR_FS) - return 0; - - if ((ino < EXT2_FIRST_INODE(fs->super)) || - (ino > fs->super->s_inodes_count)) { - clear_problem_context(&pctx); - pctx.ino = ino; - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx); - return 1; - } - - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, - "block iterate buffer"); - e2fsck_read_bitmaps(ctx); - - while (ino) { - e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes"); - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.inode = &inode; - pctx.str = inode.i_links_count ? _("Truncating") : - _("Clearing"); - - fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx); - - next_ino = inode.i_dtime; - if (next_ino && - ((next_ino < EXT2_FIRST_INODE(fs->super)) || - (next_ino > fs->super->s_inodes_count))) { - pctx.ino = next_ino; - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx); - goto return_abort; - } - - if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx)) - goto return_abort; - - if (!inode.i_links_count) { - ext2fs_inode_alloc_stats2(fs, ino, -1, - LINUX_S_ISDIR(inode.i_mode)); - inode.i_dtime = time(NULL); - } else { - inode.i_dtime = 0; - } - e2fsck_write_inode(ctx, ino, &inode, "delete_file"); - ino = next_ino; - } - ext2fs_free_mem(&block_buf); - return 0; - return_abort: - ext2fs_free_mem(&block_buf); - return 1; -} - -/* - * Check the resize inode to make sure it is sane. We check both for - * the case where on-line resizing is not enabled (in which case the - * resize inode should be cleared) as well as the case where on-line - * resizing is enabled. - */ -static void check_resize_inode(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - int i, j, gdt_off, ind_off; - blk_t blk, pblk, expect; - __u32 *dind_buf = NULL, *ind_buf; - errcode_t retval; - - clear_problem_context(&pctx); - - /* - * If the resize inode feature isn't set, then - * s_reserved_gdt_blocks must be zero. - */ - if (!(fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INO)) { - if (fs->super->s_reserved_gdt_blocks) { - pctx.num = fs->super->s_reserved_gdt_blocks; - if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS, - &pctx)) { - fs->super->s_reserved_gdt_blocks = 0; - ext2fs_mark_super_dirty(fs); - } - } - } - - /* Read the resize inode */ - pctx.ino = EXT2_RESIZE_INO; - retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); - if (retval) { - if (fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INO) - ctx->flags |= E2F_FLAG_RESIZE_INODE; - return; - } - - /* - * If the resize inode feature isn't set, check to make sure - * the resize inode is cleared; then we're done. - */ - if (!(fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INO)) { - for (i=0; i < EXT2_N_BLOCKS; i++) { - if (inode.i_block[i]) - break; - } - if ((i < EXT2_N_BLOCKS) && - fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) { - memset(&inode, 0, sizeof(inode)); - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, - "clear_resize"); - } - return; - } - - /* - * The resize inode feature is enabled; check to make sure the - * only block in use is the double indirect block - */ - blk = inode.i_block[EXT2_DIND_BLOCK]; - for (i=0; i < EXT2_N_BLOCKS; i++) { - if (i != EXT2_DIND_BLOCK && inode.i_block[i]) - break; - } - if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count || - !(inode.i_mode & LINUX_S_IFREG) || - (blk < fs->super->s_first_data_block || - blk >= fs->super->s_blocks_count)) { - resize_inode_invalid: - if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) { - memset(&inode, 0, sizeof(inode)); - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, - "clear_resize"); - ctx->flags |= E2F_FLAG_RESIZE_INODE; - } - if (!(ctx->options & E2F_OPT_READONLY)) { - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - goto cleanup; - } - dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2, - "resize dind buffer"); - ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize); - - retval = ext2fs_read_ind_block(fs, blk, dind_buf); - if (retval) - goto resize_inode_invalid; - - gdt_off = fs->desc_blocks; - pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks; - for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4; - i++, gdt_off++, pblk++) { - gdt_off %= fs->blocksize/4; - if (dind_buf[gdt_off] != pblk) - goto resize_inode_invalid; - retval = ext2fs_read_ind_block(fs, pblk, ind_buf); - if (retval) - goto resize_inode_invalid; - ind_off = 0; - for (j = 1; j < fs->group_desc_count; j++) { - if (!ext2fs_bg_has_super(fs, j)) - continue; - expect = pblk + (j * fs->super->s_blocks_per_group); - if (ind_buf[ind_off] != expect) - goto resize_inode_invalid; - ind_off++; - } - } - - cleanup: - ext2fs_free_mem(&dind_buf); -} - -static void check_super_block(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t first_block, last_block; - struct ext2_super_block *sb = fs->super; - struct ext2_group_desc *gd; - blk_t blocks_per_group = fs->super->s_blocks_per_group; - blk_t bpg_max; - int inodes_per_block; - int ipg_max; - int inode_size; - dgrp_t i; - blk_t should_be; - struct problem_context pctx; - __u32 free_blocks = 0, free_inodes = 0; - - inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super); - ipg_max = inodes_per_block * (blocks_per_group - 4); - if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb)) - ipg_max = EXT2_MAX_INODES_PER_GROUP(sb); - bpg_max = 8 * EXT2_BLOCK_SIZE(sb); - if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb)) - bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb); - - ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap"); - ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_block_bitmap"); - ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_inode_table"); - - clear_problem_context(&pctx); - - /* - * Verify the super block constants... - */ - check_super_value(ctx, "inodes_count", sb->s_inodes_count, - MIN_CHECK, 1, 0); - check_super_value(ctx, "blocks_count", sb->s_blocks_count, - MIN_CHECK, 1, 0); - check_super_value(ctx, "first_data_block", sb->s_first_data_block, - MAX_CHECK, 0, sb->s_blocks_count); - check_super_value(ctx, "log_block_size", sb->s_log_block_size, - MIN_CHECK | MAX_CHECK, 0, - EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE); - check_super_value(ctx, "log_frag_size", sb->s_log_frag_size, - MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size); - check_super_value(ctx, "frags_per_group", sb->s_frags_per_group, - MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group, - bpg_max); - check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, - MIN_CHECK | MAX_CHECK, 8, bpg_max); - check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, - MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max); - check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count, - MAX_CHECK, 0, sb->s_blocks_count / 2); - check_super_value(ctx, "reserved_gdt_blocks", - sb->s_reserved_gdt_blocks, MAX_CHECK, 0, - fs->blocksize/4); - inode_size = EXT2_INODE_SIZE(sb); - check_super_value(ctx, "inode_size", - inode_size, MIN_CHECK | MAX_CHECK, - EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize); - if (inode_size & (inode_size - 1)) { - pctx.num = inode_size; - pctx.str = "inode_size"; - fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ - return; - } - - if (!ctx->num_blocks) { - pctx.errcode = e2fsck_get_device_size(ctx); - if (pctx.errcode && pctx.errcode != EXT2_ET_UNIMPLEMENTED) { - fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) && - (ctx->num_blocks < sb->s_blocks_count)) { - pctx.blk = sb->s_blocks_count; - pctx.blk2 = ctx->num_blocks; - if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - } - - if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) { - pctx.blk = EXT2_BLOCK_SIZE(sb); - pctx.blk2 = EXT2_FRAG_SIZE(sb); - fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = sb->s_frags_per_group >> - (sb->s_log_block_size - sb->s_log_frag_size); - if (sb->s_blocks_per_group != should_be) { - pctx.blk = sb->s_blocks_per_group; - pctx.blk2 = should_be; - fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = (sb->s_log_block_size == 0) ? 1 : 0; - if (sb->s_first_data_block != should_be) { - pctx.blk = sb->s_first_data_block; - pctx.blk2 = should_be; - fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = sb->s_inodes_per_group * fs->group_desc_count; - if (sb->s_inodes_count != should_be) { - pctx.ino = sb->s_inodes_count; - pctx.ino2 = should_be; - if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) { - sb->s_inodes_count = should_be; - ext2fs_mark_super_dirty(fs); - } - } - - /* - * Verify the group descriptors.... - */ - first_block = sb->s_first_data_block; - last_block = first_block + blocks_per_group; - - for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) { - pctx.group = i; - - if (i == fs->group_desc_count - 1) - last_block = sb->s_blocks_count; - if ((gd->bg_block_bitmap < first_block) || - (gd->bg_block_bitmap >= last_block)) { - pctx.blk = gd->bg_block_bitmap; - if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) - gd->bg_block_bitmap = 0; - } - if (gd->bg_block_bitmap == 0) { - ctx->invalid_block_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - if ((gd->bg_inode_bitmap < first_block) || - (gd->bg_inode_bitmap >= last_block)) { - pctx.blk = gd->bg_inode_bitmap; - if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) - gd->bg_inode_bitmap = 0; - } - if (gd->bg_inode_bitmap == 0) { - ctx->invalid_inode_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - if ((gd->bg_inode_table < first_block) || - ((gd->bg_inode_table + - fs->inode_blocks_per_group - 1) >= last_block)) { - pctx.blk = gd->bg_inode_table; - if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) - gd->bg_inode_table = 0; - } - if (gd->bg_inode_table == 0) { - ctx->invalid_inode_table_flag[i]++; - ctx->invalid_bitmaps++; - } - free_blocks += gd->bg_free_blocks_count; - free_inodes += gd->bg_free_inodes_count; - first_block += sb->s_blocks_per_group; - last_block += sb->s_blocks_per_group; - - if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || - (gd->bg_free_inodes_count > sb->s_inodes_per_group) || - (gd->bg_used_dirs_count > sb->s_inodes_per_group)) - ext2fs_unmark_valid(fs); - } - - /* - * Update the global counts from the block group counts. This - * is needed for an experimental patch which eliminates - * locking the entire filesystem when allocating blocks or - * inodes; if the filesystem is not unmounted cleanly, the - * global counts may not be accurate. - */ - if ((free_blocks != sb->s_free_blocks_count) || - (free_inodes != sb->s_free_inodes_count)) { - if (ctx->options & E2F_OPT_READONLY) - ext2fs_unmark_valid(fs); - else { - sb->s_free_blocks_count = free_blocks; - sb->s_free_inodes_count = free_inodes; - ext2fs_mark_super_dirty(fs); - } - } - - if ((sb->s_free_blocks_count > sb->s_blocks_count) || - (sb->s_free_inodes_count > sb->s_inodes_count)) - ext2fs_unmark_valid(fs); - - - /* - * If we have invalid bitmaps, set the error state of the - * filesystem. - */ - if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) { - sb->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - - clear_problem_context(&pctx); - - /* - * If the UUID field isn't assigned, assign it. - */ - if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) { - if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { - uuid_generate(sb->s_uuid); - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - } - } - - /* FIXME - HURD support? - * For the Hurd, check to see if the filetype option is set, - * since it doesn't support it. - */ - if (!(ctx->options & E2F_OPT_READONLY) && - fs->super->s_creator_os == EXT2_OS_HURD && - (fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_FILETYPE)) { - if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { - fs->super->s_feature_incompat &= - ~EXT2_FEATURE_INCOMPAT_FILETYPE; - ext2fs_mark_super_dirty(fs); - } - } - - /* - * If we have any of the compatibility flags set, we need to have a - * revision 1 filesystem. Most kernels will not check the flags on - * a rev 0 filesystem and we may have corruption issues because of - * the incompatible changes to the filesystem. - */ - if (!(ctx->options & E2F_OPT_READONLY) && - fs->super->s_rev_level == EXT2_GOOD_OLD_REV && - (fs->super->s_feature_compat || - fs->super->s_feature_ro_compat || - fs->super->s_feature_incompat) && - fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) { - ext2fs_update_dynamic_rev(fs); - ext2fs_mark_super_dirty(fs); - } - - check_resize_inode(ctx); - - /* - * Clean up any orphan inodes, if present. - */ - if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) { - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - - /* - * Move the ext3 journal file, if necessary. - */ - e2fsck_move_ext3_journal(ctx); -} - -/* - * swapfs.c --- byte-swap an ext2 filesystem - */ - -#ifdef ENABLE_SWAPFS - -struct swap_block_struct { - ext2_ino_t ino; - int isdir; - errcode_t errcode; - char *dir_buf; - struct ext2_inode *inode; -}; - -/* - * This is a helper function for block_iterate. We mark all of the - * indirect and direct blocks as changed, so that block_iterate will - * write them out. - */ -static int swap_block(ext2_filsys fs, blk_t *block_nr, int blockcnt, - void *priv_data) -{ - errcode_t retval; - - struct swap_block_struct *sb = (struct swap_block_struct *) priv_data; - - if (sb->isdir && (blockcnt >= 0) && *block_nr) { - retval = ext2fs_read_dir_block(fs, *block_nr, sb->dir_buf); - if (retval) { - sb->errcode = retval; - return BLOCK_ABORT; - } - retval = ext2fs_write_dir_block(fs, *block_nr, sb->dir_buf); - if (retval) { - sb->errcode = retval; - return BLOCK_ABORT; - } - } - if (blockcnt >= 0) { - if (blockcnt < EXT2_NDIR_BLOCKS) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_IND) { - if (*block_nr == sb->inode->i_block[EXT2_IND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_DIND) { - if (*block_nr == sb->inode->i_block[EXT2_DIND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_TIND) { - if (*block_nr == sb->inode->i_block[EXT2_TIND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - return BLOCK_CHANGED; -} - -/* - * This function is responsible for byte-swapping all of the indirect, - * block pointers. It is also responsible for byte-swapping directories. - */ -static void swap_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, char *block_buf, - struct ext2_inode *inode) -{ - errcode_t retval; - struct swap_block_struct sb; - - sb.ino = ino; - sb.inode = inode; - sb.dir_buf = block_buf + ctx->fs->blocksize*3; - sb.errcode = 0; - sb.isdir = 0; - if (LINUX_S_ISDIR(inode->i_mode)) - sb.isdir = 1; - - retval = ext2fs_block_iterate(ctx->fs, ino, 0, block_buf, - swap_block, &sb); - if (retval) { - bb_error_msg(_("while calling ext2fs_block_iterate")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (sb.errcode) { - bb_error_msg(_("while calling iterator function")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -static void swap_inodes(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - dgrp_t group; - unsigned int i; - ext2_ino_t ino = 1; - char *buf, *block_buf; - errcode_t retval; - struct ext2_inode * inode; - - e2fsck_use_inode_shortcuts(ctx, 1); - - retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, - &buf); - if (retval) { - bb_error_msg(_("while allocating inode buffer")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, - "block interate buffer"); - for (group = 0; group < fs->group_desc_count; group++) { - retval = io_channel_read_blk(fs->io, - fs->group_desc[group].bg_inode_table, - fs->inode_blocks_per_group, buf); - if (retval) { - bb_error_msg(_("while reading inode table (group %d)"), - group); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - inode = (struct ext2_inode *) buf; - for (i=0; i < fs->super->s_inodes_per_group; - i++, ino++, inode++) { - ctx->stashed_ino = ino; - ctx->stashed_inode = inode; - - if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ) - ext2fs_swap_inode(fs, inode, inode, 0); - - /* - * Skip deleted files. - */ - if (inode->i_links_count == 0) - continue; - - if (LINUX_S_ISDIR(inode->i_mode) || - ((inode->i_block[EXT2_IND_BLOCK] || - inode->i_block[EXT2_DIND_BLOCK] || - inode->i_block[EXT2_TIND_BLOCK]) && - ext2fs_inode_has_valid_blocks(inode))) - swap_inode_blocks(ctx, ino, block_buf, inode); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) - ext2fs_swap_inode(fs, inode, inode, 1); - } - retval = io_channel_write_blk(fs->io, - fs->group_desc[group].bg_inode_table, - fs->inode_blocks_per_group, buf); - if (retval) { - bb_error_msg(_("while writing inode table (group %d)"), - group); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_free_mem(&buf); - ext2fs_free_mem(&block_buf); - e2fsck_use_inode_shortcuts(ctx, 0); - ext2fs_flush_icache(fs); -} - -#if defined(__powerpc__) && BB_BIG_ENDIAN -/* - * On the PowerPC, the big-endian variant of the ext2 filesystem - * has its bitmaps stored as 32-bit words with bit 0 as the LSB - * of each word. Thus a bitmap with only bit 0 set would be, as - * a string of bytes, 00 00 00 01 00 ... - * To cope with this, we byte-reverse each word of a bitmap if - * we have a big-endian filesystem, that is, if we are *not* - * byte-swapping other word-sized numbers. - */ -#define EXT2_BIG_ENDIAN_BITMAPS -#endif - -#ifdef EXT2_BIG_ENDIAN_BITMAPS -static void ext2fs_swap_bitmap(ext2fs_generic_bitmap bmap) -{ - __u32 *p = (__u32 *) bmap->bitmap; - int n, nbytes = (bmap->end - bmap->start + 7) / 8; - - for (n = nbytes / sizeof(__u32); n > 0; --n, ++p) - *p = ext2fs_swab32(*p); -} -#endif - - -#ifdef ENABLE_SWAPFS -static void swap_filesys(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - if (!(ctx->options & E2F_OPT_PREEN)) - printf(_("Pass 0: Doing byte-swap of filesystem\n")); - - /* Byte swap */ - - if (fs->super->s_mnt_count) { - fprintf(stderr, _("%s: the filesystem must be freshly " - "checked using fsck\n" - "and not mounted before trying to " - "byte-swap it.\n"), ctx->device_name); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (fs->flags & EXT2_FLAG_SWAP_BYTES) { - fs->flags &= ~(EXT2_FLAG_SWAP_BYTES| - EXT2_FLAG_SWAP_BYTES_WRITE); - fs->flags |= EXT2_FLAG_SWAP_BYTES_READ; - } else { - fs->flags &= ~EXT2_FLAG_SWAP_BYTES_READ; - fs->flags |= EXT2_FLAG_SWAP_BYTES_WRITE; - } - swap_inodes(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) - fs->flags |= EXT2_FLAG_SWAP_BYTES; - fs->flags &= ~(EXT2_FLAG_SWAP_BYTES_READ| - EXT2_FLAG_SWAP_BYTES_WRITE); - -#ifdef EXT2_BIG_ENDIAN_BITMAPS - e2fsck_read_bitmaps(ctx); - ext2fs_swap_bitmap(fs->inode_map); - ext2fs_swap_bitmap(fs->block_map); - fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY; -#endif - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - ext2fs_flush(fs); - fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; -} -#endif /* ENABLE_SWAPFS */ - -#endif - -/* - * util.c --- miscellaneous utilities - */ - - -void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, - const char *description) -{ - return xzalloc(size); -} - -static char *string_copy(const char *str, int len) -{ - char *ret; - - if (!str) - return NULL; - if (!len) - len = strlen(str); - ret = xmalloc(len+1); - strncpy(ret, str, len); - ret[len] = 0; - return ret; -} - -#ifndef HAVE_CONIO_H -static int read_a_char(void) -{ - char c; - int r; - int fail = 0; - - while (1) { - if (e2fsck_global_ctx && - (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) { - return 3; - } - r = read(0, &c, 1); - if (r == 1) - return c; - if (fail++ > 100) - break; - } - return EOF; -} -#endif - -static int ask_yn(const char * string, int def) -{ - int c; - const char *defstr; - static const char short_yes[] = "yY"; - static const char short_no[] = "nN"; - -#ifdef HAVE_TERMIOS_H - struct termios termios, tmp; - - tcgetattr (0, &termios); - tmp = termios; - tmp.c_lflag &= ~(ICANON | ECHO); - tmp.c_cc[VMIN] = 1; - tmp.c_cc[VTIME] = 0; - tcsetattr_stdin_TCSANOW(&tmp); -#endif - - if (def == 1) - defstr = "<y>"; - else if (def == 0) - defstr = "<n>"; - else - defstr = " (y/n)"; - printf("%s%s? ", string, defstr); - while (1) { - fflush (stdout); - if ((c = read_a_char()) == EOF) - break; - if (c == 3) { -#ifdef HAVE_TERMIOS_H - tcsetattr_stdin_TCSANOW(&termios); -#endif - if (e2fsck_global_ctx && - e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) { - puts("\n"); - longjmp(e2fsck_global_ctx->abort_loc, 1); - } - puts(_("cancelled!\n")); - return 0; - } - if (strchr(short_yes, (char) c)) { - def = 1; - break; - } - else if (strchr(short_no, (char) c)) { - def = 0; - break; - } - else if ((c == ' ' || c == '\n') && (def != -1)) - break; - } - if (def) - puts("yes\n"); - else - puts ("no\n"); -#ifdef HAVE_TERMIOS_H - tcsetattr_stdin_TCSANOW(&termios); -#endif - return def; -} - -int ask (e2fsck_t ctx, const char * string, int def) -{ - if (ctx->options & E2F_OPT_NO) { - printf(_("%s? no\n\n"), string); - return 0; - } - if (ctx->options & E2F_OPT_YES) { - printf(_("%s? yes\n\n"), string); - return 1; - } - if (ctx->options & E2F_OPT_PREEN) { - printf("%s? %s\n\n", string, def ? _("yes") : _("no")); - return def; - } - return ask_yn(string, def); -} - -void e2fsck_read_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - - if (ctx->invalid_bitmaps) { - bb_error_msg(_("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - - ehandler_operation(_("reading inode and block bitmaps")); - retval = ext2fs_read_bitmaps(fs); - ehandler_operation(0); - if (retval) { - bb_error_msg(_("while retrying to read bitmaps for %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } -} - -static void e2fsck_write_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - - if (ext2fs_test_bb_dirty(fs)) { - ehandler_operation(_("writing block bitmaps")); - retval = ext2fs_write_block_bitmap(fs); - ehandler_operation(0); - if (retval) { - bb_error_msg(_("while retrying to write block bitmaps for %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - } - - if (ext2fs_test_ib_dirty(fs)) { - ehandler_operation(_("writing inode bitmaps")); - retval = ext2fs_write_inode_bitmap(fs); - ehandler_operation(0); - if (retval) { - bb_error_msg(_("while retrying to write inode bitmaps for %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - } -} - -void preenhalt(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - - if (!(ctx->options & E2F_OPT_PREEN)) - return; - fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; " - "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"), - ctx->device_name); - if (fs != NULL) { - fs->super->s_state |= EXT2_ERROR_FS; - ext2fs_mark_super_dirty(fs); - ext2fs_close(fs); - } - exit(EXIT_UNCORRECTED); -} - -void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char *proc) -{ - int retval; - - retval = ext2fs_read_inode(ctx->fs, ino, inode); - if (retval) { - bb_error_msg(_("while reading inode %ld in %s"), ino, proc); - bb_error_msg_and_die(0); - } -} - -extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, int bufsize, - const char *proc) -{ - int retval; - - retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); - if (retval) { - bb_error_msg(_("while writing inode %ld in %s"), ino, proc); - bb_error_msg_and_die(0); - } -} - -extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char *proc) -{ - int retval; - - retval = ext2fs_write_inode(ctx->fs, ino, inode); - if (retval) { - bb_error_msg(_("while writing inode %ld in %s"), ino, proc); - bb_error_msg_and_die(0); - } -} - -blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name, - io_manager manager) -{ - struct ext2_super_block *sb; - io_channel io = NULL; - void *buf = NULL; - int blocksize; - blk_t superblock, ret_sb = 8193; - - if (fs && fs->super) { - ret_sb = (fs->super->s_blocks_per_group + - fs->super->s_first_data_block); - if (ctx) { - ctx->superblock = ret_sb; - ctx->blocksize = fs->blocksize; - } - return ret_sb; - } - - if (ctx) { - if (ctx->blocksize) { - ret_sb = ctx->blocksize * 8; - if (ctx->blocksize == 1024) - ret_sb++; - ctx->superblock = ret_sb; - return ret_sb; - } - ctx->superblock = ret_sb; - ctx->blocksize = 1024; - } - - if (!name || !manager) - goto cleanup; - - if (manager->open(name, 0, &io) != 0) - goto cleanup; - - if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf)) - goto cleanup; - sb = (struct ext2_super_block *) buf; - - for (blocksize = EXT2_MIN_BLOCK_SIZE; - blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { - superblock = blocksize*8; - if (blocksize == 1024) - superblock++; - io_channel_set_blksize(io, blocksize); - if (io_channel_read_blk(io, superblock, - -SUPERBLOCK_SIZE, buf)) - continue; -#if BB_BIG_ENDIAN - if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) - ext2fs_swap_super(sb); -#endif - if (sb->s_magic == EXT2_SUPER_MAGIC) { - ret_sb = superblock; - if (ctx) { - ctx->superblock = superblock; - ctx->blocksize = blocksize; - } - break; - } - } - -cleanup: - if (io) - io_channel_close(io); - ext2fs_free_mem(&buf); - return ret_sb; -} - - -/* - * This function runs through the e2fsck passes and calls them all, - * returning restart, abort, or cancel as necessary... - */ -typedef void (*pass_t)(e2fsck_t ctx); - -static const pass_t e2fsck_passes[] = { - e2fsck_pass1, e2fsck_pass2, e2fsck_pass3, e2fsck_pass4, - e2fsck_pass5, 0 }; - -#define E2F_FLAG_RUN_RETURN (E2F_FLAG_SIGNAL_MASK|E2F_FLAG_RESTART) - -static int e2fsck_run(e2fsck_t ctx) -{ - int i; - pass_t e2fsck_pass; - - if (setjmp(ctx->abort_loc)) { - ctx->flags &= ~E2F_FLAG_SETJMP_OK; - return (ctx->flags & E2F_FLAG_RUN_RETURN); - } - ctx->flags |= E2F_FLAG_SETJMP_OK; - - for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) { - if (ctx->flags & E2F_FLAG_RUN_RETURN) - break; - e2fsck_pass(ctx); - if (ctx->progress) - (void) (ctx->progress)(ctx, 0, 0, 0); - } - ctx->flags &= ~E2F_FLAG_SETJMP_OK; - - if (ctx->flags & E2F_FLAG_RUN_RETURN) - return (ctx->flags & E2F_FLAG_RUN_RETURN); - return 0; -} - - -/* - * unix.c - The unix-specific code for e2fsck - */ - - -/* Command line options */ -static int swapfs; -#ifdef ENABLE_SWAPFS -static int normalize_swapfs; -#endif -static int cflag; /* check disk */ -static int show_version_only; -static int verbose; - -#define P_E2(singular, plural, n) n, ((n) == 1 ? singular : plural) - -static void show_stats(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - int inodes, inodes_used, blocks, blocks_used; - int dir_links; - int num_files, num_links; - int frag_percent; - - dir_links = 2 * ctx->fs_directory_count - 1; - num_files = ctx->fs_total_count - dir_links; - num_links = ctx->fs_links_count - dir_links; - inodes = fs->super->s_inodes_count; - inodes_used = (fs->super->s_inodes_count - - fs->super->s_free_inodes_count); - blocks = fs->super->s_blocks_count; - blocks_used = (fs->super->s_blocks_count - - fs->super->s_free_blocks_count); - - frag_percent = (10000 * ctx->fs_fragmented) / inodes_used; - frag_percent = (frag_percent + 5) / 10; - - if (!verbose) { - printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n", - ctx->device_name, inodes_used, inodes, - frag_percent / 10, frag_percent % 10, - blocks_used, blocks); - return; - } - printf("\n%8d inode%s used (%d%%)\n", P_E2("", "s", inodes_used), - 100 * inodes_used / inodes); - printf("%8d non-contiguous inode%s (%0d.%d%%)\n", - P_E2("", "s", ctx->fs_fragmented), - frag_percent / 10, frag_percent % 10); - printf(_(" # of inodes with ind/dind/tind blocks: %d/%d/%d\n"), - ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count); - printf("%8d block%s used (%d%%)\n", P_E2("", "s", blocks_used), - (int) ((long long) 100 * blocks_used / blocks)); - printf("%8d large file%s\n", P_E2("", "s", ctx->large_files)); - printf("\n%8d regular file%s\n", P_E2("", "s", ctx->fs_regular_count)); - printf("%8d director%s\n", P_E2("y", "ies", ctx->fs_directory_count)); - printf("%8d character device file%s\n", P_E2("", "s", ctx->fs_chardev_count)); - printf("%8d block device file%s\n", P_E2("", "s", ctx->fs_blockdev_count)); - printf("%8d fifo%s\n", P_E2("", "s", ctx->fs_fifo_count)); - printf("%8d link%s\n", P_E2("", "s", ctx->fs_links_count - dir_links)); - printf("%8d symbolic link%s", P_E2("", "s", ctx->fs_symlinks_count)); - printf(" (%d fast symbolic link%s)\n", P_E2("", "s", ctx->fs_fast_symlinks_count)); - printf("%8d socket%s--------\n\n", P_E2("", "s", ctx->fs_sockets_count)); - printf("%8d file%s\n", P_E2("", "s", ctx->fs_total_count - dir_links)); -} - -static void check_mount(e2fsck_t ctx) -{ - errcode_t retval; - int cont; - - retval = ext2fs_check_if_mounted(ctx->filesystem_name, - &ctx->mount_flags); - if (retval) { - bb_error_msg(_("while determining whether %s is mounted"), - ctx->filesystem_name); - return; - } - - /* - * If the filesystem isn't mounted, or it's the root filesystem - * and it's mounted read-only, then everything's fine. - */ - if ((!(ctx->mount_flags & EXT2_MF_MOUNTED)) || - ((ctx->mount_flags & EXT2_MF_ISROOT) && - (ctx->mount_flags & EXT2_MF_READONLY))) - return; - - if (ctx->options & E2F_OPT_READONLY) { - printf(_("Warning! %s is mounted.\n"), ctx->filesystem_name); - return; - } - - printf(_("%s is mounted. "), ctx->filesystem_name); - if (!ctx->interactive) - 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" - "SEVERE filesystem damage.\007\007\007\n\n")); - cont = ask_yn(_("Do you really want to continue"), -1); - if (!cont) { - printf(_("check aborted.\n")); - exit(0); - } -} - -static int is_on_batt(void) -{ - FILE *f; - DIR *d; - char tmp[80], tmp2[80], fname[80]; - unsigned int acflag; - struct dirent* de; - - f = fopen_for_read("/proc/apm"); - if (f) { - if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) - acflag = 1; - fclose(f); - return (acflag != 1); - } - d = opendir("/proc/acpi/ac_adapter"); - if (d) { - while ((de=readdir(d)) != NULL) { - if (!strncmp(".", de->d_name, 1)) - continue; - snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", - de->d_name); - f = fopen_for_read(fname); - if (!f) - continue; - if (fscanf(f, "%s %s", tmp2, tmp) != 2) - tmp[0] = 0; - fclose(f); - if (strncmp(tmp, "off-line", 8) == 0) { - closedir(d); - return 1; - } - } - closedir(d); - } - return 0; -} - -/* - * This routine checks to see if a filesystem can be skipped; if so, - * it will exit with EXIT_OK. Under some conditions it will print a - * message explaining why a check is being forced. - */ -static void check_if_skip(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - const char *reason = NULL; - unsigned int reason_arg = 0; - long next_check; - int batt = is_on_batt(); - time_t now = time(NULL); - - if ((ctx->options & E2F_OPT_FORCE) || cflag || swapfs) - return; - - if ((fs->super->s_state & EXT2_ERROR_FS) || - !ext2fs_test_valid(fs)) - reason = _(" contains a file system with errors"); - else if ((fs->super->s_state & EXT2_VALID_FS) == 0) - reason = _(" was not cleanly unmounted"); - else if ((fs->super->s_max_mnt_count > 0) && - (fs->super->s_mnt_count >= - (unsigned) fs->super->s_max_mnt_count)) { - reason = _(" has been mounted %u times without being checked"); - reason_arg = fs->super->s_mnt_count; - if (batt && (fs->super->s_mnt_count < - (unsigned) fs->super->s_max_mnt_count*2)) - reason = 0; - } else if (fs->super->s_checkinterval && - ((now - fs->super->s_lastcheck) >= - fs->super->s_checkinterval)) { - reason = _(" has gone %u days without being checked"); - reason_arg = (now - fs->super->s_lastcheck)/(3600*24); - if (batt && ((now - fs->super->s_lastcheck) < - fs->super->s_checkinterval*2)) - reason = 0; - } - if (reason) { - fputs(ctx->device_name, stdout); - printf(reason, reason_arg); - fputs(_(", check forced.\n"), stdout); - return; - } - printf(_("%s: clean, %d/%d files, %d/%d blocks"), ctx->device_name, - fs->super->s_inodes_count - fs->super->s_free_inodes_count, - fs->super->s_inodes_count, - fs->super->s_blocks_count - fs->super->s_free_blocks_count, - fs->super->s_blocks_count); - next_check = 100000; - if (fs->super->s_max_mnt_count > 0) { - next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count; - if (next_check <= 0) - next_check = 1; - } - if (fs->super->s_checkinterval && - ((now - fs->super->s_lastcheck) >= fs->super->s_checkinterval)) - next_check = 1; - if (next_check <= 5) { - if (next_check == 1) - fputs(_(" (check after next mount)"), stdout); - else - printf(_(" (check in %ld mounts)"), next_check); - } - bb_putchar('\n'); - ext2fs_close(fs); - ctx->fs = NULL; - e2fsck_free_context(ctx); - exit(EXIT_OK); -} - -/* - * For completion notice - */ -struct percent_tbl { - int max_pass; - int table[32]; -}; -static const struct percent_tbl e2fsck_tbl = { - 5, { 0, 70, 90, 92, 95, 100 } -}; - -static char bar[128], spaces[128]; - -static float calc_percent(const struct percent_tbl *tbl, int pass, int curr, - int max) -{ - float percent; - - if (pass <= 0) - return 0.0; - if (pass > tbl->max_pass || max == 0) - return 100.0; - percent = ((float) curr) / ((float) max); - return ((percent * (tbl->table[pass] - tbl->table[pass-1])) - + tbl->table[pass-1]); -} - -void e2fsck_clear_progbar(e2fsck_t ctx) -{ - if (!(ctx->flags & E2F_FLAG_PROG_BAR)) - return; - - printf("%s%s\r%s", ctx->start_meta, spaces + (sizeof(spaces) - 80), - ctx->stop_meta); - fflush(stdout); - ctx->flags &= ~E2F_FLAG_PROG_BAR; -} - -int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, - unsigned int dpynum) -{ - static const char spinner[] = "\\|/-"; - int i; - unsigned int tick; - struct timeval tv; - int dpywidth; - int fixed_percent; - - if (ctx->flags & E2F_FLAG_PROG_SUPPRESS) - return 0; - - /* - * Calculate the new progress position. If the - * percentage hasn't changed, then we skip out right - * away. - */ - fixed_percent = (int) ((10 * percent) + 0.5); - if (ctx->progress_last_percent == fixed_percent) - return 0; - ctx->progress_last_percent = fixed_percent; - - /* - * If we've already updated the spinner once within - * the last 1/8th of a second, no point doing it - * again. - */ - gettimeofday(&tv, NULL); - tick = (tv.tv_sec << 3) + (tv.tv_usec / (1000000 / 8)); - if ((tick == ctx->progress_last_time) && - (fixed_percent != 0) && (fixed_percent != 1000)) - return 0; - ctx->progress_last_time = tick; - - /* - * Advance the spinner, and note that the progress bar - * will be on the screen - */ - ctx->progress_pos = (ctx->progress_pos+1) & 3; - ctx->flags |= E2F_FLAG_PROG_BAR; - - dpywidth = 66 - strlen(label); - dpywidth = 8 * (dpywidth / 8); - if (dpynum) - dpywidth -= 8; - - i = ((percent * dpywidth) + 50) / 100; - printf("%s%s: |%s%s", ctx->start_meta, label, - bar + (sizeof(bar) - (i+1)), - spaces + (sizeof(spaces) - (dpywidth - i + 1))); - if (fixed_percent == 1000) - bb_putchar('|'); - else - bb_putchar(spinner[ctx->progress_pos & 3]); - printf(" %4.1f%% ", percent); - if (dpynum) - printf("%u\r", dpynum); - else - fputs(" \r", stdout); - fputs(ctx->stop_meta, stdout); - - if (fixed_percent == 1000) - e2fsck_clear_progbar(ctx); - fflush(stdout); - - return 0; -} - -static int e2fsck_update_progress(e2fsck_t ctx, int pass, - unsigned long cur, unsigned long max) -{ - char buf[80]; - float percent; - - if (pass == 0) - return 0; - - if (ctx->progress_fd) { - sprintf(buf, "%d %lu %lu\n", pass, cur, max); - xwrite_str(ctx->progress_fd, buf); - } else { - percent = calc_percent(&e2fsck_tbl, pass, cur, max); - e2fsck_simple_progress(ctx, ctx->device_name, - percent, 0); - } - return 0; -} - -static void reserve_stdio_fds(void) -{ - int fd; - - while (1) { - fd = open(bb_dev_null, O_RDWR); - if (fd > 2) - break; - if (fd < 0) { - fprintf(stderr, _("ERROR: Cannot open " - "/dev/null (%s)\n"), - strerror(errno)); - break; - } - } - close(fd); -} - -static void signal_progress_on(int sig FSCK_ATTR((unused))) -{ - e2fsck_t ctx = e2fsck_global_ctx; - - if (!ctx) - return; - - ctx->progress = e2fsck_update_progress; - ctx->progress_fd = 0; -} - -static void signal_progress_off(int sig FSCK_ATTR((unused))) -{ - e2fsck_t ctx = e2fsck_global_ctx; - - if (!ctx) - return; - - e2fsck_clear_progbar(ctx); - ctx->progress = 0; -} - -static void signal_cancel(int sig FSCK_ATTR((unused))) -{ - e2fsck_t ctx = e2fsck_global_ctx; - - if (!ctx) - exit(FSCK_CANCELED); - - ctx->flags |= E2F_FLAG_CANCEL; -} - -static void parse_extended_opts(e2fsck_t ctx, const char *opts) -{ - char *buf, *token, *next, *p, *arg; - int ea_ver; - int extended_usage = 0; - - buf = string_copy(opts, 0); - for (token = buf; token && *token; token = next) { - p = strchr(token, ','); - next = 0; - if (p) { - *p = 0; - next = p+1; - } - arg = strchr(token, '='); - if (arg) { - *arg = 0; - arg++; - } - if (strcmp(token, "ea_ver") == 0) { - if (!arg) { - extended_usage++; - continue; - } - ea_ver = strtoul(arg, &p, 0); - if (*p || - ((ea_ver != 1) && (ea_ver != 2))) { - fprintf(stderr, - _("Invalid EA version.\n")); - extended_usage++; - continue; - } - ctx->ext_attr_ver = ea_ver; - } else { - fprintf(stderr, _("Unknown extended option: %s\n"), - token); - extended_usage++; - } - } - if (extended_usage) { - bb_error_msg_and_die( - "Extended options are separated by commas, " - "and may take an argument which\n" - "is set off by an equals ('=') sign. " - "Valid extended options are:\n" - "\tea_ver=<ea_version (1 or 2)>\n\n"); - } -} - - -static errcode_t PRS(int argc, char **argv, e2fsck_t *ret_ctx) -{ - int flush = 0; - int c, fd; - e2fsck_t ctx; - errcode_t retval; - struct sigaction sa; - char *extended_opts = NULL; - - retval = e2fsck_allocate_context(&ctx); - if (retval) - return retval; - - *ret_ctx = ctx; - - setvbuf(stdout, NULL, _IONBF, BUFSIZ); - setvbuf(stderr, NULL, _IONBF, BUFSIZ); - if (isatty(0) && isatty(1)) { - ctx->interactive = 1; - } else { - ctx->start_meta[0] = '\001'; - ctx->stop_meta[0] = '\002'; - } - memset(bar, '=', sizeof(bar)-1); - memset(spaces, ' ', sizeof(spaces)-1); - blkid_get_cache(&ctx->blkid, NULL); - - if (argc && *argv) - ctx->program_name = *argv; - else - ctx->program_name = "e2fsck"; - while ((c = getopt (argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDk")) != EOF) - switch (c) { - case 'C': - ctx->progress = e2fsck_update_progress; - ctx->progress_fd = atoi(optarg); - if (!ctx->progress_fd) - break; - /* Validate the file descriptor to avoid disasters */ - fd = dup(ctx->progress_fd); - if (fd < 0) { - fprintf(stderr, - _("Error validating file descriptor %d: %s\n"), - ctx->progress_fd, - error_message(errno)); - bb_error_msg_and_die(_("Invalid completion information file descriptor")); - } else - close(fd); - break; - case 'D': - ctx->options |= E2F_OPT_COMPRESS_DIRS; - break; - case 'E': - extended_opts = optarg; - break; - case 'p': - case 'a': - 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")); - } - ctx->options |= E2F_OPT_PREEN; - break; - case 'n': - if (ctx->options & (E2F_OPT_YES|E2F_OPT_PREEN)) - goto conflict_opt; - ctx->options |= E2F_OPT_NO; - break; - case 'y': - if (ctx->options & (E2F_OPT_PREEN|E2F_OPT_NO)) - goto conflict_opt; - ctx->options |= E2F_OPT_YES; - break; - case 't': - /* FIXME - This needs to go away in a future path - will change binary */ - fprintf(stderr, _("The -t option is not " - "supported on this version of e2fsck.\n")); - break; - case 'c': - if (cflag++) - ctx->options |= E2F_OPT_WRITECHECK; - ctx->options |= E2F_OPT_CHECKBLOCKS; - break; - case 'r': - /* What we do by default, anyway! */ - break; - case 'b': - ctx->use_superblock = atoi(optarg); - ctx->flags |= E2F_FLAG_SB_SPECIFIED; - break; - case 'B': - ctx->blocksize = atoi(optarg); - break; - case 'I': - ctx->inode_buffer_blocks = atoi(optarg); - break; - case 'j': - ctx->journal_name = string_copy(optarg, 0); - break; - case 'P': - ctx->process_inode_size = atoi(optarg); - break; - case 'd': - ctx->options |= E2F_OPT_DEBUG; - break; - case 'f': - ctx->options |= E2F_OPT_FORCE; - break; - case 'F': - flush = 1; - break; - case 'v': - verbose = 1; - break; - case 'V': - show_version_only = 1; - break; - case 'N': - ctx->device_name = optarg; - break; -#ifdef ENABLE_SWAPFS - case 's': - normalize_swapfs = 1; - case 'S': - swapfs = 1; - break; -#else - case 's': - case 'S': - fprintf(stderr, _("Byte-swapping filesystems " - "not compiled in this version " - "of e2fsck\n")); - exit(1); -#endif - default: - bb_show_usage(); - } - if (show_version_only) - return 0; - if (optind != argc - 1) - bb_show_usage(); - if ((ctx->options & E2F_OPT_NO) && - !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) - ctx->options |= E2F_OPT_READONLY; - ctx->io_options = strchr(argv[optind], '?'); - if (ctx->io_options) - *ctx->io_options++ = 0; - ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0); - if (!ctx->filesystem_name) { - bb_error_msg(_("Unable to resolve '%s'"), argv[optind]); - bb_error_msg_and_die(0); - } - if (extended_opts) - parse_extended_opts(ctx, extended_opts); - - if (flush) { - fd = open(ctx->filesystem_name, O_RDONLY, 0); - if (fd < 0) { - bb_error_msg(_("while opening %s for flushing"), - ctx->filesystem_name); - bb_error_msg_and_die(0); - } - if ((retval = ext2fs_sync_device(fd, 1))) { - bb_error_msg(_("while trying to flush %s"), - ctx->filesystem_name); - bb_error_msg_and_die(0); - } - close(fd); - } -#ifdef ENABLE_SWAPFS - if (swapfs && cflag) { - fprintf(stderr, _("Incompatible options not " - "allowed when byte-swapping.\n")); - exit(EXIT_USAGE); - } -#endif - /* - * Set up signal action - */ - memset(&sa, 0, sizeof(struct sigaction)); - sa.sa_handler = signal_cancel; - sigaction(SIGINT, &sa, 0); - sigaction(SIGTERM, &sa, 0); -#ifdef SA_RESTART - sa.sa_flags = SA_RESTART; -#endif - e2fsck_global_ctx = ctx; - sa.sa_handler = signal_progress_on; - sigaction(SIGUSR1, &sa, 0); - sa.sa_handler = signal_progress_off; - sigaction(SIGUSR2, &sa, 0); - - /* Update our PATH to include /sbin if we need to run badblocks */ - if (cflag) - e2fs_set_sbin_path(); - return 0; -} - -static const char my_ver_string[] = E2FSPROGS_VERSION; -static const char my_ver_date[] = E2FSPROGS_DATE; - -int e2fsck_main (int argc, char **argv); -int e2fsck_main (int argc, char **argv) -{ - errcode_t retval; - int exit_value = EXIT_OK; - ext2_filsys fs = 0; - io_manager io_ptr; - struct ext2_super_block *sb; - const char *lib_ver_date; - int my_ver, lib_ver; - e2fsck_t ctx; - struct problem_context pctx; - int flags, run_result; - - clear_problem_context(&pctx); - - my_ver = ext2fs_parse_version_string(my_ver_string); - lib_ver = ext2fs_get_library_version(0, &lib_ver_date); - if (my_ver > lib_ver) { - fprintf( stderr, _("Error: ext2fs library version " - "out of date!\n")); - show_version_only++; - } - - retval = PRS(argc, argv, &ctx); - if (retval) { - bb_error_msg(_("while trying to initialize program")); - exit(EXIT_ERROR); - } - reserve_stdio_fds(); - - if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) - fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string, - my_ver_date); - - if (show_version_only) { - fprintf(stderr, _("\tUsing %s, %s\n"), - error_message(EXT2_ET_BASE), lib_ver_date); - exit(EXIT_OK); - } - - check_mount(ctx); - - if (!(ctx->options & E2F_OPT_PREEN) && - !(ctx->options & E2F_OPT_NO) && - !(ctx->options & E2F_OPT_YES)) { - if (!ctx->interactive) - bb_error_msg_and_die(_("need terminal for interactive repairs")); - } - ctx->superblock = ctx->use_superblock; -restart: -#ifdef CONFIG_TESTIO_DEBUG - io_ptr = test_io_manager; - test_io_backing_manager = unix_io_manager; -#else - io_ptr = unix_io_manager; -#endif - flags = 0; - if ((ctx->options & E2F_OPT_READONLY) == 0) - flags |= EXT2_FLAG_RW; - - if (ctx->superblock && ctx->blocksize) { - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, - flags, ctx->superblock, ctx->blocksize, - io_ptr, &fs); - } else if (ctx->superblock) { - int blocksize; - for (blocksize = EXT2_MIN_BLOCK_SIZE; - blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { - retval = ext2fs_open2(ctx->filesystem_name, - ctx->io_options, flags, - ctx->superblock, blocksize, - io_ptr, &fs); - if (!retval) - break; - } - } else - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, - flags, 0, 0, io_ptr, &fs); - if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && - !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && - ((retval == EXT2_ET_BAD_MAGIC) || - ((retval == 0) && ext2fs_check_desc(fs)))) { - if (!fs || (fs->group_desc_count > 1)) { - printf(_("%s trying backup blocks...\n"), - retval ? _("Couldn't find ext2 superblock,") : - _("Group descriptors look bad...")); - get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); - if (fs) - ext2fs_close(fs); - goto restart; - } - } - if (retval) { - bb_error_msg(_("while trying to open %s"), - ctx->filesystem_name); - if (retval == EXT2_ET_REV_TOO_HIGH) { - printf(_("The filesystem revision is apparently " - "too high for this version of e2fsck.\n" - "(Or the filesystem superblock " - "is corrupt)\n\n")); - fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); - } else if (retval == EXT2_ET_SHORT_READ) - printf(_("Could this be a zero-length partition?\n")); - else if ((retval == EPERM) || (retval == EACCES)) - printf(_("You must have %s access to the " - "filesystem or be root\n"), - (ctx->options & E2F_OPT_READONLY) ? - "r/o" : "r/w"); - else if (retval == ENXIO) - printf(_("Possibly non-existent or swap device?\n")); -#ifdef EROFS - else if (retval == EROFS) - printf(_("Disk write-protected; use the -n option " - "to do a read-only\n" - "check of the device.\n")); -#endif - else - fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); - bb_error_msg_and_die(0); - } - ctx->fs = fs; - fs->priv_data = ctx; - sb = fs->super; - if (sb->s_rev_level > E2FSCK_CURRENT_REV) { - bb_error_msg(_("while trying to open %s"), - ctx->filesystem_name); - get_newer: - bb_error_msg_and_die(_("Get a newer version of e2fsck!")); - } - - /* - * Set the device name, which is used whenever we print error - * or informational messages to the user. - */ - if (ctx->device_name == 0 && - (sb->s_volume_name[0] != 0)) { - ctx->device_name = string_copy(sb->s_volume_name, - sizeof(sb->s_volume_name)); - } - if (ctx->device_name == 0) - ctx->device_name = ctx->filesystem_name; - - /* - * Make sure the ext3 superblock fields are consistent. - */ - retval = e2fsck_check_ext3_journal(ctx); - if (retval) { - bb_error_msg(_("while checking ext3 journal for %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - - /* - * Check to see if we need to do ext3-style recovery. If so, - * do it, and then restart the fsck. - */ - if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) { - if (ctx->options & E2F_OPT_READONLY) { - printf(_("Warning: skipping journal recovery " - "because doing a read-only filesystem " - "check.\n")); - io_channel_flush(ctx->fs->io); - } else { - if (ctx->flags & E2F_FLAG_RESTARTED) { - /* - * Whoops, we attempted to run the - * journal twice. This should never - * happen, unless the hardware or - * device driver is being bogus. - */ - bb_error_msg(_("can't set superblock flags on %s"), ctx->device_name); - bb_error_msg_and_die(0); - } - retval = e2fsck_run_ext3_journal(ctx); - if (retval) { - bb_error_msg(_("while recovering ext3 journal of %s"), - ctx->device_name); - bb_error_msg_and_die(0); - } - ext2fs_close(ctx->fs); - ctx->fs = 0; - ctx->flags |= E2F_FLAG_RESTARTED; - goto restart; - } - } - - /* - * Check for compatibility with the feature sets. We need to - * be more stringent than ext2fs_open(). - */ - if ((sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) || - (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) { - bb_error_msg("(%s)", ctx->device_name); - goto get_newer; - } - if (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) { - bb_error_msg("(%s)", ctx->device_name); - goto get_newer; - } -#ifdef ENABLE_COMPRESSION - /* FIXME - do we support this at all? */ - if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION) - bb_error_msg(_("warning: compression support is experimental")); -#endif -#ifndef ENABLE_HTREE - if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) { - bb_error_msg(_("E2fsck not compiled with HTREE support,\n\t" - "but filesystem %s has HTREE directories."), - ctx->device_name); - goto get_newer; - } -#endif - - /* - * If the user specified a specific superblock, presumably the - * master superblock has been trashed. So we mark the - * superblock as dirty, so it can be written out. - */ - if (ctx->superblock && - !(ctx->options & E2F_OPT_READONLY)) - ext2fs_mark_super_dirty(fs); - - /* - * We only update the master superblock because (a) paranoia; - * we don't want to corrupt the backup superblocks, and (b) we - * don't need to update the mount count and last checked - * fields in the backup superblock (the kernel doesn't - * update the backup superblocks anyway). - */ - fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; - - ehandler_init(fs->io); - - if (ctx->superblock) - set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); - ext2fs_mark_valid(fs); - check_super_block(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - bb_error_msg_and_die(0); - check_if_skip(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - bb_error_msg_and_die(0); -#ifdef ENABLE_SWAPFS - -#ifdef WORDS_BIGENDIAN -#define NATIVE_FLAG EXT2_FLAG_SWAP_BYTES -#else -#define NATIVE_FLAG 0 -#endif - - - if (normalize_swapfs) { - if ((fs->flags & EXT2_FLAG_SWAP_BYTES) == NATIVE_FLAG) { - fprintf(stderr, _("%s: Filesystem byte order " - "already normalized.\n"), ctx->device_name); - bb_error_msg_and_die(0); - } - } - if (swapfs) { - swap_filesys(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - bb_error_msg_and_die(0); - } -#endif - - /* - * Mark the system as valid, 'til proven otherwise - */ - ext2fs_mark_valid(fs); - - retval = ext2fs_read_bb_inode(fs, &fs->badblocks); - if (retval) { - bb_error_msg(_("while reading bad blocks inode")); - preenhalt(ctx); - printf(_("This doesn't bode well," - " but we'll try to go on...\n")); - } - - run_result = e2fsck_run(ctx); - e2fsck_clear_progbar(ctx); - if (run_result == E2F_FLAG_RESTART) { - printf(_("Restarting e2fsck from the beginning...\n")); - retval = e2fsck_reset_context(ctx); - if (retval) { - bb_error_msg(_("while resetting context")); - bb_error_msg_and_die(0); - } - ext2fs_close(fs); - goto restart; - } - if (run_result & E2F_FLAG_CANCEL) { - printf(_("%s: e2fsck canceled.\n"), ctx->device_name ? - ctx->device_name : ctx->filesystem_name); - exit_value |= FSCK_CANCELED; - } - if (run_result & E2F_FLAG_ABORT) - bb_error_msg_and_die(_("aborted")); - - /* Cleanup */ - if (ext2fs_test_changed(fs)) { - exit_value |= EXIT_NONDESTRUCT; - if (!(ctx->options & E2F_OPT_PREEN)) - printf(_("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"), - ctx->device_name); - if (ctx->mount_flags & EXT2_MF_ISROOT) { - printf(_("%s: ***** REBOOT LINUX *****\n"), - ctx->device_name); - exit_value |= EXIT_DESTRUCT; - } - } - if (!ext2fs_test_valid(fs)) { - printf(_("\n%s: ********** WARNING: Filesystem still has " - "errors **********\n\n"), ctx->device_name); - exit_value |= EXIT_UNCORRECTED; - exit_value &= ~EXIT_NONDESTRUCT; - } - if (exit_value & FSCK_CANCELED) - exit_value &= ~EXIT_NONDESTRUCT; - else { - show_stats(ctx); - if (!(ctx->options & E2F_OPT_READONLY)) { - if (ext2fs_test_valid(fs)) { - if (!(sb->s_state & EXT2_VALID_FS)) - exit_value |= EXIT_NONDESTRUCT; - sb->s_state = EXT2_VALID_FS; - } else - sb->s_state &= ~EXT2_VALID_FS; - sb->s_mnt_count = 0; - sb->s_lastcheck = time(NULL); - ext2fs_mark_super_dirty(fs); - } - } - - e2fsck_write_bitmaps(ctx); - - ext2fs_close(fs); - ctx->fs = NULL; - free(ctx->filesystem_name); - free(ctx->journal_name); - e2fsck_free_context(ctx); - - return exit_value; -} |