pass1.c revision 29e8e74e02ae742874c8c37012da1e04a858eb2f
1f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com/* 2f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table 3f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 4f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. 5f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 6f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * %Begin-Header% 7f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * This file may be redistributed under the terms of the GNU Public 8f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * License. 9f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * %End-Header% 10f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 11f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * Pass 1 of e2fsck iterates over all the inodes in the filesystems, 12f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * and applies the following tests to each inode: 13f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 14f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - The mode field of the inode must be legal. 15f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - The size and block count fields of the inode are correct. 16f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A data block must not be used by another inode 17f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 18f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * Pass 1 also gathers the collects the following information: 19f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 20f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes are in use. (inode_used_map) 21f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes are directories. (inode_dir_map) 22f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes are regular files. (inode_reg_map) 23f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes have bad fields. (inode_bad_map) 24f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes are in bad blocks. (inode_bb_map) 25f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) 26f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which blocks are in use. (block_found_map) 27f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - A bitmap of which blocks are in use by two inodes (block_dup_map) 28f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * - The data blocks of the directory inodes. (dir_map) 29f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * 30f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * Pass 1 is designed to stash away enough information so that the 31f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * other passes should not need to read in the inode information 32f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com * during the normal course of a filesystem check. (Althogh if an 3308bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org * inconsistency is detected, other passes may need to read in an 3408bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org * inode to fix it.) 3508bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org * 3608bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org * Note that pass 1B will be invoked if there are any duplicate blocks 3708bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org * found. 3808bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org */ 3908bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org 4008bf86c56495b6779001b5756839fc2c73decba3commit-bot@chromium.org#define _GNU_SOURCE 1 /* get strnlen() */ 41f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include "config.h" 42f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include <string.h> 43f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include <time.h> 44f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#ifdef HAVE_ERRNO_H 45f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include <errno.h> 46f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#endif 47f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com 48f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include "e2fsck.h" 49f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include <ext2fs/ext2_ext_attr.h> 50f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com 51f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#include "problem.h" 52f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com 53f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#ifdef NO_INLINE_FUNCS 54f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#define _INLINE_ 55f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#else 56f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#define _INLINE_ inline 57f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com#endif 58f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com 59f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.comstatic int process_block(ext2_filsys fs, blk64_t *blocknr, 60f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com e2_blkcnt_t blockcnt, blk64_t ref_blk, 61f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com int ref_offset, void *priv_data); 62f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.comstatic int process_bad_block(ext2_filsys fs, blk64_t *block_nr, 63f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com e2_blkcnt_t blockcnt, blk64_t ref_blk, 64f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com int ref_offset, void *priv_data); 65f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.comstatic void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 66f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.com char *block_buf); 67f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.comstatic void mark_table_blocks(e2fsck_t ctx); 68f5cc5b140c1c00c536e02b5cfbe158bb2d5c2c15bungeman@google.comstatic void alloc_bb_map(e2fsck_t ctx); 692e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic void alloc_imagic_map(e2fsck_t ctx); 702e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic void mark_inode_bad(e2fsck_t ctx, ino_t ino); 712e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic void handle_fs_bad_blocks(e2fsck_t ctx); 722e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic void process_inodes(e2fsck_t ctx, char *block_buf); 732e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); 742e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, 752e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org dgrp_t group, void * priv_data); 762e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstatic void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 772e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org char *block_buf, int adjust_sign); 782e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org/* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */ 792e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org 802e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstruct process_block_struct { 812e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org ext2_ino_t ino; 822e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org unsigned is_dir:1, is_reg:1, clear:1, suppress:1, 832e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org fragmented:1, compressed:1, bbcheck:1; 842e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org blk64_t num_blocks; 852e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org blk64_t max_blocks; 862e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org e2_blkcnt_t last_block; 872e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org e2_blkcnt_t last_init_lblock; 882e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org e2_blkcnt_t last_db_block; 892e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org int num_illegal_blocks; 902e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org blk64_t previous_block; 912e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org struct ext2_inode *inode; 922e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org struct problem_context *pctx; 932e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org ext2fs_block_bitmap fs_meta_blocks; 942e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org e2fsck_t ctx; 952e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org}; 962e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org 972e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.orgstruct process_inode_block { 982e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org ext2_ino_t ino; 992e0c32af0508a1e544c9953ea2fe128dbae7d429commit-bot@chromium.org struct ext2_inode inode; 10073fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org}; 10173fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org 10273fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.orgstruct scan_callback_struct { 10373fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org e2fsck_t ctx; 10473fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org char *block_buf; 10573fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org}; 10673fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org 10773fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org/* 10873fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org * For the inodes to process list. 10973fffeb83aab56bc8c2c5ce143ee9d132d64ac37commit-bot@chromium.org */ 1104b3ef5ad33aa3dcef083101177dd8a91978cc7debungeman@google.comstatic struct process_inode_block *inodes_to_process; 111static int process_inode_count; 112 113static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - 114 EXT2_MIN_BLOCK_LOG_SIZE + 1]; 115 116/* 117 * Free all memory allocated by pass1 in preparation for restarting 118 * things. 119 */ 120static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused))) 121{ 122 ext2fs_free_mem(&inodes_to_process); 123 inodes_to_process = 0; 124} 125 126/* 127 * Check to make sure a device inode is real. Returns 1 if the device 128 * checks out, 0 if not. 129 * 130 * Note: this routine is now also used to check FIFO's and Sockets, 131 * since they have the same requirement; the i_block fields should be 132 * zero. 133 */ 134int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), 135 struct ext2_inode *inode) 136{ 137 int i; 138 139 /* 140 * If the index flag is set, then this is a bogus 141 * device/fifo/socket 142 */ 143 if (inode->i_flags & EXT2_INDEX_FL) 144 return 0; 145 146 /* 147 * We should be able to do the test below all the time, but 148 * because the kernel doesn't forcibly clear the device 149 * inode's additional i_block fields, there are some rare 150 * occasions when a legitimate device inode will have non-zero 151 * additional i_block fields. So for now, we only complain 152 * when the immutable flag is set, which should never happen 153 * for devices. (And that's when the problem is caused, since 154 * you can't set or clear immutable flags for devices.) Once 155 * the kernel has been fixed we can change this... 156 */ 157 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { 158 for (i=4; i < EXT2_N_BLOCKS; i++) 159 if (inode->i_block[i]) 160 return 0; 161 } 162 return 1; 163} 164 165/* 166 * Check to make sure a symlink inode is real. Returns 1 if the symlink 167 * checks out, 0 if not. 168 */ 169int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, 170 struct ext2_inode *inode, char *buf) 171{ 172 unsigned int len; 173 int i; 174 blk64_t blocks; 175 ext2_extent_handle_t handle; 176 struct ext2_extent_info info; 177 struct ext2fs_extent extent; 178 179 if ((inode->i_size_high || inode->i_size == 0) || 180 (inode->i_flags & EXT2_INDEX_FL)) 181 return 0; 182 183 if (inode->i_flags & EXT4_EXTENTS_FL) { 184 if (inode->i_size > fs->blocksize) 185 return 0; 186 if (ext2fs_extent_open2(fs, ino, inode, &handle)) 187 return 0; 188 i = 0; 189 if (ext2fs_extent_get_info(handle, &info) || 190 (info.num_entries != 1) || 191 (info.max_depth != 0)) 192 goto exit_extent; 193 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) || 194 (extent.e_lblk != 0) || 195 (extent.e_len != 1) || 196 (extent.e_pblk < fs->super->s_first_data_block) || 197 (extent.e_pblk >= ext2fs_blocks_count(fs->super))) 198 goto exit_extent; 199 i = 1; 200 exit_extent: 201 ext2fs_extent_free(handle); 202 return i; 203 } 204 205 blocks = ext2fs_inode_data_blocks2(fs, inode); 206 if (blocks) { 207 if ((inode->i_size >= fs->blocksize) || 208 (blocks != fs->blocksize >> 9) || 209 (inode->i_block[0] < fs->super->s_first_data_block) || 210 (inode->i_block[0] >= ext2fs_blocks_count(fs->super))) 211 return 0; 212 213 for (i = 1; i < EXT2_N_BLOCKS; i++) 214 if (inode->i_block[i]) 215 return 0; 216 217 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf)) 218 return 0; 219 220 len = strnlen(buf, fs->blocksize); 221 if (len == fs->blocksize) 222 return 0; 223 } else { 224 if (inode->i_size >= sizeof(inode->i_block)) 225 return 0; 226 227 len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); 228 if (len == sizeof(inode->i_block)) 229 return 0; 230 } 231 if (len != inode->i_size) 232 return 0; 233 return 1; 234} 235 236/* 237 * If the immutable (or append-only) flag is set on the inode, offer 238 * to clear it. 239 */ 240#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) 241static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) 242{ 243 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) 244 return; 245 246 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) 247 return; 248 249 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; 250 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 251} 252 253/* 254 * If device, fifo or socket, check size is zero -- if not offer to 255 * clear it 256 */ 257static void check_size(e2fsck_t ctx, struct problem_context *pctx) 258{ 259 struct ext2_inode *inode = pctx->inode; 260 261 if (EXT2_I_SIZE(inode) == 0) 262 return; 263 264 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) 265 return; 266 267 inode->i_size = 0; 268 inode->i_size_high = 0; 269 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 270} 271 272static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) 273{ 274 struct ext2_super_block *sb = ctx->fs->super; 275 struct ext2_inode_large *inode; 276 struct ext2_ext_attr_entry *entry; 277 char *start, *end; 278 unsigned int storage_size, remain; 279 int problem = 0; 280 281 inode = (struct ext2_inode_large *) pctx->inode; 282 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - 283 inode->i_extra_isize; 284 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 285 inode->i_extra_isize + sizeof(__u32); 286 end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super); 287 entry = (struct ext2_ext_attr_entry *) start; 288 289 /* scan all entry's headers first */ 290 291 /* take finish entry 0UL into account */ 292 remain = storage_size - sizeof(__u32); 293 294 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { 295 __u32 hash; 296 297 /* header eats this space */ 298 remain -= sizeof(struct ext2_ext_attr_entry); 299 300 /* is attribute name valid? */ 301 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { 302 pctx->num = entry->e_name_len; 303 problem = PR_1_ATTR_NAME_LEN; 304 goto fix; 305 } 306 307 /* attribute len eats this space */ 308 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); 309 310 /* check value size */ 311 if (entry->e_value_size == 0 || entry->e_value_size > remain) { 312 pctx->num = entry->e_value_size; 313 problem = PR_1_ATTR_VALUE_SIZE; 314 goto fix; 315 } 316 317 /* e_value_block must be 0 in inode's ea */ 318 if (entry->e_value_block != 0) { 319 pctx->num = entry->e_value_block; 320 problem = PR_1_ATTR_VALUE_BLOCK; 321 goto fix; 322 } 323 324 hash = ext2fs_ext_attr_hash_entry(entry, 325 start + entry->e_value_offs); 326 327 /* e_hash may be 0 in older inode's ea */ 328 if (entry->e_hash != 0 && entry->e_hash != hash) { 329 pctx->num = entry->e_hash; 330 problem = PR_1_ATTR_HASH; 331 goto fix; 332 } 333 334 remain -= entry->e_value_size; 335 336 entry = EXT2_EXT_ATTR_NEXT(entry); 337 } 338fix: 339 /* 340 * it seems like a corruption. it's very unlikely we could repair 341 * EA(s) in automatic fashion -bzzz 342 */ 343 if (problem == 0 || !fix_problem(ctx, problem, pctx)) 344 return; 345 346 /* simply remove all possible EA(s) */ 347 *((__u32 *)start) = 0UL; 348 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 349 EXT2_INODE_SIZE(sb), "pass1"); 350} 351 352static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) 353{ 354 struct ext2_super_block *sb = ctx->fs->super; 355 struct ext2_inode_large *inode; 356 __u32 *eamagic; 357 int min, max; 358 359 inode = (struct ext2_inode_large *) pctx->inode; 360 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { 361 /* this isn't large inode. so, nothing to check */ 362 return; 363 } 364 365#if 0 366 printf("inode #%u, i_extra_size %d\n", pctx->ino, 367 inode->i_extra_isize); 368#endif 369 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */ 370 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi); 371 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; 372 /* 373 * For now we will allow i_extra_isize to be 0, but really 374 * implementations should never allow i_extra_isize to be 0 375 */ 376 if (inode->i_extra_isize && 377 (inode->i_extra_isize < min || inode->i_extra_isize > max)) { 378 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) 379 return; 380 inode->i_extra_isize = min; 381 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 382 EXT2_INODE_SIZE(sb), "pass1"); 383 return; 384 } 385 386 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 387 inode->i_extra_isize); 388 if (*eamagic == EXT2_EXT_ATTR_MAGIC) { 389 /* it seems inode has an extended attribute(s) in body */ 390 check_ea_in_inode(ctx, pctx); 391 } 392} 393 394/* 395 * Check to see if the inode might really be a directory, despite i_mode 396 * 397 * This is a lot of complexity for something for which I'm not really 398 * convinced happens frequently in the wild. If for any reason this 399 * causes any problems, take this code out. 400 * [tytso:20070331.0827EDT] 401 */ 402static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, 403 char *buf) 404{ 405 struct ext2_inode *inode = pctx->inode; 406 struct ext2_dir_entry *dirent; 407 errcode_t retval; 408 blk64_t blk; 409 unsigned int i, rec_len, not_device = 0; 410 int extent_fs; 411 412 /* 413 * If the mode looks OK, we believe it. If the first block in 414 * the i_block array is 0, this cannot be a directory. If the 415 * inode is extent-mapped, it is still the case that the latter 416 * cannot be 0 - the magic number in the extent header would make 417 * it nonzero. 418 */ 419 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) || 420 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0) 421 return; 422 423 /* 424 * Check the block numbers in the i_block array for validity: 425 * zero blocks are skipped (but the first one cannot be zero - 426 * see above), other blocks are checked against the first and 427 * max data blocks (from the the superblock) and against the 428 * block bitmap. Any invalid block found means this cannot be 429 * a directory. 430 * 431 * If there are non-zero blocks past the fourth entry, then 432 * this cannot be a device file: we remember that for the next 433 * check. 434 * 435 * For extent mapped files, we don't do any sanity checking: 436 * just try to get the phys block of logical block 0 and run 437 * with it. 438 */ 439 440 extent_fs = (ctx->fs->super->s_feature_incompat & 441 EXT3_FEATURE_INCOMPAT_EXTENTS); 442 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { 443 /* extent mapped */ 444 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, 445 &blk)) 446 return; 447 /* device files are never extent mapped */ 448 not_device++; 449 } else { 450 for (i=0; i < EXT2_N_BLOCKS; i++) { 451 blk = inode->i_block[i]; 452 if (!blk) 453 continue; 454 if (i >= 4) 455 not_device++; 456 457 if (blk < ctx->fs->super->s_first_data_block || 458 blk >= ext2fs_blocks_count(ctx->fs->super) || 459 ext2fs_fast_test_block_bitmap2(ctx->block_found_map, 460 blk)) 461 return; /* Invalid block, can't be dir */ 462 } 463 blk = inode->i_block[0]; 464 } 465 466 /* 467 * If the mode says this is a device file and the i_links_count field 468 * is sane and we have not ruled it out as a device file previously, 469 * we declare it a device file, not a directory. 470 */ 471 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) && 472 (inode->i_links_count == 1) && !not_device) 473 return; 474 475 /* read the first block */ 476 ehandler_operation(_("reading directory block")); 477 retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0); 478 ehandler_operation(0); 479 if (retval) 480 return; 481 482 dirent = (struct ext2_dir_entry *) buf; 483 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 484 if (retval) 485 return; 486 if (((dirent->name_len & 0xFF) != 1) || 487 (dirent->name[0] != '.') || 488 (dirent->inode != pctx->ino) || 489 (rec_len < 12) || 490 (rec_len % 4) || 491 (rec_len >= ctx->fs->blocksize - 12)) 492 return; 493 494 dirent = (struct ext2_dir_entry *) (buf + rec_len); 495 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 496 if (retval) 497 return; 498 if (((dirent->name_len & 0xFF) != 2) || 499 (dirent->name[0] != '.') || 500 (dirent->name[1] != '.') || 501 (rec_len < 12) || 502 (rec_len % 4)) 503 return; 504 505 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) { 506 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR; 507 e2fsck_write_inode_full(ctx, pctx->ino, inode, 508 EXT2_INODE_SIZE(ctx->fs->super), 509 "check_is_really_dir"); 510 } 511} 512 513extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, 514 ext2_icount_t *ret) 515{ 516 unsigned int threshold; 517 ext2_ino_t num_dirs; 518 errcode_t retval; 519 char *tdb_dir; 520 int enable; 521 522 *ret = 0; 523 524 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, 525 &tdb_dir); 526 profile_get_uint(ctx->profile, "scratch_files", 527 "numdirs_threshold", 0, 0, &threshold); 528 profile_get_boolean(ctx->profile, "scratch_files", 529 "icount", 0, 1, &enable); 530 531 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); 532 if (retval) 533 num_dirs = 1024; /* Guess */ 534 535 if (!enable || !tdb_dir || access(tdb_dir, W_OK) || 536 (threshold && num_dirs <= threshold)) 537 return; 538 539 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret); 540 if (retval) 541 *ret = 0; 542} 543 544void e2fsck_pass1(e2fsck_t ctx) 545{ 546 int i; 547 __u64 max_sizes; 548 ext2_filsys fs = ctx->fs; 549 ext2_ino_t ino = 0; 550 struct ext2_inode *inode; 551 ext2_inode_scan scan; 552 char *block_buf; 553#ifdef RESOURCE_TRACK 554 struct resource_track rtrack; 555#endif 556 unsigned char frag, fsize; 557 struct problem_context pctx; 558 struct scan_callback_struct scan_struct; 559 struct ext2_super_block *sb = ctx->fs->super; 560 const char *old_op; 561 unsigned int save_type; 562 int imagic_fs, extent_fs; 563 int busted_fs_time = 0; 564 int inode_size; 565 566 init_resource_track(&rtrack, ctx->fs->io); 567 clear_problem_context(&pctx); 568 569 if (!(ctx->options & E2F_OPT_PREEN)) 570 fix_problem(ctx, PR_1_PASS_HEADER, &pctx); 571 572 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && 573 !(ctx->options & E2F_OPT_NO)) { 574 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) 575 ctx->dirs_to_hash = 0; 576 } 577 578#ifdef MTRACE 579 mtrace_print("Pass 1"); 580#endif 581 582#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) 583 584 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { 585 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); 586 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); 587 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); 588 max_sizes = (max_sizes * (1UL << i)); 589 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; 590 } 591#undef EXT2_BPP 592 593 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); 594 extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); 595 596 /* 597 * Allocate bitmaps structures 598 */ 599 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"), 600 EXT2FS_BMAP64_RBTREE, 601 "inode_used_map", 602 &ctx->inode_used_map); 603 if (pctx.errcode) { 604 pctx.num = 1; 605 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 606 ctx->flags |= E2F_FLAG_ABORT; 607 return; 608 } 609 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 610 _("directory inode map"), 611 EXT2FS_BMAP64_AUTODIR, 612 "inode_dir_map", &ctx->inode_dir_map); 613 if (pctx.errcode) { 614 pctx.num = 2; 615 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 616 ctx->flags |= E2F_FLAG_ABORT; 617 return; 618 } 619 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 620 _("regular file inode map"), EXT2FS_BMAP64_RBTREE, 621 "inode_reg_map", &ctx->inode_reg_map); 622 if (pctx.errcode) { 623 pctx.num = 6; 624 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 625 ctx->flags |= E2F_FLAG_ABORT; 626 return; 627 } 628 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs, 629 _("in-use block map"), EXT2FS_BMAP64_RBTREE, 630 "block_found_map", &ctx->block_found_map); 631 if (pctx.errcode) { 632 pctx.num = 1; 633 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 634 ctx->flags |= E2F_FLAG_ABORT; 635 return; 636 } 637 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info); 638 if (!ctx->inode_link_info) { 639 e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, 640 "inode_link_info", &save_type); 641 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, 642 &ctx->inode_link_info); 643 fs->default_bitmap_type = save_type; 644 } 645 646 if (pctx.errcode) { 647 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); 648 ctx->flags |= E2F_FLAG_ABORT; 649 return; 650 } 651 inode_size = EXT2_INODE_SIZE(fs->super); 652 inode = (struct ext2_inode *) 653 e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); 654 655 inodes_to_process = (struct process_inode_block *) 656 e2fsck_allocate_memory(ctx, 657 (ctx->process_inode_size * 658 sizeof(struct process_inode_block)), 659 "array of inodes to process"); 660 process_inode_count = 0; 661 662 pctx.errcode = ext2fs_init_dblist(fs, 0); 663 if (pctx.errcode) { 664 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); 665 ctx->flags |= E2F_FLAG_ABORT; 666 ext2fs_free_mem(&inode); 667 return; 668 } 669 670 /* 671 * If the last orphan field is set, clear it, since the pass1 672 * processing will automatically find and clear the orphans. 673 * In the future, we may want to try using the last_orphan 674 * linked list ourselves, but for now, we clear it so that the 675 * ext3 mount code won't get confused. 676 */ 677 if (!(ctx->options & E2F_OPT_READONLY)) { 678 if (fs->super->s_last_orphan) { 679 fs->super->s_last_orphan = 0; 680 ext2fs_mark_super_dirty(fs); 681 } 682 } 683 684 mark_table_blocks(ctx); 685 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, 686 &ctx->block_found_map); 687 if (pctx.errcode) { 688 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); 689 ctx->flags |= E2F_FLAG_ABORT; 690 ext2fs_free_mem(&inode); 691 return; 692 } 693 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, 694 "block interate buffer"); 695 e2fsck_use_inode_shortcuts(ctx, 1); 696 old_op = ehandler_operation(_("opening inode scan")); 697 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, 698 &scan); 699 ehandler_operation(old_op); 700 if (pctx.errcode) { 701 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 702 ctx->flags |= E2F_FLAG_ABORT; 703 ext2fs_free_mem(&block_buf); 704 ext2fs_free_mem(&inode); 705 return; 706 } 707 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); 708 ctx->stashed_inode = inode; 709 scan_struct.ctx = ctx; 710 scan_struct.block_buf = block_buf; 711 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); 712 if (ctx->progress) 713 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) 714 return; 715 if ((fs->super->s_wtime < fs->super->s_inodes_count) || 716 (fs->super->s_mtime < fs->super->s_inodes_count)) 717 busted_fs_time = 1; 718 719 if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) && 720 !(fs->super->s_mmp_block <= fs->super->s_first_data_block || 721 fs->super->s_mmp_block >= fs->super->s_blocks_count)) 722 ext2fs_mark_block_bitmap2(ctx->block_found_map, 723 fs->super->s_mmp_block); 724 725 while (1) { 726 if (ino % (fs->super->s_inodes_per_group * 4) == 1) { 727 if (e2fsck_mmp_update(fs)) 728 fatal_error(ctx, 0); 729 } 730 old_op = ehandler_operation(_("getting next inode from scan")); 731 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, 732 inode, inode_size); 733 ehandler_operation(old_op); 734 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 735 return; 736 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { 737 if (!ctx->inode_bb_map) 738 alloc_bb_map(ctx); 739 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); 740 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 741 continue; 742 } 743 if (pctx.errcode) { 744 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 745 ctx->flags |= E2F_FLAG_ABORT; 746 return; 747 } 748 if (!ino) 749 break; 750 pctx.ino = ino; 751 pctx.inode = inode; 752 ctx->stashed_ino = ino; 753 if (inode->i_links_count) { 754 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, 755 ino, inode->i_links_count); 756 if (pctx.errcode) { 757 pctx.num = inode->i_links_count; 758 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); 759 ctx->flags |= E2F_FLAG_ABORT; 760 return; 761 } 762 } 763 764 /* 765 * Test for incorrect extent flag settings. 766 * 767 * On big-endian machines we must be careful: 768 * When the inode is read, the i_block array is not swapped 769 * if the extent flag is set. Therefore if we are testing 770 * for or fixing a wrongly-set flag, we must potentially 771 * (un)swap before testing, or after fixing. 772 */ 773 774 /* 775 * In this case the extents flag was set when read, so 776 * extent_header_verify is ok. If the inode is cleared, 777 * no need to swap... so no extra swapping here. 778 */ 779 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs && 780 (inode->i_links_count || (ino == EXT2_BAD_INO) || 781 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) { 782 if ((ext2fs_extent_header_verify(inode->i_block, 783 sizeof(inode->i_block)) == 0) && 784 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { 785 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS; 786 ext2fs_mark_super_dirty(fs); 787 extent_fs = 1; 788 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { 789 clear_inode: 790 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 791 if (ino == EXT2_BAD_INO) 792 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, 793 ino); 794 continue; 795 } 796 } 797 798 /* 799 * For big-endian machines: 800 * If the inode didn't have the extents flag set when it 801 * was read, then the i_blocks array was swapped. To test 802 * as an extents header, we must swap it back first. 803 * IF we then set the extents flag, the entire i_block 804 * array must be un/re-swapped to make it proper extents data. 805 */ 806 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) && 807 (inode->i_links_count || (ino == EXT2_BAD_INO) || 808 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) && 809 (LINUX_S_ISREG(inode->i_mode) || 810 LINUX_S_ISDIR(inode->i_mode))) { 811 void *ehp; 812#ifdef WORDS_BIGENDIAN 813 __u32 tmp_block[EXT2_N_BLOCKS]; 814 815 for (i = 0; i < EXT2_N_BLOCKS; i++) 816 tmp_block[i] = ext2fs_swab32(inode->i_block[i]); 817 ehp = tmp_block; 818#else 819 ehp = inode->i_block; 820#endif 821 if ((ext2fs_extent_header_verify(ehp, 822 sizeof(inode->i_block)) == 0) && 823 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) { 824 inode->i_flags |= EXT4_EXTENTS_FL; 825#ifdef WORDS_BIGENDIAN 826 memcpy(inode->i_block, tmp_block, 827 sizeof(inode->i_block)); 828#endif 829 e2fsck_write_inode(ctx, ino, inode, "pass1"); 830 } 831 } 832 833 if (ino == EXT2_BAD_INO) { 834 struct process_block_struct pb; 835 836 if ((inode->i_mode || inode->i_uid || inode->i_gid || 837 inode->i_links_count || inode->i_file_acl) && 838 fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) { 839 memset(inode, 0, sizeof(struct ext2_inode)); 840 e2fsck_write_inode(ctx, ino, inode, 841 "clear bad inode"); 842 } 843 844 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, 845 &pb.fs_meta_blocks); 846 if (pctx.errcode) { 847 pctx.num = 4; 848 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 849 ctx->flags |= E2F_FLAG_ABORT; 850 return; 851 } 852 pb.ino = EXT2_BAD_INO; 853 pb.num_blocks = pb.last_block = 0; 854 pb.last_db_block = -1; 855 pb.num_illegal_blocks = 0; 856 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; 857 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; 858 pb.inode = inode; 859 pb.pctx = &pctx; 860 pb.ctx = ctx; 861 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, 862 block_buf, process_bad_block, &pb); 863 ext2fs_free_block_bitmap(pb.fs_meta_blocks); 864 if (pctx.errcode) { 865 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); 866 ctx->flags |= E2F_FLAG_ABORT; 867 return; 868 } 869 if (pb.bbcheck) 870 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { 871 ctx->flags |= E2F_FLAG_ABORT; 872 return; 873 } 874 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 875 clear_problem_context(&pctx); 876 continue; 877 } else if (ino == EXT2_ROOT_INO) { 878 /* 879 * Make sure the root inode is a directory; if 880 * not, offer to clear it. It will be 881 * regnerated in pass #3. 882 */ 883 if (!LINUX_S_ISDIR(inode->i_mode)) { 884 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) 885 goto clear_inode; 886 } 887 /* 888 * If dtime is set, offer to clear it. mke2fs 889 * version 0.2b created filesystems with the 890 * dtime field set for the root and lost+found 891 * directories. We won't worry about 892 * /lost+found, since that can be regenerated 893 * easily. But we will fix the root directory 894 * as a special case. 895 */ 896 if (inode->i_dtime && inode->i_links_count) { 897 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { 898 inode->i_dtime = 0; 899 e2fsck_write_inode(ctx, ino, inode, 900 "pass1"); 901 } 902 } 903 } else if (ino == EXT2_JOURNAL_INO) { 904 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 905 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { 906 if (!LINUX_S_ISREG(inode->i_mode) && 907 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, 908 &pctx)) { 909 inode->i_mode = LINUX_S_IFREG; 910 e2fsck_write_inode(ctx, ino, inode, 911 "pass1"); 912 } 913 check_blocks(ctx, &pctx, block_buf); 914 continue; 915 } 916 if ((inode->i_links_count || 917 inode->i_blocks || inode->i_block[0]) && 918 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, 919 &pctx)) { 920 memset(inode, 0, inode_size); 921 ext2fs_icount_store(ctx->inode_link_info, 922 ino, 0); 923 e2fsck_write_inode_full(ctx, ino, inode, 924 inode_size, "pass1"); 925 } 926 } else if ((ino == EXT4_USR_QUOTA_INO) || 927 (ino == EXT4_GRP_QUOTA_INO)) { 928 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 929 if ((fs->super->s_feature_ro_compat & 930 EXT4_FEATURE_RO_COMPAT_QUOTA) && 931 ((fs->super->s_usr_quota_inum == ino) || 932 (fs->super->s_grp_quota_inum == ino))) { 933 if (!LINUX_S_ISREG(inode->i_mode) && 934 fix_problem(ctx, PR_1_QUOTA_BAD_MODE, 935 &pctx)) { 936 inode->i_mode = LINUX_S_IFREG; 937 e2fsck_write_inode(ctx, ino, inode, 938 "pass1"); 939 } 940 check_blocks(ctx, &pctx, block_buf); 941 continue; 942 } 943 if ((inode->i_links_count || 944 inode->i_blocks || inode->i_block[0]) && 945 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR, 946 &pctx)) { 947 memset(inode, 0, inode_size); 948 ext2fs_icount_store(ctx->inode_link_info, 949 ino, 0); 950 e2fsck_write_inode_full(ctx, ino, inode, 951 inode_size, "pass1"); 952 } 953 } else if (ino < EXT2_FIRST_INODE(fs->super)) { 954 int problem = 0; 955 956 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 957 if (ino == EXT2_BOOT_LOADER_INO) { 958 if (LINUX_S_ISDIR(inode->i_mode)) 959 problem = PR_1_RESERVED_BAD_MODE; 960 } else if (ino == EXT2_RESIZE_INO) { 961 if (inode->i_mode && 962 !LINUX_S_ISREG(inode->i_mode)) 963 problem = PR_1_RESERVED_BAD_MODE; 964 } else { 965 if (inode->i_mode != 0) 966 problem = PR_1_RESERVED_BAD_MODE; 967 } 968 if (problem) { 969 if (fix_problem(ctx, problem, &pctx)) { 970 inode->i_mode = 0; 971 e2fsck_write_inode(ctx, ino, inode, 972 "pass1"); 973 } 974 } 975 check_blocks(ctx, &pctx, block_buf); 976 continue; 977 } 978 979 /* 980 * Check for inodes who might have been part of the 981 * orphaned list linked list. They should have gotten 982 * dealt with by now, unless the list had somehow been 983 * corrupted. 984 * 985 * FIXME: In the future, inodes which are still in use 986 * (and which are therefore) pending truncation should 987 * be handled specially. Right now we just clear the 988 * dtime field, and the normal e2fsck handling of 989 * inodes where i_size and the inode blocks are 990 * inconsistent is to fix i_size, instead of releasing 991 * the extra blocks. This won't catch the inodes that 992 * was at the end of the orphan list, but it's better 993 * than nothing. The right answer is that there 994 * shouldn't be any bugs in the orphan list handling. :-) 995 */ 996 if (inode->i_dtime && !busted_fs_time && 997 inode->i_dtime < ctx->fs->super->s_inodes_count) { 998 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { 999 inode->i_dtime = inode->i_links_count ? 1000 0 : ctx->now; 1001 e2fsck_write_inode(ctx, ino, inode, 1002 "pass1"); 1003 } 1004 } 1005 1006 /* 1007 * This code assumes that deleted inodes have 1008 * i_links_count set to 0. 1009 */ 1010 if (!inode->i_links_count) { 1011 if (!inode->i_dtime && inode->i_mode) { 1012 if (fix_problem(ctx, 1013 PR_1_ZERO_DTIME, &pctx)) { 1014 inode->i_dtime = ctx->now; 1015 e2fsck_write_inode(ctx, ino, inode, 1016 "pass1"); 1017 } 1018 } 1019 continue; 1020 } 1021 /* 1022 * n.b. 0.3c ext2fs code didn't clear i_links_count for 1023 * deleted files. Oops. 1024 * 1025 * Since all new ext2 implementations get this right, 1026 * we now assume that the case of non-zero 1027 * i_links_count and non-zero dtime means that we 1028 * should keep the file, not delete it. 1029 * 1030 */ 1031 if (inode->i_dtime) { 1032 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { 1033 inode->i_dtime = 0; 1034 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1035 } 1036 } 1037 1038 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1039 switch (fs->super->s_creator_os) { 1040 case EXT2_OS_HURD: 1041 frag = inode->osd2.hurd2.h_i_frag; 1042 fsize = inode->osd2.hurd2.h_i_fsize; 1043 break; 1044 default: 1045 frag = fsize = 0; 1046 } 1047 1048 if (inode->i_faddr || frag || fsize || 1049 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) 1050 mark_inode_bad(ctx, ino); 1051 if (!(fs->super->s_feature_incompat & 1052 EXT4_FEATURE_INCOMPAT_64BIT) && 1053 inode->osd2.linux2.l_i_file_acl_high != 0) 1054 mark_inode_bad(ctx, ino); 1055 if ((fs->super->s_creator_os == EXT2_OS_LINUX) && 1056 !(fs->super->s_feature_ro_compat & 1057 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && 1058 (inode->osd2.linux2.l_i_blocks_hi != 0)) 1059 mark_inode_bad(ctx, ino); 1060 if (inode->i_flags & EXT2_IMAGIC_FL) { 1061 if (imagic_fs) { 1062 if (!ctx->inode_imagic_map) 1063 alloc_imagic_map(ctx); 1064 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map, 1065 ino); 1066 } else { 1067 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { 1068 inode->i_flags &= ~EXT2_IMAGIC_FL; 1069 e2fsck_write_inode(ctx, ino, 1070 inode, "pass1"); 1071 } 1072 } 1073 } 1074 1075 check_inode_extra_space(ctx, &pctx); 1076 check_is_really_dir(ctx, &pctx, block_buf); 1077 1078 /* 1079 * ext2fs_inode_has_valid_blocks2 does not actually look 1080 * at i_block[] values, so not endian-sensitive here. 1081 */ 1082 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) && 1083 LINUX_S_ISLNK(inode->i_mode) && 1084 !ext2fs_inode_has_valid_blocks2(fs, inode) && 1085 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { 1086 inode->i_flags &= ~EXT4_EXTENTS_FL; 1087 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1088 } 1089 1090 if (LINUX_S_ISDIR(inode->i_mode)) { 1091 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); 1092 e2fsck_add_dir_info(ctx, ino, 0); 1093 ctx->fs_directory_count++; 1094 } else if (LINUX_S_ISREG (inode->i_mode)) { 1095 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino); 1096 ctx->fs_regular_count++; 1097 } else if (LINUX_S_ISCHR (inode->i_mode) && 1098 e2fsck_pass1_check_device_inode(fs, inode)) { 1099 check_immutable(ctx, &pctx); 1100 check_size(ctx, &pctx); 1101 ctx->fs_chardev_count++; 1102 } else if (LINUX_S_ISBLK (inode->i_mode) && 1103 e2fsck_pass1_check_device_inode(fs, inode)) { 1104 check_immutable(ctx, &pctx); 1105 check_size(ctx, &pctx); 1106 ctx->fs_blockdev_count++; 1107 } else if (LINUX_S_ISLNK (inode->i_mode) && 1108 e2fsck_pass1_check_symlink(fs, ino, inode, 1109 block_buf)) { 1110 check_immutable(ctx, &pctx); 1111 ctx->fs_symlinks_count++; 1112 if (ext2fs_inode_data_blocks(fs, inode) == 0) { 1113 ctx->fs_fast_symlinks_count++; 1114 check_blocks(ctx, &pctx, block_buf); 1115 continue; 1116 } 1117 } 1118 else if (LINUX_S_ISFIFO (inode->i_mode) && 1119 e2fsck_pass1_check_device_inode(fs, inode)) { 1120 check_immutable(ctx, &pctx); 1121 check_size(ctx, &pctx); 1122 ctx->fs_fifo_count++; 1123 } else if ((LINUX_S_ISSOCK (inode->i_mode)) && 1124 e2fsck_pass1_check_device_inode(fs, inode)) { 1125 check_immutable(ctx, &pctx); 1126 check_size(ctx, &pctx); 1127 ctx->fs_sockets_count++; 1128 } else 1129 mark_inode_bad(ctx, ino); 1130 if (!(inode->i_flags & EXT4_EXTENTS_FL)) { 1131 if (inode->i_block[EXT2_IND_BLOCK]) 1132 ctx->fs_ind_count++; 1133 if (inode->i_block[EXT2_DIND_BLOCK]) 1134 ctx->fs_dind_count++; 1135 if (inode->i_block[EXT2_TIND_BLOCK]) 1136 ctx->fs_tind_count++; 1137 } 1138 if (!(inode->i_flags & EXT4_EXTENTS_FL) && 1139 (inode->i_block[EXT2_IND_BLOCK] || 1140 inode->i_block[EXT2_DIND_BLOCK] || 1141 inode->i_block[EXT2_TIND_BLOCK] || 1142 ext2fs_file_acl_block(fs, inode))) { 1143 inodes_to_process[process_inode_count].ino = ino; 1144 inodes_to_process[process_inode_count].inode = *inode; 1145 process_inode_count++; 1146 } else 1147 check_blocks(ctx, &pctx, block_buf); 1148 1149 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1150 return; 1151 1152 if (process_inode_count >= ctx->process_inode_size) { 1153 process_inodes(ctx, block_buf); 1154 1155 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1156 return; 1157 } 1158 } 1159 process_inodes(ctx, block_buf); 1160 ext2fs_close_inode_scan(scan); 1161 1162 /* 1163 * If any extended attribute blocks' reference counts need to 1164 * be adjusted, either up (ctx->refcount_extra), or down 1165 * (ctx->refcount), then fix them. 1166 */ 1167 if (ctx->refcount) { 1168 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); 1169 ea_refcount_free(ctx->refcount); 1170 ctx->refcount = 0; 1171 } 1172 if (ctx->refcount_extra) { 1173 adjust_extattr_refcount(ctx, ctx->refcount_extra, 1174 block_buf, +1); 1175 ea_refcount_free(ctx->refcount_extra); 1176 ctx->refcount_extra = 0; 1177 } 1178 1179 if (ctx->invalid_bitmaps) 1180 handle_fs_bad_blocks(ctx); 1181 1182 /* We don't need the block_ea_map any more */ 1183 if (ctx->block_ea_map) { 1184 ext2fs_free_block_bitmap(ctx->block_ea_map); 1185 ctx->block_ea_map = 0; 1186 } 1187 1188 if (ctx->flags & E2F_FLAG_RESIZE_INODE) { 1189 ext2fs_block_bitmap save_bmap; 1190 1191 save_bmap = fs->block_map; 1192 fs->block_map = ctx->block_found_map; 1193 clear_problem_context(&pctx); 1194 pctx.errcode = ext2fs_create_resize_inode(fs); 1195 if (pctx.errcode) { 1196 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, 1197 &pctx)) { 1198 ctx->flags |= E2F_FLAG_ABORT; 1199 return; 1200 } 1201 pctx.errcode = 0; 1202 } 1203 if (!pctx.errcode) { 1204 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, 1205 "recreate inode"); 1206 inode->i_mtime = ctx->now; 1207 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, 1208 "recreate inode"); 1209 } 1210 fs->block_map = save_bmap; 1211 ctx->flags &= ~E2F_FLAG_RESIZE_INODE; 1212 } 1213 1214 if (ctx->flags & E2F_FLAG_RESTART) { 1215 /* 1216 * Only the master copy of the superblock and block 1217 * group descriptors are going to be written during a 1218 * restart, so set the superblock to be used to be the 1219 * master superblock. 1220 */ 1221 ctx->use_superblock = 0; 1222 unwind_pass1(fs); 1223 goto endit; 1224 } 1225 1226 if (ctx->block_dup_map) { 1227 if (ctx->options & E2F_OPT_PREEN) { 1228 clear_problem_context(&pctx); 1229 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); 1230 } 1231 e2fsck_pass1_dupblocks(ctx, block_buf); 1232 } 1233 ext2fs_free_mem(&inodes_to_process); 1234endit: 1235 e2fsck_use_inode_shortcuts(ctx, 0); 1236 1237 ext2fs_free_mem(&block_buf); 1238 ext2fs_free_mem(&inode); 1239 1240 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); 1241} 1242 1243/* 1244 * When the inode_scan routines call this callback at the end of the 1245 * glock group, call process_inodes. 1246 */ 1247static errcode_t scan_callback(ext2_filsys fs, 1248 ext2_inode_scan scan EXT2FS_ATTR((unused)), 1249 dgrp_t group, void * priv_data) 1250{ 1251 struct scan_callback_struct *scan_struct; 1252 e2fsck_t ctx; 1253 1254 scan_struct = (struct scan_callback_struct *) priv_data; 1255 ctx = scan_struct->ctx; 1256 1257 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); 1258 1259 if (ctx->progress) 1260 if ((ctx->progress)(ctx, 1, group+1, 1261 ctx->fs->group_desc_count)) 1262 return EXT2_ET_CANCEL_REQUESTED; 1263 1264 return 0; 1265} 1266 1267/* 1268 * Process the inodes in the "inodes to process" list. 1269 */ 1270static void process_inodes(e2fsck_t ctx, char *block_buf) 1271{ 1272 int i; 1273 struct ext2_inode *old_stashed_inode; 1274 ext2_ino_t old_stashed_ino; 1275 const char *old_operation; 1276 char buf[80]; 1277 struct problem_context pctx; 1278 1279#if 0 1280 printf("begin process_inodes: "); 1281#endif 1282 if (process_inode_count == 0) 1283 return; 1284 old_operation = ehandler_operation(0); 1285 old_stashed_inode = ctx->stashed_inode; 1286 old_stashed_ino = ctx->stashed_ino; 1287 qsort(inodes_to_process, process_inode_count, 1288 sizeof(struct process_inode_block), process_inode_cmp); 1289 clear_problem_context(&pctx); 1290 for (i=0; i < process_inode_count; i++) { 1291 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; 1292 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; 1293 1294#if 0 1295 printf("%u ", pctx.ino); 1296#endif 1297 sprintf(buf, _("reading indirect blocks of inode %u"), 1298 pctx.ino); 1299 ehandler_operation(buf); 1300 check_blocks(ctx, &pctx, block_buf); 1301 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1302 break; 1303 } 1304 ctx->stashed_inode = old_stashed_inode; 1305 ctx->stashed_ino = old_stashed_ino; 1306 process_inode_count = 0; 1307#if 0 1308 printf("end process inodes\n"); 1309#endif 1310 ehandler_operation(old_operation); 1311} 1312 1313static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) 1314{ 1315 const struct process_inode_block *ib_a = 1316 (const struct process_inode_block *) a; 1317 const struct process_inode_block *ib_b = 1318 (const struct process_inode_block *) b; 1319 int ret; 1320 1321 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - 1322 ib_b->inode.i_block[EXT2_IND_BLOCK]); 1323 if (ret == 0) 1324 /* 1325 * We only call process_inodes() for non-extent 1326 * inodes, so it's OK to pass NULL to 1327 * ext2fs_file_acl_block() here. 1328 */ 1329 ret = ext2fs_file_acl_block(0, &(ib_a->inode)) - 1330 ext2fs_file_acl_block(0, &(ib_b->inode)); 1331 if (ret == 0) 1332 ret = ib_a->ino - ib_b->ino; 1333 return ret; 1334} 1335 1336/* 1337 * Mark an inode as being bad in some what 1338 */ 1339static void mark_inode_bad(e2fsck_t ctx, ino_t ino) 1340{ 1341 struct problem_context pctx; 1342 1343 if (!ctx->inode_bad_map) { 1344 clear_problem_context(&pctx); 1345 1346 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1347 _("bad inode map"), EXT2FS_BMAP64_RBTREE, 1348 "inode_bad_map", &ctx->inode_bad_map); 1349 if (pctx.errcode) { 1350 pctx.num = 3; 1351 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1352 /* Should never get here */ 1353 ctx->flags |= E2F_FLAG_ABORT; 1354 return; 1355 } 1356 } 1357 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); 1358} 1359 1360 1361/* 1362 * This procedure will allocate the inode "bb" (badblock) map table 1363 */ 1364static void alloc_bb_map(e2fsck_t ctx) 1365{ 1366 struct problem_context pctx; 1367 1368 clear_problem_context(&pctx); 1369 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1370 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE, 1371 "inode_bb_map", &ctx->inode_bb_map); 1372 if (pctx.errcode) { 1373 pctx.num = 4; 1374 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1375 /* Should never get here */ 1376 ctx->flags |= E2F_FLAG_ABORT; 1377 return; 1378 } 1379} 1380 1381/* 1382 * This procedure will allocate the inode imagic table 1383 */ 1384static void alloc_imagic_map(e2fsck_t ctx) 1385{ 1386 struct problem_context pctx; 1387 1388 clear_problem_context(&pctx); 1389 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1390 _("imagic inode map"), EXT2FS_BMAP64_RBTREE, 1391 "inode_imagic_map", &ctx->inode_imagic_map); 1392 if (pctx.errcode) { 1393 pctx.num = 5; 1394 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1395 /* Should never get here */ 1396 ctx->flags |= E2F_FLAG_ABORT; 1397 return; 1398 } 1399} 1400 1401/* 1402 * Marks a block as in use, setting the dup_map if it's been set 1403 * already. Called by process_block and process_bad_block. 1404 * 1405 * WARNING: Assumes checks have already been done to make sure block 1406 * is valid. This is true in both process_block and process_bad_block. 1407 */ 1408static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) 1409{ 1410 struct problem_context pctx; 1411 1412 clear_problem_context(&pctx); 1413 1414 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { 1415 if (!ctx->block_dup_map) { 1416 pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, 1417 _("multiply claimed block map"), 1418 EXT2FS_BMAP64_RBTREE, "block_dup_map", 1419 &ctx->block_dup_map); 1420 if (pctx.errcode) { 1421 pctx.num = 3; 1422 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, 1423 &pctx); 1424 /* Should never get here */ 1425 ctx->flags |= E2F_FLAG_ABORT; 1426 return; 1427 } 1428 } 1429 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block); 1430 } else { 1431 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block); 1432 } 1433} 1434 1435static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, 1436 unsigned int num) 1437{ 1438 if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) 1439 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); 1440 else 1441 while (num--) 1442 mark_block_used(ctx, block++); 1443} 1444 1445/* 1446 * Adjust the extended attribute block's reference counts at the end 1447 * of pass 1, either by subtracting out references for EA blocks that 1448 * are still referenced in ctx->refcount, or by adding references for 1449 * EA blocks that had extra references as accounted for in 1450 * ctx->refcount_extra. 1451 */ 1452static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 1453 char *block_buf, int adjust_sign) 1454{ 1455 struct ext2_ext_attr_header *header; 1456 struct problem_context pctx; 1457 ext2_filsys fs = ctx->fs; 1458 blk64_t blk; 1459 __u32 should_be; 1460 int count; 1461 1462 clear_problem_context(&pctx); 1463 1464 ea_refcount_intr_begin(refcount); 1465 while (1) { 1466 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) 1467 break; 1468 pctx.blk = blk; 1469 pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); 1470 if (pctx.errcode) { 1471 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); 1472 return; 1473 } 1474 header = (struct ext2_ext_attr_header *) block_buf; 1475 pctx.blkcount = header->h_refcount; 1476 should_be = header->h_refcount + adjust_sign * count; 1477 pctx.num = should_be; 1478 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { 1479 header->h_refcount = should_be; 1480 pctx.errcode = ext2fs_write_ext_attr2(fs, blk, 1481 block_buf); 1482 if (pctx.errcode) { 1483 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, 1484 &pctx); 1485 continue; 1486 } 1487 } 1488 } 1489} 1490 1491/* 1492 * Handle processing the extended attribute blocks 1493 */ 1494static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, 1495 char *block_buf) 1496{ 1497 ext2_filsys fs = ctx->fs; 1498 ext2_ino_t ino = pctx->ino; 1499 struct ext2_inode *inode = pctx->inode; 1500 blk64_t blk; 1501 char * end; 1502 struct ext2_ext_attr_header *header; 1503 struct ext2_ext_attr_entry *entry; 1504 int count; 1505 region_t region = 0; 1506 1507 blk = ext2fs_file_acl_block(fs, inode); 1508 if (blk == 0) 1509 return 0; 1510 1511 /* 1512 * If the Extended attribute flag isn't set, then a non-zero 1513 * file acl means that the inode is corrupted. 1514 * 1515 * Or if the extended attribute block is an invalid block, 1516 * then the inode is also corrupted. 1517 */ 1518 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || 1519 (blk < fs->super->s_first_data_block) || 1520 (blk >= ext2fs_blocks_count(fs->super))) { 1521 mark_inode_bad(ctx, ino); 1522 return 0; 1523 } 1524 1525 /* If ea bitmap hasn't been allocated, create it */ 1526 if (!ctx->block_ea_map) { 1527 pctx->errcode = e2fsck_allocate_block_bitmap(fs, 1528 _("ext attr block map"), 1529 EXT2FS_BMAP64_RBTREE, "block_ea_map", 1530 &ctx->block_ea_map); 1531 if (pctx->errcode) { 1532 pctx->num = 2; 1533 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); 1534 ctx->flags |= E2F_FLAG_ABORT; 1535 return 0; 1536 } 1537 } 1538 1539 /* Create the EA refcount structure if necessary */ 1540 if (!ctx->refcount) { 1541 pctx->errcode = ea_refcount_create(0, &ctx->refcount); 1542 if (pctx->errcode) { 1543 pctx->num = 1; 1544 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 1545 ctx->flags |= E2F_FLAG_ABORT; 1546 return 0; 1547 } 1548 } 1549 1550#if 0 1551 /* Debugging text */ 1552 printf("Inode %u has EA block %u\n", ino, blk); 1553#endif 1554 1555 /* Have we seen this EA block before? */ 1556 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) { 1557 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) 1558 return 1; 1559 /* Ooops, this EA was referenced more than it stated */ 1560 if (!ctx->refcount_extra) { 1561 pctx->errcode = ea_refcount_create(0, 1562 &ctx->refcount_extra); 1563 if (pctx->errcode) { 1564 pctx->num = 2; 1565 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 1566 ctx->flags |= E2F_FLAG_ABORT; 1567 return 0; 1568 } 1569 } 1570 ea_refcount_increment(ctx->refcount_extra, blk, 0); 1571 return 1; 1572 } 1573 1574 /* 1575 * OK, we haven't seen this EA block yet. So we need to 1576 * validate it 1577 */ 1578 pctx->blk = blk; 1579 pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); 1580 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) 1581 goto clear_extattr; 1582 header = (struct ext2_ext_attr_header *) block_buf; 1583 pctx->blk = ext2fs_file_acl_block(fs, inode); 1584 if (((ctx->ext_attr_ver == 1) && 1585 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || 1586 ((ctx->ext_attr_ver == 2) && 1587 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { 1588 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) 1589 goto clear_extattr; 1590 } 1591 1592 if (header->h_blocks != 1) { 1593 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) 1594 goto clear_extattr; 1595 } 1596 1597 region = region_create(0, fs->blocksize); 1598 if (!region) { 1599 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); 1600 ctx->flags |= E2F_FLAG_ABORT; 1601 return 0; 1602 } 1603 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { 1604 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1605 goto clear_extattr; 1606 } 1607 1608 entry = (struct ext2_ext_attr_entry *)(header+1); 1609 end = block_buf + fs->blocksize; 1610 while ((char *)entry < end && *(__u32 *)entry) { 1611 __u32 hash; 1612 1613 if (region_allocate(region, (char *)entry - (char *)header, 1614 EXT2_EXT_ATTR_LEN(entry->e_name_len))) { 1615 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1616 goto clear_extattr; 1617 break; 1618 } 1619 if ((ctx->ext_attr_ver == 1 && 1620 (entry->e_name_len == 0 || entry->e_name_index != 0)) || 1621 (ctx->ext_attr_ver == 2 && 1622 entry->e_name_index == 0)) { 1623 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) 1624 goto clear_extattr; 1625 break; 1626 } 1627 if (entry->e_value_block != 0) { 1628 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 1629 goto clear_extattr; 1630 } 1631 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) { 1632 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 1633 goto clear_extattr; 1634 break; 1635 } 1636 if (entry->e_value_size && 1637 region_allocate(region, entry->e_value_offs, 1638 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { 1639 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1640 goto clear_extattr; 1641 } 1642 1643 hash = ext2fs_ext_attr_hash_entry(entry, block_buf + 1644 entry->e_value_offs); 1645 1646 if (entry->e_hash != hash) { 1647 pctx->num = entry->e_hash; 1648 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx)) 1649 goto clear_extattr; 1650 entry->e_hash = hash; 1651 } 1652 1653 entry = EXT2_EXT_ATTR_NEXT(entry); 1654 } 1655 if (region_allocate(region, (char *)entry - (char *)header, 4)) { 1656 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1657 goto clear_extattr; 1658 } 1659 region_free(region); 1660 1661 count = header->h_refcount - 1; 1662 if (count) 1663 ea_refcount_store(ctx->refcount, blk, count); 1664 mark_block_used(ctx, blk); 1665 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); 1666 return 1; 1667 1668clear_extattr: 1669 if (region) 1670 region_free(region); 1671 ext2fs_file_acl_block_set(fs, inode, 0); 1672 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); 1673 return 0; 1674} 1675 1676/* Returns 1 if bad htree, 0 if OK */ 1677static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, 1678 ext2_ino_t ino, struct ext2_inode *inode, 1679 char *block_buf) 1680{ 1681 struct ext2_dx_root_info *root; 1682 ext2_filsys fs = ctx->fs; 1683 errcode_t retval; 1684 blk64_t blk; 1685 1686 if ((!LINUX_S_ISDIR(inode->i_mode) && 1687 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || 1688 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && 1689 fix_problem(ctx, PR_1_HTREE_SET, pctx))) 1690 return 1; 1691 1692 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk); 1693 1694 if ((pctx->errcode) || 1695 (blk == 0) || 1696 (blk < fs->super->s_first_data_block) || 1697 (blk >= ext2fs_blocks_count(fs->super))) { 1698 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1699 return 1; 1700 else 1701 return 0; 1702 } 1703 1704 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); 1705 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1706 return 1; 1707 1708 /* XXX should check that beginning matches a directory */ 1709 root = (struct ext2_dx_root_info *) (block_buf + 24); 1710 1711 if ((root->reserved_zero || root->info_length < 8) && 1712 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1713 return 1; 1714 1715 pctx->num = root->hash_version; 1716 if ((root->hash_version != EXT2_HASH_LEGACY) && 1717 (root->hash_version != EXT2_HASH_HALF_MD4) && 1718 (root->hash_version != EXT2_HASH_TEA) && 1719 fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) 1720 return 1; 1721 1722 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && 1723 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) 1724 return 1; 1725 1726 pctx->num = root->indirect_levels; 1727 if ((root->indirect_levels > 1) && 1728 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) 1729 return 1; 1730 1731 return 0; 1732} 1733 1734void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, 1735 struct ext2_inode *inode, int restart_flag, 1736 const char *source) 1737{ 1738 inode->i_flags = 0; 1739 inode->i_links_count = 0; 1740 ext2fs_icount_store(ctx->inode_link_info, ino, 0); 1741 inode->i_dtime = ctx->now; 1742 1743 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); 1744 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); 1745 if (ctx->inode_reg_map) 1746 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); 1747 if (ctx->inode_bad_map) 1748 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); 1749 1750 /* 1751 * If the inode was partially accounted for before processing 1752 * was aborted, we need to restart the pass 1 scan. 1753 */ 1754 ctx->flags |= restart_flag; 1755 1756 if (ino == EXT2_BAD_INO) 1757 memset(inode, 0, sizeof(struct ext2_inode)); 1758 1759 e2fsck_write_inode(ctx, ino, inode, source); 1760} 1761 1762static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, 1763 struct process_block_struct *pb, 1764 blk64_t start_block, 1765 ext2_extent_handle_t ehandle) 1766{ 1767 struct ext2fs_extent extent; 1768 blk64_t blk; 1769 e2_blkcnt_t blockcnt; 1770 unsigned int i; 1771 int is_dir, is_leaf; 1772 errcode_t problem; 1773 struct ext2_extent_info info; 1774 1775 pctx->errcode = ext2fs_extent_get_info(ehandle, &info); 1776 if (pctx->errcode) 1777 return; 1778 1779 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, 1780 &extent); 1781 while (!pctx->errcode && info.num_entries-- > 0) { 1782 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF; 1783 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode); 1784 1785 problem = 0; 1786 if (extent.e_pblk == 0 || 1787 extent.e_pblk < ctx->fs->super->s_first_data_block || 1788 extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) 1789 problem = PR_1_EXTENT_BAD_START_BLK; 1790 else if (extent.e_lblk < start_block) 1791 problem = PR_1_OUT_OF_ORDER_EXTENTS; 1792 else if (is_leaf && extent.e_len == 0) 1793 problem = PR_1_EXTENT_LENGTH_ZERO; 1794 else if (is_leaf && 1795 (extent.e_pblk + extent.e_len) > 1796 ext2fs_blocks_count(ctx->fs->super)) 1797 problem = PR_1_EXTENT_ENDS_BEYOND; 1798 1799 if (problem) { 1800report_problem: 1801 pctx->blk = extent.e_pblk; 1802 pctx->blk2 = extent.e_lblk; 1803 pctx->num = extent.e_len; 1804 if (fix_problem(ctx, problem, pctx)) { 1805 e2fsck_read_bitmaps(ctx); 1806 pctx->errcode = 1807 ext2fs_extent_delete(ehandle, 0); 1808 if (pctx->errcode) { 1809 pctx->str = "ext2fs_extent_delete"; 1810 return; 1811 } 1812 ext2fs_extent_fix_parents(ehandle); 1813 pctx->errcode = ext2fs_extent_get(ehandle, 1814 EXT2_EXTENT_CURRENT, 1815 &extent); 1816 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) { 1817 pctx->errcode = 0; 1818 break; 1819 } 1820 continue; 1821 } 1822 goto next; 1823 } 1824 1825 if (!is_leaf) { 1826 blk64_t lblk; 1827 1828 blk = extent.e_pblk; 1829 lblk = extent.e_lblk; 1830 pctx->errcode = ext2fs_extent_get(ehandle, 1831 EXT2_EXTENT_DOWN, &extent); 1832 if (pctx->errcode) { 1833 pctx->str = "EXT2_EXTENT_DOWN"; 1834 problem = PR_1_EXTENT_HEADER_INVALID; 1835 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) 1836 goto report_problem; 1837 return; 1838 } 1839 /* The next extent should match this index's logical start */ 1840 if (extent.e_lblk != lblk) { 1841 struct ext2_extent_info info; 1842 1843 ext2fs_extent_get_info(ehandle, &info); 1844 pctx->blk = lblk; 1845 pctx->blk2 = extent.e_lblk; 1846 pctx->num = info.curr_level - 1; 1847 problem = PR_1_EXTENT_INDEX_START_INVALID; 1848 if (fix_problem(ctx, problem, pctx)) 1849 ext2fs_extent_fix_parents(ehandle); 1850 } 1851 scan_extent_node(ctx, pctx, pb, extent.e_lblk, ehandle); 1852 if (pctx->errcode) 1853 return; 1854 pctx->errcode = ext2fs_extent_get(ehandle, 1855 EXT2_EXTENT_UP, &extent); 1856 if (pctx->errcode) { 1857 pctx->str = "EXT2_EXTENT_UP"; 1858 return; 1859 } 1860 mark_block_used(ctx, blk); 1861 pb->num_blocks++; 1862 goto next; 1863 } 1864 1865 if ((pb->previous_block != 0) && 1866 (pb->previous_block+1 != extent.e_pblk)) { 1867 if (ctx->options & E2F_OPT_FRAGCHECK) { 1868 char type = '?'; 1869 1870 if (pb->is_dir) 1871 type = 'd'; 1872 else if (pb->is_reg) 1873 type = 'f'; 1874 1875 printf(("%6lu(%c): expecting %6lu " 1876 "actual extent " 1877 "phys %6lu log %lu len %lu\n"), 1878 (unsigned long) pctx->ino, type, 1879 (unsigned long) pb->previous_block+1, 1880 (unsigned long) extent.e_pblk, 1881 (unsigned long) extent.e_lblk, 1882 (unsigned long) extent.e_len); 1883 } 1884 pb->fragmented = 1; 1885 } 1886 while (is_dir && ++pb->last_db_block < extent.e_lblk) { 1887 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, 1888 pb->ino, 0, 1889 pb->last_db_block); 1890 if (pctx->errcode) { 1891 pctx->blk = 0; 1892 pctx->num = pb->last_db_block; 1893 goto failed_add_dir_block; 1894 } 1895 } 1896 if (!ctx->fs->cluster_ratio_bits) { 1897 mark_blocks_used(ctx, extent.e_pblk, extent.e_len); 1898 pb->num_blocks += extent.e_len; 1899 } 1900 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0; 1901 i < extent.e_len; 1902 blk++, blockcnt++, i++) { 1903 if (ctx->fs->cluster_ratio_bits && 1904 !(pb->previous_block && 1905 (EXT2FS_B2C(ctx->fs, blk) == 1906 EXT2FS_B2C(ctx->fs, pb->previous_block)) && 1907 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 1908 (blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 1909 mark_block_used(ctx, blk); 1910 pb->num_blocks++; 1911 } 1912 1913 pb->previous_block = blk; 1914 1915 if (is_dir) { 1916 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt); 1917 if (pctx->errcode) { 1918 pctx->blk = blk; 1919 pctx->num = blockcnt; 1920 failed_add_dir_block: 1921 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 1922 /* Should never get here */ 1923 ctx->flags |= E2F_FLAG_ABORT; 1924 return; 1925 } 1926 } 1927 } 1928 if (is_dir && extent.e_len > 0) 1929 pb->last_db_block = blockcnt - 1; 1930 pb->previous_block = extent.e_pblk + extent.e_len - 1; 1931 start_block = pb->last_block = extent.e_lblk + extent.e_len - 1; 1932 if (is_leaf && !is_dir && 1933 !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) 1934 pb->last_init_lblock = extent.e_lblk + extent.e_len - 1; 1935 next: 1936 pctx->errcode = ext2fs_extent_get(ehandle, 1937 EXT2_EXTENT_NEXT_SIB, 1938 &extent); 1939 } 1940 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT) 1941 pctx->errcode = 0; 1942} 1943 1944static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, 1945 struct process_block_struct *pb) 1946{ 1947 struct ext2_extent_info info; 1948 struct ext2_inode *inode = pctx->inode; 1949 ext2_extent_handle_t ehandle; 1950 ext2_filsys fs = ctx->fs; 1951 ext2_ino_t ino = pctx->ino; 1952 errcode_t retval; 1953 1954 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); 1955 if (pctx->errcode) { 1956 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx)) 1957 e2fsck_clear_inode(ctx, ino, inode, 0, 1958 "check_blocks_extents"); 1959 pctx->errcode = 0; 1960 return; 1961 } 1962 1963 retval = ext2fs_extent_get_info(ehandle, &info); 1964 if (retval == 0) { 1965 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT) 1966 info.max_depth = MAX_EXTENT_DEPTH_COUNT-1; 1967 ctx->extent_depth_count[info.max_depth]++; 1968 } 1969 1970 scan_extent_node(ctx, pctx, pb, 0, ehandle); 1971 if (pctx->errcode && 1972 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { 1973 pb->num_blocks = 0; 1974 inode->i_blocks = 0; 1975 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 1976 "check_blocks_extents"); 1977 pctx->errcode = 0; 1978 } 1979 ext2fs_extent_free(ehandle); 1980} 1981 1982/* 1983 * This subroutine is called on each inode to account for all of the 1984 * blocks used by that inode. 1985 */ 1986static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 1987 char *block_buf) 1988{ 1989 ext2_filsys fs = ctx->fs; 1990 struct process_block_struct pb; 1991 ext2_ino_t ino = pctx->ino; 1992 struct ext2_inode *inode = pctx->inode; 1993 int bad_size = 0; 1994 int dirty_inode = 0; 1995 int extent_fs; 1996 __u64 size; 1997 1998 pb.ino = ino; 1999 pb.num_blocks = 0; 2000 pb.last_block = -1; 2001 pb.last_init_lblock = -1; 2002 pb.last_db_block = -1; 2003 pb.num_illegal_blocks = 0; 2004 pb.suppress = 0; pb.clear = 0; 2005 pb.fragmented = 0; 2006 pb.compressed = 0; 2007 pb.previous_block = 0; 2008 pb.is_dir = LINUX_S_ISDIR(inode->i_mode); 2009 pb.is_reg = LINUX_S_ISREG(inode->i_mode); 2010 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); 2011 pb.inode = inode; 2012 pb.pctx = pctx; 2013 pb.ctx = ctx; 2014 pctx->ino = ino; 2015 pctx->errcode = 0; 2016 2017 extent_fs = (ctx->fs->super->s_feature_incompat & 2018 EXT3_FEATURE_INCOMPAT_EXTENTS); 2019 2020 if (inode->i_flags & EXT2_COMPRBLK_FL) { 2021 if (fs->super->s_feature_incompat & 2022 EXT2_FEATURE_INCOMPAT_COMPRESSION) 2023 pb.compressed = 1; 2024 else { 2025 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { 2026 inode->i_flags &= ~EXT2_COMPRBLK_FL; 2027 dirty_inode++; 2028 } 2029 } 2030 } 2031 2032 if (ext2fs_file_acl_block(fs, inode) && 2033 check_ext_attr(ctx, pctx, block_buf)) { 2034 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2035 goto out; 2036 pb.num_blocks++; 2037 } 2038 2039 if (ext2fs_inode_has_valid_blocks2(fs, inode)) { 2040 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) 2041 check_blocks_extents(ctx, pctx, &pb); 2042 else { 2043 pctx->errcode = ext2fs_block_iterate3(fs, ino, 2044 pb.is_dir ? BLOCK_FLAG_HOLE : 0, 2045 block_buf, process_block, &pb); 2046 /* 2047 * We do not have uninitialized extents in non extent 2048 * files. 2049 */ 2050 pb.last_init_lblock = pb.last_block; 2051 } 2052 } 2053 end_problem_latch(ctx, PR_LATCH_BLOCK); 2054 end_problem_latch(ctx, PR_LATCH_TOOBIG); 2055 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2056 goto out; 2057 if (pctx->errcode) 2058 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); 2059 2060 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) { 2061 if (LINUX_S_ISDIR(inode->i_mode)) 2062 ctx->fs_fragmented_dir++; 2063 else 2064 ctx->fs_fragmented++; 2065 } 2066 2067 if (pb.clear) { 2068 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 2069 "check_blocks"); 2070 return; 2071 } 2072 2073 if (inode->i_flags & EXT2_INDEX_FL) { 2074 if (handle_htree(ctx, pctx, ino, inode, block_buf)) { 2075 inode->i_flags &= ~EXT2_INDEX_FL; 2076 dirty_inode++; 2077 } else { 2078#ifdef ENABLE_HTREE 2079 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); 2080#endif 2081 } 2082 } 2083 2084 if (!pb.num_blocks && pb.is_dir) { 2085 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { 2086 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); 2087 ctx->fs_directory_count--; 2088 return; 2089 } 2090 } 2091 2092 if (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) { 2093 quota_data_add(ctx->qctx, inode, ino, 2094 pb.num_blocks * fs->blocksize); 2095 quota_data_inodes(ctx->qctx, inode, ino, +1); 2096 } 2097 2098 if (!(fs->super->s_feature_ro_compat & 2099 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) || 2100 !(inode->i_flags & EXT4_HUGE_FILE_FL)) 2101 pb.num_blocks *= (fs->blocksize / 512); 2102 pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); 2103#if 0 2104 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n", 2105 ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode), 2106 pb.num_blocks); 2107#endif 2108 if (pb.is_dir) { 2109 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); 2110 if (inode->i_size & (fs->blocksize - 1)) 2111 bad_size = 5; 2112 else if (nblock > (pb.last_block + 1)) 2113 bad_size = 1; 2114 else if (nblock < (pb.last_block + 1)) { 2115 if (((pb.last_block + 1) - nblock) > 2116 fs->super->s_prealloc_dir_blocks) 2117 bad_size = 2; 2118 } 2119 } else { 2120 e2_blkcnt_t blkpg = ctx->blocks_per_page; 2121 2122 size = EXT2_I_SIZE(inode); 2123 if ((pb.last_init_lblock >= 0) && 2124 /* allow allocated blocks to end of PAGE_SIZE */ 2125 (size < (__u64)pb.last_init_lblock * fs->blocksize) && 2126 (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock || 2127 size < (__u64)(pb.last_init_lblock & ~(blkpg-1)) * 2128 fs->blocksize)) 2129 bad_size = 3; 2130 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 2131 size > ext2_max_sizes[fs->super->s_log_block_size]) 2132 /* too big for a direct/indirect-mapped file */ 2133 bad_size = 4; 2134 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 2135 size > 2136 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1)) 2137 /* too big for an extent-based file - 32bit ee_block */ 2138 bad_size = 6; 2139 } 2140 /* i_size for symlinks is checked elsewhere */ 2141 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { 2142 pctx->num = (pb.last_block+1) * fs->blocksize; 2143 pctx->group = bad_size; 2144 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { 2145 inode->i_size = pctx->num; 2146 if (!LINUX_S_ISDIR(inode->i_mode)) 2147 inode->i_size_high = pctx->num >> 32; 2148 dirty_inode++; 2149 } 2150 pctx->num = 0; 2151 } 2152 if (LINUX_S_ISREG(inode->i_mode) && EXT2_I_SIZE(inode) >= 0x80000000UL) 2153 ctx->large_files++; 2154 if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || 2155 ((fs->super->s_feature_ro_compat & 2156 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && 2157 (inode->i_flags & EXT4_HUGE_FILE_FL) && 2158 (inode->osd2.linux2.l_i_blocks_hi != 0))) { 2159 pctx->num = pb.num_blocks; 2160 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { 2161 inode->i_blocks = pb.num_blocks; 2162 inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32; 2163 dirty_inode++; 2164 } 2165 pctx->num = 0; 2166 } 2167 2168 if (ctx->dirs_to_hash && pb.is_dir && 2169 !(inode->i_flags & EXT2_INDEX_FL) && 2170 ((inode->i_size / fs->blocksize) >= 3)) 2171 ext2fs_u32_list_add(ctx->dirs_to_hash, ino); 2172 2173out: 2174 if (dirty_inode) 2175 e2fsck_write_inode(ctx, ino, inode, "check_blocks"); 2176} 2177 2178#if 0 2179/* 2180 * Helper function called by process block when an illegal block is 2181 * found. It returns a description about why the block is illegal 2182 */ 2183static char *describe_illegal_block(ext2_filsys fs, blk64_t block) 2184{ 2185 blk64_t super; 2186 int i; 2187 static char problem[80]; 2188 2189 super = fs->super->s_first_data_block; 2190 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block"); 2191 if (block < super) { 2192 sprintf(problem, "< FIRSTBLOCK (%u)", super); 2193 return(problem); 2194 } else if (block >= ext2fs_blocks_count(fs->super)) { 2195 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super)); 2196 return(problem); 2197 } 2198 for (i = 0; i < fs->group_desc_count; i++) { 2199 if (block == super) { 2200 sprintf(problem, "is the superblock in group %d", i); 2201 break; 2202 } 2203 if (block > super && 2204 block <= (super + fs->desc_blocks)) { 2205 sprintf(problem, "is in the group descriptors " 2206 "of group %d", i); 2207 break; 2208 } 2209 if (block == ext2fs_block_bitmap_loc(fs, i)) { 2210 sprintf(problem, "is the block bitmap of group %d", i); 2211 break; 2212 } 2213 if (block == ext2fs_inode_bitmap_loc(fs, i)) { 2214 sprintf(problem, "is the inode bitmap of group %d", i); 2215 break; 2216 } 2217 if (block >= ext2fs_inode_table_loc(fs, i) && 2218 (block < ext2fs_inode_table_loc(fs, i) 2219 + fs->inode_blocks_per_group)) { 2220 sprintf(problem, "is in the inode table of group %d", 2221 i); 2222 break; 2223 } 2224 super += fs->super->s_blocks_per_group; 2225 } 2226 return(problem); 2227} 2228#endif 2229 2230/* 2231 * This is a helper function for check_blocks(). 2232 */ 2233static int process_block(ext2_filsys fs, 2234 blk64_t *block_nr, 2235 e2_blkcnt_t blockcnt, 2236 blk64_t ref_block EXT2FS_ATTR((unused)), 2237 int ref_offset EXT2FS_ATTR((unused)), 2238 void *priv_data) 2239{ 2240 struct process_block_struct *p; 2241 struct problem_context *pctx; 2242 blk64_t blk = *block_nr; 2243 int ret_code = 0; 2244 int problem = 0; 2245 e2fsck_t ctx; 2246 2247 p = (struct process_block_struct *) priv_data; 2248 pctx = p->pctx; 2249 ctx = p->ctx; 2250 2251 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { 2252 /* todo: Check that the comprblk_fl is high, that the 2253 blkaddr pattern looks right (all non-holes up to 2254 first EXT2FS_COMPRESSED_BLKADDR, then all 2255 EXT2FS_COMPRESSED_BLKADDR up to end of cluster), 2256 that the feature_incompat bit is high, and that the 2257 inode is a regular file. If we're doing a "full 2258 check" (a concept introduced to e2fsck by e2compr, 2259 meaning that we look at data blocks as well as 2260 metadata) then call some library routine that 2261 checks the compressed data. I'll have to think 2262 about this, because one particularly important 2263 problem to be able to fix is to recalculate the 2264 cluster size if necessary. I think that perhaps 2265 we'd better do most/all e2compr-specific checks 2266 separately, after the non-e2compr checks. If not 2267 doing a full check, it may be useful to test that 2268 the personality is linux; e.g. if it isn't then 2269 perhaps this really is just an illegal block. */ 2270 return 0; 2271 } 2272 2273 if (blk == 0) 2274 return 0; 2275 2276#if 0 2277 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk, 2278 blockcnt); 2279#endif 2280 2281 /* 2282 * Simplistic fragmentation check. We merely require that the 2283 * file be contiguous. (Which can never be true for really 2284 * big files that are greater than a block group.) 2285 */ 2286 if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) { 2287 if (p->previous_block+1 != blk) { 2288 if (ctx->options & E2F_OPT_FRAGCHECK) { 2289 char type = '?'; 2290 2291 if (p->is_dir) 2292 type = 'd'; 2293 else if (p->is_reg) 2294 type = 'f'; 2295 2296 printf(_("%6lu(%c): expecting %6lu " 2297 "got phys %6lu (blkcnt %lld)\n"), 2298 (unsigned long) pctx->ino, type, 2299 (unsigned long) p->previous_block+1, 2300 (unsigned long) blk, 2301 blockcnt); 2302 } 2303 p->fragmented = 1; 2304 } 2305 } 2306 2307 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) 2308 problem = PR_1_TOOBIG_DIR; 2309 if (p->is_reg && p->num_blocks+1 >= p->max_blocks) 2310 problem = PR_1_TOOBIG_REG; 2311 if (!p->is_dir && !p->is_reg && blockcnt > 0) 2312 problem = PR_1_TOOBIG_SYMLINK; 2313 2314 if (blk < fs->super->s_first_data_block || 2315 blk >= ext2fs_blocks_count(fs->super)) 2316 problem = PR_1_ILLEGAL_BLOCK_NUM; 2317 2318 if (problem) { 2319 p->num_illegal_blocks++; 2320 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { 2321 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { 2322 p->clear = 1; 2323 return BLOCK_ABORT; 2324 } 2325 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { 2326 p->suppress = 1; 2327 set_latch_flags(PR_LATCH_BLOCK, 2328 PRL_SUPPRESS, 0); 2329 } 2330 } 2331 pctx->blk = blk; 2332 pctx->blkcount = blockcnt; 2333 if (fix_problem(ctx, problem, pctx)) { 2334 blk = *block_nr = 0; 2335 ret_code = BLOCK_CHANGED; 2336 goto mark_dir; 2337 } else 2338 return 0; 2339 } 2340 2341 if (p->ino == EXT2_RESIZE_INO) { 2342 /* 2343 * The resize inode has already be sanity checked 2344 * during pass #0 (the superblock checks). All we 2345 * have to do is mark the double indirect block as 2346 * being in use; all of the other blocks are handled 2347 * by mark_table_blocks()). 2348 */ 2349 if (blockcnt == BLOCK_COUNT_DIND) 2350 mark_block_used(ctx, blk); 2351 p->num_blocks++; 2352 } else if (!(ctx->fs->cluster_ratio_bits && 2353 p->previous_block && 2354 (EXT2FS_B2C(ctx->fs, blk) == 2355 EXT2FS_B2C(ctx->fs, p->previous_block)) && 2356 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 2357 (blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 2358 mark_block_used(ctx, blk); 2359 p->num_blocks++; 2360 } 2361 if (blockcnt >= 0) 2362 p->last_block = blockcnt; 2363 p->previous_block = blk; 2364mark_dir: 2365 if (p->is_dir && (blockcnt >= 0)) { 2366 while (++p->last_db_block < blockcnt) { 2367 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, 2368 p->ino, 0, 2369 p->last_db_block); 2370 if (pctx->errcode) { 2371 pctx->blk = 0; 2372 pctx->num = p->last_db_block; 2373 goto failed_add_dir_block; 2374 } 2375 } 2376 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 2377 blk, blockcnt); 2378 if (pctx->errcode) { 2379 pctx->blk = blk; 2380 pctx->num = blockcnt; 2381 failed_add_dir_block: 2382 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 2383 /* Should never get here */ 2384 ctx->flags |= E2F_FLAG_ABORT; 2385 return BLOCK_ABORT; 2386 } 2387 } 2388 return ret_code; 2389} 2390 2391static int process_bad_block(ext2_filsys fs, 2392 blk64_t *block_nr, 2393 e2_blkcnt_t blockcnt, 2394 blk64_t ref_block EXT2FS_ATTR((unused)), 2395 int ref_offset EXT2FS_ATTR((unused)), 2396 void *priv_data) 2397{ 2398 struct process_block_struct *p; 2399 blk64_t blk = *block_nr; 2400 blk64_t first_block; 2401 dgrp_t i; 2402 struct problem_context *pctx; 2403 e2fsck_t ctx; 2404 2405 /* 2406 * Note: This function processes blocks for the bad blocks 2407 * inode, which is never compressed. So we don't use HOLE_BLKADDR(). 2408 */ 2409 2410 if (!blk) 2411 return 0; 2412 2413 p = (struct process_block_struct *) priv_data; 2414 ctx = p->ctx; 2415 pctx = p->pctx; 2416 2417 pctx->ino = EXT2_BAD_INO; 2418 pctx->blk = blk; 2419 pctx->blkcount = blockcnt; 2420 2421 if ((blk < fs->super->s_first_data_block) || 2422 (blk >= ext2fs_blocks_count(fs->super))) { 2423 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { 2424 *block_nr = 0; 2425 return BLOCK_CHANGED; 2426 } else 2427 return 0; 2428 } 2429 2430 if (blockcnt < 0) { 2431 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) { 2432 p->bbcheck = 1; 2433 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { 2434 *block_nr = 0; 2435 return BLOCK_CHANGED; 2436 } 2437 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2438 blk)) { 2439 p->bbcheck = 1; 2440 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, 2441 pctx)) { 2442 *block_nr = 0; 2443 return BLOCK_CHANGED; 2444 } 2445 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2446 return BLOCK_ABORT; 2447 } else 2448 mark_block_used(ctx, blk); 2449 return 0; 2450 } 2451#if 0 2452 printf ("DEBUG: Marking %u as bad.\n", blk); 2453#endif 2454 ctx->fs_badblocks_count++; 2455 /* 2456 * If the block is not used, then mark it as used and return. 2457 * If it is already marked as found, this must mean that 2458 * there's an overlap between the filesystem table blocks 2459 * (bitmaps and inode table) and the bad block list. 2460 */ 2461 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { 2462 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 2463 return 0; 2464 } 2465 /* 2466 * Try to find the where the filesystem block was used... 2467 */ 2468 first_block = fs->super->s_first_data_block; 2469 2470 for (i = 0; i < fs->group_desc_count; i++ ) { 2471 pctx->group = i; 2472 pctx->blk = blk; 2473 if (!ext2fs_bg_has_super(fs, i)) 2474 goto skip_super; 2475 if (blk == first_block) { 2476 if (i == 0) { 2477 if (fix_problem(ctx, 2478 PR_1_BAD_PRIMARY_SUPERBLOCK, 2479 pctx)) { 2480 *block_nr = 0; 2481 return BLOCK_CHANGED; 2482 } 2483 return 0; 2484 } 2485 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx); 2486 return 0; 2487 } 2488 if ((blk > first_block) && 2489 (blk <= first_block + fs->desc_blocks)) { 2490 if (i == 0) { 2491 pctx->blk = *block_nr; 2492 if (fix_problem(ctx, 2493 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) { 2494 *block_nr = 0; 2495 return BLOCK_CHANGED; 2496 } 2497 return 0; 2498 } 2499 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx); 2500 return 0; 2501 } 2502 skip_super: 2503 if (blk == ext2fs_block_bitmap_loc(fs, i)) { 2504 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { 2505 ctx->invalid_block_bitmap_flag[i]++; 2506 ctx->invalid_bitmaps++; 2507 } 2508 return 0; 2509 } 2510 if (blk == ext2fs_inode_bitmap_loc(fs, i)) { 2511 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { 2512 ctx->invalid_inode_bitmap_flag[i]++; 2513 ctx->invalid_bitmaps++; 2514 } 2515 return 0; 2516 } 2517 if ((blk >= ext2fs_inode_table_loc(fs, i)) && 2518 (blk < (ext2fs_inode_table_loc(fs, i) + 2519 fs->inode_blocks_per_group))) { 2520 /* 2521 * If there are bad blocks in the inode table, 2522 * the inode scan code will try to do 2523 * something reasonable automatically. 2524 */ 2525 return 0; 2526 } 2527 first_block += fs->super->s_blocks_per_group; 2528 } 2529 /* 2530 * If we've gotten to this point, then the only 2531 * possibility is that the bad block inode meta data 2532 * is using a bad block. 2533 */ 2534 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) || 2535 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) || 2536 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) { 2537 p->bbcheck = 1; 2538 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) { 2539 *block_nr = 0; 2540 return BLOCK_CHANGED; 2541 } 2542 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2543 return BLOCK_ABORT; 2544 return 0; 2545 } 2546 2547 pctx->group = -1; 2548 2549 /* Warn user that the block wasn't claimed */ 2550 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx); 2551 2552 return 0; 2553} 2554 2555static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, 2556 const char *name, int num, blk64_t *new_block) 2557{ 2558 ext2_filsys fs = ctx->fs; 2559 dgrp_t last_grp; 2560 blk64_t old_block = *new_block; 2561 blk64_t last_block; 2562 int i, is_flexbg, flexbg, flexbg_size; 2563 char *buf; 2564 struct problem_context pctx; 2565 2566 clear_problem_context(&pctx); 2567 2568 pctx.group = group; 2569 pctx.blk = old_block; 2570 pctx.str = name; 2571 2572 /* 2573 * For flex_bg filesystems, first try to allocate the metadata 2574 * within the flex_bg, and if that fails then try finding the 2575 * space anywhere in the filesystem. 2576 */ 2577 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super, 2578 EXT4_FEATURE_INCOMPAT_FLEX_BG); 2579 if (is_flexbg) { 2580 flexbg_size = 1 << fs->super->s_log_groups_per_flex; 2581 flexbg = group / flexbg_size; 2582 first_block = ext2fs_group_first_block2(fs, 2583 flexbg_size * flexbg); 2584 last_grp = group | (flexbg_size - 1); 2585 if (last_grp > fs->group_desc_count) 2586 last_grp = fs->group_desc_count; 2587 last_block = ext2fs_group_last_block2(fs, last_grp); 2588 } else 2589 last_block = ext2fs_group_last_block2(fs, group); 2590 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block, 2591 num, ctx->block_found_map, 2592 new_block); 2593 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL)) 2594 pctx.errcode = ext2fs_get_free_blocks2(fs, 2595 fs->super->s_first_data_block, 2596 ext2fs_blocks_count(fs->super), 2597 num, ctx->block_found_map, new_block); 2598 if (pctx.errcode) { 2599 pctx.num = num; 2600 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx); 2601 ext2fs_unmark_valid(fs); 2602 ctx->flags |= E2F_FLAG_ABORT; 2603 return; 2604 } 2605 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); 2606 if (pctx.errcode) { 2607 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); 2608 ext2fs_unmark_valid(fs); 2609 ctx->flags |= E2F_FLAG_ABORT; 2610 return; 2611 } 2612 ext2fs_mark_super_dirty(fs); 2613 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 2614 pctx.blk2 = *new_block; 2615 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO : 2616 PR_1_RELOC_TO), &pctx); 2617 pctx.blk2 = 0; 2618 for (i = 0; i < num; i++) { 2619 pctx.blk = i; 2620 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i); 2621 if (old_block) { 2622 pctx.errcode = io_channel_read_blk64(fs->io, 2623 old_block + i, 1, buf); 2624 if (pctx.errcode) 2625 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); 2626 } else 2627 memset(buf, 0, fs->blocksize); 2628 2629 pctx.blk = (*new_block) + i; 2630 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, 2631 1, buf); 2632 if (pctx.errcode) 2633 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); 2634 } 2635 ext2fs_free_mem(&buf); 2636} 2637 2638/* 2639 * This routine gets called at the end of pass 1 if bad blocks are 2640 * detected in the superblock, group descriptors, inode_bitmaps, or 2641 * block bitmaps. At this point, all of the blocks have been mapped 2642 * out, so we can try to allocate new block(s) to replace the bad 2643 * blocks. 2644 */ 2645static void handle_fs_bad_blocks(e2fsck_t ctx) 2646{ 2647 ext2_filsys fs = ctx->fs; 2648 dgrp_t i; 2649 blk64_t first_block; 2650 blk64_t new_blk; 2651 2652 for (i = 0; i < fs->group_desc_count; i++) { 2653 first_block = ext2fs_group_first_block2(fs, i); 2654 2655 if (ctx->invalid_block_bitmap_flag[i]) { 2656 new_blk = ext2fs_block_bitmap_loc(fs, i); 2657 new_table_block(ctx, first_block, i, _("block bitmap"), 2658 1, &new_blk); 2659 ext2fs_block_bitmap_loc_set(fs, i, new_blk); 2660 } 2661 if (ctx->invalid_inode_bitmap_flag[i]) { 2662 new_blk = ext2fs_inode_bitmap_loc(fs, i); 2663 new_table_block(ctx, first_block, i, _("inode bitmap"), 2664 1, &new_blk); 2665 ext2fs_inode_bitmap_loc_set(fs, i, new_blk); 2666 } 2667 if (ctx->invalid_inode_table_flag[i]) { 2668 new_blk = ext2fs_inode_table_loc(fs, i); 2669 new_table_block(ctx, first_block, i, _("inode table"), 2670 fs->inode_blocks_per_group, 2671 &new_blk); 2672 ext2fs_inode_table_loc_set(fs, i, new_blk); 2673 ctx->flags |= E2F_FLAG_RESTART; 2674 } 2675 } 2676 ctx->invalid_bitmaps = 0; 2677} 2678 2679/* 2680 * This routine marks all blocks which are used by the superblock, 2681 * group descriptors, inode bitmaps, and block bitmaps. 2682 */ 2683static void mark_table_blocks(e2fsck_t ctx) 2684{ 2685 ext2_filsys fs = ctx->fs; 2686 blk64_t b; 2687 dgrp_t i; 2688 int j; 2689 struct problem_context pctx; 2690 2691 clear_problem_context(&pctx); 2692 2693 for (i = 0; i < fs->group_desc_count; i++) { 2694 pctx.group = i; 2695 2696 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); 2697 2698 /* 2699 * Mark the blocks used for the inode table 2700 */ 2701 if (ext2fs_inode_table_loc(fs, i)) { 2702 for (j = 0, b = ext2fs_inode_table_loc(fs, i); 2703 j < fs->inode_blocks_per_group; 2704 j++, b++) { 2705 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2706 b)) { 2707 pctx.blk = b; 2708 if (!ctx->invalid_inode_table_flag[i] && 2709 fix_problem(ctx, 2710 PR_1_ITABLE_CONFLICT, &pctx)) { 2711 ctx->invalid_inode_table_flag[i]++; 2712 ctx->invalid_bitmaps++; 2713 } 2714 } else { 2715 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2716 b); 2717 } 2718 } 2719 } 2720 2721 /* 2722 * Mark block used for the block bitmap 2723 */ 2724 if (ext2fs_block_bitmap_loc(fs, i)) { 2725 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2726 ext2fs_block_bitmap_loc(fs, i))) { 2727 pctx.blk = ext2fs_block_bitmap_loc(fs, i); 2728 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { 2729 ctx->invalid_block_bitmap_flag[i]++; 2730 ctx->invalid_bitmaps++; 2731 } 2732 } else { 2733 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2734 ext2fs_block_bitmap_loc(fs, i)); 2735 } 2736 2737 } 2738 /* 2739 * Mark block used for the inode bitmap 2740 */ 2741 if (ext2fs_inode_bitmap_loc(fs, i)) { 2742 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2743 ext2fs_inode_bitmap_loc(fs, i))) { 2744 pctx.blk = ext2fs_inode_bitmap_loc(fs, i); 2745 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { 2746 ctx->invalid_inode_bitmap_flag[i]++; 2747 ctx->invalid_bitmaps++; 2748 } 2749 } else { 2750 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2751 ext2fs_inode_bitmap_loc(fs, i)); 2752 } 2753 } 2754 } 2755} 2756 2757/* 2758 * Thes subroutines short circuits ext2fs_get_blocks and 2759 * ext2fs_check_directory; we use them since we already have the inode 2760 * structure, so there's no point in letting the ext2fs library read 2761 * the inode again. 2762 */ 2763static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, 2764 blk_t *blocks) 2765{ 2766 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2767 int i; 2768 2769 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2770 return EXT2_ET_CALLBACK_NOTHANDLED; 2771 2772 for (i=0; i < EXT2_N_BLOCKS; i++) 2773 blocks[i] = ctx->stashed_inode->i_block[i]; 2774 return 0; 2775} 2776 2777static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, 2778 struct ext2_inode *inode) 2779{ 2780 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2781 2782 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2783 return EXT2_ET_CALLBACK_NOTHANDLED; 2784 *inode = *ctx->stashed_inode; 2785 return 0; 2786} 2787 2788static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, 2789 struct ext2_inode *inode) 2790{ 2791 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2792 2793 if ((ino == ctx->stashed_ino) && ctx->stashed_inode && 2794 (inode != ctx->stashed_inode)) 2795 *ctx->stashed_inode = *inode; 2796 return EXT2_ET_CALLBACK_NOTHANDLED; 2797} 2798 2799static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) 2800{ 2801 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2802 2803 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2804 return EXT2_ET_CALLBACK_NOTHANDLED; 2805 2806 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) 2807 return EXT2_ET_NO_DIRECTORY; 2808 return 0; 2809} 2810 2811static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, 2812 blk64_t *ret) 2813{ 2814 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2815 errcode_t retval; 2816 blk64_t new_block; 2817 2818 if (ctx->block_found_map) { 2819 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map, 2820 &new_block); 2821 if (retval) 2822 return retval; 2823 if (fs->block_map) { 2824 ext2fs_mark_block_bitmap2(fs->block_map, new_block); 2825 ext2fs_mark_bb_dirty(fs); 2826 } 2827 } else { 2828 if (!fs->block_map) { 2829 retval = ext2fs_read_block_bitmap(fs); 2830 if (retval) 2831 return retval; 2832 } 2833 2834 retval = ext2fs_new_block2(fs, goal, 0, &new_block); 2835 if (retval) 2836 return retval; 2837 } 2838 2839 *ret = new_block; 2840 return (0); 2841} 2842 2843static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) 2844{ 2845 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2846 2847 if (ctx->block_found_map) { 2848 if (inuse > 0) 2849 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 2850 else 2851 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); 2852 } 2853} 2854 2855void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) 2856{ 2857 ext2_filsys fs = ctx->fs; 2858 2859 if (use_shortcuts) { 2860 fs->get_blocks = pass1_get_blocks; 2861 fs->check_directory = pass1_check_directory; 2862 fs->read_inode = pass1_read_inode; 2863 fs->write_inode = pass1_write_inode; 2864 ctx->stashed_ino = 0; 2865 ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block, 2866 0); 2867 ext2fs_set_block_alloc_stats_callback(fs, 2868 e2fsck_block_alloc_stats, 2869 0); 2870 } else { 2871 fs->get_blocks = 0; 2872 fs->check_directory = 0; 2873 fs->read_inode = 0; 2874 fs->write_inode = 0; 2875 } 2876} 2877