| /* vi: set sw=4 ts=4: */ |
| /* |
| * block.c --- iterate over all blocks in an inode |
| * |
| * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. |
| * |
| * %Begin-Header% |
| * This file may be redistributed under the terms of the GNU Public |
| * License. |
| * %End-Header% |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #if HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif |
| |
| #include "ext2_fs.h" |
| #include "ext2fs.h" |
| |
| struct block_context { |
| ext2_filsys fs; |
| int (*func)(ext2_filsys fs, |
| blk_t *blocknr, |
| e2_blkcnt_t bcount, |
| blk_t ref_blk, |
| int ref_offset, |
| void *priv_data); |
| e2_blkcnt_t bcount; |
| int bsize; |
| int flags; |
| errcode_t errcode; |
| char *ind_buf; |
| char *dind_buf; |
| char *tind_buf; |
| void *priv_data; |
| }; |
| |
| static int block_iterate_ind(blk_t *ind_block, blk_t ref_block, |
| int ref_offset, struct block_context *ctx) |
| { |
| int ret = 0, changed = 0; |
| int i, flags, limit, offset; |
| blk_t *block_nr; |
| |
| limit = ctx->fs->blocksize >> 2; |
| if (!(ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && |
| !(ctx->flags & BLOCK_FLAG_DATA_ONLY)) |
| ret = (*ctx->func)(ctx->fs, ind_block, |
| BLOCK_COUNT_IND, ref_block, |
| ref_offset, ctx->priv_data); |
| if (!*ind_block || (ret & BLOCK_ABORT)) { |
| ctx->bcount += limit; |
| return ret; |
| } |
| if (*ind_block >= ctx->fs->super->s_blocks_count || |
| *ind_block < ctx->fs->super->s_first_data_block) { |
| ctx->errcode = EXT2_ET_BAD_IND_BLOCK; |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| ctx->errcode = ext2fs_read_ind_block(ctx->fs, *ind_block, |
| ctx->ind_buf); |
| if (ctx->errcode) { |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| |
| block_nr = (blk_t *) ctx->ind_buf; |
| offset = 0; |
| if (ctx->flags & BLOCK_FLAG_APPEND) { |
| for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) { |
| flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount, |
| *ind_block, offset, |
| ctx->priv_data); |
| changed |= flags; |
| if (flags & BLOCK_ABORT) { |
| ret |= BLOCK_ABORT; |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } else { |
| for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) { |
| if (*block_nr == 0) |
| continue; |
| flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount, |
| *ind_block, offset, |
| ctx->priv_data); |
| changed |= flags; |
| if (flags & BLOCK_ABORT) { |
| ret |= BLOCK_ABORT; |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } |
| if (changed & BLOCK_CHANGED) { |
| ctx->errcode = ext2fs_write_ind_block(ctx->fs, *ind_block, |
| ctx->ind_buf); |
| if (ctx->errcode) |
| ret |= BLOCK_ERROR | BLOCK_ABORT; |
| } |
| if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && |
| !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && |
| !(ret & BLOCK_ABORT)) |
| ret |= (*ctx->func)(ctx->fs, ind_block, |
| BLOCK_COUNT_IND, ref_block, |
| ref_offset, ctx->priv_data); |
| return ret; |
| } |
| |
| static int block_iterate_dind(blk_t *dind_block, blk_t ref_block, |
| int ref_offset, struct block_context *ctx) |
| { |
| int ret = 0, changed = 0; |
| int i, flags, limit, offset; |
| blk_t *block_nr; |
| |
| limit = ctx->fs->blocksize >> 2; |
| if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE | |
| BLOCK_FLAG_DATA_ONLY))) |
| ret = (*ctx->func)(ctx->fs, dind_block, |
| BLOCK_COUNT_DIND, ref_block, |
| ref_offset, ctx->priv_data); |
| if (!*dind_block || (ret & BLOCK_ABORT)) { |
| ctx->bcount += limit*limit; |
| return ret; |
| } |
| if (*dind_block >= ctx->fs->super->s_blocks_count || |
| *dind_block < ctx->fs->super->s_first_data_block) { |
| ctx->errcode = EXT2_ET_BAD_DIND_BLOCK; |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| ctx->errcode = ext2fs_read_ind_block(ctx->fs, *dind_block, |
| ctx->dind_buf); |
| if (ctx->errcode) { |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| |
| block_nr = (blk_t *) ctx->dind_buf; |
| offset = 0; |
| if (ctx->flags & BLOCK_FLAG_APPEND) { |
| for (i = 0; i < limit; i++, block_nr++) { |
| flags = block_iterate_ind(block_nr, |
| *dind_block, offset, |
| ctx); |
| changed |= flags; |
| if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { |
| ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } else { |
| for (i = 0; i < limit; i++, block_nr++) { |
| if (*block_nr == 0) { |
| ctx->bcount += limit; |
| continue; |
| } |
| flags = block_iterate_ind(block_nr, |
| *dind_block, offset, |
| ctx); |
| changed |= flags; |
| if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { |
| ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } |
| if (changed & BLOCK_CHANGED) { |
| ctx->errcode = ext2fs_write_ind_block(ctx->fs, *dind_block, |
| ctx->dind_buf); |
| if (ctx->errcode) |
| ret |= BLOCK_ERROR | BLOCK_ABORT; |
| } |
| if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && |
| !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && |
| !(ret & BLOCK_ABORT)) |
| ret |= (*ctx->func)(ctx->fs, dind_block, |
| BLOCK_COUNT_DIND, ref_block, |
| ref_offset, ctx->priv_data); |
| return ret; |
| } |
| |
| static int block_iterate_tind(blk_t *tind_block, blk_t ref_block, |
| int ref_offset, struct block_context *ctx) |
| { |
| int ret = 0, changed = 0; |
| int i, flags, limit, offset; |
| blk_t *block_nr; |
| |
| limit = ctx->fs->blocksize >> 2; |
| if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE | |
| BLOCK_FLAG_DATA_ONLY))) |
| ret = (*ctx->func)(ctx->fs, tind_block, |
| BLOCK_COUNT_TIND, ref_block, |
| ref_offset, ctx->priv_data); |
| if (!*tind_block || (ret & BLOCK_ABORT)) { |
| ctx->bcount += limit*limit*limit; |
| return ret; |
| } |
| if (*tind_block >= ctx->fs->super->s_blocks_count || |
| *tind_block < ctx->fs->super->s_first_data_block) { |
| ctx->errcode = EXT2_ET_BAD_TIND_BLOCK; |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| ctx->errcode = ext2fs_read_ind_block(ctx->fs, *tind_block, |
| ctx->tind_buf); |
| if (ctx->errcode) { |
| ret |= BLOCK_ERROR; |
| return ret; |
| } |
| |
| block_nr = (blk_t *) ctx->tind_buf; |
| offset = 0; |
| if (ctx->flags & BLOCK_FLAG_APPEND) { |
| for (i = 0; i < limit; i++, block_nr++) { |
| flags = block_iterate_dind(block_nr, |
| *tind_block, |
| offset, ctx); |
| changed |= flags; |
| if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { |
| ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } else { |
| for (i = 0; i < limit; i++, block_nr++) { |
| if (*block_nr == 0) { |
| ctx->bcount += limit*limit; |
| continue; |
| } |
| flags = block_iterate_dind(block_nr, |
| *tind_block, |
| offset, ctx); |
| changed |= flags; |
| if (flags & (BLOCK_ABORT | BLOCK_ERROR)) { |
| ret |= flags & (BLOCK_ABORT | BLOCK_ERROR); |
| break; |
| } |
| offset += sizeof(blk_t); |
| } |
| } |
| if (changed & BLOCK_CHANGED) { |
| ctx->errcode = ext2fs_write_ind_block(ctx->fs, *tind_block, |
| ctx->tind_buf); |
| if (ctx->errcode) |
| ret |= BLOCK_ERROR | BLOCK_ABORT; |
| } |
| if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) && |
| !(ctx->flags & BLOCK_FLAG_DATA_ONLY) && |
| !(ret & BLOCK_ABORT)) |
| ret |= (*ctx->func)(ctx->fs, tind_block, |
| BLOCK_COUNT_TIND, ref_block, |
| ref_offset, ctx->priv_data); |
| |
| return ret; |
| } |
| |
| errcode_t ext2fs_block_iterate2(ext2_filsys fs, |
| ext2_ino_t ino, |
| int flags, |
| char *block_buf, |
| int (*func)(ext2_filsys fs, |
| blk_t *blocknr, |
| e2_blkcnt_t blockcnt, |
| blk_t ref_blk, |
| int ref_offset, |
| void *priv_data), |
| void *priv_data) |
| { |
| int i; |
| int got_inode = 0; |
| int ret = 0; |
| blk_t blocks[EXT2_N_BLOCKS]; /* directory data blocks */ |
| struct ext2_inode inode; |
| errcode_t retval; |
| struct block_context ctx; |
| int limit; |
| |
| EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); |
| |
| /* |
| * Check to see if we need to limit large files |
| */ |
| if (flags & BLOCK_FLAG_NO_LARGE) { |
| ctx.errcode = ext2fs_read_inode(fs, ino, &inode); |
| if (ctx.errcode) |
| return ctx.errcode; |
| got_inode = 1; |
| if (!LINUX_S_ISDIR(inode.i_mode) && |
| (inode.i_size_high != 0)) |
| return EXT2_ET_FILE_TOO_BIG; |
| } |
| |
| retval = ext2fs_get_blocks(fs, ino, blocks); |
| if (retval) |
| return retval; |
| |
| limit = fs->blocksize >> 2; |
| |
| ctx.fs = fs; |
| ctx.func = func; |
| ctx.priv_data = priv_data; |
| ctx.flags = flags; |
| ctx.bcount = 0; |
| if (block_buf) { |
| ctx.ind_buf = block_buf; |
| } else { |
| retval = ext2fs_get_mem(fs->blocksize * 3, &ctx.ind_buf); |
| if (retval) |
| return retval; |
| } |
| ctx.dind_buf = ctx.ind_buf + fs->blocksize; |
| ctx.tind_buf = ctx.dind_buf + fs->blocksize; |
| |
| /* |
| * Iterate over the HURD translator block (if present) |
| */ |
| if ((fs->super->s_creator_os == EXT2_OS_HURD) && |
| !(flags & BLOCK_FLAG_DATA_ONLY)) { |
| ctx.errcode = ext2fs_read_inode(fs, ino, &inode); |
| if (ctx.errcode) |
| goto abort_exit; |
| got_inode = 1; |
| if (inode.osd1.hurd1.h_i_translator) { |
| ret |= (*ctx.func)(fs, |
| &inode.osd1.hurd1.h_i_translator, |
| BLOCK_COUNT_TRANSLATOR, |
| 0, 0, priv_data); |
| if (ret & BLOCK_ABORT) |
| goto abort_exit; |
| } |
| } |
| |
| /* |
| * Iterate over normal data blocks |
| */ |
| for (i = 0; i < EXT2_NDIR_BLOCKS; i++, ctx.bcount++) { |
| if (blocks[i] || (flags & BLOCK_FLAG_APPEND)) { |
| ret |= (*ctx.func)(fs, &blocks[i], |
| ctx.bcount, 0, i, priv_data); |
| if (ret & BLOCK_ABORT) |
| goto abort_exit; |
| } |
| } |
| if (*(blocks + EXT2_IND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) { |
| ret |= block_iterate_ind(blocks + EXT2_IND_BLOCK, |
| 0, EXT2_IND_BLOCK, &ctx); |
| if (ret & BLOCK_ABORT) |
| goto abort_exit; |
| } else |
| ctx.bcount += limit; |
| if (*(blocks + EXT2_DIND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) { |
| ret |= block_iterate_dind(blocks + EXT2_DIND_BLOCK, |
| 0, EXT2_DIND_BLOCK, &ctx); |
| if (ret & BLOCK_ABORT) |
| goto abort_exit; |
| } else |
| ctx.bcount += limit * limit; |
| if (*(blocks + EXT2_TIND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) { |
| ret |= block_iterate_tind(blocks + EXT2_TIND_BLOCK, |
| 0, EXT2_TIND_BLOCK, &ctx); |
| if (ret & BLOCK_ABORT) |
| goto abort_exit; |
| } |
| |
| abort_exit: |
| if (ret & BLOCK_CHANGED) { |
| if (!got_inode) { |
| retval = ext2fs_read_inode(fs, ino, &inode); |
| if (retval) |
| return retval; |
| } |
| for (i=0; i < EXT2_N_BLOCKS; i++) |
| inode.i_block[i] = blocks[i]; |
| retval = ext2fs_write_inode(fs, ino, &inode); |
| if (retval) |
| return retval; |
| } |
| |
| if (!block_buf) |
| ext2fs_free_mem(&ctx.ind_buf); |
| |
| return (ret & BLOCK_ERROR) ? ctx.errcode : 0; |
| } |
| |
| /* |
| * Emulate the old ext2fs_block_iterate function! |
| */ |
| |
| struct xlate { |
| int (*func)(ext2_filsys fs, |
| blk_t *blocknr, |
| int bcount, |
| void *priv_data); |
| void *real_private; |
| }; |
| |
| #ifdef __TURBOC__ |
| # pragma argsused |
| #endif |
| static int xlate_func(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt, |
| blk_t ref_block EXT2FS_ATTR((unused)), |
| int ref_offset EXT2FS_ATTR((unused)), |
| void *priv_data) |
| { |
| struct xlate *xl = (struct xlate *) priv_data; |
| |
| return (*xl->func)(fs, blocknr, (int) blockcnt, xl->real_private); |
| } |
| |
| errcode_t ext2fs_block_iterate(ext2_filsys fs, |
| ext2_ino_t ino, |
| int flags, |
| char *block_buf, |
| int (*func)(ext2_filsys fs, |
| blk_t *blocknr, |
| int blockcnt, |
| void *priv_data), |
| void *priv_data) |
| { |
| struct xlate xl; |
| |
| xl.real_private = priv_data; |
| xl.func = func; |
| |
| return ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_NO_LARGE | flags, |
| block_buf, xlate_func, &xl); |
| } |
