?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.16-rc2
[linux/fpc-iii.git] / fs / xfs / xfs_dir2_data.c
blob8c2f6422648ea76788a32b0a3accf755db14f000
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_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_sb.h"
25 #include "xfs_ag.h"
26 #include "xfs_mount.h"
27 #include "xfs_da_format.h"
28 #include "xfs_da_btree.h"
29 #include "xfs_inode.h"
30 #include "xfs_dir2.h"
31 #include "xfs_dir2_priv.h"
32 #include "xfs_error.h"
33 #include "xfs_trans.h"
34 #include "xfs_buf_item.h"
35 #include "xfs_cksum.h"
36
37 /*
38 * Check the consistency of the data block.
39 * The input can also be a block-format directory.
40 * Return 0 is the buffer is good, otherwise an error.
41 */
42 int
43 __xfs_dir3_data_check(
44 struct xfs_inode *dp, /* incore inode pointer */
45 struct xfs_buf *bp) /* data block's buffer */
46 {
47 xfs_dir2_dataptr_t addr; /* addr for leaf lookup */
48 xfs_dir2_data_free_t *bf; /* bestfree table */
49 xfs_dir2_block_tail_t *btp=NULL; /* block tail */
50 int count; /* count of entries found */
51 xfs_dir2_data_hdr_t *hdr; /* data block header */
52 xfs_dir2_data_entry_t *dep; /* data entry */
53 xfs_dir2_data_free_t *dfp; /* bestfree entry */
54 xfs_dir2_data_unused_t *dup; /* unused entry */
55 char *endp; /* end of useful data */
56 int freeseen; /* mask of bestfrees seen */
57 xfs_dahash_t hash; /* hash of current name */
58 int i; /* leaf index */
59 int lastfree; /* last entry was unused */
60 xfs_dir2_leaf_entry_t *lep=NULL; /* block leaf entries */
61 xfs_mount_t *mp; /* filesystem mount point */
62 char *p; /* current data position */
63 int stale; /* count of stale leaves */
64 struct xfs_name name;
65 const struct xfs_dir_ops *ops;
66 struct xfs_da_geometry *geo;
67
68 mp = bp->b_target->bt_mount;
69 geo = mp->m_dir_geo;
70
71 /*
72 * We can be passed a null dp here from a verifier, so we need to go the
73 * hard way to get them.
74 */
75 ops = xfs_dir_get_ops(mp, dp);
76
77 hdr = bp->b_addr;
78 p = (char *)ops->data_entry_p(hdr);
79
80 switch (hdr->magic) {
81 case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
82 case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
83 btp = xfs_dir2_block_tail_p(geo, hdr);
84 lep = xfs_dir2_block_leaf_p(btp);
85 endp = (char *)lep;
86
87 /*
88 * The number of leaf entries is limited by the size of the
89 * block and the amount of space used by the data entries.
90 * We don't know how much space is used by the data entries yet,
91 * so just ensure that the count falls somewhere inside the
92 * block right now.
93 */
94 XFS_WANT_CORRUPTED_RETURN(be32_to_cpu(btp->count) <
95 ((char *)btp - p) / sizeof(struct xfs_dir2_leaf_entry));
96 break;
97 case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
98 case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
99 endp = (char *)hdr + geo->blksize;
100 break;
101 default:
102 XFS_ERROR_REPORT("Bad Magic", XFS_ERRLEVEL_LOW, mp);
103 return EFSCORRUPTED;
104 }
105
106 /*
107 * Account for zero bestfree entries.
108 */
109 bf = ops->data_bestfree_p(hdr);
110 count = lastfree = freeseen = 0;
111 if (!bf[0].length) {
112 XFS_WANT_CORRUPTED_RETURN(!bf[0].offset);
113 freeseen |= 1 << 0;
114 }
115 if (!bf[1].length) {
116 XFS_WANT_CORRUPTED_RETURN(!bf[1].offset);
117 freeseen |= 1 << 1;
118 }
119 if (!bf[2].length) {
120 XFS_WANT_CORRUPTED_RETURN(!bf[2].offset);
121 freeseen |= 1 << 2;
122 }
123
124 XFS_WANT_CORRUPTED_RETURN(be16_to_cpu(bf[0].length) >=
125 be16_to_cpu(bf[1].length));
126 XFS_WANT_CORRUPTED_RETURN(be16_to_cpu(bf[1].length) >=
127 be16_to_cpu(bf[2].length));
128 /*
129 * Loop over the data/unused entries.
130 */
131 while (p < endp) {
132 dup = (xfs_dir2_data_unused_t *)p;
133 /*
134 * If it's unused, look for the space in the bestfree table.
135 * If we find it, account for that, else make sure it
136 * doesn't need to be there.
137 */
138 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
139 XFS_WANT_CORRUPTED_RETURN(lastfree == 0);
140 XFS_WANT_CORRUPTED_RETURN(
141 be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) ==
142 (char *)dup - (char *)hdr);
143 dfp = xfs_dir2_data_freefind(hdr, bf, dup);
144 if (dfp) {
145 i = (int)(dfp - bf);
146 XFS_WANT_CORRUPTED_RETURN(
147 (freeseen & (1 << i)) == 0);
148 freeseen |= 1 << i;
149 } else {
150 XFS_WANT_CORRUPTED_RETURN(
151 be16_to_cpu(dup->length) <=
152 be16_to_cpu(bf[2].length));
153 }
154 p += be16_to_cpu(dup->length);
155 lastfree = 1;
156 continue;
157 }
158 /*
159 * It's a real entry. Validate the fields.
160 * If this is a block directory then make sure it's
161 * in the leaf section of the block.
162 * The linear search is crude but this is DEBUG code.
163 */
164 dep = (xfs_dir2_data_entry_t *)p;
165 XFS_WANT_CORRUPTED_RETURN(dep->namelen != 0);
166 XFS_WANT_CORRUPTED_RETURN(
167 !xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)));
168 XFS_WANT_CORRUPTED_RETURN(
169 be16_to_cpu(*ops->data_entry_tag_p(dep)) ==
170 (char *)dep - (char *)hdr);
171 XFS_WANT_CORRUPTED_RETURN(
172 ops->data_get_ftype(dep) < XFS_DIR3_FT_MAX);
173 count++;
174 lastfree = 0;
175 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
176 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
177 addr = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
178 (xfs_dir2_data_aoff_t)
179 ((char *)dep - (char *)hdr));
180 name.name = dep->name;
181 name.len = dep->namelen;
182 hash = mp->m_dirnameops->hashname(&name);
183 for (i = 0; i < be32_to_cpu(btp->count); i++) {
184 if (be32_to_cpu(lep[i].address) == addr &&
185 be32_to_cpu(lep[i].hashval) == hash)
186 break;
187 }
188 XFS_WANT_CORRUPTED_RETURN(i < be32_to_cpu(btp->count));
189 }
190 p += ops->data_entsize(dep->namelen);
191 }
192 /*
193 * Need to have seen all the entries and all the bestfree slots.
194 */
195 XFS_WANT_CORRUPTED_RETURN(freeseen == 7);
196 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
197 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
198 for (i = stale = 0; i < be32_to_cpu(btp->count); i++) {
199 if (lep[i].address ==
200 cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
201 stale++;
202 if (i > 0)
203 XFS_WANT_CORRUPTED_RETURN(
204 be32_to_cpu(lep[i].hashval) >=
205 be32_to_cpu(lep[i - 1].hashval));
206 }
207 XFS_WANT_CORRUPTED_RETURN(count ==
208 be32_to_cpu(btp->count) - be32_to_cpu(btp->stale));
209 XFS_WANT_CORRUPTED_RETURN(stale == be32_to_cpu(btp->stale));
210 }
211 return 0;
212 }
213
214 static bool
215 xfs_dir3_data_verify(
216 struct xfs_buf *bp)
217 {
218 struct xfs_mount *mp = bp->b_target->bt_mount;
219 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
220
221 if (xfs_sb_version_hascrc(&mp->m_sb)) {
222 if (hdr3->magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC))
223 return false;
224 if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid))
225 return false;
226 if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
227 return false;
228 } else {
229 if (hdr3->magic != cpu_to_be32(XFS_DIR2_DATA_MAGIC))
230 return false;
231 }
232 if (__xfs_dir3_data_check(NULL, bp))
233 return false;
234 return true;
235 }
236
237 /*
238 * Readahead of the first block of the directory when it is opened is completely
239 * oblivious to the format of the directory. Hence we can either get a block
240 * format buffer or a data format buffer on readahead.
241 */
242 static void
243 xfs_dir3_data_reada_verify(
244 struct xfs_buf *bp)
245 {
246 struct xfs_dir2_data_hdr *hdr = bp->b_addr;
247
248 switch (hdr->magic) {
249 case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
250 case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
251 bp->b_ops = &xfs_dir3_block_buf_ops;
252 bp->b_ops->verify_read(bp);
253 return;
254 case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
255 case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
256 xfs_dir3_data_verify(bp);
257 return;
258 default:
259 xfs_buf_ioerror(bp, EFSCORRUPTED);
260 xfs_verifier_error(bp);
261 break;
262 }
263 }
264
265 static void
266 xfs_dir3_data_read_verify(
267 struct xfs_buf *bp)
268 {
269 struct xfs_mount *mp = bp->b_target->bt_mount;
270
271 if (xfs_sb_version_hascrc(&mp->m_sb) &&
272 !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
273 xfs_buf_ioerror(bp, EFSBADCRC);
274 else if (!xfs_dir3_data_verify(bp))
275 xfs_buf_ioerror(bp, EFSCORRUPTED);
276
277 if (bp->b_error)
278 xfs_verifier_error(bp);
279 }
280
281 static void
282 xfs_dir3_data_write_verify(
283 struct xfs_buf *bp)
284 {
285 struct xfs_mount *mp = bp->b_target->bt_mount;
286 struct xfs_buf_log_item *bip = bp->b_fspriv;
287 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
288
289 if (!xfs_dir3_data_verify(bp)) {
290 xfs_buf_ioerror(bp, EFSCORRUPTED);
291 xfs_verifier_error(bp);
292 return;
293 }
294
295 if (!xfs_sb_version_hascrc(&mp->m_sb))
296 return;
297
298 if (bip)
299 hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
300
301 xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
302 }
303
304 const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
305 .verify_read = xfs_dir3_data_read_verify,
306 .verify_write = xfs_dir3_data_write_verify,
307 };
308
309 static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = {
310 .verify_read = xfs_dir3_data_reada_verify,
311 .verify_write = xfs_dir3_data_write_verify,
312 };
313
314
315 int
316 xfs_dir3_data_read(
317 struct xfs_trans *tp,
318 struct xfs_inode *dp,
319 xfs_dablk_t bno,
320 xfs_daddr_t mapped_bno,
321 struct xfs_buf **bpp)
322 {
323 int err;
324
325 err = xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
326 XFS_DATA_FORK, &xfs_dir3_data_buf_ops);
327 if (!err && tp)
328 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_DATA_BUF);
329 return err;
330 }
331
332 int
333 xfs_dir3_data_readahead(
334 struct xfs_inode *dp,
335 xfs_dablk_t bno,
336 xfs_daddr_t mapped_bno)
337 {
338 return xfs_da_reada_buf(dp, bno, mapped_bno,
339 XFS_DATA_FORK, &xfs_dir3_data_reada_buf_ops);
340 }
341
342 /*
343 * Given a data block and an unused entry from that block,
344 * return the bestfree entry if any that corresponds to it.
345 */
346 xfs_dir2_data_free_t *
347 xfs_dir2_data_freefind(
348 struct xfs_dir2_data_hdr *hdr, /* data block header */
349 struct xfs_dir2_data_free *bf, /* bestfree table pointer */
350 struct xfs_dir2_data_unused *dup) /* unused space */
351 {
352 xfs_dir2_data_free_t *dfp; /* bestfree entry */
353 xfs_dir2_data_aoff_t off; /* offset value needed */
354 #ifdef DEBUG
355 int matched; /* matched the value */
356 int seenzero; /* saw a 0 bestfree entry */
357 #endif
358
359 off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
360
361 #ifdef DEBUG
362 /*
363 * Validate some consistency in the bestfree table.
364 * Check order, non-overlapping entries, and if we find the
365 * one we're looking for it has to be exact.
366 */
367 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
368 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
369 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
370 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
371 for (dfp = &bf[0], seenzero = matched = 0;
372 dfp < &bf[XFS_DIR2_DATA_FD_COUNT];
373 dfp++) {
374 if (!dfp->offset) {
375 ASSERT(!dfp->length);
376 seenzero = 1;
377 continue;
378 }
379 ASSERT(seenzero == 0);
380 if (be16_to_cpu(dfp->offset) == off) {
381 matched = 1;
382 ASSERT(dfp->length == dup->length);
383 } else if (off < be16_to_cpu(dfp->offset))
384 ASSERT(off + be16_to_cpu(dup->length) <= be16_to_cpu(dfp->offset));
385 else
386 ASSERT(be16_to_cpu(dfp->offset) + be16_to_cpu(dfp->length) <= off);
387 ASSERT(matched || be16_to_cpu(dfp->length) >= be16_to_cpu(dup->length));
388 if (dfp > &bf[0])
389 ASSERT(be16_to_cpu(dfp[-1].length) >= be16_to_cpu(dfp[0].length));
390 }
391 #endif
392 /*
393 * If this is smaller than the smallest bestfree entry,
394 * it can't be there since they're sorted.
395 */
396 if (be16_to_cpu(dup->length) <
397 be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
398 return NULL;
399 /*
400 * Look at the three bestfree entries for our guy.
401 */
402 for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
403 if (!dfp->offset)
404 return NULL;
405 if (be16_to_cpu(dfp->offset) == off)
406 return dfp;
407 }
408 /*
409 * Didn't find it. This only happens if there are duplicate lengths.
410 */
411 return NULL;
412 }
413
414 /*
415 * Insert an unused-space entry into the bestfree table.
416 */
417 xfs_dir2_data_free_t * /* entry inserted */
418 xfs_dir2_data_freeinsert(
419 struct xfs_dir2_data_hdr *hdr, /* data block pointer */
420 struct xfs_dir2_data_free *dfp, /* bestfree table pointer */
421 struct xfs_dir2_data_unused *dup, /* unused space */
422 int *loghead) /* log the data header (out) */
423 {
424 xfs_dir2_data_free_t new; /* new bestfree entry */
425
426 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
427 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
428 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
429 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
430
431 new.length = dup->length;
432 new.offset = cpu_to_be16((char *)dup - (char *)hdr);
433
434 /*
435 * Insert at position 0, 1, or 2; or not at all.
436 */
437 if (be16_to_cpu(new.length) > be16_to_cpu(dfp[0].length)) {
438 dfp[2] = dfp[1];
439 dfp[1] = dfp[0];
440 dfp[0] = new;
441 *loghead = 1;
442 return &dfp[0];
443 }
444 if (be16_to_cpu(new.length) > be16_to_cpu(dfp[1].length)) {
445 dfp[2] = dfp[1];
446 dfp[1] = new;
447 *loghead = 1;
448 return &dfp[1];
449 }
450 if (be16_to_cpu(new.length) > be16_to_cpu(dfp[2].length)) {
451 dfp[2] = new;
452 *loghead = 1;
453 return &dfp[2];
454 }
455 return NULL;
456 }
457
458 /*
459 * Remove a bestfree entry from the table.
460 */
461 STATIC void
462 xfs_dir2_data_freeremove(
463 struct xfs_dir2_data_hdr *hdr, /* data block header */
464 struct xfs_dir2_data_free *bf, /* bestfree table pointer */
465 struct xfs_dir2_data_free *dfp, /* bestfree entry pointer */
466 int *loghead) /* out: log data header */
467 {
468
469 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
470 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
471 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
472 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
473
474 /*
475 * It's the first entry, slide the next 2 up.
476 */
477 if (dfp == &bf[0]) {
478 bf[0] = bf[1];
479 bf[1] = bf[2];
480 }
481 /*
482 * It's the second entry, slide the 3rd entry up.
483 */
484 else if (dfp == &bf[1])
485 bf[1] = bf[2];
486 /*
487 * Must be the last entry.
488 */
489 else
490 ASSERT(dfp == &bf[2]);
491 /*
492 * Clear the 3rd entry, must be zero now.
493 */
494 bf[2].length = 0;
495 bf[2].offset = 0;
496 *loghead = 1;
497 }
498
499 /*
500 * Given a data block, reconstruct its bestfree map.
501 */
502 void
503 xfs_dir2_data_freescan(
504 struct xfs_inode *dp,
505 struct xfs_dir2_data_hdr *hdr,
506 int *loghead)
507 {
508 xfs_dir2_block_tail_t *btp; /* block tail */
509 xfs_dir2_data_entry_t *dep; /* active data entry */
510 xfs_dir2_data_unused_t *dup; /* unused data entry */
511 struct xfs_dir2_data_free *bf;
512 char *endp; /* end of block's data */
513 char *p; /* current entry pointer */
514 struct xfs_da_geometry *geo = dp->i_mount->m_dir_geo;
515
516 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
517 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
518 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
519 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
520
521 /*
522 * Start by clearing the table.
523 */
524 bf = dp->d_ops->data_bestfree_p(hdr);
525 memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
526 *loghead = 1;
527 /*
528 * Set up pointers.
529 */
530 p = (char *)dp->d_ops->data_entry_p(hdr);
531 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
532 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
533 btp = xfs_dir2_block_tail_p(geo, hdr);
534 endp = (char *)xfs_dir2_block_leaf_p(btp);
535 } else
536 endp = (char *)hdr + geo->blksize;
537 /*
538 * Loop over the block's entries.
539 */
540 while (p < endp) {
541 dup = (xfs_dir2_data_unused_t *)p;
542 /*
543 * If it's a free entry, insert it.
544 */
545 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
546 ASSERT((char *)dup - (char *)hdr ==
547 be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
548 xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
549 p += be16_to_cpu(dup->length);
550 }
551 /*
552 * For active entries, check their tags and skip them.
553 */
554 else {
555 dep = (xfs_dir2_data_entry_t *)p;
556 ASSERT((char *)dep - (char *)hdr ==
557 be16_to_cpu(*dp->d_ops->data_entry_tag_p(dep)));
558 p += dp->d_ops->data_entsize(dep->namelen);
559 }
560 }
561 }
562
563 /*
564 * Initialize a data block at the given block number in the directory.
565 * Give back the buffer for the created block.
566 */
567 int /* error */
568 xfs_dir3_data_init(
569 xfs_da_args_t *args, /* directory operation args */
570 xfs_dir2_db_t blkno, /* logical dir block number */
571 struct xfs_buf **bpp) /* output block buffer */
572 {
573 struct xfs_buf *bp; /* block buffer */
574 xfs_dir2_data_hdr_t *hdr; /* data block header */
575 xfs_inode_t *dp; /* incore directory inode */
576 xfs_dir2_data_unused_t *dup; /* unused entry pointer */
577 struct xfs_dir2_data_free *bf;
578 int error; /* error return value */
579 int i; /* bestfree index */
580 xfs_mount_t *mp; /* filesystem mount point */
581 xfs_trans_t *tp; /* transaction pointer */
582 int t; /* temp */
583
584 dp = args->dp;
585 mp = dp->i_mount;
586 tp = args->trans;
587 /*
588 * Get the buffer set up for the block.
589 */
590 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, blkno),
591 -1, &bp, XFS_DATA_FORK);
592 if (error)
593 return error;
594 bp->b_ops = &xfs_dir3_data_buf_ops;
595 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_DATA_BUF);
596
597 /*
598 * Initialize the header.
599 */
600 hdr = bp->b_addr;
601 if (xfs_sb_version_hascrc(&mp->m_sb)) {
602 struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
603
604 memset(hdr3, 0, sizeof(*hdr3));
605 hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
606 hdr3->blkno = cpu_to_be64(bp->b_bn);
607 hdr3->owner = cpu_to_be64(dp->i_ino);
608 uuid_copy(&hdr3->uuid, &mp->m_sb.sb_uuid);
609
610 } else
611 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
612
613 bf = dp->d_ops->data_bestfree_p(hdr);
614 bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset);
615 for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
616 bf[i].length = 0;
617 bf[i].offset = 0;
618 }
619
620 /*
621 * Set up an unused entry for the block's body.
622 */
623 dup = dp->d_ops->data_unused_p(hdr);
624 dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
625
626 t = args->geo->blksize - (uint)dp->d_ops->data_entry_offset;
627 bf[0].length = cpu_to_be16(t);
628 dup->length = cpu_to_be16(t);
629 *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
630 /*
631 * Log it and return it.
632 */
633 xfs_dir2_data_log_header(args, bp);
634 xfs_dir2_data_log_unused(args, bp, dup);
635 *bpp = bp;
636 return 0;
637 }
638
639 /*
640 * Log an active data entry from the block.
641 */
642 void
643 xfs_dir2_data_log_entry(
644 struct xfs_da_args *args,
645 struct xfs_buf *bp,
646 xfs_dir2_data_entry_t *dep) /* data entry pointer */
647 {
648 struct xfs_dir2_data_hdr *hdr = bp->b_addr;
649
650 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
651 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
652 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
653 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
654
655 xfs_trans_log_buf(args->trans, bp, (uint)((char *)dep - (char *)hdr),
656 (uint)((char *)(args->dp->d_ops->data_entry_tag_p(dep) + 1) -
657 (char *)hdr - 1));
658 }
659
660 /*
661 * Log a data block header.
662 */
663 void
664 xfs_dir2_data_log_header(
665 struct xfs_da_args *args,
666 struct xfs_buf *bp)
667 {
668 #ifdef DEBUG
669 struct xfs_dir2_data_hdr *hdr = bp->b_addr;
670
671 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
672 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
673 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
674 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
675 #endif
676
677 xfs_trans_log_buf(args->trans, bp, 0,
678 args->dp->d_ops->data_entry_offset - 1);
679 }
680
681 /*
682 * Log a data unused entry.
683 */
684 void
685 xfs_dir2_data_log_unused(
686 struct xfs_da_args *args,
687 struct xfs_buf *bp,
688 xfs_dir2_data_unused_t *dup) /* data unused pointer */
689 {
690 xfs_dir2_data_hdr_t *hdr = bp->b_addr;
691
692 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
693 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
694 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
695 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
696
697 /*
698 * Log the first part of the unused entry.
699 */
700 xfs_trans_log_buf(args->trans, bp, (uint)((char *)dup - (char *)hdr),
701 (uint)((char *)&dup->length + sizeof(dup->length) -
702 1 - (char *)hdr));
703 /*
704 * Log the end (tag) of the unused entry.
705 */
706 xfs_trans_log_buf(args->trans, bp,
707 (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),
708 (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +
709 sizeof(xfs_dir2_data_off_t) - 1));
710 }
711
712 /*
713 * Make a byte range in the data block unused.
714 * Its current contents are unimportant.
715 */
716 void
717 xfs_dir2_data_make_free(
718 struct xfs_da_args *args,
719 struct xfs_buf *bp,
720 xfs_dir2_data_aoff_t offset, /* starting byte offset */
721 xfs_dir2_data_aoff_t len, /* length in bytes */
722 int *needlogp, /* out: log header */
723 int *needscanp) /* out: regen bestfree */
724 {
725 xfs_dir2_data_hdr_t *hdr; /* data block pointer */
726 xfs_dir2_data_free_t *dfp; /* bestfree pointer */
727 char *endptr; /* end of data area */
728 int needscan; /* need to regen bestfree */
729 xfs_dir2_data_unused_t *newdup; /* new unused entry */
730 xfs_dir2_data_unused_t *postdup; /* unused entry after us */
731 xfs_dir2_data_unused_t *prevdup; /* unused entry before us */
732 struct xfs_dir2_data_free *bf;
733
734 hdr = bp->b_addr;
735
736 /*
737 * Figure out where the end of the data area is.
738 */
739 if (hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
740 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC))
741 endptr = (char *)hdr + args->geo->blksize;
742 else {
743 xfs_dir2_block_tail_t *btp; /* block tail */
744
745 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
746 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
747 btp = xfs_dir2_block_tail_p(args->geo, hdr);
748 endptr = (char *)xfs_dir2_block_leaf_p(btp);
749 }
750 /*
751 * If this isn't the start of the block, then back up to
752 * the previous entry and see if it's free.
753 */
754 if (offset > args->dp->d_ops->data_entry_offset) {
755 __be16 *tagp; /* tag just before us */
756
757 tagp = (__be16 *)((char *)hdr + offset) - 1;
758 prevdup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
759 if (be16_to_cpu(prevdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
760 prevdup = NULL;
761 } else
762 prevdup = NULL;
763 /*
764 * If this isn't the end of the block, see if the entry after
765 * us is free.
766 */
767 if ((char *)hdr + offset + len < endptr) {
768 postdup =
769 (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
770 if (be16_to_cpu(postdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
771 postdup = NULL;
772 } else
773 postdup = NULL;
774 ASSERT(*needscanp == 0);
775 needscan = 0;
776 /*
777 * Previous and following entries are both free,
778 * merge everything into a single free entry.
779 */
780 bf = args->dp->d_ops->data_bestfree_p(hdr);
781 if (prevdup && postdup) {
782 xfs_dir2_data_free_t *dfp2; /* another bestfree pointer */
783
784 /*
785 * See if prevdup and/or postdup are in bestfree table.
786 */
787 dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
788 dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
789 /*
790 * We need a rescan unless there are exactly 2 free entries
791 * namely our two. Then we know what's happening, otherwise
792 * since the third bestfree is there, there might be more
793 * entries.
794 */
795 needscan = (bf[2].length != 0);
796 /*
797 * Fix up the new big freespace.
798 */
799 be16_add_cpu(&prevdup->length, len + be16_to_cpu(postdup->length));
800 *xfs_dir2_data_unused_tag_p(prevdup) =
801 cpu_to_be16((char *)prevdup - (char *)hdr);
802 xfs_dir2_data_log_unused(args, bp, prevdup);
803 if (!needscan) {
804 /*
805 * Has to be the case that entries 0 and 1 are
806 * dfp and dfp2 (don't know which is which), and
807 * entry 2 is empty.
808 * Remove entry 1 first then entry 0.
809 */
810 ASSERT(dfp && dfp2);
811 if (dfp == &bf[1]) {
812 dfp = &bf[0];
813 ASSERT(dfp2 == dfp);
814 dfp2 = &bf[1];
815 }
816 xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
817 xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
818 /*
819 * Now insert the new entry.
820 */
821 dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
822 needlogp);
823 ASSERT(dfp == &bf[0]);
824 ASSERT(dfp->length == prevdup->length);
825 ASSERT(!dfp[1].length);
826 ASSERT(!dfp[2].length);
827 }
828 }
829 /*
830 * The entry before us is free, merge with it.
831 */
832 else if (prevdup) {
833 dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
834 be16_add_cpu(&prevdup->length, len);
835 *xfs_dir2_data_unused_tag_p(prevdup) =
836 cpu_to_be16((char *)prevdup - (char *)hdr);
837 xfs_dir2_data_log_unused(args, bp, prevdup);
838 /*
839 * If the previous entry was in the table, the new entry
840 * is longer, so it will be in the table too. Remove
841 * the old one and add the new one.
842 */
843 if (dfp) {
844 xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
845 xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
846 }
847 /*
848 * Otherwise we need a scan if the new entry is big enough.
849 */
850 else {
851 needscan = be16_to_cpu(prevdup->length) >
852 be16_to_cpu(bf[2].length);
853 }
854 }
855 /*
856 * The following entry is free, merge with it.
857 */
858 else if (postdup) {
859 dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
860 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
861 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
862 newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
863 *xfs_dir2_data_unused_tag_p(newdup) =
864 cpu_to_be16((char *)newdup - (char *)hdr);
865 xfs_dir2_data_log_unused(args, bp, newdup);
866 /*
867 * If the following entry was in the table, the new entry
868 * is longer, so it will be in the table too. Remove
869 * the old one and add the new one.
870 */
871 if (dfp) {
872 xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
873 xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
874 }
875 /*
876 * Otherwise we need a scan if the new entry is big enough.
877 */
878 else {
879 needscan = be16_to_cpu(newdup->length) >
880 be16_to_cpu(bf[2].length);
881 }
882 }
883 /*
884 * Neither neighbor is free. Make a new entry.
885 */
886 else {
887 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
888 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
889 newdup->length = cpu_to_be16(len);
890 *xfs_dir2_data_unused_tag_p(newdup) =
891 cpu_to_be16((char *)newdup - (char *)hdr);
892 xfs_dir2_data_log_unused(args, bp, newdup);
893 xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
894 }
895 *needscanp = needscan;
896 }
897
898 /*
899 * Take a byte range out of an existing unused space and make it un-free.
900 */
901 void
902 xfs_dir2_data_use_free(
903 struct xfs_da_args *args,
904 struct xfs_buf *bp,
905 xfs_dir2_data_unused_t *dup, /* unused entry */
906 xfs_dir2_data_aoff_t offset, /* starting offset to use */
907 xfs_dir2_data_aoff_t len, /* length to use */
908 int *needlogp, /* out: need to log header */
909 int *needscanp) /* out: need regen bestfree */
910 {
911 xfs_dir2_data_hdr_t *hdr; /* data block header */
912 xfs_dir2_data_free_t *dfp; /* bestfree pointer */
913 int matchback; /* matches end of freespace */
914 int matchfront; /* matches start of freespace */
915 int needscan; /* need to regen bestfree */
916 xfs_dir2_data_unused_t *newdup; /* new unused entry */
917 xfs_dir2_data_unused_t *newdup2; /* another new unused entry */
918 int oldlen; /* old unused entry's length */
919 struct xfs_dir2_data_free *bf;
920
921 hdr = bp->b_addr;
922 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
923 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
924 hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
925 hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
926 ASSERT(be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG);
927 ASSERT(offset >= (char *)dup - (char *)hdr);
928 ASSERT(offset + len <= (char *)dup + be16_to_cpu(dup->length) - (char *)hdr);
929 ASSERT((char *)dup - (char *)hdr == be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
930 /*
931 * Look up the entry in the bestfree table.
932 */
933 oldlen = be16_to_cpu(dup->length);
934 bf = args->dp->d_ops->data_bestfree_p(hdr);
935 dfp = xfs_dir2_data_freefind(hdr, bf, dup);
936 ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
937 /*
938 * Check for alignment with front and back of the entry.
939 */
940 matchfront = (char *)dup - (char *)hdr == offset;
941 matchback = (char *)dup + oldlen - (char *)hdr == offset + len;
942 ASSERT(*needscanp == 0);
943 needscan = 0;
944 /*
945 * If we matched it exactly we just need to get rid of it from
946 * the bestfree table.
947 */
948 if (matchfront && matchback) {
949 if (dfp) {
950 needscan = (bf[2].offset != 0);
951 if (!needscan)
952 xfs_dir2_data_freeremove(hdr, bf, dfp,
953 needlogp);
954 }
955 }
956 /*
957 * We match the first part of the entry.
958 * Make a new entry with the remaining freespace.
959 */
960 else if (matchfront) {
961 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
962 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
963 newdup->length = cpu_to_be16(oldlen - len);
964 *xfs_dir2_data_unused_tag_p(newdup) =
965 cpu_to_be16((char *)newdup - (char *)hdr);
966 xfs_dir2_data_log_unused(args, bp, newdup);
967 /*
968 * If it was in the table, remove it and add the new one.
969 */
970 if (dfp) {
971 xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
972 dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
973 needlogp);
974 ASSERT(dfp != NULL);
975 ASSERT(dfp->length == newdup->length);
976 ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
977 /*
978 * If we got inserted at the last slot,
979 * that means we don't know if there was a better
980 * choice for the last slot, or not. Rescan.
981 */
982 needscan = dfp == &bf[2];
983 }
984 }
985 /*
986 * We match the last part of the entry.
987 * Trim the allocated space off the tail of the entry.
988 */
989 else if (matchback) {
990 newdup = dup;
991 newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
992 *xfs_dir2_data_unused_tag_p(newdup) =
993 cpu_to_be16((char *)newdup - (char *)hdr);
994 xfs_dir2_data_log_unused(args, bp, newdup);
995 /*
996 * If it was in the table, remove it and add the new one.
997 */
998 if (dfp) {
999 xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
1000 dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
1001 needlogp);
1002 ASSERT(dfp != NULL);
1003 ASSERT(dfp->length == newdup->length);
1004 ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
1005 /*
1006 * If we got inserted at the last slot,
1007 * that means we don't know if there was a better
1008 * choice for the last slot, or not. Rescan.
1009 */
1010 needscan = dfp == &bf[2];
1011 }
1012 }
1013 /*
1014 * Poking out the middle of an entry.
1015 * Make two new entries.
1016 */
1017 else {
1018 newdup = dup;
1019 newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
1020 *xfs_dir2_data_unused_tag_p(newdup) =
1021 cpu_to_be16((char *)newdup - (char *)hdr);
1022 xfs_dir2_data_log_unused(args, bp, newdup);
1023 newdup2 = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
1024 newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
1025 newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));
1026 *xfs_dir2_data_unused_tag_p(newdup2) =
1027 cpu_to_be16((char *)newdup2 - (char *)hdr);
1028 xfs_dir2_data_log_unused(args, bp, newdup2);
1029 /*
1030 * If the old entry was in the table, we need to scan
1031 * if the 3rd entry was valid, since these entries
1032 * are smaller than the old one.
1033 * If we don't need to scan that means there were 1 or 2
1034 * entries in the table, and removing the old and adding
1035 * the 2 new will work.
1036 */
1037 if (dfp) {
1038 needscan = (bf[2].length != 0);
1039 if (!needscan) {
1040 xfs_dir2_data_freeremove(hdr, bf, dfp,
1041 needlogp);
1042 xfs_dir2_data_freeinsert(hdr, bf, newdup,
1043 needlogp);
1044 xfs_dir2_data_freeinsert(hdr, bf, newdup2,
1045 needlogp);
1046 }
1047 }
1048 }
1049 *needscanp = needscan;
1050 }
Linux with added FPC-III support