2 * Copyright (c) 2000,2002,2005 Silicon Graphics, Inc.
3 * Copyright (c) 2013 Red Hat, Inc.
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.
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.
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
21 #include "xfs_shared.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
27 #include "xfs_mount.h"
28 #include "xfs_da_format.h"
29 #include "xfs_da_btree.h"
30 #include "xfs_inode.h"
32 #include "xfs_dir2_priv.h"
35 * Shortform directory ops
39 struct xfs_dir2_sf_hdr *hdr,
42 int count = sizeof(struct xfs_dir2_sf_entry); /* namelen + offset */
44 count += len; /* name */
45 count += hdr->i8count ? sizeof(xfs_dir2_ino8_t) :
46 sizeof(xfs_dir2_ino4_t); /* ino # */
52 struct xfs_dir2_sf_hdr *hdr,
55 return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t);
58 static struct xfs_dir2_sf_entry *
59 xfs_dir2_sf_nextentry(
60 struct xfs_dir2_sf_hdr *hdr,
61 struct xfs_dir2_sf_entry *sfep)
63 return (struct xfs_dir2_sf_entry *)
64 ((char *)sfep + xfs_dir2_sf_entsize(hdr, sfep->namelen));
67 static struct xfs_dir2_sf_entry *
68 xfs_dir3_sf_nextentry(
69 struct xfs_dir2_sf_hdr *hdr,
70 struct xfs_dir2_sf_entry *sfep)
72 return (struct xfs_dir2_sf_entry *)
73 ((char *)sfep + xfs_dir3_sf_entsize(hdr, sfep->namelen));
78 * For filetype enabled shortform directories, the file type field is stored at
79 * the end of the name. Because it's only a single byte, endian conversion is
80 * not necessary. For non-filetype enable directories, the type is always
81 * unknown and we never store the value.
84 xfs_dir2_sfe_get_ftype(
85 struct xfs_dir2_sf_entry *sfep)
87 return XFS_DIR3_FT_UNKNOWN;
91 xfs_dir2_sfe_put_ftype(
92 struct xfs_dir2_sf_entry *sfep,
95 ASSERT(ftype < XFS_DIR3_FT_MAX);
99 xfs_dir3_sfe_get_ftype(
100 struct xfs_dir2_sf_entry *sfep)
104 ftype = sfep->name[sfep->namelen];
105 if (ftype >= XFS_DIR3_FT_MAX)
106 return XFS_DIR3_FT_UNKNOWN;
111 xfs_dir3_sfe_put_ftype(
112 struct xfs_dir2_sf_entry *sfep,
115 ASSERT(ftype < XFS_DIR3_FT_MAX);
117 sfep->name[sfep->namelen] = ftype;
121 * Inode numbers in short-form directories can come in two versions,
122 * either 4 bytes or 8 bytes wide. These helpers deal with the
123 * two forms transparently by looking at the headers i8count field.
125 * For 64-bit inode number the most significant byte must be zero.
129 struct xfs_dir2_sf_hdr *hdr,
130 xfs_dir2_inou_t *from)
133 return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
135 return get_unaligned_be32(&from->i4.i);
140 struct xfs_dir2_sf_hdr *hdr,
144 ASSERT((ino & 0xff00000000000000ULL) == 0);
147 put_unaligned_be64(ino, &to->i8.i);
149 put_unaligned_be32(ino, &to->i4.i);
153 xfs_dir2_sf_get_parent_ino(
154 struct xfs_dir2_sf_hdr *hdr)
156 return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
160 xfs_dir2_sf_put_parent_ino(
161 struct xfs_dir2_sf_hdr *hdr,
164 xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
168 * In short-form directory entries the inode numbers are stored at variable
169 * offset behind the entry name. If the entry stores a filetype value, then it
170 * sits between the name and the inode number. Hence the inode numbers may only
171 * be accessed through the helpers below.
174 xfs_dir2_sfe_get_ino(
175 struct xfs_dir2_sf_hdr *hdr,
176 struct xfs_dir2_sf_entry *sfep)
178 return xfs_dir2_sf_get_ino(hdr,
179 (xfs_dir2_inou_t *)&sfep->name[sfep->namelen]);
183 xfs_dir2_sfe_put_ino(
184 struct xfs_dir2_sf_hdr *hdr,
185 struct xfs_dir2_sf_entry *sfep,
188 xfs_dir2_sf_put_ino(hdr,
189 (xfs_dir2_inou_t *)&sfep->name[sfep->namelen], ino);
193 xfs_dir3_sfe_get_ino(
194 struct xfs_dir2_sf_hdr *hdr,
195 struct xfs_dir2_sf_entry *sfep)
197 return xfs_dir2_sf_get_ino(hdr,
198 (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1]);
202 xfs_dir3_sfe_put_ino(
203 struct xfs_dir2_sf_hdr *hdr,
204 struct xfs_dir2_sf_entry *sfep,
207 xfs_dir2_sf_put_ino(hdr,
208 (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1], ino);
213 * Directory data block operations
217 * For special situations, the dirent size ends up fixed because we always know
218 * what the size of the entry is. That's true for the "." and "..", and
219 * therefore we know that they are a fixed size and hence their offsets are
220 * constant, as is the first entry.
222 * Hence, this calculation is written as a macro to be able to be calculated at
223 * compile time and so certain offsets can be calculated directly in the
224 * structure initaliser via the macro. There are two macros - one for dirents
225 * with ftype and without so there are no unresolvable conditionals in the
226 * calculations. We also use round_up() as XFS_DIR2_DATA_ALIGN is always a power
227 * of 2 and the compiler doesn't reject it (unlike roundup()).
229 #define XFS_DIR2_DATA_ENTSIZE(n) \
230 round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
231 sizeof(xfs_dir2_data_off_t)), XFS_DIR2_DATA_ALIGN)
233 #define XFS_DIR3_DATA_ENTSIZE(n) \
234 round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
235 sizeof(xfs_dir2_data_off_t) + sizeof(__uint8_t)), \
239 xfs_dir2_data_entsize(
242 return XFS_DIR2_DATA_ENTSIZE(n);
246 xfs_dir3_data_entsize(
249 return XFS_DIR3_DATA_ENTSIZE(n);
253 xfs_dir2_data_get_ftype(
254 struct xfs_dir2_data_entry *dep)
256 return XFS_DIR3_FT_UNKNOWN;
260 xfs_dir2_data_put_ftype(
261 struct xfs_dir2_data_entry *dep,
264 ASSERT(ftype < XFS_DIR3_FT_MAX);
268 xfs_dir3_data_get_ftype(
269 struct xfs_dir2_data_entry *dep)
271 __uint8_t ftype = dep->name[dep->namelen];
273 if (ftype >= XFS_DIR3_FT_MAX)
274 return XFS_DIR3_FT_UNKNOWN;
279 xfs_dir3_data_put_ftype(
280 struct xfs_dir2_data_entry *dep,
283 ASSERT(type < XFS_DIR3_FT_MAX);
284 ASSERT(dep->namelen != 0);
286 dep->name[dep->namelen] = type;
290 * Pointer to an entry's tag word.
293 xfs_dir2_data_entry_tag_p(
294 struct xfs_dir2_data_entry *dep)
296 return (__be16 *)((char *)dep +
297 xfs_dir2_data_entsize(dep->namelen) - sizeof(__be16));
301 xfs_dir3_data_entry_tag_p(
302 struct xfs_dir2_data_entry *dep)
304 return (__be16 *)((char *)dep +
305 xfs_dir3_data_entsize(dep->namelen) - sizeof(__be16));
309 * location of . and .. in data space (always block 0)
311 static struct xfs_dir2_data_entry *
312 xfs_dir2_data_dot_entry_p(
313 struct xfs_dir2_data_hdr *hdr)
315 return (struct xfs_dir2_data_entry *)
316 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
319 static struct xfs_dir2_data_entry *
320 xfs_dir2_data_dotdot_entry_p(
321 struct xfs_dir2_data_hdr *hdr)
323 return (struct xfs_dir2_data_entry *)
324 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
325 XFS_DIR2_DATA_ENTSIZE(1));
328 static struct xfs_dir2_data_entry *
329 xfs_dir2_data_first_entry_p(
330 struct xfs_dir2_data_hdr *hdr)
332 return (struct xfs_dir2_data_entry *)
333 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
334 XFS_DIR2_DATA_ENTSIZE(1) +
335 XFS_DIR2_DATA_ENTSIZE(2));
338 static struct xfs_dir2_data_entry *
339 xfs_dir2_ftype_data_dotdot_entry_p(
340 struct xfs_dir2_data_hdr *hdr)
342 return (struct xfs_dir2_data_entry *)
343 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
344 XFS_DIR3_DATA_ENTSIZE(1));
347 static struct xfs_dir2_data_entry *
348 xfs_dir2_ftype_data_first_entry_p(
349 struct xfs_dir2_data_hdr *hdr)
351 return (struct xfs_dir2_data_entry *)
352 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
353 XFS_DIR3_DATA_ENTSIZE(1) +
354 XFS_DIR3_DATA_ENTSIZE(2));
357 static struct xfs_dir2_data_entry *
358 xfs_dir3_data_dot_entry_p(
359 struct xfs_dir2_data_hdr *hdr)
361 return (struct xfs_dir2_data_entry *)
362 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
365 static struct xfs_dir2_data_entry *
366 xfs_dir3_data_dotdot_entry_p(
367 struct xfs_dir2_data_hdr *hdr)
369 return (struct xfs_dir2_data_entry *)
370 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
371 XFS_DIR3_DATA_ENTSIZE(1));
374 static struct xfs_dir2_data_entry *
375 xfs_dir3_data_first_entry_p(
376 struct xfs_dir2_data_hdr *hdr)
378 return (struct xfs_dir2_data_entry *)
379 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
380 XFS_DIR3_DATA_ENTSIZE(1) +
381 XFS_DIR3_DATA_ENTSIZE(2));
384 static struct xfs_dir2_data_free *
385 xfs_dir2_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
387 return hdr->bestfree;
390 static struct xfs_dir2_data_free *
391 xfs_dir3_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
393 return ((struct xfs_dir3_data_hdr *)hdr)->best_free;
396 static struct xfs_dir2_data_entry *
397 xfs_dir2_data_entry_p(struct xfs_dir2_data_hdr *hdr)
399 return (struct xfs_dir2_data_entry *)
400 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
403 static struct xfs_dir2_data_unused *
404 xfs_dir2_data_unused_p(struct xfs_dir2_data_hdr *hdr)
406 return (struct xfs_dir2_data_unused *)
407 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
410 static struct xfs_dir2_data_entry *
411 xfs_dir3_data_entry_p(struct xfs_dir2_data_hdr *hdr)
413 return (struct xfs_dir2_data_entry *)
414 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
417 static struct xfs_dir2_data_unused *
418 xfs_dir3_data_unused_p(struct xfs_dir2_data_hdr *hdr)
420 return (struct xfs_dir2_data_unused *)
421 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
426 * Directory Leaf block operations
429 xfs_dir2_max_leaf_ents(struct xfs_da_geometry *geo)
431 return (geo->blksize - sizeof(struct xfs_dir2_leaf_hdr)) /
432 (uint)sizeof(struct xfs_dir2_leaf_entry);
435 static struct xfs_dir2_leaf_entry *
436 xfs_dir2_leaf_ents_p(struct xfs_dir2_leaf *lp)
442 xfs_dir3_max_leaf_ents(struct xfs_da_geometry *geo)
444 return (geo->blksize - sizeof(struct xfs_dir3_leaf_hdr)) /
445 (uint)sizeof(struct xfs_dir2_leaf_entry);
448 static struct xfs_dir2_leaf_entry *
449 xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)
451 return ((struct xfs_dir3_leaf *)lp)->__ents;
455 xfs_dir2_leaf_hdr_from_disk(
456 struct xfs_dir3_icleaf_hdr *to,
457 struct xfs_dir2_leaf *from)
459 to->forw = be32_to_cpu(from->hdr.info.forw);
460 to->back = be32_to_cpu(from->hdr.info.back);
461 to->magic = be16_to_cpu(from->hdr.info.magic);
462 to->count = be16_to_cpu(from->hdr.count);
463 to->stale = be16_to_cpu(from->hdr.stale);
465 ASSERT(to->magic == XFS_DIR2_LEAF1_MAGIC ||
466 to->magic == XFS_DIR2_LEAFN_MAGIC);
470 xfs_dir2_leaf_hdr_to_disk(
471 struct xfs_dir2_leaf *to,
472 struct xfs_dir3_icleaf_hdr *from)
474 ASSERT(from->magic == XFS_DIR2_LEAF1_MAGIC ||
475 from->magic == XFS_DIR2_LEAFN_MAGIC);
477 to->hdr.info.forw = cpu_to_be32(from->forw);
478 to->hdr.info.back = cpu_to_be32(from->back);
479 to->hdr.info.magic = cpu_to_be16(from->magic);
480 to->hdr.count = cpu_to_be16(from->count);
481 to->hdr.stale = cpu_to_be16(from->stale);
485 xfs_dir3_leaf_hdr_from_disk(
486 struct xfs_dir3_icleaf_hdr *to,
487 struct xfs_dir2_leaf *from)
489 struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)from;
491 to->forw = be32_to_cpu(hdr3->info.hdr.forw);
492 to->back = be32_to_cpu(hdr3->info.hdr.back);
493 to->magic = be16_to_cpu(hdr3->info.hdr.magic);
494 to->count = be16_to_cpu(hdr3->count);
495 to->stale = be16_to_cpu(hdr3->stale);
497 ASSERT(to->magic == XFS_DIR3_LEAF1_MAGIC ||
498 to->magic == XFS_DIR3_LEAFN_MAGIC);
502 xfs_dir3_leaf_hdr_to_disk(
503 struct xfs_dir2_leaf *to,
504 struct xfs_dir3_icleaf_hdr *from)
506 struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)to;
508 ASSERT(from->magic == XFS_DIR3_LEAF1_MAGIC ||
509 from->magic == XFS_DIR3_LEAFN_MAGIC);
511 hdr3->info.hdr.forw = cpu_to_be32(from->forw);
512 hdr3->info.hdr.back = cpu_to_be32(from->back);
513 hdr3->info.hdr.magic = cpu_to_be16(from->magic);
514 hdr3->count = cpu_to_be16(from->count);
515 hdr3->stale = cpu_to_be16(from->stale);
520 * Directory/Attribute Node block operations
522 static struct xfs_da_node_entry *
523 xfs_da2_node_tree_p(struct xfs_da_intnode *dap)
528 static struct xfs_da_node_entry *
529 xfs_da3_node_tree_p(struct xfs_da_intnode *dap)
531 return ((struct xfs_da3_intnode *)dap)->__btree;
535 xfs_da2_node_hdr_from_disk(
536 struct xfs_da3_icnode_hdr *to,
537 struct xfs_da_intnode *from)
539 ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
540 to->forw = be32_to_cpu(from->hdr.info.forw);
541 to->back = be32_to_cpu(from->hdr.info.back);
542 to->magic = be16_to_cpu(from->hdr.info.magic);
543 to->count = be16_to_cpu(from->hdr.__count);
544 to->level = be16_to_cpu(from->hdr.__level);
548 xfs_da2_node_hdr_to_disk(
549 struct xfs_da_intnode *to,
550 struct xfs_da3_icnode_hdr *from)
552 ASSERT(from->magic == XFS_DA_NODE_MAGIC);
553 to->hdr.info.forw = cpu_to_be32(from->forw);
554 to->hdr.info.back = cpu_to_be32(from->back);
555 to->hdr.info.magic = cpu_to_be16(from->magic);
556 to->hdr.__count = cpu_to_be16(from->count);
557 to->hdr.__level = cpu_to_be16(from->level);
561 xfs_da3_node_hdr_from_disk(
562 struct xfs_da3_icnode_hdr *to,
563 struct xfs_da_intnode *from)
565 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
567 ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
568 to->forw = be32_to_cpu(hdr3->info.hdr.forw);
569 to->back = be32_to_cpu(hdr3->info.hdr.back);
570 to->magic = be16_to_cpu(hdr3->info.hdr.magic);
571 to->count = be16_to_cpu(hdr3->__count);
572 to->level = be16_to_cpu(hdr3->__level);
576 xfs_da3_node_hdr_to_disk(
577 struct xfs_da_intnode *to,
578 struct xfs_da3_icnode_hdr *from)
580 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
582 ASSERT(from->magic == XFS_DA3_NODE_MAGIC);
583 hdr3->info.hdr.forw = cpu_to_be32(from->forw);
584 hdr3->info.hdr.back = cpu_to_be32(from->back);
585 hdr3->info.hdr.magic = cpu_to_be16(from->magic);
586 hdr3->__count = cpu_to_be16(from->count);
587 hdr3->__level = cpu_to_be16(from->level);
592 * Directory free space block operations
595 xfs_dir2_free_max_bests(struct xfs_da_geometry *geo)
597 return (geo->blksize - sizeof(struct xfs_dir2_free_hdr)) /
598 sizeof(xfs_dir2_data_off_t);
602 xfs_dir2_free_bests_p(struct xfs_dir2_free *free)
604 return (__be16 *)((char *)free + sizeof(struct xfs_dir2_free_hdr));
608 * Convert data space db to the corresponding free db.
611 xfs_dir2_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
613 return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) +
614 (db / xfs_dir2_free_max_bests(geo));
618 * Convert data space db to the corresponding index in a free db.
621 xfs_dir2_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
623 return db % xfs_dir2_free_max_bests(geo);
627 xfs_dir3_free_max_bests(struct xfs_da_geometry *geo)
629 return (geo->blksize - sizeof(struct xfs_dir3_free_hdr)) /
630 sizeof(xfs_dir2_data_off_t);
634 xfs_dir3_free_bests_p(struct xfs_dir2_free *free)
636 return (__be16 *)((char *)free + sizeof(struct xfs_dir3_free_hdr));
640 * Convert data space db to the corresponding free db.
643 xfs_dir3_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
645 return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) +
646 (db / xfs_dir3_free_max_bests(geo));
650 * Convert data space db to the corresponding index in a free db.
653 xfs_dir3_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
655 return db % xfs_dir3_free_max_bests(geo);
659 xfs_dir2_free_hdr_from_disk(
660 struct xfs_dir3_icfree_hdr *to,
661 struct xfs_dir2_free *from)
663 to->magic = be32_to_cpu(from->hdr.magic);
664 to->firstdb = be32_to_cpu(from->hdr.firstdb);
665 to->nvalid = be32_to_cpu(from->hdr.nvalid);
666 to->nused = be32_to_cpu(from->hdr.nused);
667 ASSERT(to->magic == XFS_DIR2_FREE_MAGIC);
671 xfs_dir2_free_hdr_to_disk(
672 struct xfs_dir2_free *to,
673 struct xfs_dir3_icfree_hdr *from)
675 ASSERT(from->magic == XFS_DIR2_FREE_MAGIC);
677 to->hdr.magic = cpu_to_be32(from->magic);
678 to->hdr.firstdb = cpu_to_be32(from->firstdb);
679 to->hdr.nvalid = cpu_to_be32(from->nvalid);
680 to->hdr.nused = cpu_to_be32(from->nused);
684 xfs_dir3_free_hdr_from_disk(
685 struct xfs_dir3_icfree_hdr *to,
686 struct xfs_dir2_free *from)
688 struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
690 to->magic = be32_to_cpu(hdr3->hdr.magic);
691 to->firstdb = be32_to_cpu(hdr3->firstdb);
692 to->nvalid = be32_to_cpu(hdr3->nvalid);
693 to->nused = be32_to_cpu(hdr3->nused);
695 ASSERT(to->magic == XFS_DIR3_FREE_MAGIC);
699 xfs_dir3_free_hdr_to_disk(
700 struct xfs_dir2_free *to,
701 struct xfs_dir3_icfree_hdr *from)
703 struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
705 ASSERT(from->magic == XFS_DIR3_FREE_MAGIC);
707 hdr3->hdr.magic = cpu_to_be32(from->magic);
708 hdr3->firstdb = cpu_to_be32(from->firstdb);
709 hdr3->nvalid = cpu_to_be32(from->nvalid);
710 hdr3->nused = cpu_to_be32(from->nused);
713 static const struct xfs_dir_ops xfs_dir2_ops = {
714 .sf_entsize = xfs_dir2_sf_entsize,
715 .sf_nextentry = xfs_dir2_sf_nextentry,
716 .sf_get_ftype = xfs_dir2_sfe_get_ftype,
717 .sf_put_ftype = xfs_dir2_sfe_put_ftype,
718 .sf_get_ino = xfs_dir2_sfe_get_ino,
719 .sf_put_ino = xfs_dir2_sfe_put_ino,
720 .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
721 .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
723 .data_entsize = xfs_dir2_data_entsize,
724 .data_get_ftype = xfs_dir2_data_get_ftype,
725 .data_put_ftype = xfs_dir2_data_put_ftype,
726 .data_entry_tag_p = xfs_dir2_data_entry_tag_p,
727 .data_bestfree_p = xfs_dir2_data_bestfree_p,
729 .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
730 .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
731 XFS_DIR2_DATA_ENTSIZE(1),
732 .data_first_offset = sizeof(struct xfs_dir2_data_hdr) +
733 XFS_DIR2_DATA_ENTSIZE(1) +
734 XFS_DIR2_DATA_ENTSIZE(2),
735 .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
737 .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
738 .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p,
739 .data_first_entry_p = xfs_dir2_data_first_entry_p,
740 .data_entry_p = xfs_dir2_data_entry_p,
741 .data_unused_p = xfs_dir2_data_unused_p,
743 .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
744 .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
745 .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
746 .leaf_max_ents = xfs_dir2_max_leaf_ents,
747 .leaf_ents_p = xfs_dir2_leaf_ents_p,
749 .node_hdr_size = sizeof(struct xfs_da_node_hdr),
750 .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
751 .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
752 .node_tree_p = xfs_da2_node_tree_p,
754 .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
755 .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
756 .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
757 .free_max_bests = xfs_dir2_free_max_bests,
758 .free_bests_p = xfs_dir2_free_bests_p,
759 .db_to_fdb = xfs_dir2_db_to_fdb,
760 .db_to_fdindex = xfs_dir2_db_to_fdindex,
763 static const struct xfs_dir_ops xfs_dir2_ftype_ops = {
764 .sf_entsize = xfs_dir3_sf_entsize,
765 .sf_nextentry = xfs_dir3_sf_nextentry,
766 .sf_get_ftype = xfs_dir3_sfe_get_ftype,
767 .sf_put_ftype = xfs_dir3_sfe_put_ftype,
768 .sf_get_ino = xfs_dir3_sfe_get_ino,
769 .sf_put_ino = xfs_dir3_sfe_put_ino,
770 .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
771 .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
773 .data_entsize = xfs_dir3_data_entsize,
774 .data_get_ftype = xfs_dir3_data_get_ftype,
775 .data_put_ftype = xfs_dir3_data_put_ftype,
776 .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
777 .data_bestfree_p = xfs_dir2_data_bestfree_p,
779 .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
780 .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
781 XFS_DIR3_DATA_ENTSIZE(1),
782 .data_first_offset = sizeof(struct xfs_dir2_data_hdr) +
783 XFS_DIR3_DATA_ENTSIZE(1) +
784 XFS_DIR3_DATA_ENTSIZE(2),
785 .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
787 .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
788 .data_dotdot_entry_p = xfs_dir2_ftype_data_dotdot_entry_p,
789 .data_first_entry_p = xfs_dir2_ftype_data_first_entry_p,
790 .data_entry_p = xfs_dir2_data_entry_p,
791 .data_unused_p = xfs_dir2_data_unused_p,
793 .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
794 .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
795 .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
796 .leaf_max_ents = xfs_dir2_max_leaf_ents,
797 .leaf_ents_p = xfs_dir2_leaf_ents_p,
799 .node_hdr_size = sizeof(struct xfs_da_node_hdr),
800 .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
801 .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
802 .node_tree_p = xfs_da2_node_tree_p,
804 .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
805 .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
806 .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
807 .free_max_bests = xfs_dir2_free_max_bests,
808 .free_bests_p = xfs_dir2_free_bests_p,
809 .db_to_fdb = xfs_dir2_db_to_fdb,
810 .db_to_fdindex = xfs_dir2_db_to_fdindex,
813 static const struct xfs_dir_ops xfs_dir3_ops = {
814 .sf_entsize = xfs_dir3_sf_entsize,
815 .sf_nextentry = xfs_dir3_sf_nextentry,
816 .sf_get_ftype = xfs_dir3_sfe_get_ftype,
817 .sf_put_ftype = xfs_dir3_sfe_put_ftype,
818 .sf_get_ino = xfs_dir3_sfe_get_ino,
819 .sf_put_ino = xfs_dir3_sfe_put_ino,
820 .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
821 .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
823 .data_entsize = xfs_dir3_data_entsize,
824 .data_get_ftype = xfs_dir3_data_get_ftype,
825 .data_put_ftype = xfs_dir3_data_put_ftype,
826 .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
827 .data_bestfree_p = xfs_dir3_data_bestfree_p,
829 .data_dot_offset = sizeof(struct xfs_dir3_data_hdr),
830 .data_dotdot_offset = sizeof(struct xfs_dir3_data_hdr) +
831 XFS_DIR3_DATA_ENTSIZE(1),
832 .data_first_offset = sizeof(struct xfs_dir3_data_hdr) +
833 XFS_DIR3_DATA_ENTSIZE(1) +
834 XFS_DIR3_DATA_ENTSIZE(2),
835 .data_entry_offset = sizeof(struct xfs_dir3_data_hdr),
837 .data_dot_entry_p = xfs_dir3_data_dot_entry_p,
838 .data_dotdot_entry_p = xfs_dir3_data_dotdot_entry_p,
839 .data_first_entry_p = xfs_dir3_data_first_entry_p,
840 .data_entry_p = xfs_dir3_data_entry_p,
841 .data_unused_p = xfs_dir3_data_unused_p,
843 .leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr),
844 .leaf_hdr_to_disk = xfs_dir3_leaf_hdr_to_disk,
845 .leaf_hdr_from_disk = xfs_dir3_leaf_hdr_from_disk,
846 .leaf_max_ents = xfs_dir3_max_leaf_ents,
847 .leaf_ents_p = xfs_dir3_leaf_ents_p,
849 .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
850 .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
851 .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
852 .node_tree_p = xfs_da3_node_tree_p,
854 .free_hdr_size = sizeof(struct xfs_dir3_free_hdr),
855 .free_hdr_to_disk = xfs_dir3_free_hdr_to_disk,
856 .free_hdr_from_disk = xfs_dir3_free_hdr_from_disk,
857 .free_max_bests = xfs_dir3_free_max_bests,
858 .free_bests_p = xfs_dir3_free_bests_p,
859 .db_to_fdb = xfs_dir3_db_to_fdb,
860 .db_to_fdindex = xfs_dir3_db_to_fdindex,
863 static const struct xfs_dir_ops xfs_dir2_nondir_ops = {
864 .node_hdr_size = sizeof(struct xfs_da_node_hdr),
865 .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
866 .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
867 .node_tree_p = xfs_da2_node_tree_p,
870 static const struct xfs_dir_ops xfs_dir3_nondir_ops = {
871 .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
872 .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
873 .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
874 .node_tree_p = xfs_da3_node_tree_p,
878 * Return the ops structure according to the current config. If we are passed
879 * an inode, then that overrides the default config we use which is based on
882 const struct xfs_dir_ops *
884 struct xfs_mount *mp,
885 struct xfs_inode *dp)
889 if (mp->m_dir_inode_ops)
890 return mp->m_dir_inode_ops;
891 if (xfs_sb_version_hascrc(&mp->m_sb))
892 return &xfs_dir3_ops;
893 if (xfs_sb_version_hasftype(&mp->m_sb))
894 return &xfs_dir2_ftype_ops;
895 return &xfs_dir2_ops;
898 const struct xfs_dir_ops *
900 struct xfs_mount *mp,
901 struct xfs_inode *dp)
905 if (mp->m_nondir_inode_ops)
906 return mp->m_nondir_inode_ops;
907 if (xfs_sb_version_hascrc(&mp->m_sb))
908 return &xfs_dir3_nondir_ops;
909 return &xfs_dir2_nondir_ops;