projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xfs: convert directory segment limits to xfs_da_geometry
[deliverable/linux.git] / fs / xfs / xfs_dir2_readdir.c
1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * Copyright (c) 2013 Red Hat, Inc.
4 * All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it would be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19 #include "xfs.h"
20 #include "xfs_fs.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_bit.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_mount.h"
28 #include "xfs_da_format.h"
29 #include "xfs_da_btree.h"
30 #include "xfs_inode.h"
31 #include "xfs_dir2.h"
32 #include "xfs_dir2_priv.h"
33 #include "xfs_error.h"
34 #include "xfs_trace.h"
35 #include "xfs_bmap.h"
36 #include "xfs_trans.h"
37 #include "xfs_dinode.h"
38
39 /*
40 * Directory file type support functions
41 */
42 static unsigned char xfs_dir3_filetype_table[] = {
43 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK,
44 DT_FIFO, DT_SOCK, DT_LNK, DT_WHT,
45 };
46
47 unsigned char
48 xfs_dir3_get_dtype(
49 struct xfs_mount *mp,
50 __uint8_t filetype)
51 {
52 if (!xfs_sb_version_hasftype(&mp->m_sb))
53 return DT_UNKNOWN;
54
55 if (filetype >= XFS_DIR3_FT_MAX)
56 return DT_UNKNOWN;
57
58 return xfs_dir3_filetype_table[filetype];
59 }
60 /*
61 * @mode, if set, indicates that the type field needs to be set up.
62 * This uses the transformation from file mode to DT_* as defined in linux/fs.h
63 * for file type specification. This will be propagated into the directory
64 * structure if appropriate for the given operation and filesystem config.
65 */
66 const unsigned char xfs_mode_to_ftype[S_IFMT >> S_SHIFT] = {
67 [0] = XFS_DIR3_FT_UNKNOWN,
68 [S_IFREG >> S_SHIFT] = XFS_DIR3_FT_REG_FILE,
69 [S_IFDIR >> S_SHIFT] = XFS_DIR3_FT_DIR,
70 [S_IFCHR >> S_SHIFT] = XFS_DIR3_FT_CHRDEV,
71 [S_IFBLK >> S_SHIFT] = XFS_DIR3_FT_BLKDEV,
72 [S_IFIFO >> S_SHIFT] = XFS_DIR3_FT_FIFO,
73 [S_IFSOCK >> S_SHIFT] = XFS_DIR3_FT_SOCK,
74 [S_IFLNK >> S_SHIFT] = XFS_DIR3_FT_SYMLINK,
75 };
76
77 STATIC int
78 xfs_dir2_sf_getdents(
79 xfs_inode_t *dp, /* incore directory inode */
80 struct dir_context *ctx)
81 {
82 int i; /* shortform entry number */
83 xfs_mount_t *mp; /* filesystem mount point */
84 xfs_dir2_dataptr_t off; /* current entry's offset */
85 xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
86 xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
87 xfs_dir2_dataptr_t dot_offset;
88 xfs_dir2_dataptr_t dotdot_offset;
89 xfs_ino_t ino;
90 struct xfs_da_geometry *geo;
91
92 mp = dp->i_mount;
93 geo = mp->m_dir_geo;
94
95 ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
96 /*
97 * Give up if the directory is way too short.
98 */
99 if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
100 ASSERT(XFS_FORCED_SHUTDOWN(mp));
101 return XFS_ERROR(EIO);
102 }
103
104 ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
105 ASSERT(dp->i_df.if_u1.if_data != NULL);
106
107 sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
108
109 ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
110
111 /*
112 * If the block number in the offset is out of range, we're done.
113 */
114 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
115 return 0;
116
117 /*
118 * Precalculate offsets for . and .. as we will always need them.
119 *
120 * XXX(hch): the second argument is sometimes 0 and sometimes
121 * geo->datablk
122 */
123 dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
124 dp->d_ops->data_dot_offset);
125 dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
126 dp->d_ops->data_dotdot_offset);
127
128 /*
129 * Put . entry unless we're starting past it.
130 */
131 if (ctx->pos <= dot_offset) {
132 ctx->pos = dot_offset & 0x7fffffff;
133 if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR))
134 return 0;
135 }
136
137 /*
138 * Put .. entry unless we're starting past it.
139 */
140 if (ctx->pos <= dotdot_offset) {
141 ino = dp->d_ops->sf_get_parent_ino(sfp);
142 ctx->pos = dotdot_offset & 0x7fffffff;
143 if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
144 return 0;
145 }
146
147 /*
148 * Loop while there are more entries and put'ing works.
149 */
150 sfep = xfs_dir2_sf_firstentry(sfp);
151 for (i = 0; i < sfp->count; i++) {
152 __uint8_t filetype;
153
154 off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
155 xfs_dir2_sf_get_offset(sfep));
156
157 if (ctx->pos > off) {
158 sfep = dp->d_ops->sf_nextentry(sfp, sfep);
159 continue;
160 }
161
162 ino = dp->d_ops->sf_get_ino(sfp, sfep);
163 filetype = dp->d_ops->sf_get_ftype(sfep);
164 ctx->pos = off & 0x7fffffff;
165 if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
166 xfs_dir3_get_dtype(mp, filetype)))
167 return 0;
168 sfep = dp->d_ops->sf_nextentry(sfp, sfep);
169 }
170
171 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
172 0x7fffffff;
173 return 0;
174 }
175
176 /*
177 * Readdir for block directories.
178 */
179 STATIC int
180 xfs_dir2_block_getdents(
181 xfs_inode_t *dp, /* incore inode */
182 struct dir_context *ctx)
183 {
184 xfs_dir2_data_hdr_t *hdr; /* block header */
185 struct xfs_buf *bp; /* buffer for block */
186 xfs_dir2_block_tail_t *btp; /* block tail */
187 xfs_dir2_data_entry_t *dep; /* block data entry */
188 xfs_dir2_data_unused_t *dup; /* block unused entry */
189 char *endptr; /* end of the data entries */
190 int error; /* error return value */
191 xfs_mount_t *mp; /* filesystem mount point */
192 char *ptr; /* current data entry */
193 int wantoff; /* starting block offset */
194 xfs_off_t cook;
195 struct xfs_da_geometry *geo;
196
197 mp = dp->i_mount;
198 geo = mp->m_dir_geo;
199 /*
200 * If the block number in the offset is out of range, we're done.
201 */
202 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
203 return 0;
204
205 error = xfs_dir3_block_read(NULL, dp, &bp);
206 if (error)
207 return error;
208
209 /*
210 * Extract the byte offset we start at from the seek pointer.
211 * We'll skip entries before this.
212 */
213 wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
214 hdr = bp->b_addr;
215 xfs_dir3_data_check(dp, bp);
216 /*
217 * Set up values for the loop.
218 */
219 btp = xfs_dir2_block_tail_p(mp, hdr);
220 ptr = (char *)dp->d_ops->data_entry_p(hdr);
221 endptr = (char *)xfs_dir2_block_leaf_p(btp);
222
223 /*
224 * Loop over the data portion of the block.
225 * Each object is a real entry (dep) or an unused one (dup).
226 */
227 while (ptr < endptr) {
228 __uint8_t filetype;
229
230 dup = (xfs_dir2_data_unused_t *)ptr;
231 /*
232 * Unused, skip it.
233 */
234 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
235 ptr += be16_to_cpu(dup->length);
236 continue;
237 }
238
239 dep = (xfs_dir2_data_entry_t *)ptr;
240
241 /*
242 * Bump pointer for the next iteration.
243 */
244 ptr += dp->d_ops->data_entsize(dep->namelen);
245 /*
246 * The entry is before the desired starting point, skip it.
247 */
248 if ((char *)dep - (char *)hdr < wantoff)
249 continue;
250
251 cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
252 (char *)dep - (char *)hdr);
253
254 ctx->pos = cook & 0x7fffffff;
255 filetype = dp->d_ops->data_get_ftype(dep);
256 /*
257 * If it didn't fit, set the final offset to here & return.
258 */
259 if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
260 be64_to_cpu(dep->inumber),
261 xfs_dir3_get_dtype(mp, filetype))) {
262 xfs_trans_brelse(NULL, bp);
263 return 0;
264 }
265 }
266
267 /*
268 * Reached the end of the block.
269 * Set the offset to a non-existent block 1 and return.
270 */
271 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
272 0x7fffffff;
273 xfs_trans_brelse(NULL, bp);
274 return 0;
275 }
276
277 struct xfs_dir2_leaf_map_info {
278 xfs_extlen_t map_blocks; /* number of fsbs in map */
279 xfs_dablk_t map_off; /* last mapped file offset */
280 int map_size; /* total entries in *map */
281 int map_valid; /* valid entries in *map */
282 int nmap; /* mappings to ask xfs_bmapi */
283 xfs_dir2_db_t curdb; /* db for current block */
284 int ra_current; /* number of read-ahead blks */
285 int ra_index; /* *map index for read-ahead */
286 int ra_offset; /* map entry offset for ra */
287 int ra_want; /* readahead count wanted */
288 struct xfs_bmbt_irec map[]; /* map vector for blocks */
289 };
290
291 STATIC int
292 xfs_dir2_leaf_readbuf(
293 struct xfs_inode *dp,
294 size_t bufsize,
295 struct xfs_dir2_leaf_map_info *mip,
296 xfs_dir2_off_t *curoff,
297 struct xfs_buf **bpp)
298 {
299 struct xfs_mount *mp = dp->i_mount;
300 struct xfs_buf *bp = *bpp;
301 struct xfs_bmbt_irec *map = mip->map;
302 struct blk_plug plug;
303 int error = 0;
304 int length;
305 int i;
306 int j;
307 struct xfs_da_geometry *geo = mp->m_dir_geo;
308
309 /*
310 * If we have a buffer, we need to release it and
311 * take it out of the mapping.
312 */
313
314 if (bp) {
315 xfs_trans_brelse(NULL, bp);
316 bp = NULL;
317 mip->map_blocks -= mp->m_dirblkfsbs;
318 /*
319 * Loop to get rid of the extents for the
320 * directory block.
321 */
322 for (i = mp->m_dirblkfsbs; i > 0; ) {
323 j = min_t(int, map->br_blockcount, i);
324 map->br_blockcount -= j;
325 map->br_startblock += j;
326 map->br_startoff += j;
327 /*
328 * If mapping is done, pitch it from
329 * the table.
330 */
331 if (!map->br_blockcount && --mip->map_valid)
332 memmove(&map[0], &map[1],
333 sizeof(map[0]) * mip->map_valid);
334 i -= j;
335 }
336 }
337
338 /*
339 * Recalculate the readahead blocks wanted.
340 */
341 mip->ra_want = howmany(bufsize + mp->m_dirblksize,
342 mp->m_sb.sb_blocksize) - 1;
343 ASSERT(mip->ra_want >= 0);
344
345 /*
346 * If we don't have as many as we want, and we haven't
347 * run out of data blocks, get some more mappings.
348 */
349 if (1 + mip->ra_want > mip->map_blocks &&
350 mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
351 /*
352 * Get more bmaps, fill in after the ones
353 * we already have in the table.
354 */
355 mip->nmap = mip->map_size - mip->map_valid;
356 error = xfs_bmapi_read(dp, mip->map_off,
357 xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
358 mip->map_off,
359 &map[mip->map_valid], &mip->nmap, 0);
360
361 /*
362 * Don't know if we should ignore this or try to return an
363 * error. The trouble with returning errors is that readdir
364 * will just stop without actually passing the error through.
365 */
366 if (error)
367 goto out; /* XXX */
368
369 /*
370 * If we got all the mappings we asked for, set the final map
371 * offset based on the last bmap value received. Otherwise,
372 * we've reached the end.
373 */
374 if (mip->nmap == mip->map_size - mip->map_valid) {
375 i = mip->map_valid + mip->nmap - 1;
376 mip->map_off = map[i].br_startoff + map[i].br_blockcount;
377 } else
378 mip->map_off = xfs_dir2_byte_to_da(geo,
379 XFS_DIR2_LEAF_OFFSET);
380
381 /*
382 * Look for holes in the mapping, and eliminate them. Count up
383 * the valid blocks.
384 */
385 for (i = mip->map_valid; i < mip->map_valid + mip->nmap; ) {
386 if (map[i].br_startblock == HOLESTARTBLOCK) {
387 mip->nmap--;
388 length = mip->map_valid + mip->nmap - i;
389 if (length)
390 memmove(&map[i], &map[i + 1],
391 sizeof(map[i]) * length);
392 } else {
393 mip->map_blocks += map[i].br_blockcount;
394 i++;
395 }
396 }
397 mip->map_valid += mip->nmap;
398 }
399
400 /*
401 * No valid mappings, so no more data blocks.
402 */
403 if (!mip->map_valid) {
404 *curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
405 goto out;
406 }
407
408 /*
409 * Read the directory block starting at the first mapping.
410 */
411 mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
412 error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
413 map->br_blockcount >= mp->m_dirblkfsbs ?
414 XFS_FSB_TO_DADDR(mp, map->br_startblock) : -1, &bp);
415
416 /*
417 * Should just skip over the data block instead of giving up.
418 */
419 if (error)
420 goto out; /* XXX */
421
422 /*
423 * Adjust the current amount of read-ahead: we just read a block that
424 * was previously ra.
425 */
426 if (mip->ra_current)
427 mip->ra_current -= mp->m_dirblkfsbs;
428
429 /*
430 * Do we need more readahead?
431 */
432 blk_start_plug(&plug);
433 for (mip->ra_index = mip->ra_offset = i = 0;
434 mip->ra_want > mip->ra_current && i < mip->map_blocks;
435 i += mp->m_dirblkfsbs) {
436 ASSERT(mip->ra_index < mip->map_valid);
437 /*
438 * Read-ahead a contiguous directory block.
439 */
440 if (i > mip->ra_current &&
441 map[mip->ra_index].br_blockcount >= mp->m_dirblkfsbs) {
442 xfs_dir3_data_readahead(dp,
443 map[mip->ra_index].br_startoff + mip->ra_offset,
444 XFS_FSB_TO_DADDR(mp,
445 map[mip->ra_index].br_startblock +
446 mip->ra_offset));
447 mip->ra_current = i;
448 }
449
450 /*
451 * Read-ahead a non-contiguous directory block. This doesn't
452 * use our mapping, but this is a very rare case.
453 */
454 else if (i > mip->ra_current) {
455 xfs_dir3_data_readahead(dp,
456 map[mip->ra_index].br_startoff +
457 mip->ra_offset, -1);
458 mip->ra_current = i;
459 }
460
461 /*
462 * Advance offset through the mapping table.
463 */
464 for (j = 0; j < mp->m_dirblkfsbs; j += length ) {
465 /*
466 * The rest of this extent but not more than a dir
467 * block.
468 */
469 length = min_t(int, mp->m_dirblkfsbs,
470 map[mip->ra_index].br_blockcount -
471 mip->ra_offset);
472 mip->ra_offset += length;
473
474 /*
475 * Advance to the next mapping if this one is used up.
476 */
477 if (mip->ra_offset == map[mip->ra_index].br_blockcount) {
478 mip->ra_offset = 0;
479 mip->ra_index++;
480 }
481 }
482 }
483 blk_finish_plug(&plug);
484
485 out:
486 *bpp = bp;
487 return error;
488 }
489
490 /*
491 * Getdents (readdir) for leaf and node directories.
492 * This reads the data blocks only, so is the same for both forms.
493 */
494 STATIC int
495 xfs_dir2_leaf_getdents(
496 xfs_inode_t *dp, /* incore directory inode */
497 struct dir_context *ctx,
498 size_t bufsize)
499 {
500 struct xfs_buf *bp = NULL; /* data block buffer */
501 xfs_dir2_data_hdr_t *hdr; /* data block header */
502 xfs_dir2_data_entry_t *dep; /* data entry */
503 xfs_dir2_data_unused_t *dup; /* unused entry */
504 int error = 0; /* error return value */
505 int length; /* temporary length value */
506 xfs_mount_t *mp; /* filesystem mount point */
507 int byteoff; /* offset in current block */
508 xfs_dir2_off_t curoff; /* current overall offset */
509 xfs_dir2_off_t newoff; /* new curoff after new blk */
510 char *ptr = NULL; /* pointer to current data */
511 struct xfs_dir2_leaf_map_info *map_info;
512 struct xfs_da_geometry *geo;
513
514 /*
515 * If the offset is at or past the largest allowed value,
516 * give up right away.
517 */
518 if (ctx->pos >= XFS_DIR2_MAX_DATAPTR)
519 return 0;
520
521 mp = dp->i_mount;
522 geo = mp->m_dir_geo;
523
524 /*
525 * Set up to bmap a number of blocks based on the caller's
526 * buffer size, the directory block size, and the filesystem
527 * block size.
528 */
529 length = howmany(bufsize + mp->m_dirblksize,
530 mp->m_sb.sb_blocksize);
531 map_info = kmem_zalloc(offsetof(struct xfs_dir2_leaf_map_info, map) +
532 (length * sizeof(struct xfs_bmbt_irec)),
533 KM_SLEEP | KM_NOFS);
534 map_info->map_size = length;
535
536 /*
537 * Inside the loop we keep the main offset value as a byte offset
538 * in the directory file.
539 */
540 curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
541
542 /*
543 * Force this conversion through db so we truncate the offset
544 * down to get the start of the data block.
545 */
546 map_info->map_off = xfs_dir2_db_to_da(geo,
547 xfs_dir2_byte_to_db(geo, curoff));
548
549 /*
550 * Loop over directory entries until we reach the end offset.
551 * Get more blocks and readahead as necessary.
552 */
553 while (curoff < XFS_DIR2_LEAF_OFFSET) {
554 __uint8_t filetype;
555
556 /*
557 * If we have no buffer, or we're off the end of the
558 * current buffer, need to get another one.
559 */
560 if (!bp || ptr >= (char *)bp->b_addr + mp->m_dirblksize) {
561
562 error = xfs_dir2_leaf_readbuf(dp, bufsize, map_info,
563 &curoff, &bp);
564 if (error || !map_info->map_valid)
565 break;
566
567 /*
568 * Having done a read, we need to set a new offset.
569 */
570 newoff = xfs_dir2_db_off_to_byte(mp->m_dir_geo,
571 map_info->curdb, 0);
572 /*
573 * Start of the current block.
574 */
575 if (curoff < newoff)
576 curoff = newoff;
577 /*
578 * Make sure we're in the right block.
579 */
580 else if (curoff > newoff)
581 ASSERT(xfs_dir2_byte_to_db(geo, curoff) ==
582 map_info->curdb);
583 hdr = bp->b_addr;
584 xfs_dir3_data_check(dp, bp);
585 /*
586 * Find our position in the block.
587 */
588 ptr = (char *)dp->d_ops->data_entry_p(hdr);
589 byteoff = xfs_dir2_byte_to_off(mp->m_dir_geo, curoff);
590 /*
591 * Skip past the header.
592 */
593 if (byteoff == 0)
594 curoff += dp->d_ops->data_entry_offset;
595 /*
596 * Skip past entries until we reach our offset.
597 */
598 else {
599 while ((char *)ptr - (char *)hdr < byteoff) {
600 dup = (xfs_dir2_data_unused_t *)ptr;
601
602 if (be16_to_cpu(dup->freetag)
603 == XFS_DIR2_DATA_FREE_TAG) {
604
605 length = be16_to_cpu(dup->length);
606 ptr += length;
607 continue;
608 }
609 dep = (xfs_dir2_data_entry_t *)ptr;
610 length =
611 dp->d_ops->data_entsize(dep->namelen);
612 ptr += length;
613 }
614 /*
615 * Now set our real offset.
616 */
617 curoff =
618 xfs_dir2_db_off_to_byte(geo,
619 xfs_dir2_byte_to_db(geo, curoff),
620 (char *)ptr - (char *)hdr);
621 if (ptr >= (char *)hdr + mp->m_dirblksize) {
622 continue;
623 }
624 }
625 }
626 /*
627 * We have a pointer to an entry.
628 * Is it a live one?
629 */
630 dup = (xfs_dir2_data_unused_t *)ptr;
631 /*
632 * No, it's unused, skip over it.
633 */
634 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
635 length = be16_to_cpu(dup->length);
636 ptr += length;
637 curoff += length;
638 continue;
639 }
640
641 dep = (xfs_dir2_data_entry_t *)ptr;
642 length = dp->d_ops->data_entsize(dep->namelen);
643 filetype = dp->d_ops->data_get_ftype(dep);
644
645 ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
646 if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
647 be64_to_cpu(dep->inumber),
648 xfs_dir3_get_dtype(mp, filetype)))
649 break;
650
651 /*
652 * Advance to next entry in the block.
653 */
654 ptr += length;
655 curoff += length;
656 /* bufsize may have just been a guess; don't go negative */
657 bufsize = bufsize > length ? bufsize - length : 0;
658 }
659
660 /*
661 * All done. Set output offset value to current offset.
662 */
663 if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
664 ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
665 else
666 ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
667 kmem_free(map_info);
668 if (bp)
669 xfs_trans_brelse(NULL, bp);
670 return error;
671 }
672
673 /*
674 * Read a directory.
675 */
676 int
677 xfs_readdir(
678 xfs_inode_t *dp,
679 struct dir_context *ctx,
680 size_t bufsize)
681 {
682 int rval; /* return value */
683 int v; /* type-checking value */
684 uint lock_mode;
685
686 trace_xfs_readdir(dp);
687
688 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
689 return XFS_ERROR(EIO);
690
691 ASSERT(S_ISDIR(dp->i_d.di_mode));
692 XFS_STATS_INC(xs_dir_getdents);
693
694 lock_mode = xfs_ilock_data_map_shared(dp);
695 if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
696 rval = xfs_dir2_sf_getdents(dp, ctx);
697 else if ((rval = xfs_dir2_isblock(dp, &v)))
698 ;
699 else if (v)
700 rval = xfs_dir2_block_getdents(dp, ctx);
701 else
702 rval = xfs_dir2_leaf_getdents(dp, ctx, bufsize);
703 xfs_iunlock(dp, lock_mode);
704
705 return rval;
706 }
Linux kernel - Deliverables
This page took 0.044863 seconds and 5 git commands to generate.