1 /* 2 * block.c --- iterate over all blocks in an inode 3 * 4 * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. 5 * 6 * %Begin-Header% 7 * This file may be redistributed under the terms of the GNU Library 8 * General Public License, version 2. 9 * %End-Header% 10 */ 11 12 #include <stdio.h> 13 #include <string.h> 14 #if HAVE_UNISTD_H 15 #include <unistd.h> 16 #endif 17 18 #include "ext2_fs.h" 19 #include "ext2fs.h" 20 21 struct block_context { 22 ext2_filsys fs; 23 int (*func)(ext2_filsys fs, 24 blk_t *blocknr, 25 e2_blkcnt_t bcount, 26 blk_t ref_blk, 27 int ref_offset, 28 void *priv_data); 29 e2_blkcnt_t bcount; 30 int bsize; 31 int flags; 32 errcode_t errcode; 33 char *ind_buf; 34 char *dind_buf; 35 char *tind_buf; 36 void *priv_data; 37 }; 38 39 #define check_for_ro_violation_return(ctx, ret) \ 40 do { \ 41 if (((ctx)->flags & BLOCK_FLAG_READ_ONLY) && \ 42 ((ret) & BLOCK_CHANGED)) { \ 43 (ctx)->errcode = EXT2_ET_RO_BLOCK_ITERATE; \ 44 ret |= BLOCK_ABORT | BLOCK_ERROR; \ 45 return ret; \ 46 } \ 47 } while (0) 48 49 #define check_for_ro_violation_goto(ctx, ret, label) \ 50 do { \ 51 if (((ctx)->flags & BLOCK_FLAG_READ_ONLY) && \ 52 ((ret) & BLOCK_CHANGED)) { \ 53 (ctx)->errcode = EXT2_ET_RO_BLOCK_ITERATE; \ 54 ret |= BLOCK_ABORT | BLOCK_ERROR; \ 55 goto label; \ 56 } \ 57 } while (0) 58 59 static int block_iterate_ind(blk_t *ind_block, blk_t ref_block, 60 int ref_offset, struct block_context *ctx) 61 { 62 int ret = 0, changed = 0; 63 int i, flags, limit, offset; 64 blk_t *block_nr; 65 66 limit = ctx->fs->blocksize >> 2; 67 if (!(ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && 68 !(ctx->flags & BLOCK_FLAG_DATA_ONLY)) 69 ret = (*ctx->func)(ctx->fs, ind_block, 70 BLOCK_COUNT_IND, ref_block, 71 ref_offset, ctx->priv_data); 72 check_for_ro_violation_return(ctx, ret); 73 if (!*ind_block || (ret & BLOCK_ABORT)) { 74 ctx->bcount += limit; 75 return ret; 76 } 77 if (*ind_block >= ctx->fs->super->s_blocks_count || 78 *ind_block < ctx->fs->super->s_first_data_block) { 79 ctx->errcode = EXT2_ET_BAD_IND_BLOCK; 80 ret |= BLOCK_ERROR; 81 return ret; 82 } 83 ctx->errcode = ext2fs_read_ind_block(ctx->fs, *ind_block, 84 ctx->ind_buf); 85 if (ctx->errcode) { 86 ret |= BLOCK_ERROR; 87 return ret; 88 } 89 90 block_nr = (blk_t *) ctx->ind_buf; 91 offset = 0; 92 if (ctx->flags & BLOCK_FLAG_APPEND) { 93 for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) { 94 flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount, 95 *ind_block, offset, 96 ctx->priv_data); 97 changed |= flags; 98 if (flags & BLOCK_ABORT) { 99 ret |= BLOCK_ABORT; 100 break; 101 } 102 offset += sizeof(blk_t); 103 } 104 } else { 105 for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) { 106 if (*block_nr == 0) 107 goto skip_sparse; 108 flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount, 109 *ind_block, offset, 110 ctx->priv_data); 111 changed |= flags; 112 if (flags & BLOCK_ABORT) { 113 ret |= BLOCK_ABORT; 114 break; 115 } 116 skip_sparse: 117 offset += sizeof(blk_t); 118 } 119 } 120 check_for_ro_violation_return(ctx, changed); 121 if (changed & BLOCK_CHANGED) { 122 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *ind_block, 123 ctx->ind_buf); 124 if (ctx->errcode) 125 ret |= BLOCK_ERROR | BLOCK_ABORT; 126 } 127 if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && 128 !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && 129 !(ret & BLOCK_ABORT)) 130 ret |= (*ctx->func)(ctx->fs, ind_block, 131 BLOCK_COUNT_IND, ref_block, 132 ref_offset, ctx->priv_data); 133 check_for_ro_violation_return(ctx, ret); 134 return ret; 135 } 136 137 static int block_iterate_dind(blk_t *dind_block, blk_t ref_block, 138 int ref_offset, struct block_context *ctx) 139 { 140 int ret = 0, changed = 0; 141 int i, flags, limit, offset; 142 blk_t *block_nr; 143 144 limit = ctx->fs->blocksize >> 2; 145 if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE | 146 BLOCK_FLAG_DATA_ONLY))) 147 ret = (*ctx->func)(ctx->fs, dind_block, 148 BLOCK_COUNT_DIND, ref_block, 149 ref_offset, ctx->priv_data); 150 check_for_ro_violation_return(ctx, ret); 151 if (!*dind_block || (ret & BLOCK_ABORT)) { 152 ctx->bcount += limit*limit; 153 return ret; 154 } 155 if (*dind_block >= ctx->fs->super->s_blocks_count || 156 *dind_block < ctx->fs->super->s_first_data_block) { 157 ctx->errcode = EXT2_ET_BAD_DIND_BLOCK; 158 ret |= BLOCK_ERROR; 159 return ret; 160 } 161 ctx->errcode = ext2fs_read_ind_block(ctx->fs, *dind_block, 162 ctx->dind_buf); 163 if (ctx->errcode) { 164 ret |= BLOCK_ERROR; 165 return ret; 166 } 167 168 block_nr = (blk_t *) ctx->dind_buf; 169 offset = 0; 170 if (ctx->flags & BLOCK_FLAG_APPEND) { 171 for (i = 0; i < limit; i++, block_nr++) { 172 flags = block_iterate_ind(block_nr, 173 *dind_block, offset, 174 ctx); 175 changed |= flags; 176 if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { 177 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); 178 break; 179 } 180 offset += sizeof(blk_t); 181 } 182 } else { 183 for (i = 0; i < limit; i++, block_nr++) { 184 if (*block_nr == 0) { 185 ctx->bcount += limit; 186 continue; 187 } 188 flags = block_iterate_ind(block_nr, 189 *dind_block, offset, 190 ctx); 191 changed |= flags; 192 if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { 193 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); 194 break; 195 } 196 offset += sizeof(blk_t); 197 } 198 } 199 check_for_ro_violation_return(ctx, changed); 200 if (changed & BLOCK_CHANGED) { 201 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *dind_block, 202 ctx->dind_buf); 203 if (ctx->errcode) 204 ret |= BLOCK_ERROR | BLOCK_ABORT; 205 } 206 if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && 207 !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && 208 !(ret & BLOCK_ABORT)) 209 ret |= (*ctx->func)(ctx->fs, dind_block, 210 BLOCK_COUNT_DIND, ref_block, 211 ref_offset, ctx->priv_data); 212 check_for_ro_violation_return(ctx, ret); 213 return ret; 214 } 215 216 static int block_iterate_tind(blk_t *tind_block, blk_t ref_block, 217 int ref_offset, struct block_context *ctx) 218 { 219 int ret = 0, changed = 0; 220 int i, flags, limit, offset; 221 blk_t *block_nr; 222 223 limit = ctx->fs->blocksize >> 2; 224 if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE | 225 BLOCK_FLAG_DATA_ONLY))) 226 ret = (*ctx->func)(ctx->fs, tind_block, 227 BLOCK_COUNT_TIND, ref_block, 228 ref_offset, ctx->priv_data); 229 check_for_ro_violation_return(ctx, ret); 230 if (!*tind_block || (ret & BLOCK_ABORT)) { 231 ctx->bcount += limit*limit*limit; 232 return ret; 233 } 234 if (*tind_block >= ctx->fs->super->s_blocks_count || 235 *tind_block < ctx->fs->super->s_first_data_block) { 236 ctx->errcode = EXT2_ET_BAD_TIND_BLOCK; 237 ret |= BLOCK_ERROR; 238 return ret; 239 } 240 ctx->errcode = ext2fs_read_ind_block(ctx->fs, *tind_block, 241 ctx->tind_buf); 242 if (ctx->errcode) { 243 ret |= BLOCK_ERROR; 244 return ret; 245 } 246 247 block_nr = (blk_t *) ctx->tind_buf; 248 offset = 0; 249 if (ctx->flags & BLOCK_FLAG_APPEND) { 250 for (i = 0; i < limit; i++, block_nr++) { 251 flags = block_iterate_dind(block_nr, 252 *tind_block, 253 offset, ctx); 254 changed |= flags; 255 if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { 256 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); 257 break; 258 } 259 offset += sizeof(blk_t); 260 } 261 } else { 262 for (i = 0; i < limit; i++, block_nr++) { 263 if (*block_nr == 0) { 264 ctx->bcount += limit*limit; 265 continue; 266 } 267 flags = block_iterate_dind(block_nr, 268 *tind_block, 269 offset, ctx); 270 changed |= flags; 271 if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { 272 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); 273 break; 274 } 275 offset += sizeof(blk_t); 276 } 277 } 278 check_for_ro_violation_return(ctx, changed); 279 if (changed & BLOCK_CHANGED) { 280 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *tind_block, 281 ctx->tind_buf); 282 if (ctx->errcode) 283 ret |= BLOCK_ERROR | BLOCK_ABORT; 284 } 285 if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && 286 !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && 287 !(ret & BLOCK_ABORT)) 288 ret |= (*ctx->func)(ctx->fs, tind_block, 289 BLOCK_COUNT_TIND, ref_block, 290 ref_offset, ctx->priv_data); 291 check_for_ro_violation_return(ctx, ret); 292 return ret; 293 } 294 295 errcode_t ext2fs_block_iterate2(ext2_filsys fs, 296 ext2_ino_t ino, 297 int flags, 298 char *block_buf, 299 int (*func)(ext2_filsys fs, 300 blk_t *blocknr, 301 e2_blkcnt_t blockcnt, 302 blk_t ref_blk, 303 int ref_offset, 304 void *priv_data), 305 void *priv_data) 306 { 307 int i; 308 int r, ret = 0; 309 struct ext2_inode inode; 310 errcode_t retval; 311 struct block_context ctx; 312 int limit; 313 314 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); 315 316 ctx.errcode = ext2fs_read_inode(fs, ino, &inode); 317 if (ctx.errcode) 318 return ctx.errcode; 319 320 /* 321 * Check to see if we need to limit large files 322 */ 323 if (flags & BLOCK_FLAG_NO_LARGE) { 324 if (!LINUX_S_ISDIR(inode.i_mode) && 325 (inode.i_size_high != 0)) 326 return EXT2_ET_FILE_TOO_BIG; 327 } 328 329 limit = fs->blocksize >> 2; 330 331 ctx.fs = fs; 332 ctx.func = func; 333 ctx.priv_data = priv_data; 334 ctx.flags = flags; 335 ctx.bcount = 0; 336 if (block_buf) { 337 ctx.ind_buf = block_buf; 338 } else { 339 retval = ext2fs_get_array(3, fs->blocksize, &ctx.ind_buf); 340 if (retval) 341 return retval; 342 } 343 ctx.dind_buf = ctx.ind_buf + fs->blocksize; 344 ctx.tind_buf = ctx.dind_buf + fs->blocksize; 345 346 /* 347 * Iterate over the HURD translator block (if present) 348 */ 349 if ((fs->super->s_creator_os == EXT2_OS_HURD) && 350 !(flags & BLOCK_FLAG_DATA_ONLY)) { 351 if (inode.osd1.hurd1.h_i_translator) { 352 ret |= (*ctx.func)(fs, 353 &inode.osd1.hurd1.h_i_translator, 354 BLOCK_COUNT_TRANSLATOR, 355 0, 0, priv_data); 356 if (ret & BLOCK_ABORT) 357 goto abort_exit; 358 check_for_ro_violation_goto(&ctx, ret, abort_exit); 359 } 360 } 361 362 if (inode.i_flags & EXT4_EXTENTS_FL) { 363 ext2_extent_handle_t handle; 364 struct ext2fs_extent extent; 365 e2_blkcnt_t blockcnt = 0; 366 blk_t blk, new_blk; 367 int op = EXT2_EXTENT_ROOT; 368 int uninit; 369 unsigned int j; 370 371 ctx.errcode = ext2fs_extent_open2(fs, ino, &inode, &handle); 372 if (ctx.errcode) 373 goto abort_exit; 374 375 while (1) { 376 ctx.errcode = ext2fs_extent_get(handle, op, &extent); 377 if (ctx.errcode) { 378 if (ctx.errcode != EXT2_ET_EXTENT_NO_NEXT) 379 break; 380 ctx.errcode = 0; 381 if (!(flags & BLOCK_FLAG_APPEND)) 382 break; 383 next_block_set: 384 blk = 0; 385 r = (*ctx.func)(fs, &blk, blockcnt, 386 0, 0, priv_data); 387 ret |= r; 388 check_for_ro_violation_goto(&ctx, ret, 389 extent_errout); 390 if (r & BLOCK_CHANGED) { 391 ctx.errcode = 392 ext2fs_extent_set_bmap(handle, 393 (blk64_t) blockcnt++, 394 (blk64_t) blk, 0); 395 if (ctx.errcode || (ret & BLOCK_ABORT)) 396 break; 397 if (blk) 398 goto next_block_set; 399 } 400 break; 401 } 402 403 op = EXT2_EXTENT_NEXT; 404 blk = extent.e_pblk; 405 if (!(extent.e_flags & EXT2_EXTENT_FLAGS_LEAF)) { 406 if (ctx.flags & BLOCK_FLAG_DATA_ONLY) 407 continue; 408 if ((!(extent.e_flags & 409 EXT2_EXTENT_FLAGS_SECOND_VISIT) && 410 !(ctx.flags & BLOCK_FLAG_DEPTH_TRAVERSE)) || 411 ((extent.e_flags & 412 EXT2_EXTENT_FLAGS_SECOND_VISIT) && 413 (ctx.flags & BLOCK_FLAG_DEPTH_TRAVERSE))) { 414 ret |= (*ctx.func)(fs, &blk, 415 -1, 0, 0, priv_data); 416 if (ret & BLOCK_CHANGED) { 417 extent.e_pblk = blk; 418 ctx.errcode = 419 ext2fs_extent_replace(handle, 0, &extent); 420 if (ctx.errcode) 421 break; 422 } 423 } 424 continue; 425 } 426 uninit = 0; 427 if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) 428 uninit = EXT2_EXTENT_SET_BMAP_UNINIT; 429 for (blockcnt = extent.e_lblk, j = 0; 430 j < extent.e_len; 431 blk++, blockcnt++, j++) { 432 new_blk = blk; 433 r = (*ctx.func)(fs, &new_blk, blockcnt, 434 0, 0, priv_data); 435 ret |= r; 436 check_for_ro_violation_goto(&ctx, ret, 437 extent_errout); 438 if (r & BLOCK_CHANGED) { 439 ctx.errcode = 440 ext2fs_extent_set_bmap(handle, 441 (blk64_t) blockcnt, 442 (blk64_t) new_blk, 443 uninit); 444 if (ctx.errcode) 445 goto extent_errout; 446 } 447 if (ret & BLOCK_ABORT) 448 break; 449 } 450 } 451 452 extent_errout: 453 ext2fs_extent_free(handle); 454 ret |= BLOCK_ERROR | BLOCK_ABORT; 455 goto errout; 456 } 457 458 /* 459 * Iterate over normal data blocks 460 */ 461 for (i = 0; i < EXT2_NDIR_BLOCKS ; i++, ctx.bcount++) { 462 if (inode.i_block[i] || (flags & BLOCK_FLAG_APPEND)) { 463 ret |= (*ctx.func)(fs, &inode.i_block[i], 464 ctx.bcount, 0, i, priv_data); 465 if (ret & BLOCK_ABORT) 466 goto abort_exit; 467 } 468 } 469 check_for_ro_violation_goto(&ctx, ret, abort_exit); 470 if (inode.i_block[EXT2_IND_BLOCK] || (flags & BLOCK_FLAG_APPEND)) { 471 ret |= block_iterate_ind(&inode.i_block[EXT2_IND_BLOCK], 472 0, EXT2_IND_BLOCK, &ctx); 473 if (ret & BLOCK_ABORT) 474 goto abort_exit; 475 } else 476 ctx.bcount += limit; 477 if (inode.i_block[EXT2_DIND_BLOCK] || (flags & BLOCK_FLAG_APPEND)) { 478 ret |= block_iterate_dind(&inode.i_block[EXT2_DIND_BLOCK], 479 0, EXT2_DIND_BLOCK, &ctx); 480 if (ret & BLOCK_ABORT) 481 goto abort_exit; 482 } else 483 ctx.bcount += limit * limit; 484 if (inode.i_block[EXT2_TIND_BLOCK] || (flags & BLOCK_FLAG_APPEND)) { 485 ret |= block_iterate_tind(&inode.i_block[EXT2_TIND_BLOCK], 486 0, EXT2_TIND_BLOCK, &ctx); 487 if (ret & BLOCK_ABORT) 488 goto abort_exit; 489 } 490 491 abort_exit: 492 if (ret & BLOCK_CHANGED) { 493 retval = ext2fs_write_inode(fs, ino, &inode); 494 if (retval) { 495 ret |= BLOCK_ERROR; 496 ctx.errcode = retval; 497 } 498 } 499 errout: 500 if (!block_buf) 501 ext2fs_free_mem(&ctx.ind_buf); 502 503 return (ret & BLOCK_ERROR) ? ctx.errcode : 0; 504 } 505 506 /* 507 * Emulate the old ext2fs_block_iterate function! 508 */ 509 510 struct xlate { 511 int (*func)(ext2_filsys fs, 512 blk_t *blocknr, 513 int bcount, 514 void *priv_data); 515 void *real_private; 516 }; 517 518 #ifdef __TURBOC__ 519 #pragma argsused 520 #endif 521 static int xlate_func(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt, 522 blk_t ref_block EXT2FS_ATTR((unused)), 523 int ref_offset EXT2FS_ATTR((unused)), 524 void *priv_data) 525 { 526 struct xlate *xl = (struct xlate *) priv_data; 527 528 return (*xl->func)(fs, blocknr, (int) blockcnt, xl->real_private); 529 } 530 531 errcode_t ext2fs_block_iterate(ext2_filsys fs, 532 ext2_ino_t ino, 533 int flags, 534 char *block_buf, 535 int (*func)(ext2_filsys fs, 536 blk_t *blocknr, 537 int blockcnt, 538 void *priv_data), 539 void *priv_data) 540 { 541 struct xlate xl; 542 543 xl.real_private = priv_data; 544 xl.func = func; 545 546 return ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_NO_LARGE | flags, 547 block_buf, xlate_func, &xl); 548 } 549 550
