]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
1da177e4 LT |
14 | #include <linux/buffer_head.h> |
15 | #include <linux/string.h> | |
16 | ||
17 | #include "befs.h" | |
18 | #include "datastream.h" | |
19 | #include "io.h" | |
1da177e4 LT |
20 | |
21 | const befs_inode_addr BAD_IADDR = { 0, 0, 0 }; | |
22 | ||
23 | static int befs_find_brun_direct(struct super_block *sb, | |
22341d8f | 24 | const befs_data_stream *data, |
a17e7d20 | 25 | befs_blocknr_t blockno, befs_block_run *run); |
1da177e4 LT |
26 | |
27 | static int befs_find_brun_indirect(struct super_block *sb, | |
22341d8f | 28 | const befs_data_stream *data, |
1da177e4 | 29 | befs_blocknr_t blockno, |
a17e7d20 | 30 | befs_block_run *run); |
1da177e4 LT |
31 | |
32 | static int befs_find_brun_dblindirect(struct super_block *sb, | |
22341d8f | 33 | const befs_data_stream *data, |
1da177e4 | 34 | befs_blocknr_t blockno, |
a17e7d20 | 35 | befs_block_run *run); |
1da177e4 LT |
36 | |
37 | /** | |
38 | * befs_read_datastream - get buffer_head containing data, starting from pos. | |
39 | * @sb: Filesystem superblock | |
d327e612 | 40 | * @ds: datastream to find data with |
1da177e4 LT |
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 * | |
22341d8f | 48 | befs_read_datastream(struct super_block *sb, const befs_data_stream *ds, |
a17e7d20 | 49 | befs_off_t pos, uint *off) |
1da177e4 | 50 | { |
ff2fe0aa | 51 | struct buffer_head *bh; |
1da177e4 LT |
52 | befs_block_run run; |
53 | befs_blocknr_t block; /* block coresponding to pos */ | |
54 | ||
dac52fc1 | 55 | befs_debug(sb, "---> %s %llu", __func__, pos); |
1da177e4 LT |
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", | |
dac52fc1 FF |
62 | (unsigned long)block); |
63 | befs_debug(sb, "<--- %s ERROR", __func__); | |
1da177e4 LT |
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", | |
dac52fc1 | 69 | (unsigned long)block); |
1da177e4 LT |
70 | return NULL; |
71 | } | |
72 | ||
dac52fc1 | 73 | befs_debug(sb, "<--- %s read data, starting at %llu", __func__, pos); |
1da177e4 LT |
74 | |
75 | return bh; | |
76 | } | |
77 | ||
a20af5f9 LB |
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 | * | |
1da177e4 LT |
85 | * Takes a file position and gives back a brun who's starting block |
86 | * is block number fblock of the file. | |
e60f749b | 87 | * |
1da177e4 | 88 | * Returns BEFS_OK or BEFS_ERR. |
e60f749b | 89 | * |
1da177e4 LT |
90 | * Calls specialized functions for each of the three possible |
91 | * datastream regions. | |
1da177e4 LT |
92 | */ |
93 | int | |
22341d8f | 94 | befs_fblock2brun(struct super_block *sb, const befs_data_stream *data, |
a17e7d20 | 95 | befs_blocknr_t fblock, befs_block_run *run) |
1da177e4 LT |
96 | { |
97 | int err; | |
98 | befs_off_t pos = fblock << BEFS_SB(sb)->block_shift; | |
99 | ||
100 | if (pos < data->max_direct_range) { | |
101 | err = befs_find_brun_direct(sb, data, fblock, run); | |
102 | ||
103 | } else if (pos < data->max_indirect_range) { | |
104 | err = befs_find_brun_indirect(sb, data, fblock, run); | |
105 | ||
106 | } else if (pos < data->max_double_indirect_range) { | |
107 | err = befs_find_brun_dblindirect(sb, data, fblock, run); | |
108 | ||
109 | } else { | |
110 | befs_error(sb, | |
111 | "befs_fblock2brun() was asked to find block %lu, " | |
dac52fc1 FF |
112 | "which is not mapped by the datastream\n", |
113 | (unsigned long)fblock); | |
1da177e4 LT |
114 | err = BEFS_ERR; |
115 | } | |
116 | return err; | |
117 | } | |
118 | ||
119 | /** | |
120 | * befs_read_lsmylink - read long symlink from datastream. | |
e60f749b | 121 | * @sb: Filesystem superblock |
d327e612 | 122 | * @ds: Datastream to read from |
817e1d90 | 123 | * @buff: Buffer in which to place long symlink data |
1da177e4 LT |
124 | * @len: Length of the long symlink in bytes |
125 | * | |
126 | * Returns the number of bytes read | |
127 | */ | |
128 | size_t | |
22341d8f AV |
129 | befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds, |
130 | void *buff, befs_off_t len) | |
1da177e4 LT |
131 | { |
132 | befs_off_t bytes_read = 0; /* bytes readed */ | |
133 | u16 plen; | |
3080ea9e | 134 | struct buffer_head *bh; |
a17e7d20 | 135 | |
dac52fc1 | 136 | befs_debug(sb, "---> %s length: %llu", __func__, len); |
1da177e4 LT |
137 | |
138 | while (bytes_read < len) { | |
139 | bh = befs_read_datastream(sb, ds, bytes_read, NULL); | |
140 | if (!bh) { | |
141 | befs_error(sb, "BeFS: Error reading datastream block " | |
dac52fc1 FF |
142 | "starting from %llu", bytes_read); |
143 | befs_debug(sb, "<--- %s ERROR", __func__); | |
1da177e4 LT |
144 | return bytes_read; |
145 | ||
146 | } | |
147 | plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ? | |
148 | BEFS_SB(sb)->block_size : len - bytes_read; | |
149 | memcpy(buff + bytes_read, bh->b_data, plen); | |
150 | brelse(bh); | |
151 | bytes_read += plen; | |
152 | } | |
153 | ||
dac52fc1 FF |
154 | befs_debug(sb, "<--- %s read %u bytes", __func__, (unsigned int) |
155 | bytes_read); | |
1da177e4 LT |
156 | return bytes_read; |
157 | } | |
158 | ||
159 | /** | |
160 | * befs_count_blocks - blocks used by a file | |
161 | * @sb: Filesystem superblock | |
162 | * @ds: Datastream of the file | |
163 | * | |
164 | * Counts the number of fs blocks that the file represented by | |
165 | * inode occupies on the filesystem, counting both regular file | |
166 | * data and filesystem metadata (and eventually attribute data | |
167 | * when we support attributes) | |
168 | */ | |
169 | ||
170 | befs_blocknr_t | |
22341d8f | 171 | befs_count_blocks(struct super_block *sb, const befs_data_stream *ds) |
1da177e4 LT |
172 | { |
173 | befs_blocknr_t blocks; | |
174 | befs_blocknr_t datablocks; /* File data blocks */ | |
175 | befs_blocknr_t metablocks; /* FS metadata blocks */ | |
038428fc | 176 | struct befs_sb_info *befs_sb = BEFS_SB(sb); |
1da177e4 | 177 | |
dac52fc1 | 178 | befs_debug(sb, "---> %s", __func__); |
1da177e4 LT |
179 | |
180 | datablocks = ds->size >> befs_sb->block_shift; | |
181 | if (ds->size & (befs_sb->block_size - 1)) | |
182 | datablocks += 1; | |
183 | ||
184 | metablocks = 1; /* Start with 1 block for inode */ | |
185 | ||
186 | /* Size of indirect block */ | |
187 | if (ds->size > ds->max_direct_range) | |
188 | metablocks += ds->indirect.len; | |
189 | ||
190 | /* | |
a17e7d20 LB |
191 | * Double indir block, plus all the indirect blocks it maps. |
192 | * In the double-indirect range, all block runs of data are | |
193 | * BEFS_DBLINDIR_BRUN_LEN blocks long. Therefore, we know | |
194 | * how many data block runs are in the double-indirect region, | |
195 | * and from that we know how many indirect blocks it takes to | |
196 | * map them. We assume that the indirect blocks are also | |
197 | * BEFS_DBLINDIR_BRUN_LEN blocks long. | |
1da177e4 LT |
198 | */ |
199 | if (ds->size > ds->max_indirect_range && ds->max_indirect_range != 0) { | |
200 | uint dbl_bytes; | |
201 | uint dbl_bruns; | |
202 | uint indirblocks; | |
203 | ||
204 | dbl_bytes = | |
205 | ds->max_double_indirect_range - ds->max_indirect_range; | |
206 | dbl_bruns = | |
207 | dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN); | |
208 | indirblocks = dbl_bruns / befs_iaddrs_per_block(sb); | |
209 | ||
210 | metablocks += ds->double_indirect.len; | |
211 | metablocks += indirblocks; | |
212 | } | |
213 | ||
214 | blocks = datablocks + metablocks; | |
dac52fc1 | 215 | befs_debug(sb, "<--- %s %u blocks", __func__, (unsigned int)blocks); |
1da177e4 LT |
216 | |
217 | return blocks; | |
218 | } | |
219 | ||
a20af5f9 LB |
220 | /** |
221 | * befs_find_brun_direct - find a direct block run in the datastream | |
222 | * @sb: the superblock | |
223 | * @data: the datastream | |
224 | * @blockno: the blocknumber to find | |
225 | * @run: The found run is passed back through this pointer | |
226 | * | |
227 | * Finds the block run that starts at file block number blockno | |
228 | * in the file represented by the datastream data, if that | |
229 | * blockno is in the direct region of the datastream. | |
230 | * | |
231 | * Return value is BEFS_OK if the blockrun is found, BEFS_ERR | |
232 | * otherwise. | |
233 | * | |
234 | * Algorithm: | |
235 | * Linear search. Checks each element of array[] to see if it | |
236 | * contains the blockno-th filesystem block. This is necessary | |
237 | * because the block runs map variable amounts of data. Simply | |
238 | * keeps a count of the number of blocks searched so far (sum), | |
239 | * incrementing this by the length of each block run as we come | |
240 | * across it. Adds sum to *count before returning (this is so | |
241 | * you can search multiple arrays that are logicaly one array, | |
242 | * as in the indirect region code). | |
243 | * | |
244 | * When/if blockno is found, if blockno is inside of a block | |
245 | * run as stored on disk, we offset the start and length members | |
246 | * of the block run, so that blockno is the start and len is | |
247 | * still valid (the run ends in the same place). | |
248 | */ | |
1da177e4 | 249 | static int |
22341d8f | 250 | befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data, |
a17e7d20 | 251 | befs_blocknr_t blockno, befs_block_run *run) |
1da177e4 LT |
252 | { |
253 | int i; | |
22341d8f | 254 | const befs_block_run *array = data->direct; |
1da177e4 | 255 | befs_blocknr_t sum; |
1da177e4 | 256 | |
dac52fc1 | 257 | befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno); |
1da177e4 | 258 | |
1da177e4 LT |
259 | for (i = 0, sum = 0; i < BEFS_NUM_DIRECT_BLOCKS; |
260 | sum += array[i].len, i++) { | |
261 | if (blockno >= sum && blockno < sum + (array[i].len)) { | |
262 | int offset = blockno - sum; | |
a17e7d20 | 263 | |
1da177e4 LT |
264 | run->allocation_group = array[i].allocation_group; |
265 | run->start = array[i].start + offset; | |
266 | run->len = array[i].len - offset; | |
267 | ||
dac52fc1 FF |
268 | befs_debug(sb, "---> %s, " |
269 | "found %lu at direct[%d]", __func__, | |
270 | (unsigned long)blockno, i); | |
1da177e4 LT |
271 | return BEFS_OK; |
272 | } | |
273 | } | |
274 | ||
4c3897cc LB |
275 | befs_error(sb, "%s failed to find file block %lu", __func__, |
276 | (unsigned long)blockno); | |
dac52fc1 | 277 | befs_debug(sb, "---> %s ERROR", __func__); |
1da177e4 LT |
278 | return BEFS_ERR; |
279 | } | |
280 | ||
a20af5f9 LB |
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 | */ | |
1da177e4 LT |
303 | static int |
304 | befs_find_brun_indirect(struct super_block *sb, | |
22341d8f AV |
305 | const befs_data_stream *data, |
306 | befs_blocknr_t blockno, | |
a17e7d20 | 307 | befs_block_run *run) |
1da177e4 LT |
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; | |
a9721f31 | 314 | befs_disk_block_run *array; |
1da177e4 LT |
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 | ||
dac52fc1 | 320 | befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno); |
1da177e4 LT |
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++) { | |
f7f67540 | 327 | indirblock = sb_bread(sb, indirblockno + i); |
1da177e4 | 328 | if (indirblock == NULL) { |
4c3897cc | 329 | befs_error(sb, "---> %s failed to read " |
dac52fc1 FF |
330 | "disk block %lu from the indirect brun", |
331 | __func__, (unsigned long)indirblockno + i); | |
4c3897cc | 332 | befs_debug(sb, "<--- %s ERROR", __func__); |
1da177e4 LT |
333 | return BEFS_ERR; |
334 | } | |
335 | ||
a9721f31 | 336 | array = (befs_disk_block_run *) indirblock->b_data; |
1da177e4 LT |
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, | |
dac52fc1 FF |
352 | "<--- %s found file block " |
353 | "%lu at indirect[%d]", __func__, | |
354 | (unsigned long)blockno, | |
355 | j + (i * arraylen)); | |
1da177e4 LT |
356 | return BEFS_OK; |
357 | } | |
358 | sum += len; | |
359 | } | |
360 | ||
361 | brelse(indirblock); | |
362 | } | |
363 | ||
364 | /* Only fallthrough is an error */ | |
dac52fc1 FF |
365 | befs_error(sb, "BeFS: %s failed to find " |
366 | "file block %lu", __func__, (unsigned long)blockno); | |
1da177e4 | 367 | |
dac52fc1 | 368 | befs_debug(sb, "<--- %s ERROR", __func__); |
1da177e4 LT |
369 | return BEFS_ERR; |
370 | } | |
371 | ||
a20af5f9 LB |
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 | */ | |
1da177e4 LT |
412 | static int |
413 | befs_find_brun_dblindirect(struct super_block *sb, | |
22341d8f AV |
414 | const befs_data_stream *data, |
415 | befs_blocknr_t blockno, | |
a17e7d20 | 416 | befs_block_run *run) |
1da177e4 LT |
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; | |
6c8da24b | 430 | befs_disk_inode_addr *iaddr_array; |
1da177e4 LT |
431 | |
432 | befs_blocknr_t indir_start_blk = | |
f3066103 | 433 | data->max_indirect_range >> BEFS_SB(sb)->block_shift; |
1da177e4 LT |
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 | ||
dac52fc1 | 448 | befs_debug(sb, "---> %s find %lu", __func__, (unsigned long)blockno); |
1da177e4 LT |
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 " | |
dac52fc1 FF |
464 | "%s, %d, is outside the range " |
465 | "of the double-indirect block", __func__, | |
466 | dblindir_indx); | |
1da177e4 LT |
467 | return BEFS_ERR; |
468 | } | |
469 | ||
470 | dbl_indir_block = | |
f7f67540 | 471 | sb_bread(sb, iaddr2blockno(sb, &data->double_indirect) + |
1da177e4 LT |
472 | dbl_which_block); |
473 | if (dbl_indir_block == NULL) { | |
dac52fc1 FF |
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) + | |
1da177e4 | 478 | dbl_which_block); |
1da177e4 LT |
479 | return BEFS_ERR; |
480 | } | |
481 | ||
482 | dbl_block_indx = | |
483 | dblindir_indx - (dbl_which_block * befs_iaddrs_per_block(sb)); | |
a9721f31 | 484 | iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data; |
1da177e4 LT |
485 | indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]); |
486 | brelse(dbl_indir_block); | |
1da177e4 LT |
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 " | |
dac52fc1 FF |
492 | "%s, %d, is outside the range " |
493 | "of the indirect block", __func__, indir_indx); | |
1da177e4 LT |
494 | return BEFS_ERR; |
495 | } | |
496 | ||
497 | indir_block = | |
f7f67540 | 498 | sb_bread(sb, iaddr2blockno(sb, &indir_run) + which_block); |
1da177e4 | 499 | if (indir_block == NULL) { |
dac52fc1 FF |
500 | befs_error(sb, "%s couldn't read the indirect block " |
501 | "at blockno %lu", __func__, (unsigned long) | |
1da177e4 | 502 | iaddr2blockno(sb, &indir_run) + which_block); |
1da177e4 LT |
503 | return BEFS_ERR; |
504 | } | |
505 | ||
506 | block_indx = indir_indx - (which_block * befs_iaddrs_per_block(sb)); | |
a9721f31 | 507 | iaddr_array = (befs_disk_inode_addr *) indir_block->b_data; |
1da177e4 LT |
508 | *run = fsrun_to_cpu(sb, iaddr_array[block_indx]); |
509 | brelse(indir_block); | |
1da177e4 LT |
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]," | |
dac52fc1 | 520 | " double_indirect_leftover = %lu", (unsigned long) |
1da177e4 LT |
521 | blockno, dblindir_indx, indir_indx, dblindir_leftover); |
522 | ||
523 | return BEFS_OK; | |
524 | } |