1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/befs/datastream.c 4 * 5 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com> 6 * 7 * Based on portions of file.c by Makoto Kato <m_kato@ga2.so-net.ne.jp> 8 * 9 * Many thanks to Dominic Giampaolo, author of "Practical File System 10 * Design with the Be File System", for such a helpful book. 11 * 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/buffer_head.h> 16 #include <linux/string.h> 17 18 #include "befs.h" 19 #include "datastream.h" 20 #include "io.h" 21 22 const befs_inode_addr BAD_IADDR = { 0, 0, 0 }; 23 24 static int befs_find_brun_direct(struct super_block *sb, 25 const befs_data_stream *data, 26 befs_blocknr_t blockno, befs_block_run *run); 27 28 static int befs_find_brun_indirect(struct super_block *sb, 29 const befs_data_stream *data, 30 befs_blocknr_t blockno, 31 befs_block_run *run); 32 33 static int befs_find_brun_dblindirect(struct super_block *sb, 34 const befs_data_stream *data, 35 befs_blocknr_t blockno, 36 befs_block_run *run); 37 38 /** 39 * befs_read_datastream - get buffer_head containing data, starting from pos. 40 * @sb: Filesystem superblock 41 * @ds: datastream to find data with 42 * @pos: start of data 43 * @off: offset of data in buffer_head->b_data 44 * 45 * Returns pointer to buffer_head containing data starting with offset @off, 46 * if you don't need to know offset just set @off = NULL. 47 */ 48 struct buffer_head * 49 befs_read_datastream(struct super_block *sb, const befs_data_stream *ds, 50 befs_off_t pos, uint *off) 51 { 52 struct buffer_head *bh; 53 befs_block_run run; 54 befs_blocknr_t block; /* block coresponding to pos */ 55 56 befs_debug(sb, "---> %s %llu", __func__, pos); 57 block = pos >> BEFS_SB(sb)->block_shift; 58 if (off) 59 *off = pos - (block << BEFS_SB(sb)->block_shift); 60 61 if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) { 62 befs_error(sb, "BeFS: Error finding disk addr of block %lu", 63 (unsigned long)block); 64 befs_debug(sb, "<--- %s ERROR", __func__); 65 return NULL; 66 } 67 bh = befs_bread_iaddr(sb, run); 68 if (!bh) { 69 befs_error(sb, "BeFS: Error reading block %lu from datastream", 70 (unsigned long)block); 71 return NULL; 72 } 73 74 befs_debug(sb, "<--- %s read data, starting at %llu", __func__, pos); 75 76 return bh; 77 } 78 79 /** 80 * befs_fblock2brun - give back block run for fblock 81 * @sb: the superblock 82 * @data: datastream to read from 83 * @fblock: the blocknumber with the file position to find 84 * @run: The found run is passed back through this pointer 85 * 86 * Takes a file position and gives back a brun who's starting block 87 * is block number fblock of the file. 88 * 89 * Returns BEFS_OK or BEFS_ERR. 90 * 91 * Calls specialized functions for each of the three possible 92 * datastream regions. 93 */ 94 int 95 befs_fblock2brun(struct super_block *sb, const befs_data_stream *data, 96 befs_blocknr_t fblock, befs_block_run *run) 97 { 98 int err; 99 befs_off_t pos = fblock << BEFS_SB(sb)->block_shift; 100 101 if (pos < data->max_direct_range) { 102 err = befs_find_brun_direct(sb, data, fblock, run); 103 104 } else if (pos < data->max_indirect_range) { 105 err = befs_find_brun_indirect(sb, data, fblock, run); 106 107 } else if (pos < data->max_double_indirect_range) { 108 err = befs_find_brun_dblindirect(sb, data, fblock, run); 109 110 } else { 111 befs_error(sb, 112 "befs_fblock2brun() was asked to find block %lu, " 113 "which is not mapped by the datastream\n", 114 (unsigned long)fblock); 115 err = BEFS_ERR; 116 } 117 return err; 118 } 119 120 /** 121 * befs_read_lsmylink - read long symlink from datastream. 122 * @sb: Filesystem superblock 123 * @ds: Datastream to read from 124 * @buff: Buffer in which to place long symlink data 125 * @len: Length of the long symlink in bytes 126 * 127 * Returns the number of bytes read 128 */ 129 size_t 130 befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds, 131 void *buff, befs_off_t len) 132 { 133 befs_off_t bytes_read = 0; /* bytes readed */ 134 u16 plen; 135 struct buffer_head *bh; 136 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 265 run->allocation_group = array[i].allocation_group; 266 run->start = array[i].start + offset; 267 run->len = array[i].len - offset; 268 269 befs_debug(sb, "---> %s, " 270 "found %lu at direct[%d]", __func__, 271 (unsigned long)blockno, i); 272 return BEFS_OK; 273 } 274 } 275 276 befs_error(sb, "%s failed to find file block %lu", __func__, 277 (unsigned long)blockno); 278 befs_debug(sb, "---> %s ERROR", __func__); 279 return BEFS_ERR; 280 } 281 282 /** 283 * befs_find_brun_indirect - find a block run in the datastream 284 * @sb: the superblock 285 * @data: the datastream 286 * @blockno: the blocknumber to find 287 * @run: The found run is passed back through this pointer 288 * 289 * Finds the block run that starts at file block number blockno 290 * in the file represented by the datastream data, if that 291 * blockno is in the indirect region of the datastream. 292 * 293 * Return value is BEFS_OK if the blockrun is found, BEFS_ERR 294 * otherwise. 295 * 296 * Algorithm: 297 * For each block in the indirect run of the datastream, read 298 * it in and search through it for search_blk. 299 * 300 * XXX: 301 * Really should check to make sure blockno is inside indirect 302 * region. 303 */ 304 static int 305 befs_find_brun_indirect(struct super_block *sb, 306 const befs_data_stream *data, 307 befs_blocknr_t blockno, 308 befs_block_run *run) 309 { 310 int i, j; 311 befs_blocknr_t sum = 0; 312 befs_blocknr_t indir_start_blk; 313 befs_blocknr_t search_blk; 314 struct buffer_head *indirblock; 315 befs_disk_block_run *array; 316 317 befs_block_run indirect = data->indirect; 318 befs_blocknr_t indirblockno = iaddr2blockno(sb, &indirect); 319 int arraylen = befs_iaddrs_per_block(sb); 320 321 befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno); 322 323 indir_start_blk = data->max_direct_range >> BEFS_SB(sb)->block_shift; 324 search_blk = blockno - indir_start_blk; 325 326 /* Examine blocks of the indirect run one at a time */ 327 for (i = 0; i < indirect.len; i++) { 328 indirblock = sb_bread(sb, indirblockno + i); 329 if (indirblock == NULL) { 330 befs_error(sb, "---> %s failed to read " 331 "disk block %lu from the indirect brun", 332 __func__, (unsigned long)indirblockno + i); 333 befs_debug(sb, "<--- %s ERROR", __func__); 334 return BEFS_ERR; 335 } 336 337 array = (befs_disk_block_run *) indirblock->b_data; 338 339 for (j = 0; j < arraylen; ++j) { 340 int len = fs16_to_cpu(sb, array[j].len); 341 342 if (search_blk >= sum && search_blk < sum + len) { 343 int offset = search_blk - sum; 344 run->allocation_group = 345 fs32_to_cpu(sb, array[j].allocation_group); 346 run->start = 347 fs16_to_cpu(sb, array[j].start) + offset; 348 run->len = 349 fs16_to_cpu(sb, array[j].len) - offset; 350 351 brelse(indirblock); 352 befs_debug(sb, 353 "<--- %s found file block " 354 "%lu at indirect[%d]", __func__, 355 (unsigned long)blockno, 356 j + (i * arraylen)); 357 return BEFS_OK; 358 } 359 sum += len; 360 } 361 362 brelse(indirblock); 363 } 364 365 /* Only fallthrough is an error */ 366 befs_error(sb, "BeFS: %s failed to find " 367 "file block %lu", __func__, (unsigned long)blockno); 368 369 befs_debug(sb, "<--- %s ERROR", __func__); 370 return BEFS_ERR; 371 } 372 373 /** 374 * befs_find_brun_dblindirect - find a block run in the datastream 375 * @sb: the superblock 376 * @data: the datastream 377 * @blockno: the blocknumber to find 378 * @run: The found run is passed back through this pointer 379 * 380 * Finds the block run that starts at file block number blockno 381 * in the file represented by the datastream data, if that 382 * blockno is in the double-indirect region of the datastream. 383 * 384 * Return value is BEFS_OK if the blockrun is found, BEFS_ERR 385 * otherwise. 386 * 387 * Algorithm: 388 * The block runs in the double-indirect region are different. 389 * They are always allocated 4 fs blocks at a time, so each 390 * block run maps a constant amount of file data. This means 391 * that we can directly calculate how many block runs into the 392 * double-indirect region we need to go to get to the one that 393 * maps a particular filesystem block. 394 * 395 * We do this in two stages. First we calculate which of the 396 * inode addresses in the double-indirect block will point us 397 * to the indirect block that contains the mapping for the data, 398 * then we calculate which of the inode addresses in that 399 * indirect block maps the data block we are after. 400 * 401 * Oh, and once we've done that, we actually read in the blocks 402 * that contain the inode addresses we calculated above. Even 403 * though the double-indirect run may be several blocks long, 404 * we can calculate which of those blocks will contain the index 405 * we are after and only read that one. We then follow it to 406 * the indirect block and perform a similar process to find 407 * the actual block run that maps the data block we are interested 408 * in. 409 * 410 * Then we offset the run as in befs_find_brun_array() and we are 411 * done. 412 */ 413 static int 414 befs_find_brun_dblindirect(struct super_block *sb, 415 const befs_data_stream *data, 416 befs_blocknr_t blockno, 417 befs_block_run *run) 418 { 419 int dblindir_indx; 420 int indir_indx; 421 int offset; 422 int dbl_which_block; 423 int which_block; 424 int dbl_block_indx; 425 int block_indx; 426 off_t dblindir_leftover; 427 befs_blocknr_t blockno_at_run_start; 428 struct buffer_head *dbl_indir_block; 429 struct buffer_head *indir_block; 430 befs_block_run indir_run; 431 befs_disk_inode_addr *iaddr_array; 432 433 befs_blocknr_t indir_start_blk = 434 data->max_indirect_range >> BEFS_SB(sb)->block_shift; 435 436 off_t dbl_indir_off = blockno - indir_start_blk; 437 438 /* number of data blocks mapped by each of the iaddrs in 439 * the indirect block pointed to by the double indirect block 440 */ 441 size_t iblklen = BEFS_DBLINDIR_BRUN_LEN; 442 443 /* number of data blocks mapped by each of the iaddrs in 444 * the double indirect block 445 */ 446 size_t diblklen = iblklen * befs_iaddrs_per_block(sb) 447 * BEFS_DBLINDIR_BRUN_LEN; 448 449 befs_debug(sb, "---> %s find %lu", __func__, (unsigned long)blockno); 450 451 /* First, discover which of the double_indir->indir blocks 452 * contains pos. Then figure out how much of pos that 453 * accounted for. Then discover which of the iaddrs in 454 * the indirect block contains pos. 455 */ 456 457 dblindir_indx = dbl_indir_off / diblklen; 458 dblindir_leftover = dbl_indir_off % diblklen; 459 indir_indx = dblindir_leftover / diblklen; 460 461 /* Read double indirect block */ 462 dbl_which_block = dblindir_indx / befs_iaddrs_per_block(sb); 463 if (dbl_which_block > data->double_indirect.len) { 464 befs_error(sb, "The double-indirect index calculated by " 465 "%s, %d, is outside the range " 466 "of the double-indirect block", __func__, 467 dblindir_indx); 468 return BEFS_ERR; 469 } 470 471 dbl_indir_block = 472 sb_bread(sb, iaddr2blockno(sb, &data->double_indirect) + 473 dbl_which_block); 474 if (dbl_indir_block == NULL) { 475 befs_error(sb, "%s couldn't read the " 476 "double-indirect block at blockno %lu", __func__, 477 (unsigned long) 478 iaddr2blockno(sb, &data->double_indirect) + 479 dbl_which_block); 480 return BEFS_ERR; 481 } 482 483 dbl_block_indx = 484 dblindir_indx - (dbl_which_block * befs_iaddrs_per_block(sb)); 485 iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data; 486 indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]); 487 brelse(dbl_indir_block); 488 489 /* Read indirect block */ 490 which_block = indir_indx / befs_iaddrs_per_block(sb); 491 if (which_block > indir_run.len) { 492 befs_error(sb, "The indirect index calculated by " 493 "%s, %d, is outside the range " 494 "of the indirect block", __func__, indir_indx); 495 return BEFS_ERR; 496 } 497 498 indir_block = 499 sb_bread(sb, iaddr2blockno(sb, &indir_run) + which_block); 500 if (indir_block == NULL) { 501 befs_error(sb, "%s couldn't read the indirect block " 502 "at blockno %lu", __func__, (unsigned long) 503 iaddr2blockno(sb, &indir_run) + which_block); 504 return BEFS_ERR; 505 } 506 507 block_indx = indir_indx - (which_block * befs_iaddrs_per_block(sb)); 508 iaddr_array = (befs_disk_inode_addr *) indir_block->b_data; 509 *run = fsrun_to_cpu(sb, iaddr_array[block_indx]); 510 brelse(indir_block); 511 512 blockno_at_run_start = indir_start_blk; 513 blockno_at_run_start += diblklen * dblindir_indx; 514 blockno_at_run_start += iblklen * indir_indx; 515 offset = blockno - blockno_at_run_start; 516 517 run->start += offset; 518 run->len -= offset; 519 520 befs_debug(sb, "Found file block %lu in double_indirect[%d][%d]," 521 " double_indirect_leftover = %lu", (unsigned long) 522 blockno, dblindir_indx, indir_indx, dblindir_leftover); 523 524 return BEFS_OK; 525 } 526