10b61f8a4SDave Chinner // SPDX-License-Identifier: GPL-2.0
230f712c9SDave Chinner /*
330f712c9SDave Chinner * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
430f712c9SDave Chinner * Copyright (c) 2013 Red Hat, Inc.
530f712c9SDave Chinner * All Rights Reserved.
630f712c9SDave Chinner */
730f712c9SDave Chinner #include "xfs.h"
830f712c9SDave Chinner #include "xfs_fs.h"
95467b34bSDarrick J. Wong #include "xfs_shared.h"
1030f712c9SDave Chinner #include "xfs_format.h"
1130f712c9SDave Chinner #include "xfs_log_format.h"
1230f712c9SDave Chinner #include "xfs_trans_resv.h"
1330f712c9SDave Chinner #include "xfs_mount.h"
1430f712c9SDave Chinner #include "xfs_inode.h"
1530f712c9SDave Chinner #include "xfs_dir2.h"
16fdbb8c5bSChristoph Hellwig #include "xfs_dir2_priv.h"
1730f712c9SDave Chinner #include "xfs_error.h"
1830f712c9SDave Chinner #include "xfs_trans.h"
1930f712c9SDave Chinner #include "xfs_buf_item.h"
20a45086e2SBrian Foster #include "xfs_log.h"
21ca14c096SDarrick J. Wong #include "xfs_health.h"
2230f712c9SDave Chinner
23e4f45effSDarrick J. Wong static xfs_failaddr_t xfs_dir2_data_freefind_verify(
24e4f45effSDarrick J. Wong struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
25e4f45effSDarrick J. Wong struct xfs_dir2_data_unused *dup,
26e4f45effSDarrick J. Wong struct xfs_dir2_data_free **bf_ent);
27e4f45effSDarrick J. Wong
281848b607SChristoph Hellwig struct xfs_dir2_data_free *
xfs_dir2_data_bestfree_p(struct xfs_mount * mp,struct xfs_dir2_data_hdr * hdr)291848b607SChristoph Hellwig xfs_dir2_data_bestfree_p(
301848b607SChristoph Hellwig struct xfs_mount *mp,
311848b607SChristoph Hellwig struct xfs_dir2_data_hdr *hdr)
321848b607SChristoph Hellwig {
33ebd9027dSDave Chinner if (xfs_has_crc(mp))
341848b607SChristoph Hellwig return ((struct xfs_dir3_data_hdr *)hdr)->best_free;
351848b607SChristoph Hellwig return hdr->bestfree;
361848b607SChristoph Hellwig }
371848b607SChristoph Hellwig
3830f712c9SDave Chinner /*
397e8ae7bdSChristoph Hellwig * Pointer to an entry's tag word.
407e8ae7bdSChristoph Hellwig */
417e8ae7bdSChristoph Hellwig __be16 *
xfs_dir2_data_entry_tag_p(struct xfs_mount * mp,struct xfs_dir2_data_entry * dep)427e8ae7bdSChristoph Hellwig xfs_dir2_data_entry_tag_p(
437e8ae7bdSChristoph Hellwig struct xfs_mount *mp,
447e8ae7bdSChristoph Hellwig struct xfs_dir2_data_entry *dep)
457e8ae7bdSChristoph Hellwig {
467e8ae7bdSChristoph Hellwig return (__be16 *)((char *)dep +
477e8ae7bdSChristoph Hellwig xfs_dir2_data_entsize(mp, dep->namelen) - sizeof(__be16));
487e8ae7bdSChristoph Hellwig }
497e8ae7bdSChristoph Hellwig
5059b8b465SChristoph Hellwig uint8_t
xfs_dir2_data_get_ftype(struct xfs_mount * mp,struct xfs_dir2_data_entry * dep)5159b8b465SChristoph Hellwig xfs_dir2_data_get_ftype(
5259b8b465SChristoph Hellwig struct xfs_mount *mp,
5359b8b465SChristoph Hellwig struct xfs_dir2_data_entry *dep)
5459b8b465SChristoph Hellwig {
55ebd9027dSDave Chinner if (xfs_has_ftype(mp)) {
5659b8b465SChristoph Hellwig uint8_t ftype = dep->name[dep->namelen];
5759b8b465SChristoph Hellwig
5859b8b465SChristoph Hellwig if (likely(ftype < XFS_DIR3_FT_MAX))
5959b8b465SChristoph Hellwig return ftype;
6059b8b465SChristoph Hellwig }
6159b8b465SChristoph Hellwig
6259b8b465SChristoph Hellwig return XFS_DIR3_FT_UNKNOWN;
6359b8b465SChristoph Hellwig }
6459b8b465SChristoph Hellwig
6559b8b465SChristoph Hellwig void
xfs_dir2_data_put_ftype(struct xfs_mount * mp,struct xfs_dir2_data_entry * dep,uint8_t ftype)6659b8b465SChristoph Hellwig xfs_dir2_data_put_ftype(
6759b8b465SChristoph Hellwig struct xfs_mount *mp,
6859b8b465SChristoph Hellwig struct xfs_dir2_data_entry *dep,
6959b8b465SChristoph Hellwig uint8_t ftype)
7059b8b465SChristoph Hellwig {
7159b8b465SChristoph Hellwig ASSERT(ftype < XFS_DIR3_FT_MAX);
7259b8b465SChristoph Hellwig ASSERT(dep->namelen != 0);
7359b8b465SChristoph Hellwig
74ebd9027dSDave Chinner if (xfs_has_ftype(mp))
7559b8b465SChristoph Hellwig dep->name[dep->namelen] = ftype;
7659b8b465SChristoph Hellwig }
7759b8b465SChristoph Hellwig
787e8ae7bdSChristoph Hellwig /*
7948a71399SChristoph Hellwig * The number of leaf entries is limited by the size of the block and the amount
8048a71399SChristoph Hellwig * of space used by the data entries. We don't know how much space is used by
8148a71399SChristoph Hellwig * the data entries yet, so just ensure that the count falls somewhere inside
8248a71399SChristoph Hellwig * the block right now.
8348a71399SChristoph Hellwig */
8448a71399SChristoph Hellwig static inline unsigned int
xfs_dir2_data_max_leaf_entries(struct xfs_da_geometry * geo)8548a71399SChristoph Hellwig xfs_dir2_data_max_leaf_entries(
8648a71399SChristoph Hellwig struct xfs_da_geometry *geo)
8748a71399SChristoph Hellwig {
8848a71399SChristoph Hellwig return (geo->blksize - sizeof(struct xfs_dir2_block_tail) -
89d73e1ceeSChristoph Hellwig geo->data_entry_offset) /
9048a71399SChristoph Hellwig sizeof(struct xfs_dir2_leaf_entry);
9148a71399SChristoph Hellwig }
9248a71399SChristoph Hellwig
9348a71399SChristoph Hellwig /*
9430f712c9SDave Chinner * Check the consistency of the data block.
9530f712c9SDave Chinner * The input can also be a block-format directory.
96a6a781a5SDarrick J. Wong * Return NULL if the buffer is good, otherwise the address of the error.
9730f712c9SDave Chinner */
98a6a781a5SDarrick J. Wong xfs_failaddr_t
__xfs_dir3_data_check(struct xfs_inode * dp,struct xfs_buf * bp)9930f712c9SDave Chinner __xfs_dir3_data_check(
10030f712c9SDave Chinner struct xfs_inode *dp, /* incore inode pointer */
10130f712c9SDave Chinner struct xfs_buf *bp) /* data block's buffer */
10230f712c9SDave Chinner {
10330f712c9SDave Chinner xfs_dir2_dataptr_t addr; /* addr for leaf lookup */
10430f712c9SDave Chinner xfs_dir2_data_free_t *bf; /* bestfree table */
10530f712c9SDave Chinner xfs_dir2_block_tail_t *btp=NULL; /* block tail */
10630f712c9SDave Chinner int count; /* count of entries found */
10730f712c9SDave Chinner xfs_dir2_data_hdr_t *hdr; /* data block header */
10830f712c9SDave Chinner xfs_dir2_data_free_t *dfp; /* bestfree entry */
10930f712c9SDave Chinner int freeseen; /* mask of bestfrees seen */
11030f712c9SDave Chinner xfs_dahash_t hash; /* hash of current name */
11130f712c9SDave Chinner int i; /* leaf index */
11230f712c9SDave Chinner int lastfree; /* last entry was unused */
11330f712c9SDave Chinner xfs_dir2_leaf_entry_t *lep=NULL; /* block leaf entries */
114dbd329f1SChristoph Hellwig struct xfs_mount *mp = bp->b_mount;
11530f712c9SDave Chinner int stale; /* count of stale leaves */
11630f712c9SDave Chinner struct xfs_name name;
11748a71399SChristoph Hellwig unsigned int offset;
11848a71399SChristoph Hellwig unsigned int end;
11948a71399SChristoph Hellwig struct xfs_da_geometry *geo = mp->m_dir_geo;
12030f712c9SDave Chinner
12130f712c9SDave Chinner /*
12259b8b465SChristoph Hellwig * If this isn't a directory, something is seriously wrong. Bail out.
12330f712c9SDave Chinner */
12459b8b465SChristoph Hellwig if (dp && !S_ISDIR(VFS_I(dp)->i_mode))
12546c59736SDarrick J. Wong return __this_address;
12646c59736SDarrick J. Wong
12730f712c9SDave Chinner hdr = bp->b_addr;
128d73e1ceeSChristoph Hellwig offset = geo->data_entry_offset;
12930f712c9SDave Chinner
13030f712c9SDave Chinner switch (hdr->magic) {
13130f712c9SDave Chinner case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
13230f712c9SDave Chinner case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
13330f712c9SDave Chinner btp = xfs_dir2_block_tail_p(geo, hdr);
13430f712c9SDave Chinner lep = xfs_dir2_block_leaf_p(btp);
13530f712c9SDave Chinner
1369101d370SDarrick J. Wong if (be32_to_cpu(btp->count) >=
137d73e1ceeSChristoph Hellwig xfs_dir2_data_max_leaf_entries(geo))
138a6a781a5SDarrick J. Wong return __this_address;
13930f712c9SDave Chinner break;
14030f712c9SDave Chinner case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
14130f712c9SDave Chinner case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
14230f712c9SDave Chinner break;
14330f712c9SDave Chinner default:
144a6a781a5SDarrick J. Wong return __this_address;
14530f712c9SDave Chinner }
1465c072127SChristoph Hellwig end = xfs_dir3_data_end_offset(geo, hdr);
1475c072127SChristoph Hellwig if (!end)
148ce92d29dSDarrick J. Wong return __this_address;
14930f712c9SDave Chinner
15030f712c9SDave Chinner /*
15130f712c9SDave Chinner * Account for zero bestfree entries.
15230f712c9SDave Chinner */
1531848b607SChristoph Hellwig bf = xfs_dir2_data_bestfree_p(mp, hdr);
15430f712c9SDave Chinner count = lastfree = freeseen = 0;
15530f712c9SDave Chinner if (!bf[0].length) {
1569101d370SDarrick J. Wong if (bf[0].offset)
157a6a781a5SDarrick J. Wong return __this_address;
15830f712c9SDave Chinner freeseen |= 1 << 0;
15930f712c9SDave Chinner }
16030f712c9SDave Chinner if (!bf[1].length) {
1619101d370SDarrick J. Wong if (bf[1].offset)
162a6a781a5SDarrick J. Wong return __this_address;
16330f712c9SDave Chinner freeseen |= 1 << 1;
16430f712c9SDave Chinner }
16530f712c9SDave Chinner if (!bf[2].length) {
1669101d370SDarrick J. Wong if (bf[2].offset)
167a6a781a5SDarrick J. Wong return __this_address;
16830f712c9SDave Chinner freeseen |= 1 << 2;
16930f712c9SDave Chinner }
17030f712c9SDave Chinner
1719101d370SDarrick J. Wong if (be16_to_cpu(bf[0].length) < be16_to_cpu(bf[1].length))
172a6a781a5SDarrick J. Wong return __this_address;
1739101d370SDarrick J. Wong if (be16_to_cpu(bf[1].length) < be16_to_cpu(bf[2].length))
174a6a781a5SDarrick J. Wong return __this_address;
17530f712c9SDave Chinner /*
17630f712c9SDave Chinner * Loop over the data/unused entries.
17730f712c9SDave Chinner */
17848a71399SChristoph Hellwig while (offset < end) {
17948a71399SChristoph Hellwig struct xfs_dir2_data_unused *dup = bp->b_addr + offset;
18048a71399SChristoph Hellwig struct xfs_dir2_data_entry *dep = bp->b_addr + offset;
181*0c7fcdb6Slei lu unsigned int reclen;
182*0c7fcdb6Slei lu
183*0c7fcdb6Slei lu /*
184*0c7fcdb6Slei lu * Are the remaining bytes large enough to hold an
185*0c7fcdb6Slei lu * unused entry?
186*0c7fcdb6Slei lu */
187*0c7fcdb6Slei lu if (offset > end - xfs_dir2_data_unusedsize(1))
188*0c7fcdb6Slei lu return __this_address;
18948a71399SChristoph Hellwig
19030f712c9SDave Chinner /*
19130f712c9SDave Chinner * If it's unused, look for the space in the bestfree table.
19230f712c9SDave Chinner * If we find it, account for that, else make sure it
19330f712c9SDave Chinner * doesn't need to be there.
19430f712c9SDave Chinner */
19530f712c9SDave Chinner if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
196e4f45effSDarrick J. Wong xfs_failaddr_t fa;
197e4f45effSDarrick J. Wong
198*0c7fcdb6Slei lu reclen = xfs_dir2_data_unusedsize(
199*0c7fcdb6Slei lu be16_to_cpu(dup->length));
2009101d370SDarrick J. Wong if (lastfree != 0)
201a6a781a5SDarrick J. Wong return __this_address;
202*0c7fcdb6Slei lu if (be16_to_cpu(dup->length) != reclen)
203*0c7fcdb6Slei lu return __this_address;
204*0c7fcdb6Slei lu if (offset + reclen > end)
205a6a781a5SDarrick J. Wong return __this_address;
2069101d370SDarrick J. Wong if (be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) !=
20748a71399SChristoph Hellwig offset)
208a6a781a5SDarrick J. Wong return __this_address;
209e4f45effSDarrick J. Wong fa = xfs_dir2_data_freefind_verify(hdr, bf, dup, &dfp);
210e4f45effSDarrick J. Wong if (fa)
211e4f45effSDarrick J. Wong return fa;
21230f712c9SDave Chinner if (dfp) {
21330f712c9SDave Chinner i = (int)(dfp - bf);
2149101d370SDarrick J. Wong if ((freeseen & (1 << i)) != 0)
215a6a781a5SDarrick J. Wong return __this_address;
21630f712c9SDave Chinner freeseen |= 1 << i;
21730f712c9SDave Chinner } else {
2189101d370SDarrick J. Wong if (be16_to_cpu(dup->length) >
2199101d370SDarrick J. Wong be16_to_cpu(bf[2].length))
220a6a781a5SDarrick J. Wong return __this_address;
22130f712c9SDave Chinner }
222*0c7fcdb6Slei lu offset += reclen;
22330f712c9SDave Chinner lastfree = 1;
22430f712c9SDave Chinner continue;
22530f712c9SDave Chinner }
226*0c7fcdb6Slei lu
227*0c7fcdb6Slei lu /*
228*0c7fcdb6Slei lu * This is not an unused entry. Are the remaining bytes
229*0c7fcdb6Slei lu * large enough for a dirent with a single-byte name?
230*0c7fcdb6Slei lu */
231*0c7fcdb6Slei lu if (offset > end - xfs_dir2_data_entsize(mp, 1))
232*0c7fcdb6Slei lu return __this_address;
233*0c7fcdb6Slei lu
23430f712c9SDave Chinner /*
23530f712c9SDave Chinner * It's a real entry. Validate the fields.
23630f712c9SDave Chinner * If this is a block directory then make sure it's
23730f712c9SDave Chinner * in the leaf section of the block.
23830f712c9SDave Chinner * The linear search is crude but this is DEBUG code.
23930f712c9SDave Chinner */
2409101d370SDarrick J. Wong if (dep->namelen == 0)
241a6a781a5SDarrick J. Wong return __this_address;
242*0c7fcdb6Slei lu reclen = xfs_dir2_data_entsize(mp, dep->namelen);
243*0c7fcdb6Slei lu if (offset + reclen > end)
244a6a781a5SDarrick J. Wong return __this_address;
245*0c7fcdb6Slei lu if (!xfs_verify_dir_ino(mp, be64_to_cpu(dep->inumber)))
246a6a781a5SDarrick J. Wong return __this_address;
2477e8ae7bdSChristoph Hellwig if (be16_to_cpu(*xfs_dir2_data_entry_tag_p(mp, dep)) != offset)
248a6a781a5SDarrick J. Wong return __this_address;
24959b8b465SChristoph Hellwig if (xfs_dir2_data_get_ftype(mp, dep) >= XFS_DIR3_FT_MAX)
250a6a781a5SDarrick J. Wong return __this_address;
25130f712c9SDave Chinner count++;
25230f712c9SDave Chinner lastfree = 0;
25330f712c9SDave Chinner if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
25430f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
25530f712c9SDave Chinner addr = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
25630f712c9SDave Chinner (xfs_dir2_data_aoff_t)
25730f712c9SDave Chinner ((char *)dep - (char *)hdr));
25830f712c9SDave Chinner name.name = dep->name;
25930f712c9SDave Chinner name.len = dep->namelen;
260d8d11fc7SChristoph Hellwig hash = xfs_dir2_hashname(mp, &name);
26130f712c9SDave Chinner for (i = 0; i < be32_to_cpu(btp->count); i++) {
26230f712c9SDave Chinner if (be32_to_cpu(lep[i].address) == addr &&
26330f712c9SDave Chinner be32_to_cpu(lep[i].hashval) == hash)
26430f712c9SDave Chinner break;
26530f712c9SDave Chinner }
2669101d370SDarrick J. Wong if (i >= be32_to_cpu(btp->count))
267a6a781a5SDarrick J. Wong return __this_address;
26830f712c9SDave Chinner }
269*0c7fcdb6Slei lu offset += reclen;
27030f712c9SDave Chinner }
27130f712c9SDave Chinner /*
27230f712c9SDave Chinner * Need to have seen all the entries and all the bestfree slots.
27330f712c9SDave Chinner */
2749101d370SDarrick J. Wong if (freeseen != 7)
275a6a781a5SDarrick J. Wong return __this_address;
27630f712c9SDave Chinner if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
27730f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
27830f712c9SDave Chinner for (i = stale = 0; i < be32_to_cpu(btp->count); i++) {
27930f712c9SDave Chinner if (lep[i].address ==
28030f712c9SDave Chinner cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
28130f712c9SDave Chinner stale++;
2829101d370SDarrick J. Wong if (i > 0 && be32_to_cpu(lep[i].hashval) <
2839101d370SDarrick J. Wong be32_to_cpu(lep[i - 1].hashval))
284a6a781a5SDarrick J. Wong return __this_address;
28530f712c9SDave Chinner }
2869101d370SDarrick J. Wong if (count != be32_to_cpu(btp->count) - be32_to_cpu(btp->stale))
287a6a781a5SDarrick J. Wong return __this_address;
2889101d370SDarrick J. Wong if (stale != be32_to_cpu(btp->stale))
289a6a781a5SDarrick J. Wong return __this_address;
29030f712c9SDave Chinner }
291a6a781a5SDarrick J. Wong return NULL;
29230f712c9SDave Chinner }
29330f712c9SDave Chinner
294a6a781a5SDarrick J. Wong #ifdef DEBUG
295a6a781a5SDarrick J. Wong void
xfs_dir3_data_check(struct xfs_inode * dp,struct xfs_buf * bp)296a6a781a5SDarrick J. Wong xfs_dir3_data_check(
297a6a781a5SDarrick J. Wong struct xfs_inode *dp,
298a6a781a5SDarrick J. Wong struct xfs_buf *bp)
299a6a781a5SDarrick J. Wong {
300a6a781a5SDarrick J. Wong xfs_failaddr_t fa;
301a6a781a5SDarrick J. Wong
302a6a781a5SDarrick J. Wong fa = __xfs_dir3_data_check(dp, bp);
303a6a781a5SDarrick J. Wong if (!fa)
304a6a781a5SDarrick J. Wong return;
305a6a781a5SDarrick J. Wong xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, dp->i_mount,
3062551a530SDarrick J. Wong bp->b_addr, BBTOB(bp->b_length), __FILE__, __LINE__,
3072551a530SDarrick J. Wong fa);
308a6a781a5SDarrick J. Wong ASSERT(0);
309a6a781a5SDarrick J. Wong }
310a6a781a5SDarrick J. Wong #endif
311a6a781a5SDarrick J. Wong
312a6a781a5SDarrick J. Wong static xfs_failaddr_t
xfs_dir3_data_verify(struct xfs_buf * bp)31330f712c9SDave Chinner xfs_dir3_data_verify(
31430f712c9SDave Chinner struct xfs_buf *bp)
31530f712c9SDave Chinner {
316dbd329f1SChristoph Hellwig struct xfs_mount *mp = bp->b_mount;
31730f712c9SDave Chinner struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
31830f712c9SDave Chinner
31939708c20SBrian Foster if (!xfs_verify_magic(bp, hdr3->magic))
320a6a781a5SDarrick J. Wong return __this_address;
32139708c20SBrian Foster
322ebd9027dSDave Chinner if (xfs_has_crc(mp)) {
323ce748eaaSEric Sandeen if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
324a6a781a5SDarrick J. Wong return __this_address;
3259343ee76SDave Chinner if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
326a6a781a5SDarrick J. Wong return __this_address;
327a45086e2SBrian Foster if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
328a6a781a5SDarrick J. Wong return __this_address;
32930f712c9SDave Chinner }
3309101d370SDarrick J. Wong return __xfs_dir3_data_check(NULL, bp);
33130f712c9SDave Chinner }
33230f712c9SDave Chinner
33330f712c9SDave Chinner /*
33430f712c9SDave Chinner * Readahead of the first block of the directory when it is opened is completely
33530f712c9SDave Chinner * oblivious to the format of the directory. Hence we can either get a block
33630f712c9SDave Chinner * format buffer or a data format buffer on readahead.
33730f712c9SDave Chinner */
33830f712c9SDave Chinner static void
xfs_dir3_data_reada_verify(struct xfs_buf * bp)33930f712c9SDave Chinner xfs_dir3_data_reada_verify(
34030f712c9SDave Chinner struct xfs_buf *bp)
34130f712c9SDave Chinner {
34230f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr = bp->b_addr;
34330f712c9SDave Chinner
34430f712c9SDave Chinner switch (hdr->magic) {
34530f712c9SDave Chinner case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
34630f712c9SDave Chinner case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
34730f712c9SDave Chinner bp->b_ops = &xfs_dir3_block_buf_ops;
34830f712c9SDave Chinner bp->b_ops->verify_read(bp);
34930f712c9SDave Chinner return;
35030f712c9SDave Chinner case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
35130f712c9SDave Chinner case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
3522f123bceSDarrick J. Wong bp->b_ops = &xfs_dir3_data_buf_ops;
3532f123bceSDarrick J. Wong bp->b_ops->verify_read(bp);
35430f712c9SDave Chinner return;
35530f712c9SDave Chinner default:
356bc1a09b8SDarrick J. Wong xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
35730f712c9SDave Chinner break;
35830f712c9SDave Chinner }
35930f712c9SDave Chinner }
36030f712c9SDave Chinner
36130f712c9SDave Chinner static void
xfs_dir3_data_read_verify(struct xfs_buf * bp)36230f712c9SDave Chinner xfs_dir3_data_read_verify(
36330f712c9SDave Chinner struct xfs_buf *bp)
36430f712c9SDave Chinner {
365dbd329f1SChristoph Hellwig struct xfs_mount *mp = bp->b_mount;
366bc1a09b8SDarrick J. Wong xfs_failaddr_t fa;
36730f712c9SDave Chinner
36838c26bfdSDave Chinner if (xfs_has_crc(mp) &&
36930f712c9SDave Chinner !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
370bc1a09b8SDarrick J. Wong xfs_verifier_error(bp, -EFSBADCRC, __this_address);
371bc1a09b8SDarrick J. Wong else {
372bc1a09b8SDarrick J. Wong fa = xfs_dir3_data_verify(bp);
373bc1a09b8SDarrick J. Wong if (fa)
374bc1a09b8SDarrick J. Wong xfs_verifier_error(bp, -EFSCORRUPTED, fa);
375bc1a09b8SDarrick J. Wong }
37630f712c9SDave Chinner }
37730f712c9SDave Chinner
37830f712c9SDave Chinner static void
xfs_dir3_data_write_verify(struct xfs_buf * bp)37930f712c9SDave Chinner xfs_dir3_data_write_verify(
38030f712c9SDave Chinner struct xfs_buf *bp)
38130f712c9SDave Chinner {
382dbd329f1SChristoph Hellwig struct xfs_mount *mp = bp->b_mount;
383fb1755a6SCarlos Maiolino struct xfs_buf_log_item *bip = bp->b_log_item;
38430f712c9SDave Chinner struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
385bc1a09b8SDarrick J. Wong xfs_failaddr_t fa;
38630f712c9SDave Chinner
387bc1a09b8SDarrick J. Wong fa = xfs_dir3_data_verify(bp);
388bc1a09b8SDarrick J. Wong if (fa) {
389bc1a09b8SDarrick J. Wong xfs_verifier_error(bp, -EFSCORRUPTED, fa);
39030f712c9SDave Chinner return;
39130f712c9SDave Chinner }
39230f712c9SDave Chinner
39338c26bfdSDave Chinner if (!xfs_has_crc(mp))
39430f712c9SDave Chinner return;
39530f712c9SDave Chinner
39630f712c9SDave Chinner if (bip)
39730f712c9SDave Chinner hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
39830f712c9SDave Chinner
39930f712c9SDave Chinner xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
40030f712c9SDave Chinner }
40130f712c9SDave Chinner
40230f712c9SDave Chinner const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
403233135b7SEric Sandeen .name = "xfs_dir3_data",
40439708c20SBrian Foster .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
40539708c20SBrian Foster cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
40630f712c9SDave Chinner .verify_read = xfs_dir3_data_read_verify,
40730f712c9SDave Chinner .verify_write = xfs_dir3_data_write_verify,
408b5572597SDarrick J. Wong .verify_struct = xfs_dir3_data_verify,
40930f712c9SDave Chinner };
41030f712c9SDave Chinner
41130f712c9SDave Chinner static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = {
412233135b7SEric Sandeen .name = "xfs_dir3_data_reada",
41339708c20SBrian Foster .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
41439708c20SBrian Foster cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
41530f712c9SDave Chinner .verify_read = xfs_dir3_data_reada_verify,
41630f712c9SDave Chinner .verify_write = xfs_dir3_data_write_verify,
41730f712c9SDave Chinner };
41830f712c9SDave Chinner
419cc6740ddSDarrick J. Wong xfs_failaddr_t
xfs_dir3_data_header_check(struct xfs_buf * bp,xfs_ino_t owner)420a10c21edSDarrick J. Wong xfs_dir3_data_header_check(
421cc6740ddSDarrick J. Wong struct xfs_buf *bp,
422cc6740ddSDarrick J. Wong xfs_ino_t owner)
423a10c21edSDarrick J. Wong {
424cc6740ddSDarrick J. Wong struct xfs_mount *mp = bp->b_mount;
425a10c21edSDarrick J. Wong
426ebd9027dSDave Chinner if (xfs_has_crc(mp)) {
427a10c21edSDarrick J. Wong struct xfs_dir3_data_hdr *hdr3 = bp->b_addr;
428a10c21edSDarrick J. Wong
429cc6740ddSDarrick J. Wong if (hdr3->hdr.magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC))
430cc6740ddSDarrick J. Wong return __this_address;
431cc6740ddSDarrick J. Wong
432cc6740ddSDarrick J. Wong if (be64_to_cpu(hdr3->hdr.owner) != owner)
433a10c21edSDarrick J. Wong return __this_address;
434a10c21edSDarrick J. Wong }
435a10c21edSDarrick J. Wong
436a10c21edSDarrick J. Wong return NULL;
437a10c21edSDarrick J. Wong }
43830f712c9SDave Chinner
43930f712c9SDave Chinner int
xfs_dir3_data_read(struct xfs_trans * tp,struct xfs_inode * dp,xfs_ino_t owner,xfs_dablk_t bno,unsigned int flags,struct xfs_buf ** bpp)44030f712c9SDave Chinner xfs_dir3_data_read(
44130f712c9SDave Chinner struct xfs_trans *tp,
44230f712c9SDave Chinner struct xfs_inode *dp,
443cc6740ddSDarrick J. Wong xfs_ino_t owner,
44430f712c9SDave Chinner xfs_dablk_t bno,
445cd2c9f1bSChristoph Hellwig unsigned int flags,
44630f712c9SDave Chinner struct xfs_buf **bpp)
44730f712c9SDave Chinner {
448a10c21edSDarrick J. Wong xfs_failaddr_t fa;
44930f712c9SDave Chinner int err;
45030f712c9SDave Chinner
451cd2c9f1bSChristoph Hellwig err = xfs_da_read_buf(tp, dp, bno, flags, bpp, XFS_DATA_FORK,
452cd2c9f1bSChristoph Hellwig &xfs_dir3_data_buf_ops);
453a10c21edSDarrick J. Wong if (err || !*bpp)
454a10c21edSDarrick J. Wong return err;
455a10c21edSDarrick J. Wong
456a10c21edSDarrick J. Wong /* Check things that we can't do in the verifier. */
457cc6740ddSDarrick J. Wong fa = xfs_dir3_data_header_check(*bpp, owner);
458a10c21edSDarrick J. Wong if (fa) {
459a10c21edSDarrick J. Wong __xfs_buf_mark_corrupt(*bpp, fa);
460a10c21edSDarrick J. Wong xfs_trans_brelse(tp, *bpp);
461a10c21edSDarrick J. Wong *bpp = NULL;
462ca14c096SDarrick J. Wong xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
463a10c21edSDarrick J. Wong return -EFSCORRUPTED;
464a10c21edSDarrick J. Wong }
465a10c21edSDarrick J. Wong
46630f712c9SDave Chinner xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_DATA_BUF);
46730f712c9SDave Chinner return err;
46830f712c9SDave Chinner }
46930f712c9SDave Chinner
47030f712c9SDave Chinner int
xfs_dir3_data_readahead(struct xfs_inode * dp,xfs_dablk_t bno,unsigned int flags)47130f712c9SDave Chinner xfs_dir3_data_readahead(
47230f712c9SDave Chinner struct xfs_inode *dp,
47330f712c9SDave Chinner xfs_dablk_t bno,
47406566fdaSChristoph Hellwig unsigned int flags)
47530f712c9SDave Chinner {
47606566fdaSChristoph Hellwig return xfs_da_reada_buf(dp, bno, flags, XFS_DATA_FORK,
47706566fdaSChristoph Hellwig &xfs_dir3_data_reada_buf_ops);
47830f712c9SDave Chinner }
47930f712c9SDave Chinner
48030f712c9SDave Chinner /*
481e4f45effSDarrick J. Wong * Find the bestfree entry that exactly coincides with unused directory space
482e4f45effSDarrick J. Wong * or a verifier error because the bestfree data are bad.
483e4f45effSDarrick J. Wong */
484e4f45effSDarrick J. Wong static xfs_failaddr_t
xfs_dir2_data_freefind_verify(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_free * bf,struct xfs_dir2_data_unused * dup,struct xfs_dir2_data_free ** bf_ent)485e4f45effSDarrick J. Wong xfs_dir2_data_freefind_verify(
486e4f45effSDarrick J. Wong struct xfs_dir2_data_hdr *hdr,
487e4f45effSDarrick J. Wong struct xfs_dir2_data_free *bf,
488e4f45effSDarrick J. Wong struct xfs_dir2_data_unused *dup,
489e4f45effSDarrick J. Wong struct xfs_dir2_data_free **bf_ent)
490e4f45effSDarrick J. Wong {
491e4f45effSDarrick J. Wong struct xfs_dir2_data_free *dfp;
492e4f45effSDarrick J. Wong xfs_dir2_data_aoff_t off;
493e4f45effSDarrick J. Wong bool matched = false;
494e4f45effSDarrick J. Wong bool seenzero = false;
495e4f45effSDarrick J. Wong
496e4f45effSDarrick J. Wong *bf_ent = NULL;
497e4f45effSDarrick J. Wong off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
498e4f45effSDarrick J. Wong
499e4f45effSDarrick J. Wong /*
500e4f45effSDarrick J. Wong * Validate some consistency in the bestfree table.
501e4f45effSDarrick J. Wong * Check order, non-overlapping entries, and if we find the
502e4f45effSDarrick J. Wong * one we're looking for it has to be exact.
503e4f45effSDarrick J. Wong */
504e4f45effSDarrick J. Wong for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
505e4f45effSDarrick J. Wong if (!dfp->offset) {
506e4f45effSDarrick J. Wong if (dfp->length)
507e4f45effSDarrick J. Wong return __this_address;
508e4f45effSDarrick J. Wong seenzero = true;
509e4f45effSDarrick J. Wong continue;
510e4f45effSDarrick J. Wong }
511e4f45effSDarrick J. Wong if (seenzero)
512e4f45effSDarrick J. Wong return __this_address;
513e4f45effSDarrick J. Wong if (be16_to_cpu(dfp->offset) == off) {
514e4f45effSDarrick J. Wong matched = true;
515e4f45effSDarrick J. Wong if (dfp->length != dup->length)
516e4f45effSDarrick J. Wong return __this_address;
517e4f45effSDarrick J. Wong } else if (be16_to_cpu(dfp->offset) > off) {
518e4f45effSDarrick J. Wong if (off + be16_to_cpu(dup->length) >
519e4f45effSDarrick J. Wong be16_to_cpu(dfp->offset))
520e4f45effSDarrick J. Wong return __this_address;
521e4f45effSDarrick J. Wong } else {
522e4f45effSDarrick J. Wong if (be16_to_cpu(dfp->offset) +
523e4f45effSDarrick J. Wong be16_to_cpu(dfp->length) > off)
524e4f45effSDarrick J. Wong return __this_address;
525e4f45effSDarrick J. Wong }
526e4f45effSDarrick J. Wong if (!matched &&
527e4f45effSDarrick J. Wong be16_to_cpu(dfp->length) < be16_to_cpu(dup->length))
528e4f45effSDarrick J. Wong return __this_address;
529e4f45effSDarrick J. Wong if (dfp > &bf[0] &&
530e4f45effSDarrick J. Wong be16_to_cpu(dfp[-1].length) < be16_to_cpu(dfp[0].length))
531e4f45effSDarrick J. Wong return __this_address;
532e4f45effSDarrick J. Wong }
533e4f45effSDarrick J. Wong
534e4f45effSDarrick J. Wong /* Looks ok so far; now try to match up with a bestfree entry. */
535e4f45effSDarrick J. Wong *bf_ent = xfs_dir2_data_freefind(hdr, bf, dup);
536e4f45effSDarrick J. Wong return NULL;
537e4f45effSDarrick J. Wong }
538e4f45effSDarrick J. Wong
539e4f45effSDarrick J. Wong /*
54030f712c9SDave Chinner * Given a data block and an unused entry from that block,
54130f712c9SDave Chinner * return the bestfree entry if any that corresponds to it.
54230f712c9SDave Chinner */
54330f712c9SDave Chinner xfs_dir2_data_free_t *
xfs_dir2_data_freefind(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_free * bf,struct xfs_dir2_data_unused * dup)54430f712c9SDave Chinner xfs_dir2_data_freefind(
54530f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr, /* data block header */
54630f712c9SDave Chinner struct xfs_dir2_data_free *bf, /* bestfree table pointer */
54730f712c9SDave Chinner struct xfs_dir2_data_unused *dup) /* unused space */
54830f712c9SDave Chinner {
54930f712c9SDave Chinner xfs_dir2_data_free_t *dfp; /* bestfree entry */
55030f712c9SDave Chinner xfs_dir2_data_aoff_t off; /* offset value needed */
55130f712c9SDave Chinner
55230f712c9SDave Chinner off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
55330f712c9SDave Chinner
55430f712c9SDave Chinner /*
55530f712c9SDave Chinner * If this is smaller than the smallest bestfree entry,
55630f712c9SDave Chinner * it can't be there since they're sorted.
55730f712c9SDave Chinner */
55830f712c9SDave Chinner if (be16_to_cpu(dup->length) <
55930f712c9SDave Chinner be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
56030f712c9SDave Chinner return NULL;
56130f712c9SDave Chinner /*
56230f712c9SDave Chinner * Look at the three bestfree entries for our guy.
56330f712c9SDave Chinner */
56430f712c9SDave Chinner for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
56530f712c9SDave Chinner if (!dfp->offset)
56630f712c9SDave Chinner return NULL;
56730f712c9SDave Chinner if (be16_to_cpu(dfp->offset) == off)
56830f712c9SDave Chinner return dfp;
56930f712c9SDave Chinner }
57030f712c9SDave Chinner /*
57130f712c9SDave Chinner * Didn't find it. This only happens if there are duplicate lengths.
57230f712c9SDave Chinner */
57330f712c9SDave Chinner return NULL;
57430f712c9SDave Chinner }
57530f712c9SDave Chinner
57630f712c9SDave Chinner /*
57730f712c9SDave Chinner * Insert an unused-space entry into the bestfree table.
57830f712c9SDave Chinner */
57930f712c9SDave Chinner xfs_dir2_data_free_t * /* entry inserted */
xfs_dir2_data_freeinsert(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_free * dfp,struct xfs_dir2_data_unused * dup,int * loghead)58030f712c9SDave Chinner xfs_dir2_data_freeinsert(
58130f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr, /* data block pointer */
58230f712c9SDave Chinner struct xfs_dir2_data_free *dfp, /* bestfree table pointer */
58330f712c9SDave Chinner struct xfs_dir2_data_unused *dup, /* unused space */
58430f712c9SDave Chinner int *loghead) /* log the data header (out) */
58530f712c9SDave Chinner {
58630f712c9SDave Chinner xfs_dir2_data_free_t new; /* new bestfree entry */
58730f712c9SDave Chinner
58830f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
58930f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
59030f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
59130f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
59230f712c9SDave Chinner
59330f712c9SDave Chinner new.length = dup->length;
59430f712c9SDave Chinner new.offset = cpu_to_be16((char *)dup - (char *)hdr);
59530f712c9SDave Chinner
59630f712c9SDave Chinner /*
59730f712c9SDave Chinner * Insert at position 0, 1, or 2; or not at all.
59830f712c9SDave Chinner */
59930f712c9SDave Chinner if (be16_to_cpu(new.length) > be16_to_cpu(dfp[0].length)) {
60030f712c9SDave Chinner dfp[2] = dfp[1];
60130f712c9SDave Chinner dfp[1] = dfp[0];
60230f712c9SDave Chinner dfp[0] = new;
60330f712c9SDave Chinner *loghead = 1;
60430f712c9SDave Chinner return &dfp[0];
60530f712c9SDave Chinner }
60630f712c9SDave Chinner if (be16_to_cpu(new.length) > be16_to_cpu(dfp[1].length)) {
60730f712c9SDave Chinner dfp[2] = dfp[1];
60830f712c9SDave Chinner dfp[1] = new;
60930f712c9SDave Chinner *loghead = 1;
61030f712c9SDave Chinner return &dfp[1];
61130f712c9SDave Chinner }
61230f712c9SDave Chinner if (be16_to_cpu(new.length) > be16_to_cpu(dfp[2].length)) {
61330f712c9SDave Chinner dfp[2] = new;
61430f712c9SDave Chinner *loghead = 1;
61530f712c9SDave Chinner return &dfp[2];
61630f712c9SDave Chinner }
61730f712c9SDave Chinner return NULL;
61830f712c9SDave Chinner }
61930f712c9SDave Chinner
62030f712c9SDave Chinner /*
62130f712c9SDave Chinner * Remove a bestfree entry from the table.
62230f712c9SDave Chinner */
62330f712c9SDave Chinner STATIC void
xfs_dir2_data_freeremove(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_free * bf,struct xfs_dir2_data_free * dfp,int * loghead)62430f712c9SDave Chinner xfs_dir2_data_freeremove(
62530f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr, /* data block header */
62630f712c9SDave Chinner struct xfs_dir2_data_free *bf, /* bestfree table pointer */
62730f712c9SDave Chinner struct xfs_dir2_data_free *dfp, /* bestfree entry pointer */
62830f712c9SDave Chinner int *loghead) /* out: log data header */
62930f712c9SDave Chinner {
63030f712c9SDave Chinner
63130f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
63230f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
63330f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
63430f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
63530f712c9SDave Chinner
63630f712c9SDave Chinner /*
63730f712c9SDave Chinner * It's the first entry, slide the next 2 up.
63830f712c9SDave Chinner */
63930f712c9SDave Chinner if (dfp == &bf[0]) {
64030f712c9SDave Chinner bf[0] = bf[1];
64130f712c9SDave Chinner bf[1] = bf[2];
64230f712c9SDave Chinner }
64330f712c9SDave Chinner /*
64430f712c9SDave Chinner * It's the second entry, slide the 3rd entry up.
64530f712c9SDave Chinner */
64630f712c9SDave Chinner else if (dfp == &bf[1])
64730f712c9SDave Chinner bf[1] = bf[2];
64830f712c9SDave Chinner /*
64930f712c9SDave Chinner * Must be the last entry.
65030f712c9SDave Chinner */
65130f712c9SDave Chinner else
65230f712c9SDave Chinner ASSERT(dfp == &bf[2]);
65330f712c9SDave Chinner /*
65430f712c9SDave Chinner * Clear the 3rd entry, must be zero now.
65530f712c9SDave Chinner */
65630f712c9SDave Chinner bf[2].length = 0;
65730f712c9SDave Chinner bf[2].offset = 0;
65830f712c9SDave Chinner *loghead = 1;
65930f712c9SDave Chinner }
66030f712c9SDave Chinner
66130f712c9SDave Chinner /*
66230f712c9SDave Chinner * Given a data block, reconstruct its bestfree map.
66330f712c9SDave Chinner */
66430f712c9SDave Chinner void
xfs_dir2_data_freescan(struct xfs_mount * mp,struct xfs_dir2_data_hdr * hdr,int * loghead)665ae42976dSChristoph Hellwig xfs_dir2_data_freescan(
666fdbb8c5bSChristoph Hellwig struct xfs_mount *mp,
66730f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr,
66830f712c9SDave Chinner int *loghead)
66930f712c9SDave Chinner {
670d73e1ceeSChristoph Hellwig struct xfs_da_geometry *geo = mp->m_dir_geo;
6711848b607SChristoph Hellwig struct xfs_dir2_data_free *bf = xfs_dir2_data_bestfree_p(mp, hdr);
67262479f57SChristoph Hellwig void *addr = hdr;
673d73e1ceeSChristoph Hellwig unsigned int offset = geo->data_entry_offset;
67462479f57SChristoph Hellwig unsigned int end;
67530f712c9SDave Chinner
67630f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
67730f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
67830f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
67930f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
68030f712c9SDave Chinner
68130f712c9SDave Chinner /*
68230f712c9SDave Chinner * Start by clearing the table.
68330f712c9SDave Chinner */
68430f712c9SDave Chinner memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
68530f712c9SDave Chinner *loghead = 1;
68662479f57SChristoph Hellwig
687d73e1ceeSChristoph Hellwig end = xfs_dir3_data_end_offset(geo, addr);
68862479f57SChristoph Hellwig while (offset < end) {
68962479f57SChristoph Hellwig struct xfs_dir2_data_unused *dup = addr + offset;
69062479f57SChristoph Hellwig struct xfs_dir2_data_entry *dep = addr + offset;
69162479f57SChristoph Hellwig
69230f712c9SDave Chinner /*
69330f712c9SDave Chinner * If it's a free entry, insert it.
69430f712c9SDave Chinner */
69530f712c9SDave Chinner if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
69662479f57SChristoph Hellwig ASSERT(offset ==
69730f712c9SDave Chinner be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
69830f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
69962479f57SChristoph Hellwig offset += be16_to_cpu(dup->length);
70062479f57SChristoph Hellwig continue;
70130f712c9SDave Chinner }
70262479f57SChristoph Hellwig
70330f712c9SDave Chinner /*
70430f712c9SDave Chinner * For active entries, check their tags and skip them.
70530f712c9SDave Chinner */
7067e8ae7bdSChristoph Hellwig ASSERT(offset ==
7077e8ae7bdSChristoph Hellwig be16_to_cpu(*xfs_dir2_data_entry_tag_p(mp, dep)));
708fdbb8c5bSChristoph Hellwig offset += xfs_dir2_data_entsize(mp, dep->namelen);
70930f712c9SDave Chinner }
71030f712c9SDave Chinner }
71130f712c9SDave Chinner
71230f712c9SDave Chinner /*
71330f712c9SDave Chinner * Initialize a data block at the given block number in the directory.
71430f712c9SDave Chinner * Give back the buffer for the created block.
71530f712c9SDave Chinner */
71630f712c9SDave Chinner int /* error */
xfs_dir3_data_init(struct xfs_da_args * args,xfs_dir2_db_t blkno,struct xfs_buf ** bpp)71730f712c9SDave Chinner xfs_dir3_data_init(
718ee641d5aSChristoph Hellwig struct xfs_da_args *args, /* directory operation args */
71930f712c9SDave Chinner xfs_dir2_db_t blkno, /* logical dir block number */
72030f712c9SDave Chinner struct xfs_buf **bpp) /* output block buffer */
72130f712c9SDave Chinner {
722ee641d5aSChristoph Hellwig struct xfs_trans *tp = args->trans;
723ee641d5aSChristoph Hellwig struct xfs_inode *dp = args->dp;
724ee641d5aSChristoph Hellwig struct xfs_mount *mp = dp->i_mount;
725d73e1ceeSChristoph Hellwig struct xfs_da_geometry *geo = args->geo;
726ee641d5aSChristoph Hellwig struct xfs_buf *bp;
727ee641d5aSChristoph Hellwig struct xfs_dir2_data_hdr *hdr;
728ee641d5aSChristoph Hellwig struct xfs_dir2_data_unused *dup;
72930f712c9SDave Chinner struct xfs_dir2_data_free *bf;
730ee641d5aSChristoph Hellwig int error;
731ee641d5aSChristoph Hellwig int i;
73230f712c9SDave Chinner
73330f712c9SDave Chinner /*
73430f712c9SDave Chinner * Get the buffer set up for the block.
73530f712c9SDave Chinner */
73630f712c9SDave Chinner error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, blkno),
7372911edb6SChristoph Hellwig &bp, XFS_DATA_FORK);
73830f712c9SDave Chinner if (error)
73930f712c9SDave Chinner return error;
74030f712c9SDave Chinner bp->b_ops = &xfs_dir3_data_buf_ops;
74130f712c9SDave Chinner xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_DATA_BUF);
74230f712c9SDave Chinner
74330f712c9SDave Chinner /*
74430f712c9SDave Chinner * Initialize the header.
74530f712c9SDave Chinner */
74630f712c9SDave Chinner hdr = bp->b_addr;
74738c26bfdSDave Chinner if (xfs_has_crc(mp)) {
74830f712c9SDave Chinner struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
74930f712c9SDave Chinner
75030f712c9SDave Chinner memset(hdr3, 0, sizeof(*hdr3));
75130f712c9SDave Chinner hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
7529343ee76SDave Chinner hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp));
75317a85dc6SDarrick J. Wong hdr3->owner = cpu_to_be64(args->owner);
754ce748eaaSEric Sandeen uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
75530f712c9SDave Chinner
75630f712c9SDave Chinner } else
75730f712c9SDave Chinner hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
75830f712c9SDave Chinner
7591848b607SChristoph Hellwig bf = xfs_dir2_data_bestfree_p(mp, hdr);
760d73e1ceeSChristoph Hellwig bf[0].offset = cpu_to_be16(geo->data_entry_offset);
761d73e1ceeSChristoph Hellwig bf[0].length = cpu_to_be16(geo->blksize - geo->data_entry_offset);
76230f712c9SDave Chinner for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
76330f712c9SDave Chinner bf[i].length = 0;
76430f712c9SDave Chinner bf[i].offset = 0;
76530f712c9SDave Chinner }
76630f712c9SDave Chinner
76730f712c9SDave Chinner /*
76830f712c9SDave Chinner * Set up an unused entry for the block's body.
76930f712c9SDave Chinner */
770d73e1ceeSChristoph Hellwig dup = bp->b_addr + geo->data_entry_offset;
77130f712c9SDave Chinner dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
772ee641d5aSChristoph Hellwig dup->length = bf[0].length;
77330f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
774ee641d5aSChristoph Hellwig
77530f712c9SDave Chinner /*
77630f712c9SDave Chinner * Log it and return it.
77730f712c9SDave Chinner */
77830f712c9SDave Chinner xfs_dir2_data_log_header(args, bp);
77930f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, dup);
78030f712c9SDave Chinner *bpp = bp;
78130f712c9SDave Chinner return 0;
78230f712c9SDave Chinner }
78330f712c9SDave Chinner
78430f712c9SDave Chinner /*
78530f712c9SDave Chinner * Log an active data entry from the block.
78630f712c9SDave Chinner */
78730f712c9SDave Chinner void
xfs_dir2_data_log_entry(struct xfs_da_args * args,struct xfs_buf * bp,xfs_dir2_data_entry_t * dep)78830f712c9SDave Chinner xfs_dir2_data_log_entry(
78930f712c9SDave Chinner struct xfs_da_args *args,
79030f712c9SDave Chinner struct xfs_buf *bp,
79130f712c9SDave Chinner xfs_dir2_data_entry_t *dep) /* data entry pointer */
79230f712c9SDave Chinner {
7937e8ae7bdSChristoph Hellwig struct xfs_mount *mp = bp->b_mount;
79430f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr = bp->b_addr;
79530f712c9SDave Chinner
79630f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
79730f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
79830f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
79930f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
80030f712c9SDave Chinner
80130f712c9SDave Chinner xfs_trans_log_buf(args->trans, bp, (uint)((char *)dep - (char *)hdr),
8027e8ae7bdSChristoph Hellwig (uint)((char *)(xfs_dir2_data_entry_tag_p(mp, dep) + 1) -
80330f712c9SDave Chinner (char *)hdr - 1));
80430f712c9SDave Chinner }
80530f712c9SDave Chinner
80630f712c9SDave Chinner /*
80730f712c9SDave Chinner * Log a data block header.
80830f712c9SDave Chinner */
80930f712c9SDave Chinner void
xfs_dir2_data_log_header(struct xfs_da_args * args,struct xfs_buf * bp)81030f712c9SDave Chinner xfs_dir2_data_log_header(
81130f712c9SDave Chinner struct xfs_da_args *args,
81230f712c9SDave Chinner struct xfs_buf *bp)
81330f712c9SDave Chinner {
81430f712c9SDave Chinner #ifdef DEBUG
81530f712c9SDave Chinner struct xfs_dir2_data_hdr *hdr = bp->b_addr;
81630f712c9SDave Chinner
81730f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
81830f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
81930f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
82030f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
82130f712c9SDave Chinner #endif
82230f712c9SDave Chinner
823d73e1ceeSChristoph Hellwig xfs_trans_log_buf(args->trans, bp, 0, args->geo->data_entry_offset - 1);
82430f712c9SDave Chinner }
82530f712c9SDave Chinner
82630f712c9SDave Chinner /*
82730f712c9SDave Chinner * Log a data unused entry.
82830f712c9SDave Chinner */
82930f712c9SDave Chinner void
xfs_dir2_data_log_unused(struct xfs_da_args * args,struct xfs_buf * bp,xfs_dir2_data_unused_t * dup)83030f712c9SDave Chinner xfs_dir2_data_log_unused(
83130f712c9SDave Chinner struct xfs_da_args *args,
83230f712c9SDave Chinner struct xfs_buf *bp,
83330f712c9SDave Chinner xfs_dir2_data_unused_t *dup) /* data unused pointer */
83430f712c9SDave Chinner {
83530f712c9SDave Chinner xfs_dir2_data_hdr_t *hdr = bp->b_addr;
83630f712c9SDave Chinner
83730f712c9SDave Chinner ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
83830f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
83930f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
84030f712c9SDave Chinner hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
84130f712c9SDave Chinner
84230f712c9SDave Chinner /*
84330f712c9SDave Chinner * Log the first part of the unused entry.
84430f712c9SDave Chinner */
84530f712c9SDave Chinner xfs_trans_log_buf(args->trans, bp, (uint)((char *)dup - (char *)hdr),
84630f712c9SDave Chinner (uint)((char *)&dup->length + sizeof(dup->length) -
84730f712c9SDave Chinner 1 - (char *)hdr));
84830f712c9SDave Chinner /*
84930f712c9SDave Chinner * Log the end (tag) of the unused entry.
85030f712c9SDave Chinner */
85130f712c9SDave Chinner xfs_trans_log_buf(args->trans, bp,
85230f712c9SDave Chinner (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),
85330f712c9SDave Chinner (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +
85430f712c9SDave Chinner sizeof(xfs_dir2_data_off_t) - 1));
85530f712c9SDave Chinner }
85630f712c9SDave Chinner
85730f712c9SDave Chinner /*
85830f712c9SDave Chinner * Make a byte range in the data block unused.
85930f712c9SDave Chinner * Its current contents are unimportant.
86030f712c9SDave Chinner */
86130f712c9SDave Chinner void
xfs_dir2_data_make_free(struct xfs_da_args * args,struct xfs_buf * bp,xfs_dir2_data_aoff_t offset,xfs_dir2_data_aoff_t len,int * needlogp,int * needscanp)86230f712c9SDave Chinner xfs_dir2_data_make_free(
86330f712c9SDave Chinner struct xfs_da_args *args,
86430f712c9SDave Chinner struct xfs_buf *bp,
86530f712c9SDave Chinner xfs_dir2_data_aoff_t offset, /* starting byte offset */
86630f712c9SDave Chinner xfs_dir2_data_aoff_t len, /* length in bytes */
86730f712c9SDave Chinner int *needlogp, /* out: log header */
86830f712c9SDave Chinner int *needscanp) /* out: regen bestfree */
86930f712c9SDave Chinner {
87030f712c9SDave Chinner xfs_dir2_data_hdr_t *hdr; /* data block pointer */
87130f712c9SDave Chinner xfs_dir2_data_free_t *dfp; /* bestfree pointer */
87230f712c9SDave Chinner int needscan; /* need to regen bestfree */
87330f712c9SDave Chinner xfs_dir2_data_unused_t *newdup; /* new unused entry */
87430f712c9SDave Chinner xfs_dir2_data_unused_t *postdup; /* unused entry after us */
87530f712c9SDave Chinner xfs_dir2_data_unused_t *prevdup; /* unused entry before us */
8765c072127SChristoph Hellwig unsigned int end;
87730f712c9SDave Chinner struct xfs_dir2_data_free *bf;
87830f712c9SDave Chinner
87930f712c9SDave Chinner hdr = bp->b_addr;
88030f712c9SDave Chinner
88130f712c9SDave Chinner /*
88230f712c9SDave Chinner * Figure out where the end of the data area is.
88330f712c9SDave Chinner */
8845c072127SChristoph Hellwig end = xfs_dir3_data_end_offset(args->geo, hdr);
8855c072127SChristoph Hellwig ASSERT(end != 0);
88630f712c9SDave Chinner
88730f712c9SDave Chinner /*
88830f712c9SDave Chinner * If this isn't the start of the block, then back up to
88930f712c9SDave Chinner * the previous entry and see if it's free.
89030f712c9SDave Chinner */
891d73e1ceeSChristoph Hellwig if (offset > args->geo->data_entry_offset) {
89230f712c9SDave Chinner __be16 *tagp; /* tag just before us */
89330f712c9SDave Chinner
89430f712c9SDave Chinner tagp = (__be16 *)((char *)hdr + offset) - 1;
89530f712c9SDave Chinner prevdup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
89630f712c9SDave Chinner if (be16_to_cpu(prevdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
89730f712c9SDave Chinner prevdup = NULL;
89830f712c9SDave Chinner } else
89930f712c9SDave Chinner prevdup = NULL;
90030f712c9SDave Chinner /*
90130f712c9SDave Chinner * If this isn't the end of the block, see if the entry after
90230f712c9SDave Chinner * us is free.
90330f712c9SDave Chinner */
9045c072127SChristoph Hellwig if (offset + len < end) {
90530f712c9SDave Chinner postdup =
90630f712c9SDave Chinner (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
90730f712c9SDave Chinner if (be16_to_cpu(postdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
90830f712c9SDave Chinner postdup = NULL;
90930f712c9SDave Chinner } else
91030f712c9SDave Chinner postdup = NULL;
91130f712c9SDave Chinner ASSERT(*needscanp == 0);
91230f712c9SDave Chinner needscan = 0;
91330f712c9SDave Chinner /*
91430f712c9SDave Chinner * Previous and following entries are both free,
91530f712c9SDave Chinner * merge everything into a single free entry.
91630f712c9SDave Chinner */
9171848b607SChristoph Hellwig bf = xfs_dir2_data_bestfree_p(args->dp->i_mount, hdr);
91830f712c9SDave Chinner if (prevdup && postdup) {
91930f712c9SDave Chinner xfs_dir2_data_free_t *dfp2; /* another bestfree pointer */
92030f712c9SDave Chinner
92130f712c9SDave Chinner /*
92230f712c9SDave Chinner * See if prevdup and/or postdup are in bestfree table.
92330f712c9SDave Chinner */
92430f712c9SDave Chinner dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
92530f712c9SDave Chinner dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
92630f712c9SDave Chinner /*
92730f712c9SDave Chinner * We need a rescan unless there are exactly 2 free entries
92830f712c9SDave Chinner * namely our two. Then we know what's happening, otherwise
92930f712c9SDave Chinner * since the third bestfree is there, there might be more
93030f712c9SDave Chinner * entries.
93130f712c9SDave Chinner */
93230f712c9SDave Chinner needscan = (bf[2].length != 0);
93330f712c9SDave Chinner /*
93430f712c9SDave Chinner * Fix up the new big freespace.
93530f712c9SDave Chinner */
93630f712c9SDave Chinner be16_add_cpu(&prevdup->length, len + be16_to_cpu(postdup->length));
93730f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(prevdup) =
93830f712c9SDave Chinner cpu_to_be16((char *)prevdup - (char *)hdr);
93930f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, prevdup);
94030f712c9SDave Chinner if (!needscan) {
94130f712c9SDave Chinner /*
94230f712c9SDave Chinner * Has to be the case that entries 0 and 1 are
94330f712c9SDave Chinner * dfp and dfp2 (don't know which is which), and
94430f712c9SDave Chinner * entry 2 is empty.
94530f712c9SDave Chinner * Remove entry 1 first then entry 0.
94630f712c9SDave Chinner */
94730f712c9SDave Chinner ASSERT(dfp && dfp2);
94830f712c9SDave Chinner if (dfp == &bf[1]) {
94930f712c9SDave Chinner dfp = &bf[0];
95030f712c9SDave Chinner ASSERT(dfp2 == dfp);
95130f712c9SDave Chinner dfp2 = &bf[1];
95230f712c9SDave Chinner }
95330f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
95430f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
95530f712c9SDave Chinner /*
95630f712c9SDave Chinner * Now insert the new entry.
95730f712c9SDave Chinner */
95830f712c9SDave Chinner dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
95930f712c9SDave Chinner needlogp);
96030f712c9SDave Chinner ASSERT(dfp == &bf[0]);
96130f712c9SDave Chinner ASSERT(dfp->length == prevdup->length);
96230f712c9SDave Chinner ASSERT(!dfp[1].length);
96330f712c9SDave Chinner ASSERT(!dfp[2].length);
96430f712c9SDave Chinner }
96530f712c9SDave Chinner }
96630f712c9SDave Chinner /*
96730f712c9SDave Chinner * The entry before us is free, merge with it.
96830f712c9SDave Chinner */
96930f712c9SDave Chinner else if (prevdup) {
97030f712c9SDave Chinner dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
97130f712c9SDave Chinner be16_add_cpu(&prevdup->length, len);
97230f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(prevdup) =
97330f712c9SDave Chinner cpu_to_be16((char *)prevdup - (char *)hdr);
97430f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, prevdup);
97530f712c9SDave Chinner /*
97630f712c9SDave Chinner * If the previous entry was in the table, the new entry
97730f712c9SDave Chinner * is longer, so it will be in the table too. Remove
97830f712c9SDave Chinner * the old one and add the new one.
97930f712c9SDave Chinner */
98030f712c9SDave Chinner if (dfp) {
98130f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
98230f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
98330f712c9SDave Chinner }
98430f712c9SDave Chinner /*
98530f712c9SDave Chinner * Otherwise we need a scan if the new entry is big enough.
98630f712c9SDave Chinner */
98730f712c9SDave Chinner else {
98830f712c9SDave Chinner needscan = be16_to_cpu(prevdup->length) >
98930f712c9SDave Chinner be16_to_cpu(bf[2].length);
99030f712c9SDave Chinner }
99130f712c9SDave Chinner }
99230f712c9SDave Chinner /*
99330f712c9SDave Chinner * The following entry is free, merge with it.
99430f712c9SDave Chinner */
99530f712c9SDave Chinner else if (postdup) {
99630f712c9SDave Chinner dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
99730f712c9SDave Chinner newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
99830f712c9SDave Chinner newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
99930f712c9SDave Chinner newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
100030f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup) =
100130f712c9SDave Chinner cpu_to_be16((char *)newdup - (char *)hdr);
100230f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup);
100330f712c9SDave Chinner /*
100430f712c9SDave Chinner * If the following entry was in the table, the new entry
100530f712c9SDave Chinner * is longer, so it will be in the table too. Remove
100630f712c9SDave Chinner * the old one and add the new one.
100730f712c9SDave Chinner */
100830f712c9SDave Chinner if (dfp) {
100930f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
101030f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
101130f712c9SDave Chinner }
101230f712c9SDave Chinner /*
101330f712c9SDave Chinner * Otherwise we need a scan if the new entry is big enough.
101430f712c9SDave Chinner */
101530f712c9SDave Chinner else {
101630f712c9SDave Chinner needscan = be16_to_cpu(newdup->length) >
101730f712c9SDave Chinner be16_to_cpu(bf[2].length);
101830f712c9SDave Chinner }
101930f712c9SDave Chinner }
102030f712c9SDave Chinner /*
102130f712c9SDave Chinner * Neither neighbor is free. Make a new entry.
102230f712c9SDave Chinner */
102330f712c9SDave Chinner else {
102430f712c9SDave Chinner newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
102530f712c9SDave Chinner newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
102630f712c9SDave Chinner newdup->length = cpu_to_be16(len);
102730f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup) =
102830f712c9SDave Chinner cpu_to_be16((char *)newdup - (char *)hdr);
102930f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup);
103030f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
103130f712c9SDave Chinner }
103230f712c9SDave Chinner *needscanp = needscan;
103330f712c9SDave Chinner }
103430f712c9SDave Chinner
10356915ef35SDarrick J. Wong /* Check our free data for obvious signs of corruption. */
10366915ef35SDarrick J. Wong static inline xfs_failaddr_t
xfs_dir2_data_check_free(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_unused * dup,xfs_dir2_data_aoff_t offset,xfs_dir2_data_aoff_t len)10376915ef35SDarrick J. Wong xfs_dir2_data_check_free(
10386915ef35SDarrick J. Wong struct xfs_dir2_data_hdr *hdr,
10396915ef35SDarrick J. Wong struct xfs_dir2_data_unused *dup,
10406915ef35SDarrick J. Wong xfs_dir2_data_aoff_t offset,
10416915ef35SDarrick J. Wong xfs_dir2_data_aoff_t len)
10426915ef35SDarrick J. Wong {
10436915ef35SDarrick J. Wong if (hdr->magic != cpu_to_be32(XFS_DIR2_DATA_MAGIC) &&
10446915ef35SDarrick J. Wong hdr->magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC) &&
10456915ef35SDarrick J. Wong hdr->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) &&
10466915ef35SDarrick J. Wong hdr->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))
10476915ef35SDarrick J. Wong return __this_address;
10486915ef35SDarrick J. Wong if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG)
10496915ef35SDarrick J. Wong return __this_address;
10506915ef35SDarrick J. Wong if (offset < (char *)dup - (char *)hdr)
10516915ef35SDarrick J. Wong return __this_address;
10526915ef35SDarrick J. Wong if (offset + len > (char *)dup + be16_to_cpu(dup->length) - (char *)hdr)
10536915ef35SDarrick J. Wong return __this_address;
10546915ef35SDarrick J. Wong if ((char *)dup - (char *)hdr !=
10556915ef35SDarrick J. Wong be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)))
10566915ef35SDarrick J. Wong return __this_address;
10576915ef35SDarrick J. Wong return NULL;
10586915ef35SDarrick J. Wong }
10596915ef35SDarrick J. Wong
10606915ef35SDarrick J. Wong /* Sanity-check a new bestfree entry. */
10616915ef35SDarrick J. Wong static inline xfs_failaddr_t
xfs_dir2_data_check_new_free(struct xfs_dir2_data_hdr * hdr,struct xfs_dir2_data_free * dfp,struct xfs_dir2_data_unused * newdup)10626915ef35SDarrick J. Wong xfs_dir2_data_check_new_free(
10636915ef35SDarrick J. Wong struct xfs_dir2_data_hdr *hdr,
10646915ef35SDarrick J. Wong struct xfs_dir2_data_free *dfp,
10656915ef35SDarrick J. Wong struct xfs_dir2_data_unused *newdup)
10666915ef35SDarrick J. Wong {
10676915ef35SDarrick J. Wong if (dfp == NULL)
10686915ef35SDarrick J. Wong return __this_address;
10696915ef35SDarrick J. Wong if (dfp->length != newdup->length)
10706915ef35SDarrick J. Wong return __this_address;
10716915ef35SDarrick J. Wong if (be16_to_cpu(dfp->offset) != (char *)newdup - (char *)hdr)
10726915ef35SDarrick J. Wong return __this_address;
10736915ef35SDarrick J. Wong return NULL;
10746915ef35SDarrick J. Wong }
10756915ef35SDarrick J. Wong
107630f712c9SDave Chinner /*
107730f712c9SDave Chinner * Take a byte range out of an existing unused space and make it un-free.
107830f712c9SDave Chinner */
10796915ef35SDarrick J. Wong int
xfs_dir2_data_use_free(struct xfs_da_args * args,struct xfs_buf * bp,xfs_dir2_data_unused_t * dup,xfs_dir2_data_aoff_t offset,xfs_dir2_data_aoff_t len,int * needlogp,int * needscanp)108030f712c9SDave Chinner xfs_dir2_data_use_free(
108130f712c9SDave Chinner struct xfs_da_args *args,
108230f712c9SDave Chinner struct xfs_buf *bp,
108330f712c9SDave Chinner xfs_dir2_data_unused_t *dup, /* unused entry */
108430f712c9SDave Chinner xfs_dir2_data_aoff_t offset, /* starting offset to use */
108530f712c9SDave Chinner xfs_dir2_data_aoff_t len, /* length to use */
108630f712c9SDave Chinner int *needlogp, /* out: need to log header */
108730f712c9SDave Chinner int *needscanp) /* out: need regen bestfree */
108830f712c9SDave Chinner {
108930f712c9SDave Chinner xfs_dir2_data_hdr_t *hdr; /* data block header */
109030f712c9SDave Chinner xfs_dir2_data_free_t *dfp; /* bestfree pointer */
10916915ef35SDarrick J. Wong xfs_dir2_data_unused_t *newdup; /* new unused entry */
10926915ef35SDarrick J. Wong xfs_dir2_data_unused_t *newdup2; /* another new unused entry */
10936915ef35SDarrick J. Wong struct xfs_dir2_data_free *bf;
10946915ef35SDarrick J. Wong xfs_failaddr_t fa;
109530f712c9SDave Chinner int matchback; /* matches end of freespace */
109630f712c9SDave Chinner int matchfront; /* matches start of freespace */
109730f712c9SDave Chinner int needscan; /* need to regen bestfree */
109830f712c9SDave Chinner int oldlen; /* old unused entry's length */
109930f712c9SDave Chinner
110030f712c9SDave Chinner hdr = bp->b_addr;
11016915ef35SDarrick J. Wong fa = xfs_dir2_data_check_free(hdr, dup, offset, len);
11026915ef35SDarrick J. Wong if (fa)
11036915ef35SDarrick J. Wong goto corrupt;
110430f712c9SDave Chinner /*
110530f712c9SDave Chinner * Look up the entry in the bestfree table.
110630f712c9SDave Chinner */
110730f712c9SDave Chinner oldlen = be16_to_cpu(dup->length);
11081848b607SChristoph Hellwig bf = xfs_dir2_data_bestfree_p(args->dp->i_mount, hdr);
110930f712c9SDave Chinner dfp = xfs_dir2_data_freefind(hdr, bf, dup);
111030f712c9SDave Chinner ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
111130f712c9SDave Chinner /*
111230f712c9SDave Chinner * Check for alignment with front and back of the entry.
111330f712c9SDave Chinner */
111430f712c9SDave Chinner matchfront = (char *)dup - (char *)hdr == offset;
111530f712c9SDave Chinner matchback = (char *)dup + oldlen - (char *)hdr == offset + len;
111630f712c9SDave Chinner ASSERT(*needscanp == 0);
111730f712c9SDave Chinner needscan = 0;
111830f712c9SDave Chinner /*
111930f712c9SDave Chinner * If we matched it exactly we just need to get rid of it from
112030f712c9SDave Chinner * the bestfree table.
112130f712c9SDave Chinner */
112230f712c9SDave Chinner if (matchfront && matchback) {
112330f712c9SDave Chinner if (dfp) {
112430f712c9SDave Chinner needscan = (bf[2].offset != 0);
112530f712c9SDave Chinner if (!needscan)
112630f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp,
112730f712c9SDave Chinner needlogp);
112830f712c9SDave Chinner }
112930f712c9SDave Chinner }
113030f712c9SDave Chinner /*
113130f712c9SDave Chinner * We match the first part of the entry.
113230f712c9SDave Chinner * Make a new entry with the remaining freespace.
113330f712c9SDave Chinner */
113430f712c9SDave Chinner else if (matchfront) {
113530f712c9SDave Chinner newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
113630f712c9SDave Chinner newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
113730f712c9SDave Chinner newdup->length = cpu_to_be16(oldlen - len);
113830f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup) =
113930f712c9SDave Chinner cpu_to_be16((char *)newdup - (char *)hdr);
114030f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup);
114130f712c9SDave Chinner /*
114230f712c9SDave Chinner * If it was in the table, remove it and add the new one.
114330f712c9SDave Chinner */
114430f712c9SDave Chinner if (dfp) {
114530f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
114630f712c9SDave Chinner dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
114730f712c9SDave Chinner needlogp);
11486915ef35SDarrick J. Wong fa = xfs_dir2_data_check_new_free(hdr, dfp, newdup);
11496915ef35SDarrick J. Wong if (fa)
11506915ef35SDarrick J. Wong goto corrupt;
115130f712c9SDave Chinner /*
115230f712c9SDave Chinner * If we got inserted at the last slot,
115330f712c9SDave Chinner * that means we don't know if there was a better
115430f712c9SDave Chinner * choice for the last slot, or not. Rescan.
115530f712c9SDave Chinner */
115630f712c9SDave Chinner needscan = dfp == &bf[2];
115730f712c9SDave Chinner }
115830f712c9SDave Chinner }
115930f712c9SDave Chinner /*
116030f712c9SDave Chinner * We match the last part of the entry.
116130f712c9SDave Chinner * Trim the allocated space off the tail of the entry.
116230f712c9SDave Chinner */
116330f712c9SDave Chinner else if (matchback) {
116430f712c9SDave Chinner newdup = dup;
116530f712c9SDave Chinner newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
116630f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup) =
116730f712c9SDave Chinner cpu_to_be16((char *)newdup - (char *)hdr);
116830f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup);
116930f712c9SDave Chinner /*
117030f712c9SDave Chinner * If it was in the table, remove it and add the new one.
117130f712c9SDave Chinner */
117230f712c9SDave Chinner if (dfp) {
117330f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
117430f712c9SDave Chinner dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
117530f712c9SDave Chinner needlogp);
11766915ef35SDarrick J. Wong fa = xfs_dir2_data_check_new_free(hdr, dfp, newdup);
11776915ef35SDarrick J. Wong if (fa)
11786915ef35SDarrick J. Wong goto corrupt;
117930f712c9SDave Chinner /*
118030f712c9SDave Chinner * If we got inserted at the last slot,
118130f712c9SDave Chinner * that means we don't know if there was a better
118230f712c9SDave Chinner * choice for the last slot, or not. Rescan.
118330f712c9SDave Chinner */
118430f712c9SDave Chinner needscan = dfp == &bf[2];
118530f712c9SDave Chinner }
118630f712c9SDave Chinner }
118730f712c9SDave Chinner /*
118830f712c9SDave Chinner * Poking out the middle of an entry.
118930f712c9SDave Chinner * Make two new entries.
119030f712c9SDave Chinner */
119130f712c9SDave Chinner else {
119230f712c9SDave Chinner newdup = dup;
119330f712c9SDave Chinner newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
119430f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup) =
119530f712c9SDave Chinner cpu_to_be16((char *)newdup - (char *)hdr);
119630f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup);
119730f712c9SDave Chinner newdup2 = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
119830f712c9SDave Chinner newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
119930f712c9SDave Chinner newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));
120030f712c9SDave Chinner *xfs_dir2_data_unused_tag_p(newdup2) =
120130f712c9SDave Chinner cpu_to_be16((char *)newdup2 - (char *)hdr);
120230f712c9SDave Chinner xfs_dir2_data_log_unused(args, bp, newdup2);
120330f712c9SDave Chinner /*
120430f712c9SDave Chinner * If the old entry was in the table, we need to scan
120530f712c9SDave Chinner * if the 3rd entry was valid, since these entries
120630f712c9SDave Chinner * are smaller than the old one.
120730f712c9SDave Chinner * If we don't need to scan that means there were 1 or 2
120830f712c9SDave Chinner * entries in the table, and removing the old and adding
120930f712c9SDave Chinner * the 2 new will work.
121030f712c9SDave Chinner */
121130f712c9SDave Chinner if (dfp) {
121230f712c9SDave Chinner needscan = (bf[2].length != 0);
121330f712c9SDave Chinner if (!needscan) {
121430f712c9SDave Chinner xfs_dir2_data_freeremove(hdr, bf, dfp,
121530f712c9SDave Chinner needlogp);
121630f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, newdup,
121730f712c9SDave Chinner needlogp);
121830f712c9SDave Chinner xfs_dir2_data_freeinsert(hdr, bf, newdup2,
121930f712c9SDave Chinner needlogp);
122030f712c9SDave Chinner }
122130f712c9SDave Chinner }
122230f712c9SDave Chinner }
122330f712c9SDave Chinner *needscanp = needscan;
12246915ef35SDarrick J. Wong return 0;
12256915ef35SDarrick J. Wong corrupt:
12266915ef35SDarrick J. Wong xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, args->dp->i_mount,
12272551a530SDarrick J. Wong hdr, sizeof(*hdr), __FILE__, __LINE__, fa);
1228ca14c096SDarrick J. Wong xfs_da_mark_sick(args);
12296915ef35SDarrick J. Wong return -EFSCORRUPTED;
123030f712c9SDave Chinner }
1231ce92d29dSDarrick J. Wong
1232ce92d29dSDarrick J. Wong /* Find the end of the entry data in a data/block format dir block. */
12335c072127SChristoph Hellwig unsigned int
xfs_dir3_data_end_offset(struct xfs_da_geometry * geo,struct xfs_dir2_data_hdr * hdr)12345c072127SChristoph Hellwig xfs_dir3_data_end_offset(
1235ce92d29dSDarrick J. Wong struct xfs_da_geometry *geo,
1236ce92d29dSDarrick J. Wong struct xfs_dir2_data_hdr *hdr)
1237ce92d29dSDarrick J. Wong {
12385c072127SChristoph Hellwig void *p;
12395c072127SChristoph Hellwig
1240ce92d29dSDarrick J. Wong switch (hdr->magic) {
1241ce92d29dSDarrick J. Wong case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
1242ce92d29dSDarrick J. Wong case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
12435c072127SChristoph Hellwig p = xfs_dir2_block_leaf_p(xfs_dir2_block_tail_p(geo, hdr));
12445c072127SChristoph Hellwig return p - (void *)hdr;
1245ce92d29dSDarrick J. Wong case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
1246ce92d29dSDarrick J. Wong case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
12475c072127SChristoph Hellwig return geo->blksize;
1248ce92d29dSDarrick J. Wong default:
12495c072127SChristoph Hellwig return 0;
1250ce92d29dSDarrick J. Wong }
1251ce92d29dSDarrick J. Wong }
1252