Merge branch 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux...
[firefly-linux-kernel-4.4.55.git] / fs / xfs / xfs_da_format.c
1 /*
2  * Copyright (c) 2000,2002,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_shared.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.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
34 /*
35  * Shortform directory ops
36  */
37 static int
38 xfs_dir2_sf_entsize(
39         struct xfs_dir2_sf_hdr  *hdr,
40         int                     len)
41 {
42         int count = sizeof(struct xfs_dir2_sf_entry);   /* namelen + offset */
43
44         count += len;                                   /* name */
45         count += hdr->i8count ? sizeof(xfs_dir2_ino8_t) :
46                                 sizeof(xfs_dir2_ino4_t); /* ino # */
47         return count;
48 }
49
50 static int
51 xfs_dir3_sf_entsize(
52         struct xfs_dir2_sf_hdr  *hdr,
53         int                     len)
54 {
55         return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t);
56 }
57
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)
62 {
63         return (struct xfs_dir2_sf_entry *)
64                 ((char *)sfep + xfs_dir2_sf_entsize(hdr, sfep->namelen));
65 }
66
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)
71 {
72         return (struct xfs_dir2_sf_entry *)
73                 ((char *)sfep + xfs_dir3_sf_entsize(hdr, sfep->namelen));
74 }
75
76
77 /*
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.
82  */
83 static __uint8_t
84 xfs_dir2_sfe_get_ftype(
85         struct xfs_dir2_sf_entry *sfep)
86 {
87         return XFS_DIR3_FT_UNKNOWN;
88 }
89
90 static void
91 xfs_dir2_sfe_put_ftype(
92         struct xfs_dir2_sf_entry *sfep,
93         __uint8_t               ftype)
94 {
95         ASSERT(ftype < XFS_DIR3_FT_MAX);
96 }
97
98 static __uint8_t
99 xfs_dir3_sfe_get_ftype(
100         struct xfs_dir2_sf_entry *sfep)
101 {
102         __uint8_t       ftype;
103
104         ftype = sfep->name[sfep->namelen];
105         if (ftype >= XFS_DIR3_FT_MAX)
106                 return XFS_DIR3_FT_UNKNOWN;
107         return ftype;
108 }
109
110 static void
111 xfs_dir3_sfe_put_ftype(
112         struct xfs_dir2_sf_entry *sfep,
113         __uint8_t               ftype)
114 {
115         ASSERT(ftype < XFS_DIR3_FT_MAX);
116
117         sfep->name[sfep->namelen] = ftype;
118 }
119
120 /*
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.
124  *
125  * For 64-bit inode number the most significant byte must be zero.
126  */
127 static xfs_ino_t
128 xfs_dir2_sf_get_ino(
129         struct xfs_dir2_sf_hdr  *hdr,
130         xfs_dir2_inou_t         *from)
131 {
132         if (hdr->i8count)
133                 return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
134         else
135                 return get_unaligned_be32(&from->i4.i);
136 }
137
138 static void
139 xfs_dir2_sf_put_ino(
140         struct xfs_dir2_sf_hdr  *hdr,
141         xfs_dir2_inou_t         *to,
142         xfs_ino_t               ino)
143 {
144         ASSERT((ino & 0xff00000000000000ULL) == 0);
145
146         if (hdr->i8count)
147                 put_unaligned_be64(ino, &to->i8.i);
148         else
149                 put_unaligned_be32(ino, &to->i4.i);
150 }
151
152 static xfs_ino_t
153 xfs_dir2_sf_get_parent_ino(
154         struct xfs_dir2_sf_hdr  *hdr)
155 {
156         return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
157 }
158
159 static void
160 xfs_dir2_sf_put_parent_ino(
161         struct xfs_dir2_sf_hdr  *hdr,
162         xfs_ino_t               ino)
163 {
164         xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
165 }
166
167 /*
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.
172  */
173 static xfs_ino_t
174 xfs_dir2_sfe_get_ino(
175         struct xfs_dir2_sf_hdr  *hdr,
176         struct xfs_dir2_sf_entry *sfep)
177 {
178         return xfs_dir2_sf_get_ino(hdr,
179                                 (xfs_dir2_inou_t *)&sfep->name[sfep->namelen]);
180 }
181
182 static void
183 xfs_dir2_sfe_put_ino(
184         struct xfs_dir2_sf_hdr  *hdr,
185         struct xfs_dir2_sf_entry *sfep,
186         xfs_ino_t               ino)
187 {
188         xfs_dir2_sf_put_ino(hdr,
189                             (xfs_dir2_inou_t *)&sfep->name[sfep->namelen], ino);
190 }
191
192 static xfs_ino_t
193 xfs_dir3_sfe_get_ino(
194         struct xfs_dir2_sf_hdr  *hdr,
195         struct xfs_dir2_sf_entry *sfep)
196 {
197         return xfs_dir2_sf_get_ino(hdr,
198                         (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1]);
199 }
200
201 static void
202 xfs_dir3_sfe_put_ino(
203         struct xfs_dir2_sf_hdr  *hdr,
204         struct xfs_dir2_sf_entry *sfep,
205         xfs_ino_t               ino)
206 {
207         xfs_dir2_sf_put_ino(hdr,
208                         (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1], ino);
209 }
210
211
212 /*
213  * Directory data block operations
214  */
215
216 /*
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.
221  *
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()).
228  */
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)
232
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)),      \
236                 XFS_DIR2_DATA_ALIGN)
237
238 static int
239 xfs_dir2_data_entsize(
240         int                     n)
241 {
242         return XFS_DIR2_DATA_ENTSIZE(n);
243 }
244
245 static int
246 xfs_dir3_data_entsize(
247         int                     n)
248 {
249         return XFS_DIR3_DATA_ENTSIZE(n);
250 }
251
252 static __uint8_t
253 xfs_dir2_data_get_ftype(
254         struct xfs_dir2_data_entry *dep)
255 {
256         return XFS_DIR3_FT_UNKNOWN;
257 }
258
259 static void
260 xfs_dir2_data_put_ftype(
261         struct xfs_dir2_data_entry *dep,
262         __uint8_t               ftype)
263 {
264         ASSERT(ftype < XFS_DIR3_FT_MAX);
265 }
266
267 static __uint8_t
268 xfs_dir3_data_get_ftype(
269         struct xfs_dir2_data_entry *dep)
270 {
271         __uint8_t       ftype = dep->name[dep->namelen];
272
273         ASSERT(ftype < XFS_DIR3_FT_MAX);
274         if (ftype >= XFS_DIR3_FT_MAX)
275                 return XFS_DIR3_FT_UNKNOWN;
276         return ftype;
277 }
278
279 static void
280 xfs_dir3_data_put_ftype(
281         struct xfs_dir2_data_entry *dep,
282         __uint8_t               type)
283 {
284         ASSERT(type < XFS_DIR3_FT_MAX);
285         ASSERT(dep->namelen != 0);
286
287         dep->name[dep->namelen] = type;
288 }
289
290 /*
291  * Pointer to an entry's tag word.
292  */
293 static __be16 *
294 xfs_dir2_data_entry_tag_p(
295         struct xfs_dir2_data_entry *dep)
296 {
297         return (__be16 *)((char *)dep +
298                 xfs_dir2_data_entsize(dep->namelen) - sizeof(__be16));
299 }
300
301 static __be16 *
302 xfs_dir3_data_entry_tag_p(
303         struct xfs_dir2_data_entry *dep)
304 {
305         return (__be16 *)((char *)dep +
306                 xfs_dir3_data_entsize(dep->namelen) - sizeof(__be16));
307 }
308
309 /*
310  * location of . and .. in data space (always block 0)
311  */
312 static struct xfs_dir2_data_entry *
313 xfs_dir2_data_dot_entry_p(
314         struct xfs_dir2_data_hdr *hdr)
315 {
316         return (struct xfs_dir2_data_entry *)
317                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
318 }
319
320 static struct xfs_dir2_data_entry *
321 xfs_dir2_data_dotdot_entry_p(
322         struct xfs_dir2_data_hdr *hdr)
323 {
324         return (struct xfs_dir2_data_entry *)
325                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
326                                 XFS_DIR2_DATA_ENTSIZE(1));
327 }
328
329 static struct xfs_dir2_data_entry *
330 xfs_dir2_data_first_entry_p(
331         struct xfs_dir2_data_hdr *hdr)
332 {
333         return (struct xfs_dir2_data_entry *)
334                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
335                                 XFS_DIR2_DATA_ENTSIZE(1) +
336                                 XFS_DIR2_DATA_ENTSIZE(2));
337 }
338
339 static struct xfs_dir2_data_entry *
340 xfs_dir2_ftype_data_dotdot_entry_p(
341         struct xfs_dir2_data_hdr *hdr)
342 {
343         return (struct xfs_dir2_data_entry *)
344                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
345                                 XFS_DIR3_DATA_ENTSIZE(1));
346 }
347
348 static struct xfs_dir2_data_entry *
349 xfs_dir2_ftype_data_first_entry_p(
350         struct xfs_dir2_data_hdr *hdr)
351 {
352         return (struct xfs_dir2_data_entry *)
353                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
354                                 XFS_DIR3_DATA_ENTSIZE(1) +
355                                 XFS_DIR3_DATA_ENTSIZE(2));
356 }
357
358 static struct xfs_dir2_data_entry *
359 xfs_dir3_data_dot_entry_p(
360         struct xfs_dir2_data_hdr *hdr)
361 {
362         return (struct xfs_dir2_data_entry *)
363                 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
364 }
365
366 static struct xfs_dir2_data_entry *
367 xfs_dir3_data_dotdot_entry_p(
368         struct xfs_dir2_data_hdr *hdr)
369 {
370         return (struct xfs_dir2_data_entry *)
371                 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
372                                 XFS_DIR3_DATA_ENTSIZE(1));
373 }
374
375 static struct xfs_dir2_data_entry *
376 xfs_dir3_data_first_entry_p(
377         struct xfs_dir2_data_hdr *hdr)
378 {
379         return (struct xfs_dir2_data_entry *)
380                 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
381                                 XFS_DIR3_DATA_ENTSIZE(1) +
382                                 XFS_DIR3_DATA_ENTSIZE(2));
383 }
384
385 static struct xfs_dir2_data_free *
386 xfs_dir2_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
387 {
388         return hdr->bestfree;
389 }
390
391 static struct xfs_dir2_data_free *
392 xfs_dir3_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
393 {
394         return ((struct xfs_dir3_data_hdr *)hdr)->best_free;
395 }
396
397 static struct xfs_dir2_data_entry *
398 xfs_dir2_data_entry_p(struct xfs_dir2_data_hdr *hdr)
399 {
400         return (struct xfs_dir2_data_entry *)
401                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
402 }
403
404 static struct xfs_dir2_data_unused *
405 xfs_dir2_data_unused_p(struct xfs_dir2_data_hdr *hdr)
406 {
407         return (struct xfs_dir2_data_unused *)
408                 ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
409 }
410
411 static struct xfs_dir2_data_entry *
412 xfs_dir3_data_entry_p(struct xfs_dir2_data_hdr *hdr)
413 {
414         return (struct xfs_dir2_data_entry *)
415                 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
416 }
417
418 static struct xfs_dir2_data_unused *
419 xfs_dir3_data_unused_p(struct xfs_dir2_data_hdr *hdr)
420 {
421         return (struct xfs_dir2_data_unused *)
422                 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
423 }
424
425
426 /*
427  * Directory Leaf block operations
428  */
429 static int
430 xfs_dir2_max_leaf_ents(struct xfs_da_geometry *geo)
431 {
432         return (geo->blksize - sizeof(struct xfs_dir2_leaf_hdr)) /
433                 (uint)sizeof(struct xfs_dir2_leaf_entry);
434 }
435
436 static struct xfs_dir2_leaf_entry *
437 xfs_dir2_leaf_ents_p(struct xfs_dir2_leaf *lp)
438 {
439         return lp->__ents;
440 }
441
442 static int
443 xfs_dir3_max_leaf_ents(struct xfs_da_geometry *geo)
444 {
445         return (geo->blksize - sizeof(struct xfs_dir3_leaf_hdr)) /
446                 (uint)sizeof(struct xfs_dir2_leaf_entry);
447 }
448
449 static struct xfs_dir2_leaf_entry *
450 xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)
451 {
452         return ((struct xfs_dir3_leaf *)lp)->__ents;
453 }
454
455 static void
456 xfs_dir2_leaf_hdr_from_disk(
457         struct xfs_dir3_icleaf_hdr      *to,
458         struct xfs_dir2_leaf            *from)
459 {
460         to->forw = be32_to_cpu(from->hdr.info.forw);
461         to->back = be32_to_cpu(from->hdr.info.back);
462         to->magic = be16_to_cpu(from->hdr.info.magic);
463         to->count = be16_to_cpu(from->hdr.count);
464         to->stale = be16_to_cpu(from->hdr.stale);
465
466         ASSERT(to->magic == XFS_DIR2_LEAF1_MAGIC ||
467                to->magic == XFS_DIR2_LEAFN_MAGIC);
468 }
469
470 static void
471 xfs_dir2_leaf_hdr_to_disk(
472         struct xfs_dir2_leaf            *to,
473         struct xfs_dir3_icleaf_hdr      *from)
474 {
475         ASSERT(from->magic == XFS_DIR2_LEAF1_MAGIC ||
476                from->magic == XFS_DIR2_LEAFN_MAGIC);
477
478         to->hdr.info.forw = cpu_to_be32(from->forw);
479         to->hdr.info.back = cpu_to_be32(from->back);
480         to->hdr.info.magic = cpu_to_be16(from->magic);
481         to->hdr.count = cpu_to_be16(from->count);
482         to->hdr.stale = cpu_to_be16(from->stale);
483 }
484
485 static void
486 xfs_dir3_leaf_hdr_from_disk(
487         struct xfs_dir3_icleaf_hdr      *to,
488         struct xfs_dir2_leaf            *from)
489 {
490         struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)from;
491
492         to->forw = be32_to_cpu(hdr3->info.hdr.forw);
493         to->back = be32_to_cpu(hdr3->info.hdr.back);
494         to->magic = be16_to_cpu(hdr3->info.hdr.magic);
495         to->count = be16_to_cpu(hdr3->count);
496         to->stale = be16_to_cpu(hdr3->stale);
497
498         ASSERT(to->magic == XFS_DIR3_LEAF1_MAGIC ||
499                to->magic == XFS_DIR3_LEAFN_MAGIC);
500 }
501
502 static void
503 xfs_dir3_leaf_hdr_to_disk(
504         struct xfs_dir2_leaf            *to,
505         struct xfs_dir3_icleaf_hdr      *from)
506 {
507         struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)to;
508
509         ASSERT(from->magic == XFS_DIR3_LEAF1_MAGIC ||
510                from->magic == XFS_DIR3_LEAFN_MAGIC);
511
512         hdr3->info.hdr.forw = cpu_to_be32(from->forw);
513         hdr3->info.hdr.back = cpu_to_be32(from->back);
514         hdr3->info.hdr.magic = cpu_to_be16(from->magic);
515         hdr3->count = cpu_to_be16(from->count);
516         hdr3->stale = cpu_to_be16(from->stale);
517 }
518
519
520 /*
521  * Directory/Attribute Node block operations
522  */
523 static struct xfs_da_node_entry *
524 xfs_da2_node_tree_p(struct xfs_da_intnode *dap)
525 {
526         return dap->__btree;
527 }
528
529 static struct xfs_da_node_entry *
530 xfs_da3_node_tree_p(struct xfs_da_intnode *dap)
531 {
532         return ((struct xfs_da3_intnode *)dap)->__btree;
533 }
534
535 static void
536 xfs_da2_node_hdr_from_disk(
537         struct xfs_da3_icnode_hdr       *to,
538         struct xfs_da_intnode           *from)
539 {
540         ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
541         to->forw = be32_to_cpu(from->hdr.info.forw);
542         to->back = be32_to_cpu(from->hdr.info.back);
543         to->magic = be16_to_cpu(from->hdr.info.magic);
544         to->count = be16_to_cpu(from->hdr.__count);
545         to->level = be16_to_cpu(from->hdr.__level);
546 }
547
548 static void
549 xfs_da2_node_hdr_to_disk(
550         struct xfs_da_intnode           *to,
551         struct xfs_da3_icnode_hdr       *from)
552 {
553         ASSERT(from->magic == XFS_DA_NODE_MAGIC);
554         to->hdr.info.forw = cpu_to_be32(from->forw);
555         to->hdr.info.back = cpu_to_be32(from->back);
556         to->hdr.info.magic = cpu_to_be16(from->magic);
557         to->hdr.__count = cpu_to_be16(from->count);
558         to->hdr.__level = cpu_to_be16(from->level);
559 }
560
561 static void
562 xfs_da3_node_hdr_from_disk(
563         struct xfs_da3_icnode_hdr       *to,
564         struct xfs_da_intnode           *from)
565 {
566         struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
567
568         ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
569         to->forw = be32_to_cpu(hdr3->info.hdr.forw);
570         to->back = be32_to_cpu(hdr3->info.hdr.back);
571         to->magic = be16_to_cpu(hdr3->info.hdr.magic);
572         to->count = be16_to_cpu(hdr3->__count);
573         to->level = be16_to_cpu(hdr3->__level);
574 }
575
576 static void
577 xfs_da3_node_hdr_to_disk(
578         struct xfs_da_intnode           *to,
579         struct xfs_da3_icnode_hdr       *from)
580 {
581         struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
582
583         ASSERT(from->magic == XFS_DA3_NODE_MAGIC);
584         hdr3->info.hdr.forw = cpu_to_be32(from->forw);
585         hdr3->info.hdr.back = cpu_to_be32(from->back);
586         hdr3->info.hdr.magic = cpu_to_be16(from->magic);
587         hdr3->__count = cpu_to_be16(from->count);
588         hdr3->__level = cpu_to_be16(from->level);
589 }
590
591
592 /*
593  * Directory free space block operations
594  */
595 static int
596 xfs_dir2_free_max_bests(struct xfs_da_geometry *geo)
597 {
598         return (geo->blksize - sizeof(struct xfs_dir2_free_hdr)) /
599                 sizeof(xfs_dir2_data_off_t);
600 }
601
602 static __be16 *
603 xfs_dir2_free_bests_p(struct xfs_dir2_free *free)
604 {
605         return (__be16 *)((char *)free + sizeof(struct xfs_dir2_free_hdr));
606 }
607
608 /*
609  * Convert data space db to the corresponding free db.
610  */
611 static xfs_dir2_db_t
612 xfs_dir2_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
613 {
614         return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) +
615                         (db / xfs_dir2_free_max_bests(geo));
616 }
617
618 /*
619  * Convert data space db to the corresponding index in a free db.
620  */
621 static int
622 xfs_dir2_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
623 {
624         return db % xfs_dir2_free_max_bests(geo);
625 }
626
627 static int
628 xfs_dir3_free_max_bests(struct xfs_da_geometry *geo)
629 {
630         return (geo->blksize - sizeof(struct xfs_dir3_free_hdr)) /
631                 sizeof(xfs_dir2_data_off_t);
632 }
633
634 static __be16 *
635 xfs_dir3_free_bests_p(struct xfs_dir2_free *free)
636 {
637         return (__be16 *)((char *)free + sizeof(struct xfs_dir3_free_hdr));
638 }
639
640 /*
641  * Convert data space db to the corresponding free db.
642  */
643 static xfs_dir2_db_t
644 xfs_dir3_db_to_fdb(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
645 {
646         return xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET) +
647                         (db / xfs_dir3_free_max_bests(geo));
648 }
649
650 /*
651  * Convert data space db to the corresponding index in a free db.
652  */
653 static int
654 xfs_dir3_db_to_fdindex(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
655 {
656         return db % xfs_dir3_free_max_bests(geo);
657 }
658
659 static void
660 xfs_dir2_free_hdr_from_disk(
661         struct xfs_dir3_icfree_hdr      *to,
662         struct xfs_dir2_free            *from)
663 {
664         to->magic = be32_to_cpu(from->hdr.magic);
665         to->firstdb = be32_to_cpu(from->hdr.firstdb);
666         to->nvalid = be32_to_cpu(from->hdr.nvalid);
667         to->nused = be32_to_cpu(from->hdr.nused);
668         ASSERT(to->magic == XFS_DIR2_FREE_MAGIC);
669 }
670
671 static void
672 xfs_dir2_free_hdr_to_disk(
673         struct xfs_dir2_free            *to,
674         struct xfs_dir3_icfree_hdr      *from)
675 {
676         ASSERT(from->magic == XFS_DIR2_FREE_MAGIC);
677
678         to->hdr.magic = cpu_to_be32(from->magic);
679         to->hdr.firstdb = cpu_to_be32(from->firstdb);
680         to->hdr.nvalid = cpu_to_be32(from->nvalid);
681         to->hdr.nused = cpu_to_be32(from->nused);
682 }
683
684 static void
685 xfs_dir3_free_hdr_from_disk(
686         struct xfs_dir3_icfree_hdr      *to,
687         struct xfs_dir2_free            *from)
688 {
689         struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
690
691         to->magic = be32_to_cpu(hdr3->hdr.magic);
692         to->firstdb = be32_to_cpu(hdr3->firstdb);
693         to->nvalid = be32_to_cpu(hdr3->nvalid);
694         to->nused = be32_to_cpu(hdr3->nused);
695
696         ASSERT(to->magic == XFS_DIR3_FREE_MAGIC);
697 }
698
699 static void
700 xfs_dir3_free_hdr_to_disk(
701         struct xfs_dir2_free            *to,
702         struct xfs_dir3_icfree_hdr      *from)
703 {
704         struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
705
706         ASSERT(from->magic == XFS_DIR3_FREE_MAGIC);
707
708         hdr3->hdr.magic = cpu_to_be32(from->magic);
709         hdr3->firstdb = cpu_to_be32(from->firstdb);
710         hdr3->nvalid = cpu_to_be32(from->nvalid);
711         hdr3->nused = cpu_to_be32(from->nused);
712 }
713
714 static const struct xfs_dir_ops xfs_dir2_ops = {
715         .sf_entsize = xfs_dir2_sf_entsize,
716         .sf_nextentry = xfs_dir2_sf_nextentry,
717         .sf_get_ftype = xfs_dir2_sfe_get_ftype,
718         .sf_put_ftype = xfs_dir2_sfe_put_ftype,
719         .sf_get_ino = xfs_dir2_sfe_get_ino,
720         .sf_put_ino = xfs_dir2_sfe_put_ino,
721         .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
722         .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
723
724         .data_entsize = xfs_dir2_data_entsize,
725         .data_get_ftype = xfs_dir2_data_get_ftype,
726         .data_put_ftype = xfs_dir2_data_put_ftype,
727         .data_entry_tag_p = xfs_dir2_data_entry_tag_p,
728         .data_bestfree_p = xfs_dir2_data_bestfree_p,
729
730         .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
731         .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
732                                 XFS_DIR2_DATA_ENTSIZE(1),
733         .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
734                                 XFS_DIR2_DATA_ENTSIZE(1) +
735                                 XFS_DIR2_DATA_ENTSIZE(2),
736         .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
737
738         .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
739         .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p,
740         .data_first_entry_p = xfs_dir2_data_first_entry_p,
741         .data_entry_p = xfs_dir2_data_entry_p,
742         .data_unused_p = xfs_dir2_data_unused_p,
743
744         .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
745         .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
746         .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
747         .leaf_max_ents = xfs_dir2_max_leaf_ents,
748         .leaf_ents_p = xfs_dir2_leaf_ents_p,
749
750         .node_hdr_size = sizeof(struct xfs_da_node_hdr),
751         .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
752         .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
753         .node_tree_p = xfs_da2_node_tree_p,
754
755         .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
756         .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
757         .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
758         .free_max_bests = xfs_dir2_free_max_bests,
759         .free_bests_p = xfs_dir2_free_bests_p,
760         .db_to_fdb = xfs_dir2_db_to_fdb,
761         .db_to_fdindex = xfs_dir2_db_to_fdindex,
762 };
763
764 static const struct xfs_dir_ops xfs_dir2_ftype_ops = {
765         .sf_entsize = xfs_dir3_sf_entsize,
766         .sf_nextentry = xfs_dir3_sf_nextentry,
767         .sf_get_ftype = xfs_dir3_sfe_get_ftype,
768         .sf_put_ftype = xfs_dir3_sfe_put_ftype,
769         .sf_get_ino = xfs_dir3_sfe_get_ino,
770         .sf_put_ino = xfs_dir3_sfe_put_ino,
771         .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
772         .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
773
774         .data_entsize = xfs_dir3_data_entsize,
775         .data_get_ftype = xfs_dir3_data_get_ftype,
776         .data_put_ftype = xfs_dir3_data_put_ftype,
777         .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
778         .data_bestfree_p = xfs_dir2_data_bestfree_p,
779
780         .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
781         .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
782                                 XFS_DIR3_DATA_ENTSIZE(1),
783         .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
784                                 XFS_DIR3_DATA_ENTSIZE(1) +
785                                 XFS_DIR3_DATA_ENTSIZE(2),
786         .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
787
788         .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
789         .data_dotdot_entry_p = xfs_dir2_ftype_data_dotdot_entry_p,
790         .data_first_entry_p = xfs_dir2_ftype_data_first_entry_p,
791         .data_entry_p = xfs_dir2_data_entry_p,
792         .data_unused_p = xfs_dir2_data_unused_p,
793
794         .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
795         .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
796         .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
797         .leaf_max_ents = xfs_dir2_max_leaf_ents,
798         .leaf_ents_p = xfs_dir2_leaf_ents_p,
799
800         .node_hdr_size = sizeof(struct xfs_da_node_hdr),
801         .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
802         .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
803         .node_tree_p = xfs_da2_node_tree_p,
804
805         .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
806         .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
807         .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
808         .free_max_bests = xfs_dir2_free_max_bests,
809         .free_bests_p = xfs_dir2_free_bests_p,
810         .db_to_fdb = xfs_dir2_db_to_fdb,
811         .db_to_fdindex = xfs_dir2_db_to_fdindex,
812 };
813
814 static const struct xfs_dir_ops xfs_dir3_ops = {
815         .sf_entsize = xfs_dir3_sf_entsize,
816         .sf_nextentry = xfs_dir3_sf_nextentry,
817         .sf_get_ftype = xfs_dir3_sfe_get_ftype,
818         .sf_put_ftype = xfs_dir3_sfe_put_ftype,
819         .sf_get_ino = xfs_dir3_sfe_get_ino,
820         .sf_put_ino = xfs_dir3_sfe_put_ino,
821         .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
822         .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
823
824         .data_entsize = xfs_dir3_data_entsize,
825         .data_get_ftype = xfs_dir3_data_get_ftype,
826         .data_put_ftype = xfs_dir3_data_put_ftype,
827         .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
828         .data_bestfree_p = xfs_dir3_data_bestfree_p,
829
830         .data_dot_offset = sizeof(struct xfs_dir3_data_hdr),
831         .data_dotdot_offset = sizeof(struct xfs_dir3_data_hdr) +
832                                 XFS_DIR3_DATA_ENTSIZE(1),
833         .data_first_offset =  sizeof(struct xfs_dir3_data_hdr) +
834                                 XFS_DIR3_DATA_ENTSIZE(1) +
835                                 XFS_DIR3_DATA_ENTSIZE(2),
836         .data_entry_offset = sizeof(struct xfs_dir3_data_hdr),
837
838         .data_dot_entry_p = xfs_dir3_data_dot_entry_p,
839         .data_dotdot_entry_p = xfs_dir3_data_dotdot_entry_p,
840         .data_first_entry_p = xfs_dir3_data_first_entry_p,
841         .data_entry_p = xfs_dir3_data_entry_p,
842         .data_unused_p = xfs_dir3_data_unused_p,
843
844         .leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr),
845         .leaf_hdr_to_disk = xfs_dir3_leaf_hdr_to_disk,
846         .leaf_hdr_from_disk = xfs_dir3_leaf_hdr_from_disk,
847         .leaf_max_ents = xfs_dir3_max_leaf_ents,
848         .leaf_ents_p = xfs_dir3_leaf_ents_p,
849
850         .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
851         .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
852         .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
853         .node_tree_p = xfs_da3_node_tree_p,
854
855         .free_hdr_size = sizeof(struct xfs_dir3_free_hdr),
856         .free_hdr_to_disk = xfs_dir3_free_hdr_to_disk,
857         .free_hdr_from_disk = xfs_dir3_free_hdr_from_disk,
858         .free_max_bests = xfs_dir3_free_max_bests,
859         .free_bests_p = xfs_dir3_free_bests_p,
860         .db_to_fdb = xfs_dir3_db_to_fdb,
861         .db_to_fdindex = xfs_dir3_db_to_fdindex,
862 };
863
864 static const struct xfs_dir_ops xfs_dir2_nondir_ops = {
865         .node_hdr_size = sizeof(struct xfs_da_node_hdr),
866         .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
867         .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
868         .node_tree_p = xfs_da2_node_tree_p,
869 };
870
871 static const struct xfs_dir_ops xfs_dir3_nondir_ops = {
872         .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
873         .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
874         .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
875         .node_tree_p = xfs_da3_node_tree_p,
876 };
877
878 /*
879  * Return the ops structure according to the current config.  If we are passed
880  * an inode, then that overrides the default config we use which is based on
881  * feature bits.
882  */
883 const struct xfs_dir_ops *
884 xfs_dir_get_ops(
885         struct xfs_mount        *mp,
886         struct xfs_inode        *dp)
887 {
888         if (dp)
889                 return dp->d_ops;
890         if (mp->m_dir_inode_ops)
891                 return mp->m_dir_inode_ops;
892         if (xfs_sb_version_hascrc(&mp->m_sb))
893                 return &xfs_dir3_ops;
894         if (xfs_sb_version_hasftype(&mp->m_sb))
895                 return &xfs_dir2_ftype_ops;
896         return &xfs_dir2_ops;
897 }
898
899 const struct xfs_dir_ops *
900 xfs_nondir_get_ops(
901         struct xfs_mount        *mp,
902         struct xfs_inode        *dp)
903 {
904         if (dp)
905                 return dp->d_ops;
906         if (mp->m_nondir_inode_ops)
907                 return mp->m_nondir_inode_ops;
908         if (xfs_sb_version_hascrc(&mp->m_sb))
909                 return &xfs_dir3_nondir_ops;
910         return &xfs_dir2_nondir_ops;
911 }