fs/befs/datastream.c

   1 /*
   2  * linux/fs/befs/datastream.c
   3  *
   4  * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com>
   5  *
   6  * Based on portions of file.c by Makoto Kato <m_kato@ga2.so-net.ne.jp>
   7  *
   8  * Many thanks to Dominic Giampaolo, author of "Practical File System
   9  * Design with the Be File System", for such a helpful book.
  10  *
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/string.h>
  16
  17 #include "befs.h"
  18 #include "datastream.h"
  19 #include "io.h"
  20
  21 const befs_inode_addr BAD_IADDR = { 0, 0, 0 };
  22
  23 static int befs_find_brun_direct(struct super_block *sb,
  24                                  const befs_data_stream *data,
  25                                  befs_blocknr_t blockno, befs_block_run * run);
  26
  27 static int befs_find_brun_indirect(struct super_block *sb,
  28                                    const befs_data_stream *data,
  29                                    befs_blocknr_t blockno,
  30                                    befs_block_run * run);
  31
  32 static int befs_find_brun_dblindirect(struct super_block *sb,
  33                                       const befs_data_stream *data,
  34                                       befs_blocknr_t blockno,
  35                                       befs_block_run * run);
  36
  37 /**
  38  * befs_read_datastream - get buffer_head containing data, starting from pos.
  39  * @sb: Filesystem superblock
  40  * @ds: datastream to find data with
  41  * @pos: start of data
  42  * @off: offset of data in buffer_head->b_data
  43  *
  44  * Returns pointer to buffer_head containing data starting with offset @off,
  45  * if you don't need to know offset just set @off = NULL.
  46  */
  47 struct buffer_head *
  48 befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
  49                      befs_off_t pos, uint * off)
  50 {
  51         struct buffer_head *bh;
  52         befs_block_run run;
  53         befs_blocknr_t block;   /* block coresponding to pos */
  54
  55         befs_debug(sb, "---> %s %llu", __func__, pos);
  56         block = pos >> BEFS_SB(sb)->block_shift;
  57         if (off)
  58                 *off = pos - (block << BEFS_SB(sb)->block_shift);
  59
  60         if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) {
  61                 befs_error(sb, "BeFS: Error finding disk addr of block %lu",
  62                            (unsigned long)block);
  63                 befs_debug(sb, "<--- %s ERROR", __func__);
  64                 return NULL;
  65         }
  66         bh = befs_bread_iaddr(sb, run);
  67         if (!bh) {
  68                 befs_error(sb, "BeFS: Error reading block %lu from datastream",
  69                            (unsigned long)block);
  70                 return NULL;
  71         }
  72
  73         befs_debug(sb, "<--- %s read data, starting at %llu", __func__, pos);
  74
  75         return bh;
  76 }
  77
  78 /**
  79  * befs_fblock2brun - give back block run for fblock
  80  * @sb: the superblock
  81  * @data: datastream to read from
  82  * @fblock: the blocknumber with the file position to find
  83  * @run: The found run is passed back through this pointer
  84  *
  85  * Takes a file position and gives back a brun who's starting block
  86  * is block number fblock of the file.
  87  *
  88  * Returns BEFS_OK or BEFS_ERR.
  89  *
  90  * Calls specialized functions for each of the three possible
  91  * datastream regions.
  92  *
  93  * 2001-11-15 Will Dyson
  94  */
  95 int
  96 befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
  97                  befs_blocknr_t fblock, befs_block_run * run)
  98 {
  99         int err;
 100         befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;
 101
 102         if (pos < data->max_direct_range) {
 103                 err = befs_find_brun_direct(sb, data, fblock, run);
 104
 105         } else if (pos < data->max_indirect_range) {
 106                 err = befs_find_brun_indirect(sb, data, fblock, run);
 107
 108         } else if (pos < data->max_double_indirect_range) {
 109                 err = befs_find_brun_dblindirect(sb, data, fblock, run);
 110
 111         } else {
 112                 befs_error(sb,
 113                            "befs_fblock2brun() was asked to find block %lu, "
 114                            "which is not mapped by the datastream\n",
 115                            (unsigned long)fblock);
 116                 err = BEFS_ERR;
 117         }
 118         return err;
 119 }
 120
 121 /**
 122  * befs_read_lsmylink - read long symlink from datastream.
 123  * @sb: Filesystem superblock
 124  * @ds: Datastream to read from
 125  * @buff: Buffer in which to place long symlink data
 126  * @len: Length of the long symlink in bytes
 127  *
 128  * Returns the number of bytes read
 129  */
 130 size_t
 131 befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
 132                    void *buff, befs_off_t len)
 133 {
 134         befs_off_t bytes_read = 0;      /* bytes readed */
 135         u16 plen;
 136         struct buffer_head *bh;
 137         befs_debug(sb, "---> %s length: %llu", __func__, len);
 138
 139         while (bytes_read < len) {
 140                 bh = befs_read_datastream(sb, ds, bytes_read, NULL);
 141                 if (!bh) {
 142                         befs_error(sb, "BeFS: Error reading datastream block "
 143                                    "starting from %llu", bytes_read);
 144                         befs_debug(sb, "<--- %s ERROR", __func__);
 145                         return bytes_read;
 146
 147                 }
 148                 plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ?
 149                     BEFS_SB(sb)->block_size : len - bytes_read;
 150                 memcpy(buff + bytes_read, bh->b_data, plen);
 151                 brelse(bh);
 152                 bytes_read += plen;
 153         }
 154
 155         befs_debug(sb, "<--- %s read %u bytes", __func__, (unsigned int)
 156                    bytes_read);
 157         return bytes_read;
 158 }
 159
 160 /**
 161  * befs_count_blocks - blocks used by a file
 162  * @sb: Filesystem superblock
 163  * @ds: Datastream of the file
 164  *
 165  * Counts the number of fs blocks that the file represented by
 166  * inode occupies on the filesystem, counting both regular file
 167  * data and filesystem metadata (and eventually attribute data
 168  * when we support attributes)
 169 */
 170
 171 befs_blocknr_t
 172 befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
 173 {
 174         befs_blocknr_t blocks;
 175         befs_blocknr_t datablocks;      /* File data blocks */
 176         befs_blocknr_t metablocks;      /* FS metadata blocks */
 177         struct befs_sb_info *befs_sb = BEFS_SB(sb);
 178
 179         befs_debug(sb, "---> %s", __func__);
 180
 181         datablocks = ds->size >> befs_sb->block_shift;
 182         if (ds->size & (befs_sb->block_size - 1))
 183                 datablocks += 1;
 184
 185         metablocks = 1;         /* Start with 1 block for inode */
 186
 187         /* Size of indirect block */
 188         if (ds->size > ds->max_direct_range)
 189                 metablocks += ds->indirect.len;
 190
 191         /*
 192            Double indir block, plus all the indirect blocks it maps.
 193            In the double-indirect range, all block runs of data are
 194            BEFS_DBLINDIR_BRUN_LEN blocks long. Therefore, we know
 195            how many data block runs are in the double-indirect region,
 196            and from that we know how many indirect blocks it takes to
 197            map them. We assume that the indirect blocks are also
 198            BEFS_DBLINDIR_BRUN_LEN blocks long.
 199          */
 200         if (ds->size > ds->max_indirect_range && ds->max_indirect_range != 0) {
 201                 uint dbl_bytes;
 202                 uint dbl_bruns;
 203                 uint indirblocks;
 204
 205                 dbl_bytes =
 206                     ds->max_double_indirect_range - ds->max_indirect_range;
 207                 dbl_bruns =
 208                     dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN);
 209                 indirblocks = dbl_bruns / befs_iaddrs_per_block(sb);
 210
 211                 metablocks += ds->double_indirect.len;
 212                 metablocks += indirblocks;
 213         }
 214
 215         blocks = datablocks + metablocks;
 216         befs_debug(sb, "<--- %s %u blocks", __func__, (unsigned int)blocks);
 217
 218         return blocks;
 219 }
 220
 221 /**
 222  * befs_find_brun_direct - find a direct block run in the datastream
 223  * @sb: the superblock
 224  * @data: the datastream
 225  * @blockno: the blocknumber to find
 226  * @run: The found run is passed back through this pointer
 227  *
 228  * Finds the block run that starts at file block number blockno
 229  * in the file represented by the datastream data, if that
 230  * blockno is in the direct region of the datastream.
 231  *
 232  * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 233  * otherwise.
 234  *
 235  * Algorithm:
 236  * Linear search. Checks each element of array[] to see if it
 237  * contains the blockno-th filesystem block. This is necessary
 238  * because the block runs map variable amounts of data. Simply
 239  * keeps a count of the number of blocks searched so far (sum),
 240  * incrementing this by the length of each block run as we come
 241  * across it. Adds sum to *count before returning (this is so
 242  * you can search multiple arrays that are logicaly one array,
 243  * as in the indirect region code).
 244  *
 245  * When/if blockno is found, if blockno is inside of a block
 246  * run as stored on disk, we offset the start and length members
 247  * of the block run, so that blockno is the start and len is
 248  * still valid (the run ends in the same place).
 249  */
 250 static int
 251 befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
 252                       befs_blocknr_t blockno, befs_block_run * run)
 253 {
 254         int i;
 255         const befs_block_run *array = data->direct;
 256         befs_blocknr_t sum;
 257
 258         befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);
 259
 260         for (i = 0, sum = 0; i < BEFS_NUM_DIRECT_BLOCKS;
 261              sum += array[i].len, i++) {
 262                 if (blockno >= sum && blockno < sum + (array[i].len)) {
 263                         int offset = blockno - sum;
 264                         run->allocation_group = array[i].allocation_group;
 265                         run->start = array[i].start + offset;
 266                         run->len = array[i].len - offset;
 267
 268                         befs_debug(sb, "---> %s, "
 269                                    "found %lu at direct[%d]", __func__,
 270                                    (unsigned long)blockno, i);
 271                         return BEFS_OK;
 272                 }
 273         }
 274
 275         befs_error(sb, "%s failed to find file block %lu", __func__,
 276                    (unsigned long)blockno);
 277         befs_debug(sb, "---> %s ERROR", __func__);
 278         return BEFS_ERR;
 279 }
 280
 281 /**
 282  * befs_find_brun_indirect - find a block run in the datastream
 283  * @sb: the superblock
 284  * @data: the datastream
 285  * @blockno: the blocknumber to find
 286  * @run: The found run is passed back through this pointer
 287  *
 288  * Finds the block run that starts at file block number blockno
 289  * in the file represented by the datastream data, if that
 290  * blockno is in the indirect region of the datastream.
 291  *
 292  * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 293  * otherwise.
 294  *
 295  * Algorithm:
 296  * For each block in the indirect run of the datastream, read
 297  * it in and search through it for search_blk.
 298  *
 299  * XXX:
 300  * Really should check to make sure blockno is inside indirect
 301  * region.
 302  */
 303 static int
 304 befs_find_brun_indirect(struct super_block *sb,
 305                         const befs_data_stream *data,
 306                         befs_blocknr_t blockno,
 307                         befs_block_run * run)
 308 {
 309         int i, j;
 310         befs_blocknr_t sum = 0;
 311         befs_blocknr_t indir_start_blk;
 312         befs_blocknr_t search_blk;
 313         struct buffer_head *indirblock;
 314         befs_disk_block_run *array;
 315
 316         befs_block_run indirect = data->indirect;
 317         befs_blocknr_t indirblockno = iaddr2blockno(sb, &indirect);
 318         int arraylen = befs_iaddrs_per_block(sb);
 319
 320         befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);
 321
 322         indir_start_blk = data->max_direct_range >> BEFS_SB(sb)->block_shift;
 323         search_blk = blockno - indir_start_blk;
 324
 325         /* Examine blocks of the indirect run one at a time */
 326         for (i = 0; i < indirect.len; i++) {
 327                 indirblock = sb_bread(sb, indirblockno + i);
 328                 if (indirblock == NULL) {
 329                         befs_error(sb, "---> %s failed to read "
 330                                    "disk block %lu from the indirect brun",
 331                                    __func__, (unsigned long)indirblockno + i);
 332                         befs_debug(sb, "<--- %s ERROR", __func__);
 333                         return BEFS_ERR;
 334                 }
 335
 336                 array = (befs_disk_block_run *) indirblock->b_data;
 337
 338                 for (j = 0; j < arraylen; ++j) {
 339                         int len = fs16_to_cpu(sb, array[j].len);
 340
 341                         if (search_blk >= sum && search_blk < sum + len) {
 342                                 int offset = search_blk - sum;
 343                                 run->allocation_group =
 344                                     fs32_to_cpu(sb, array[j].allocation_group);
 345                                 run->start =
 346                                     fs16_to_cpu(sb, array[j].start) + offset;
 347                                 run->len =
 348                                     fs16_to_cpu(sb, array[j].len) - offset;
 349
 350                                 brelse(indirblock);
 351                                 befs_debug(sb,
 352                                            "<--- %s found file block "
 353                                            "%lu at indirect[%d]", __func__,
 354                                            (unsigned long)blockno,
 355                                            j + (i * arraylen));
 356                                 return BEFS_OK;
 357                         }
 358                         sum += len;
 359                 }
 360
 361                 brelse(indirblock);
 362         }
 363
 364         /* Only fallthrough is an error */
 365         befs_error(sb, "BeFS: %s failed to find "
 366                    "file block %lu", __func__, (unsigned long)blockno);
 367
 368         befs_debug(sb, "<--- %s ERROR", __func__);
 369         return BEFS_ERR;
 370 }
 371
 372 /**
 373  * befs_find_brun_dblindirect - find a block run in the datastream
 374  * @sb: the superblock
 375  * @data: the datastream
 376  * @blockno: the blocknumber to find
 377  * @run: The found run is passed back through this pointer
 378  *
 379  * Finds the block run that starts at file block number blockno
 380  * in the file represented by the datastream data, if that
 381  * blockno is in the double-indirect region of the datastream.
 382  *
 383  * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 384  * otherwise.
 385  *
 386  * Algorithm:
 387  * The block runs in the double-indirect region are different.
 388  * They are always allocated 4 fs blocks at a time, so each
 389  * block run maps a constant amount of file data. This means
 390  * that we can directly calculate how many block runs into the
 391  * double-indirect region we need to go to get to the one that
 392  * maps a particular filesystem block.
 393  *
 394  * We do this in two stages. First we calculate which of the
 395  * inode addresses in the double-indirect block will point us
 396  * to the indirect block that contains the mapping for the data,
 397  * then we calculate which of the inode addresses in that
 398  * indirect block maps the data block we are after.
 399  *
 400  * Oh, and once we've done that, we actually read in the blocks
 401  * that contain the inode addresses we calculated above. Even
 402  * though the double-indirect run may be several blocks long,
 403  * we can calculate which of those blocks will contain the index
 404  * we are after and only read that one. We then follow it to
 405  * the indirect block and perform a similar process to find
 406  * the actual block run that maps the data block we are interested
 407  * in.
 408  *
 409  * Then we offset the run as in befs_find_brun_array() and we are
 410  * done.
 411  */
 412 static int
 413 befs_find_brun_dblindirect(struct super_block *sb,
 414                            const befs_data_stream *data,
 415                            befs_blocknr_t blockno,
 416                            befs_block_run * run)
 417 {
 418         int dblindir_indx;
 419         int indir_indx;
 420         int offset;
 421         int dbl_which_block;
 422         int which_block;
 423         int dbl_block_indx;
 424         int block_indx;
 425         off_t dblindir_leftover;
 426         befs_blocknr_t blockno_at_run_start;
 427         struct buffer_head *dbl_indir_block;
 428         struct buffer_head *indir_block;
 429         befs_block_run indir_run;
 430         befs_disk_inode_addr *iaddr_array;
 431
 432         befs_blocknr_t indir_start_blk =
 433             data->max_indirect_range >> BEFS_SB(sb)->block_shift;
 434
 435         off_t dbl_indir_off = blockno - indir_start_blk;
 436
 437         /* number of data blocks mapped by each of the iaddrs in
 438          * the indirect block pointed to by the double indirect block
 439          */
 440         size_t iblklen = BEFS_DBLINDIR_BRUN_LEN;
 441
 442         /* number of data blocks mapped by each of the iaddrs in
 443          * the double indirect block
 444          */
 445         size_t diblklen = iblklen * befs_iaddrs_per_block(sb)
 446             * BEFS_DBLINDIR_BRUN_LEN;
 447
 448         befs_debug(sb, "---> %s find %lu", __func__, (unsigned long)blockno);
 449
 450         /* First, discover which of the double_indir->indir blocks
 451          * contains pos. Then figure out how much of pos that
 452          * accounted for. Then discover which of the iaddrs in
 453          * the indirect block contains pos.
 454          */
 455
 456         dblindir_indx = dbl_indir_off / diblklen;
 457         dblindir_leftover = dbl_indir_off % diblklen;
 458         indir_indx = dblindir_leftover / diblklen;
 459
 460         /* Read double indirect block */
 461         dbl_which_block = dblindir_indx / befs_iaddrs_per_block(sb);
 462         if (dbl_which_block > data->double_indirect.len) {
 463                 befs_error(sb, "The double-indirect index calculated by "
 464                            "%s, %d, is outside the range "
 465                            "of the double-indirect block", __func__,
 466                            dblindir_indx);
 467                 return BEFS_ERR;
 468         }
 469
 470         dbl_indir_block =
 471             sb_bread(sb, iaddr2blockno(sb, &data->double_indirect) +
 472                                         dbl_which_block);
 473         if (dbl_indir_block == NULL) {
 474                 befs_error(sb, "%s couldn't read the "
 475                            "double-indirect block at blockno %lu", __func__,
 476                            (unsigned long)
 477                            iaddr2blockno(sb, &data->double_indirect) +
 478                            dbl_which_block);
 479                 return BEFS_ERR;
 480         }
 481
 482         dbl_block_indx =
 483             dblindir_indx - (dbl_which_block * befs_iaddrs_per_block(sb));
 484         iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data;
 485         indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]);
 486         brelse(dbl_indir_block);
 487
 488         /* Read indirect block */
 489         which_block = indir_indx / befs_iaddrs_per_block(sb);
 490         if (which_block > indir_run.len) {
 491                 befs_error(sb, "The indirect index calculated by "
 492                            "%s, %d, is outside the range "
 493                            "of the indirect block", __func__, indir_indx);
 494                 return BEFS_ERR;
 495         }
 496
 497         indir_block =
 498             sb_bread(sb, iaddr2blockno(sb, &indir_run) + which_block);
 499         if (indir_block == NULL) {
 500                 befs_error(sb, "%s couldn't read the indirect block "
 501                            "at blockno %lu", __func__, (unsigned long)
 502                            iaddr2blockno(sb, &indir_run) + which_block);
 503                 return BEFS_ERR;
 504         }
 505
 506         block_indx = indir_indx - (which_block * befs_iaddrs_per_block(sb));
 507         iaddr_array = (befs_disk_inode_addr *) indir_block->b_data;
 508         *run = fsrun_to_cpu(sb, iaddr_array[block_indx]);
 509         brelse(indir_block);
 510
 511         blockno_at_run_start = indir_start_blk;
 512         blockno_at_run_start += diblklen * dblindir_indx;
 513         blockno_at_run_start += iblklen * indir_indx;
 514         offset = blockno - blockno_at_run_start;
 515
 516         run->start += offset;
 517         run->len -= offset;
 518
 519         befs_debug(sb, "Found file block %lu in double_indirect[%d][%d],"
 520                    " double_indirect_leftover = %lu", (unsigned long)
 521                    blockno, dblindir_indx, indir_indx, dblindir_leftover);
 522
 523         return BEFS_OK;
 524 }