e2fsprogs/ext2fs/block.c

   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 Public
   8  * License.
   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 static int block_iterate_ind(blk_t *ind_block, blk_t ref_block,
  40                              int ref_offset, struct block_context *ctx)
  41 {
  42         int     ret = 0, changed = 0;
  43         int     i, flags, limit, offset;
  44         blk_t   *block_nr;
  45
  46         limit = ctx->fs->blocksize >> 2;
  47         if (!(ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) &&
  48             !(ctx->flags & BLOCK_FLAG_DATA_ONLY))
  49                 ret = (*ctx->func)(ctx->fs, ind_block,
  50                                    BLOCK_COUNT_IND, ref_block,
  51                                    ref_offset, ctx->priv_data);
  52         if (!*ind_block || (ret & BLOCK_ABORT)) {
  53                 ctx->bcount += limit;
  54                 return ret;
  55         }
  56         if (*ind_block >= ctx->fs->super->s_blocks_count ||
  57             *ind_block < ctx->fs->super->s_first_data_block) {
  58                 ctx->errcode = EXT2_ET_BAD_IND_BLOCK;
  59                 ret |= BLOCK_ERROR;
  60                 return ret;
  61         }
  62         ctx->errcode = ext2fs_read_ind_block(ctx->fs, *ind_block,
  63                                              ctx->ind_buf);
  64         if (ctx->errcode) {
  65                 ret |= BLOCK_ERROR;
  66                 return ret;
  67         }
  68
  69         block_nr = (blk_t *) ctx->ind_buf;
  70         offset = 0;
  71         if (ctx->flags & BLOCK_FLAG_APPEND) {
  72                 for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) {
  73                         flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount,
  74                                              *ind_block, offset,
  75                                              ctx->priv_data);
  76                         changed |= flags;
  77                         if (flags & BLOCK_ABORT) {
  78                                 ret |= BLOCK_ABORT;
  79                                 break;
  80                         }
  81                         offset += sizeof(blk_t);
  82                 }
  83         } else {
  84                 for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) {
  85                         if (*block_nr == 0)
  86                                 continue;
  87                         flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount,
  88                                              *ind_block, offset,
  89                                              ctx->priv_data);
  90                         changed |= flags;
  91                         if (flags & BLOCK_ABORT) {
  92                                 ret |= BLOCK_ABORT;
  93                                 break;
  94                         }
  95                         offset += sizeof(blk_t);
  96                 }
  97         }
  98         if (changed & BLOCK_CHANGED) {
  99                 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *ind_block,
 100                                                       ctx->ind_buf);
 101                 if (ctx->errcode)
 102                         ret |= BLOCK_ERROR | BLOCK_ABORT;
 103         }
 104         if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) &&
 105             !(ctx->flags & BLOCK_FLAG_DATA_ONLY) &&
 106             !(ret & BLOCK_ABORT))
 107                 ret |= (*ctx->func)(ctx->fs, ind_block,
 108                                     BLOCK_COUNT_IND, ref_block,
 109                                     ref_offset, ctx->priv_data);
 110         return ret;
 111 }
 112
 113 static int block_iterate_dind(blk_t *dind_block, blk_t ref_block,
 114                               int ref_offset, struct block_context *ctx)
 115 {
 116         int     ret = 0, changed = 0;
 117         int     i, flags, limit, offset;
 118         blk_t   *block_nr;
 119
 120         limit = ctx->fs->blocksize >> 2;
 121         if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE |
 122                             BLOCK_FLAG_DATA_ONLY)))
 123                 ret = (*ctx->func)(ctx->fs, dind_block,
 124                                    BLOCK_COUNT_DIND, ref_block,
 125                                    ref_offset, ctx->priv_data);
 126         if (!*dind_block || (ret & BLOCK_ABORT)) {
 127                 ctx->bcount += limit*limit;
 128                 return ret;
 129         }
 130         if (*dind_block >= ctx->fs->super->s_blocks_count ||
 131             *dind_block < ctx->fs->super->s_first_data_block) {
 132                 ctx->errcode = EXT2_ET_BAD_DIND_BLOCK;
 133                 ret |= BLOCK_ERROR;
 134                 return ret;
 135         }
 136         ctx->errcode = ext2fs_read_ind_block(ctx->fs, *dind_block,
 137                                              ctx->dind_buf);
 138         if (ctx->errcode) {
 139                 ret |= BLOCK_ERROR;
 140                 return ret;
 141         }
 142
 143         block_nr = (blk_t *) ctx->dind_buf;
 144         offset = 0;
 145         if (ctx->flags & BLOCK_FLAG_APPEND) {
 146                 for (i = 0; i < limit; i++, block_nr++) {
 147                         flags = block_iterate_ind(block_nr,
 148                                                   *dind_block, offset,
 149                                                   ctx);
 150                         changed |= flags;
 151                         if (flags & (BLOCK_ABORT | BLOCK_ERROR)) {
 152                                 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR);
 153                                 break;
 154                         }
 155                         offset += sizeof(blk_t);
 156                 }
 157         } else {
 158                 for (i = 0; i < limit; i++, block_nr++) {
 159                         if (*block_nr == 0) {
 160                                 ctx->bcount += limit;
 161                                 continue;
 162                         }
 163                         flags = block_iterate_ind(block_nr,
 164                                                   *dind_block, offset,
 165                                                   ctx);
 166                         changed |= flags;
 167                         if (flags & (BLOCK_ABORT | BLOCK_ERROR)) {
 168                                 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR);
 169                                 break;
 170                         }
 171                         offset += sizeof(blk_t);
 172                 }
 173         }
 174         if (changed & BLOCK_CHANGED) {
 175                 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *dind_block,
 176                                                       ctx->dind_buf);
 177                 if (ctx->errcode)
 178                         ret |= BLOCK_ERROR | BLOCK_ABORT;
 179         }
 180         if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) &&
 181             !(ctx->flags & BLOCK_FLAG_DATA_ONLY) &&
 182             !(ret & BLOCK_ABORT))
 183                 ret |= (*ctx->func)(ctx->fs, dind_block,
 184                                     BLOCK_COUNT_DIND, ref_block,
 185                                     ref_offset, ctx->priv_data);
 186         return ret;
 187 }
 188
 189 static int block_iterate_tind(blk_t *tind_block, blk_t ref_block,
 190                               int ref_offset, struct block_context *ctx)
 191 {
 192         int     ret = 0, changed = 0;
 193         int     i, flags, limit, offset;
 194         blk_t   *block_nr;
 195
 196         limit = ctx->fs->blocksize >> 2;
 197         if (!(ctx->flags & (BLOCK_FLAG_DEPTH_TRAVERSE |
 198                             BLOCK_FLAG_DATA_ONLY)))
 199                 ret = (*ctx->func)(ctx->fs, tind_block,
 200                                    BLOCK_COUNT_TIND, ref_block,
 201                                    ref_offset, ctx->priv_data);
 202         if (!*tind_block || (ret & BLOCK_ABORT)) {
 203                 ctx->bcount += limit*limit*limit;
 204                 return ret;
 205         }
 206         if (*tind_block >= ctx->fs->super->s_blocks_count ||
 207             *tind_block < ctx->fs->super->s_first_data_block) {
 208                 ctx->errcode = EXT2_ET_BAD_TIND_BLOCK;
 209                 ret |= BLOCK_ERROR;
 210                 return ret;
 211         }
 212         ctx->errcode = ext2fs_read_ind_block(ctx->fs, *tind_block,
 213                                              ctx->tind_buf);
 214         if (ctx->errcode) {
 215                 ret |= BLOCK_ERROR;
 216                 return ret;
 217         }
 218
 219         block_nr = (blk_t *) ctx->tind_buf;
 220         offset = 0;
 221         if (ctx->flags & BLOCK_FLAG_APPEND) {
 222                 for (i = 0; i < limit; i++, block_nr++) {
 223                         flags = block_iterate_dind(block_nr,
 224                                                    *tind_block,
 225                                                    offset, ctx);
 226                         changed |= flags;
 227                         if (flags & (BLOCK_ABORT | BLOCK_ERROR)) {
 228                                 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR);
 229                                 break;
 230                         }
 231                         offset += sizeof(blk_t);
 232                 }
 233         } else {
 234                 for (i = 0; i < limit; i++, block_nr++) {
 235                         if (*block_nr == 0) {
 236                                 ctx->bcount += limit*limit;
 237                                 continue;
 238                         }
 239                         flags = block_iterate_dind(block_nr,
 240                                                    *tind_block,
 241                                                    offset, ctx);
 242                         changed |= flags;
 243                         if (flags & (BLOCK_ABORT | BLOCK_ERROR)) {
 244                                 ret |= flags & (BLOCK_ABORT | BLOCK_ERROR);
 245                                 break;
 246                         }
 247                         offset += sizeof(blk_t);
 248                 }
 249         }
 250         if (changed & BLOCK_CHANGED) {
 251                 ctx->errcode = ext2fs_write_ind_block(ctx->fs, *tind_block,
 252                                                       ctx->tind_buf);
 253                 if (ctx->errcode)
 254                         ret |= BLOCK_ERROR | BLOCK_ABORT;
 255         }
 256         if ((ctx->flags & BLOCK_FLAG_DEPTH_TRAVERSE) &&
 257             !(ctx->flags & BLOCK_FLAG_DATA_ONLY) &&
 258             !(ret & BLOCK_ABORT))
 259                 ret |= (*ctx->func)(ctx->fs, tind_block,
 260                                     BLOCK_COUNT_TIND, ref_block,
 261                                     ref_offset, ctx->priv_data);
 262
 263         return ret;
 264 }
 265
 266 errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 267                                 ext2_ino_t ino,
 268                                 int     flags,
 269                                 char *block_buf,
 270                                 int (*func)(ext2_filsys fs,
 271                                             blk_t       *blocknr,
 272                                             e2_blkcnt_t blockcnt,
 273                                             blk_t       ref_blk,
 274                                             int         ref_offset,
 275                                             void        *priv_data),
 276                                 void *priv_data)
 277 {
 278         int     i;
 279         int     got_inode = 0;
 280         int     ret = 0;
 281         blk_t   blocks[EXT2_N_BLOCKS];  /* directory data blocks */
 282         struct ext2_inode inode;
 283         errcode_t       retval;
 284         struct block_context ctx;
 285         int     limit;
 286
 287         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 288
 289         /*
 290          * Check to see if we need to limit large files
 291          */
 292         if (flags & BLOCK_FLAG_NO_LARGE) {
 293                 ctx.errcode = ext2fs_read_inode(fs, ino, &inode);
 294                 if (ctx.errcode)
 295                         return ctx.errcode;
 296                 got_inode = 1;
 297                 if (!LINUX_S_ISDIR(inode.i_mode) &&
 298                     (inode.i_size_high != 0))
 299                         return EXT2_ET_FILE_TOO_BIG;
 300         }
 301
 302         retval = ext2fs_get_blocks(fs, ino, blocks);
 303         if (retval)
 304                 return retval;
 305
 306         limit = fs->blocksize >> 2;
 307
 308         ctx.fs = fs;
 309         ctx.func = func;
 310         ctx.priv_data = priv_data;
 311         ctx.flags = flags;
 312         ctx.bcount = 0;
 313         if (block_buf) {
 314                 ctx.ind_buf = block_buf;
 315         } else {
 316                 retval = ext2fs_get_mem(fs->blocksize * 3, &ctx.ind_buf);
 317                 if (retval)
 318                         return retval;
 319         }
 320         ctx.dind_buf = ctx.ind_buf + fs->blocksize;
 321         ctx.tind_buf = ctx.dind_buf + fs->blocksize;
 322
 323         /*
 324          * Iterate over the HURD translator block (if present)
 325          */
 326         if ((fs->super->s_creator_os == EXT2_OS_HURD) &&
 327             !(flags & BLOCK_FLAG_DATA_ONLY)) {
 328                 ctx.errcode = ext2fs_read_inode(fs, ino, &inode);
 329                 if (ctx.errcode)
 330                         goto abort_exit;
 331                 got_inode = 1;
 332                 if (inode.osd1.hurd1.h_i_translator) {
 333                         ret |= (*ctx.func)(fs,
 334                                            &inode.osd1.hurd1.h_i_translator,
 335                                            BLOCK_COUNT_TRANSLATOR,
 336                                            0, 0, priv_data);
 337                         if (ret & BLOCK_ABORT)
 338                                 goto abort_exit;
 339                 }
 340         }
 341
 342         /*
 343          * Iterate over normal data blocks
 344          */
 345         for (i = 0; i < EXT2_NDIR_BLOCKS ; i++, ctx.bcount++) {
 346                 if (blocks[i] || (flags & BLOCK_FLAG_APPEND)) {
 347                         ret |= (*ctx.func)(fs, &blocks[i],
 348                                             ctx.bcount, 0, i, priv_data);
 349                         if (ret & BLOCK_ABORT)
 350                                 goto abort_exit;
 351                 }
 352         }
 353         if (*(blocks + EXT2_IND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) {
 354                 ret |= block_iterate_ind(blocks + EXT2_IND_BLOCK,
 355                                          0, EXT2_IND_BLOCK, &ctx);
 356                 if (ret & BLOCK_ABORT)
 357                         goto abort_exit;
 358         } else
 359                 ctx.bcount += limit;
 360         if (*(blocks + EXT2_DIND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) {
 361                 ret |= block_iterate_dind(blocks + EXT2_DIND_BLOCK,
 362                                           0, EXT2_DIND_BLOCK, &ctx);
 363                 if (ret & BLOCK_ABORT)
 364                         goto abort_exit;
 365         } else
 366                 ctx.bcount += limit * limit;
 367         if (*(blocks + EXT2_TIND_BLOCK) || (flags & BLOCK_FLAG_APPEND)) {
 368                 ret |= block_iterate_tind(blocks + EXT2_TIND_BLOCK,
 369                                           0, EXT2_TIND_BLOCK, &ctx);
 370                 if (ret & BLOCK_ABORT)
 371                         goto abort_exit;
 372         }
 373
 374 abort_exit:
 375         if (ret & BLOCK_CHANGED) {
 376                 if (!got_inode) {
 377                         retval = ext2fs_read_inode(fs, ino, &inode);
 378                         if (retval)
 379                                 return retval;
 380                 }
 381                 for (i=0; i < EXT2_N_BLOCKS; i++)
 382                         inode.i_block[i] = blocks[i];
 383                 retval = ext2fs_write_inode(fs, ino, &inode);
 384                 if (retval)
 385                         return retval;
 386         }
 387
 388         if (!block_buf)
 389                 ext2fs_free_mem(&ctx.ind_buf);
 390
 391         return (ret & BLOCK_ERROR) ? ctx.errcode : 0;
 392 }
 393
 394 /*
 395  * Emulate the old ext2fs_block_iterate function!
 396  */
 397
 398 struct xlate {
 399         int (*func)(ext2_filsys fs,
 400                     blk_t       *blocknr,
 401                     int         bcount,
 402                     void        *priv_data);
 403         void *real_private;
 404 };
 405
 406 #ifdef __TURBOC__
 407  #pragma argsused
 408 #endif
 409 static int xlate_func(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt,
 410                       blk_t ref_block EXT2FS_ATTR((unused)),
 411                       int ref_offset EXT2FS_ATTR((unused)),
 412                       void *priv_data)
 413 {
 414         struct xlate *xl = (struct xlate *) priv_data;
 415
 416         return (*xl->func)(fs, blocknr, (int) blockcnt, xl->real_private);
 417 }
 418
 419 errcode_t ext2fs_block_iterate(ext2_filsys fs,
 420                                ext2_ino_t ino,
 421                                int      flags,
 422                                char *block_buf,
 423                                int (*func)(ext2_filsys fs,
 424                                            blk_t        *blocknr,
 425                                            int  blockcnt,
 426                                            void *priv_data),
 427                                void *priv_data)
 428 {
 429         struct xlate xl;
 430
 431         xl.real_private = priv_data;
 432         xl.func = func;
 433
 434         return ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_NO_LARGE | flags,
 435                                      block_buf, xlate_func, &xl);
 436 }
 437