10b61f8a4SDave Chinner // SPDX-License-Identifier: GPL-2.0
230f712c9SDave Chinner /*
330f712c9SDave Chinner * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
430f712c9SDave Chinner * All Rights Reserved.
530f712c9SDave Chinner */
630f712c9SDave Chinner #include "xfs.h"
730f712c9SDave Chinner #include "xfs_fs.h"
85467b34bSDarrick J. Wong #include "xfs_shared.h"
930f712c9SDave Chinner #include "xfs_format.h"
1030f712c9SDave Chinner #include "xfs_log_format.h"
1130f712c9SDave Chinner #include "xfs_trans_resv.h"
1230f712c9SDave Chinner #include "xfs_mount.h"
1330f712c9SDave Chinner #include "xfs_inode.h"
1430f712c9SDave Chinner #include "xfs_trans.h"
1530f712c9SDave Chinner #include "xfs_bmap.h"
1630f712c9SDave Chinner #include "xfs_dir2.h"
1730f712c9SDave Chinner #include "xfs_dir2_priv.h"
18e9e899a2SDarrick J. Wong #include "xfs_errortag.h"
1930f712c9SDave Chinner #include "xfs_error.h"
2030f712c9SDave Chinner #include "xfs_trace.h"
2130f712c9SDave Chinner
22744e6c8aSDarrick J. Wong const struct xfs_name xfs_name_dotdot = {
23744e6c8aSDarrick J. Wong .name = (const unsigned char *)"..",
24744e6c8aSDarrick J. Wong .len = 2,
25744e6c8aSDarrick J. Wong .type = XFS_DIR3_FT_DIR,
26744e6c8aSDarrick J. Wong };
2730f712c9SDave Chinner
281b767ee3SDave Chinner /*
291fc4d33fSAmir Goldstein * Convert inode mode to directory entry filetype
301b767ee3SDave Chinner */
31a5c46e5eSDarrick J. Wong unsigned char
xfs_mode_to_ftype(int mode)32a5c46e5eSDarrick J. Wong xfs_mode_to_ftype(
33a5c46e5eSDarrick J. Wong int mode)
341fc4d33fSAmir Goldstein {
351fc4d33fSAmir Goldstein switch (mode & S_IFMT) {
361fc4d33fSAmir Goldstein case S_IFREG:
371fc4d33fSAmir Goldstein return XFS_DIR3_FT_REG_FILE;
381fc4d33fSAmir Goldstein case S_IFDIR:
391fc4d33fSAmir Goldstein return XFS_DIR3_FT_DIR;
401fc4d33fSAmir Goldstein case S_IFCHR:
411fc4d33fSAmir Goldstein return XFS_DIR3_FT_CHRDEV;
421fc4d33fSAmir Goldstein case S_IFBLK:
431fc4d33fSAmir Goldstein return XFS_DIR3_FT_BLKDEV;
441fc4d33fSAmir Goldstein case S_IFIFO:
451fc4d33fSAmir Goldstein return XFS_DIR3_FT_FIFO;
461fc4d33fSAmir Goldstein case S_IFSOCK:
471fc4d33fSAmir Goldstein return XFS_DIR3_FT_SOCK;
481fc4d33fSAmir Goldstein case S_IFLNK:
491fc4d33fSAmir Goldstein return XFS_DIR3_FT_SYMLINK;
501fc4d33fSAmir Goldstein default:
511fc4d33fSAmir Goldstein return XFS_DIR3_FT_UNKNOWN;
521fc4d33fSAmir Goldstein }
531fc4d33fSAmir Goldstein }
5430f712c9SDave Chinner
5530f712c9SDave Chinner /*
5630f712c9SDave Chinner * ASCII case-insensitive (ie. A-Z) support for directories that was
5730f712c9SDave Chinner * used in IRIX.
5830f712c9SDave Chinner */
59d8d11fc7SChristoph Hellwig xfs_dahash_t
xfs_ascii_ci_hashname(const struct xfs_name * name)6030f712c9SDave Chinner xfs_ascii_ci_hashname(
61996b2329SDarrick J. Wong const struct xfs_name *name)
6230f712c9SDave Chinner {
6330f712c9SDave Chinner xfs_dahash_t hash;
6430f712c9SDave Chinner int i;
6530f712c9SDave Chinner
6630f712c9SDave Chinner for (i = 0, hash = 0; i < name->len; i++)
67*a9248538SDarrick J. Wong hash = xfs_ascii_ci_xfrm(name->name[i]) ^ rol32(hash, 7);
6830f712c9SDave Chinner
6930f712c9SDave Chinner return hash;
7030f712c9SDave Chinner }
7130f712c9SDave Chinner
72d8d11fc7SChristoph Hellwig enum xfs_dacmp
xfs_ascii_ci_compname(struct xfs_da_args * args,const unsigned char * name,int len)7330f712c9SDave Chinner xfs_ascii_ci_compname(
7430f712c9SDave Chinner struct xfs_da_args *args,
7530f712c9SDave Chinner const unsigned char *name,
7630f712c9SDave Chinner int len)
7730f712c9SDave Chinner {
7830f712c9SDave Chinner enum xfs_dacmp result;
7930f712c9SDave Chinner int i;
8030f712c9SDave Chinner
8130f712c9SDave Chinner if (args->namelen != len)
8230f712c9SDave Chinner return XFS_CMP_DIFFERENT;
8330f712c9SDave Chinner
8430f712c9SDave Chinner result = XFS_CMP_EXACT;
8530f712c9SDave Chinner for (i = 0; i < len; i++) {
8630f712c9SDave Chinner if (args->name[i] == name[i])
8730f712c9SDave Chinner continue;
88*a9248538SDarrick J. Wong if (xfs_ascii_ci_xfrm(args->name[i]) !=
89*a9248538SDarrick J. Wong xfs_ascii_ci_xfrm(name[i]))
9030f712c9SDave Chinner return XFS_CMP_DIFFERENT;
9130f712c9SDave Chinner result = XFS_CMP_CASE;
9230f712c9SDave Chinner }
9330f712c9SDave Chinner
9430f712c9SDave Chinner return result;
9530f712c9SDave Chinner }
9630f712c9SDave Chinner
9730f712c9SDave Chinner int
xfs_da_mount(struct xfs_mount * mp)9830f712c9SDave Chinner xfs_da_mount(
9930f712c9SDave Chinner struct xfs_mount *mp)
10030f712c9SDave Chinner {
10130f712c9SDave Chinner struct xfs_da_geometry *dageo;
10230f712c9SDave Chinner
10330f712c9SDave Chinner
10430f712c9SDave Chinner ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
105ac503a4cSDarrick J. Wong ASSERT(xfs_dir2_dirblock_bytes(&mp->m_sb) <= XFS_MAX_BLOCKSIZE);
10630f712c9SDave Chinner
10730f712c9SDave Chinner mp->m_dir_geo = kmem_zalloc(sizeof(struct xfs_da_geometry),
108707e0ddaSTetsuo Handa KM_MAYFAIL);
10930f712c9SDave Chinner mp->m_attr_geo = kmem_zalloc(sizeof(struct xfs_da_geometry),
110707e0ddaSTetsuo Handa KM_MAYFAIL);
11130f712c9SDave Chinner if (!mp->m_dir_geo || !mp->m_attr_geo) {
11230f712c9SDave Chinner kmem_free(mp->m_dir_geo);
11330f712c9SDave Chinner kmem_free(mp->m_attr_geo);
1142451337dSDave Chinner return -ENOMEM;
11530f712c9SDave Chinner }
11630f712c9SDave Chinner
11730f712c9SDave Chinner /* set up directory geometry */
11830f712c9SDave Chinner dageo = mp->m_dir_geo;
11930f712c9SDave Chinner dageo->blklog = mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog;
12030f712c9SDave Chinner dageo->fsblog = mp->m_sb.sb_blocklog;
121ac503a4cSDarrick J. Wong dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb);
12230f712c9SDave Chinner dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog;
123ebd9027dSDave Chinner if (xfs_has_crc(mp)) {
1243b344413SChristoph Hellwig dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr);
125545910bcSChristoph Hellwig dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr);
126ed1d612fSChristoph Hellwig dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr);
127d73e1ceeSChristoph Hellwig dageo->data_entry_offset =
128d73e1ceeSChristoph Hellwig sizeof(struct xfs_dir3_data_hdr);
129545910bcSChristoph Hellwig } else {
1303b344413SChristoph Hellwig dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr);
131545910bcSChristoph Hellwig dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr);
132ed1d612fSChristoph Hellwig dageo->free_hdr_size = sizeof(struct xfs_dir2_free_hdr);
133d73e1ceeSChristoph Hellwig dageo->data_entry_offset =
134d73e1ceeSChristoph Hellwig sizeof(struct xfs_dir2_data_hdr);
135545910bcSChristoph Hellwig }
136478c7835SChristoph Hellwig dageo->leaf_max_ents = (dageo->blksize - dageo->leaf_hdr_size) /
137478c7835SChristoph Hellwig sizeof(struct xfs_dir2_leaf_entry);
1385893e4feSChristoph Hellwig dageo->free_max_bests = (dageo->blksize - dageo->free_hdr_size) /
1395893e4feSChristoph Hellwig sizeof(xfs_dir2_data_off_t);
14030f712c9SDave Chinner
141d73e1ceeSChristoph Hellwig dageo->data_first_offset = dageo->data_entry_offset +
142d73e1ceeSChristoph Hellwig xfs_dir2_data_entsize(mp, 1) +
143d73e1ceeSChristoph Hellwig xfs_dir2_data_entsize(mp, 2);
144d73e1ceeSChristoph Hellwig
14530f712c9SDave Chinner /*
14630f712c9SDave Chinner * Now we've set up the block conversion variables, we can calculate the
14730f712c9SDave Chinner * segment block constants using the geometry structure.
14830f712c9SDave Chinner */
14930f712c9SDave Chinner dageo->datablk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_DATA_OFFSET);
15030f712c9SDave Chinner dageo->leafblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_LEAF_OFFSET);
15130f712c9SDave Chinner dageo->freeblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_FREE_OFFSET);
1523b344413SChristoph Hellwig dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) /
15330f712c9SDave Chinner (uint)sizeof(xfs_da_node_entry_t);
15483a21c18SChandan Babu R dageo->max_extents = (XFS_DIR2_MAX_SPACES * XFS_DIR2_SPACE_SIZE) >>
15583a21c18SChandan Babu R mp->m_sb.sb_blocklog;
15630f712c9SDave Chinner dageo->magicpct = (dageo->blksize * 37) / 100;
15730f712c9SDave Chinner
15830f712c9SDave Chinner /* set up attribute geometry - single fsb only */
15930f712c9SDave Chinner dageo = mp->m_attr_geo;
16030f712c9SDave Chinner dageo->blklog = mp->m_sb.sb_blocklog;
16130f712c9SDave Chinner dageo->fsblog = mp->m_sb.sb_blocklog;
16230f712c9SDave Chinner dageo->blksize = 1 << dageo->blklog;
16330f712c9SDave Chinner dageo->fsbcount = 1;
1643b344413SChristoph Hellwig dageo->node_hdr_size = mp->m_dir_geo->node_hdr_size;
1653b344413SChristoph Hellwig dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) /
16630f712c9SDave Chinner (uint)sizeof(xfs_da_node_entry_t);
16783a21c18SChandan Babu R
16883a21c18SChandan Babu R if (xfs_has_large_extent_counts(mp))
16983a21c18SChandan Babu R dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_LARGE;
17083a21c18SChandan Babu R else
17183a21c18SChandan Babu R dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_SMALL;
17283a21c18SChandan Babu R
17330f712c9SDave Chinner dageo->magicpct = (dageo->blksize * 37) / 100;
17430f712c9SDave Chinner return 0;
17530f712c9SDave Chinner }
17630f712c9SDave Chinner
17730f712c9SDave Chinner void
xfs_da_unmount(struct xfs_mount * mp)17830f712c9SDave Chinner xfs_da_unmount(
17930f712c9SDave Chinner struct xfs_mount *mp)
18030f712c9SDave Chinner {
18130f712c9SDave Chinner kmem_free(mp->m_dir_geo);
18230f712c9SDave Chinner kmem_free(mp->m_attr_geo);
18330f712c9SDave Chinner }
18430f712c9SDave Chinner
18530f712c9SDave Chinner /*
18630f712c9SDave Chinner * Return 1 if directory contains only "." and "..".
18730f712c9SDave Chinner */
18830f712c9SDave Chinner int
xfs_dir_isempty(xfs_inode_t * dp)18930f712c9SDave Chinner xfs_dir_isempty(
19030f712c9SDave Chinner xfs_inode_t *dp)
19130f712c9SDave Chinner {
19230f712c9SDave Chinner xfs_dir2_sf_hdr_t *sfp;
19330f712c9SDave Chinner
194c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
19513d2c10bSChristoph Hellwig if (dp->i_disk_size == 0) /* might happen during shutdown. */
19630f712c9SDave Chinner return 1;
197c01147d9SDarrick J. Wong if (dp->i_disk_size > xfs_inode_data_fork_size(dp))
19830f712c9SDave Chinner return 0;
19930f712c9SDave Chinner sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
20030f712c9SDave Chinner return !sfp->count;
20130f712c9SDave Chinner }
20230f712c9SDave Chinner
20330f712c9SDave Chinner /*
20430f712c9SDave Chinner * Validate a given inode number.
20530f712c9SDave Chinner */
20630f712c9SDave Chinner int
xfs_dir_ino_validate(xfs_mount_t * mp,xfs_ino_t ino)20730f712c9SDave Chinner xfs_dir_ino_validate(
20830f712c9SDave Chinner xfs_mount_t *mp,
20930f712c9SDave Chinner xfs_ino_t ino)
21030f712c9SDave Chinner {
21191fb9afcSDarrick J. Wong bool ino_ok = xfs_verify_dir_ino(mp, ino);
21230f712c9SDave Chinner
213a71895c5SDarrick J. Wong if (XFS_IS_CORRUPT(mp, !ino_ok) ||
214a71895c5SDarrick J. Wong XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) {
21530f712c9SDave Chinner xfs_warn(mp, "Invalid inode number 0x%Lx",
21630f712c9SDave Chinner (unsigned long long) ino);
2172451337dSDave Chinner return -EFSCORRUPTED;
21830f712c9SDave Chinner }
21930f712c9SDave Chinner return 0;
22030f712c9SDave Chinner }
22130f712c9SDave Chinner
22230f712c9SDave Chinner /*
22330f712c9SDave Chinner * Initialize a directory with its "." and ".." entries.
22430f712c9SDave Chinner */
22530f712c9SDave Chinner int
xfs_dir_init(xfs_trans_t * tp,xfs_inode_t * dp,xfs_inode_t * pdp)22630f712c9SDave Chinner xfs_dir_init(
22730f712c9SDave Chinner xfs_trans_t *tp,
22830f712c9SDave Chinner xfs_inode_t *dp,
22930f712c9SDave Chinner xfs_inode_t *pdp)
23030f712c9SDave Chinner {
23130f712c9SDave Chinner struct xfs_da_args *args;
23230f712c9SDave Chinner int error;
23330f712c9SDave Chinner
234c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
23530f712c9SDave Chinner error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino);
23630f712c9SDave Chinner if (error)
23730f712c9SDave Chinner return error;
23830f712c9SDave Chinner
239707e0ddaSTetsuo Handa args = kmem_zalloc(sizeof(*args), KM_NOFS);
24030f712c9SDave Chinner if (!args)
2412451337dSDave Chinner return -ENOMEM;
24230f712c9SDave Chinner
24330f712c9SDave Chinner args->geo = dp->i_mount->m_dir_geo;
24430f712c9SDave Chinner args->dp = dp;
24530f712c9SDave Chinner args->trans = tp;
24630f712c9SDave Chinner error = xfs_dir2_sf_create(args, pdp->i_ino);
24730f712c9SDave Chinner kmem_free(args);
24830f712c9SDave Chinner return error;
24930f712c9SDave Chinner }
25030f712c9SDave Chinner
25130f712c9SDave Chinner /*
252b16ed7c1SEric Sandeen * Enter a name in a directory, or check for available space.
253b16ed7c1SEric Sandeen * If inum is 0, only the available space test is performed.
25430f712c9SDave Chinner */
25530f712c9SDave Chinner int
xfs_dir_createname(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t inum,xfs_extlen_t total)25630f712c9SDave Chinner xfs_dir_createname(
25732a9b7c6SBrian Foster struct xfs_trans *tp,
25832a9b7c6SBrian Foster struct xfs_inode *dp,
259996b2329SDarrick J. Wong const struct xfs_name *name,
26030f712c9SDave Chinner xfs_ino_t inum, /* new entry inode number */
26130f712c9SDave Chinner xfs_extlen_t total) /* bmap's total block count */
26230f712c9SDave Chinner {
26330f712c9SDave Chinner struct xfs_da_args *args;
26430f712c9SDave Chinner int rval;
265c098576fSShida Zhang bool v;
26630f712c9SDave Chinner
267c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
268c9cfdb38SBrian Foster
269b16ed7c1SEric Sandeen if (inum) {
27030f712c9SDave Chinner rval = xfs_dir_ino_validate(tp->t_mountp, inum);
27130f712c9SDave Chinner if (rval)
27230f712c9SDave Chinner return rval;
273ff6d6af2SBill O'Donnell XFS_STATS_INC(dp->i_mount, xs_dir_create);
274b16ed7c1SEric Sandeen }
27530f712c9SDave Chinner
276707e0ddaSTetsuo Handa args = kmem_zalloc(sizeof(*args), KM_NOFS);
27730f712c9SDave Chinner if (!args)
2782451337dSDave Chinner return -ENOMEM;
27930f712c9SDave Chinner
28030f712c9SDave Chinner args->geo = dp->i_mount->m_dir_geo;
28130f712c9SDave Chinner args->name = name->name;
28230f712c9SDave Chinner args->namelen = name->len;
28330f712c9SDave Chinner args->filetype = name->type;
284d8d11fc7SChristoph Hellwig args->hashval = xfs_dir2_hashname(dp->i_mount, name);
28530f712c9SDave Chinner args->inumber = inum;
28630f712c9SDave Chinner args->dp = dp;
28730f712c9SDave Chinner args->total = total;
28830f712c9SDave Chinner args->whichfork = XFS_DATA_FORK;
28930f712c9SDave Chinner args->trans = tp;
29030f712c9SDave Chinner args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
291b16ed7c1SEric Sandeen if (!inum)
292b16ed7c1SEric Sandeen args->op_flags |= XFS_DA_OP_JUSTCHECK;
29330f712c9SDave Chinner
294f7e67b20SChristoph Hellwig if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
29530f712c9SDave Chinner rval = xfs_dir2_sf_addname(args);
29630f712c9SDave Chinner goto out_free;
29730f712c9SDave Chinner }
29830f712c9SDave Chinner
29930f712c9SDave Chinner rval = xfs_dir2_isblock(args, &v);
30030f712c9SDave Chinner if (rval)
30130f712c9SDave Chinner goto out_free;
30230f712c9SDave Chinner if (v) {
30330f712c9SDave Chinner rval = xfs_dir2_block_addname(args);
30430f712c9SDave Chinner goto out_free;
30530f712c9SDave Chinner }
30630f712c9SDave Chinner
30730f712c9SDave Chinner rval = xfs_dir2_isleaf(args, &v);
30830f712c9SDave Chinner if (rval)
30930f712c9SDave Chinner goto out_free;
31030f712c9SDave Chinner if (v)
31130f712c9SDave Chinner rval = xfs_dir2_leaf_addname(args);
31230f712c9SDave Chinner else
31330f712c9SDave Chinner rval = xfs_dir2_node_addname(args);
31430f712c9SDave Chinner
31530f712c9SDave Chinner out_free:
31630f712c9SDave Chinner kmem_free(args);
31730f712c9SDave Chinner return rval;
31830f712c9SDave Chinner }
31930f712c9SDave Chinner
32030f712c9SDave Chinner /*
32130f712c9SDave Chinner * If doing a CI lookup and case-insensitive match, dup actual name into
32230f712c9SDave Chinner * args.value. Return EEXIST for success (ie. name found) or an error.
32330f712c9SDave Chinner */
32430f712c9SDave Chinner int
xfs_dir_cilookup_result(struct xfs_da_args * args,const unsigned char * name,int len)32530f712c9SDave Chinner xfs_dir_cilookup_result(
32630f712c9SDave Chinner struct xfs_da_args *args,
32730f712c9SDave Chinner const unsigned char *name,
32830f712c9SDave Chinner int len)
32930f712c9SDave Chinner {
33030f712c9SDave Chinner if (args->cmpresult == XFS_CMP_DIFFERENT)
3312451337dSDave Chinner return -ENOENT;
33230f712c9SDave Chinner if (args->cmpresult != XFS_CMP_CASE ||
33330f712c9SDave Chinner !(args->op_flags & XFS_DA_OP_CILOOKUP))
3342451337dSDave Chinner return -EEXIST;
33530f712c9SDave Chinner
33630f712c9SDave Chinner args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL);
33730f712c9SDave Chinner if (!args->value)
3382451337dSDave Chinner return -ENOMEM;
33930f712c9SDave Chinner
34030f712c9SDave Chinner memcpy(args->value, name, len);
34130f712c9SDave Chinner args->valuelen = len;
3422451337dSDave Chinner return -EEXIST;
34330f712c9SDave Chinner }
34430f712c9SDave Chinner
34530f712c9SDave Chinner /*
34630f712c9SDave Chinner * Lookup a name in a directory, give back the inode number.
34730f712c9SDave Chinner * If ci_name is not NULL, returns the actual name in ci_name if it differs
34830f712c9SDave Chinner * to name, or ci_name->name is set to NULL for an exact match.
34930f712c9SDave Chinner */
35030f712c9SDave Chinner
35130f712c9SDave Chinner int
xfs_dir_lookup(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t * inum,struct xfs_name * ci_name)35230f712c9SDave Chinner xfs_dir_lookup(
353996b2329SDarrick J. Wong struct xfs_trans *tp,
354996b2329SDarrick J. Wong struct xfs_inode *dp,
355996b2329SDarrick J. Wong const struct xfs_name *name,
35630f712c9SDave Chinner xfs_ino_t *inum, /* out: inode number */
35730f712c9SDave Chinner struct xfs_name *ci_name) /* out: actual name if CI match */
35830f712c9SDave Chinner {
35930f712c9SDave Chinner struct xfs_da_args *args;
36030f712c9SDave Chinner int rval;
361c098576fSShida Zhang bool v;
362dbad7c99SDave Chinner int lock_mode;
36330f712c9SDave Chinner
364c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
365ff6d6af2SBill O'Donnell XFS_STATS_INC(dp->i_mount, xs_dir_lookup);
36630f712c9SDave Chinner
36730f712c9SDave Chinner /*
36830f712c9SDave Chinner * We need to use KM_NOFS here so that lockdep will not throw false
36930f712c9SDave Chinner * positive deadlock warnings on a non-transactional lookup path. It is
37030f712c9SDave Chinner * safe to recurse into inode recalim in that case, but lockdep can't
37130f712c9SDave Chinner * easily be taught about it. Hence KM_NOFS avoids having to add more
37230f712c9SDave Chinner * lockdep Doing this avoids having to add a bunch of lockdep class
37330f712c9SDave Chinner * annotations into the reclaim path for the ilock.
37430f712c9SDave Chinner */
375707e0ddaSTetsuo Handa args = kmem_zalloc(sizeof(*args), KM_NOFS);
37630f712c9SDave Chinner args->geo = dp->i_mount->m_dir_geo;
37730f712c9SDave Chinner args->name = name->name;
37830f712c9SDave Chinner args->namelen = name->len;
37930f712c9SDave Chinner args->filetype = name->type;
380d8d11fc7SChristoph Hellwig args->hashval = xfs_dir2_hashname(dp->i_mount, name);
38130f712c9SDave Chinner args->dp = dp;
38230f712c9SDave Chinner args->whichfork = XFS_DATA_FORK;
38330f712c9SDave Chinner args->trans = tp;
38430f712c9SDave Chinner args->op_flags = XFS_DA_OP_OKNOENT;
38530f712c9SDave Chinner if (ci_name)
38630f712c9SDave Chinner args->op_flags |= XFS_DA_OP_CILOOKUP;
38730f712c9SDave Chinner
388dbad7c99SDave Chinner lock_mode = xfs_ilock_data_map_shared(dp);
389f7e67b20SChristoph Hellwig if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
39030f712c9SDave Chinner rval = xfs_dir2_sf_lookup(args);
39130f712c9SDave Chinner goto out_check_rval;
39230f712c9SDave Chinner }
39330f712c9SDave Chinner
39430f712c9SDave Chinner rval = xfs_dir2_isblock(args, &v);
39530f712c9SDave Chinner if (rval)
39630f712c9SDave Chinner goto out_free;
39730f712c9SDave Chinner if (v) {
39830f712c9SDave Chinner rval = xfs_dir2_block_lookup(args);
39930f712c9SDave Chinner goto out_check_rval;
40030f712c9SDave Chinner }
40130f712c9SDave Chinner
40230f712c9SDave Chinner rval = xfs_dir2_isleaf(args, &v);
40330f712c9SDave Chinner if (rval)
40430f712c9SDave Chinner goto out_free;
40530f712c9SDave Chinner if (v)
40630f712c9SDave Chinner rval = xfs_dir2_leaf_lookup(args);
40730f712c9SDave Chinner else
40830f712c9SDave Chinner rval = xfs_dir2_node_lookup(args);
40930f712c9SDave Chinner
41030f712c9SDave Chinner out_check_rval:
4112451337dSDave Chinner if (rval == -EEXIST)
41230f712c9SDave Chinner rval = 0;
41330f712c9SDave Chinner if (!rval) {
41430f712c9SDave Chinner *inum = args->inumber;
41530f712c9SDave Chinner if (ci_name) {
41630f712c9SDave Chinner ci_name->name = args->value;
41730f712c9SDave Chinner ci_name->len = args->valuelen;
41830f712c9SDave Chinner }
41930f712c9SDave Chinner }
42030f712c9SDave Chinner out_free:
421dbad7c99SDave Chinner xfs_iunlock(dp, lock_mode);
42230f712c9SDave Chinner kmem_free(args);
42330f712c9SDave Chinner return rval;
42430f712c9SDave Chinner }
42530f712c9SDave Chinner
42630f712c9SDave Chinner /*
42730f712c9SDave Chinner * Remove an entry from a directory.
42830f712c9SDave Chinner */
42930f712c9SDave Chinner int
xfs_dir_removename(struct xfs_trans * tp,struct xfs_inode * dp,struct xfs_name * name,xfs_ino_t ino,xfs_extlen_t total)43030f712c9SDave Chinner xfs_dir_removename(
43132a9b7c6SBrian Foster struct xfs_trans *tp,
43232a9b7c6SBrian Foster struct xfs_inode *dp,
43330f712c9SDave Chinner struct xfs_name *name,
43430f712c9SDave Chinner xfs_ino_t ino,
43530f712c9SDave Chinner xfs_extlen_t total) /* bmap's total block count */
43630f712c9SDave Chinner {
43730f712c9SDave Chinner struct xfs_da_args *args;
43830f712c9SDave Chinner int rval;
439c098576fSShida Zhang bool v;
44030f712c9SDave Chinner
441c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
442ff6d6af2SBill O'Donnell XFS_STATS_INC(dp->i_mount, xs_dir_remove);
44330f712c9SDave Chinner
444707e0ddaSTetsuo Handa args = kmem_zalloc(sizeof(*args), KM_NOFS);
44530f712c9SDave Chinner if (!args)
4462451337dSDave Chinner return -ENOMEM;
44730f712c9SDave Chinner
44830f712c9SDave Chinner args->geo = dp->i_mount->m_dir_geo;
44930f712c9SDave Chinner args->name = name->name;
45030f712c9SDave Chinner args->namelen = name->len;
45130f712c9SDave Chinner args->filetype = name->type;
452d8d11fc7SChristoph Hellwig args->hashval = xfs_dir2_hashname(dp->i_mount, name);
45330f712c9SDave Chinner args->inumber = ino;
45430f712c9SDave Chinner args->dp = dp;
45530f712c9SDave Chinner args->total = total;
45630f712c9SDave Chinner args->whichfork = XFS_DATA_FORK;
45730f712c9SDave Chinner args->trans = tp;
45830f712c9SDave Chinner
459f7e67b20SChristoph Hellwig if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
46030f712c9SDave Chinner rval = xfs_dir2_sf_removename(args);
46130f712c9SDave Chinner goto out_free;
46230f712c9SDave Chinner }
46330f712c9SDave Chinner
46430f712c9SDave Chinner rval = xfs_dir2_isblock(args, &v);
46530f712c9SDave Chinner if (rval)
46630f712c9SDave Chinner goto out_free;
46730f712c9SDave Chinner if (v) {
46830f712c9SDave Chinner rval = xfs_dir2_block_removename(args);
46930f712c9SDave Chinner goto out_free;
47030f712c9SDave Chinner }
47130f712c9SDave Chinner
47230f712c9SDave Chinner rval = xfs_dir2_isleaf(args, &v);
47330f712c9SDave Chinner if (rval)
47430f712c9SDave Chinner goto out_free;
47530f712c9SDave Chinner if (v)
47630f712c9SDave Chinner rval = xfs_dir2_leaf_removename(args);
47730f712c9SDave Chinner else
47830f712c9SDave Chinner rval = xfs_dir2_node_removename(args);
47930f712c9SDave Chinner out_free:
48030f712c9SDave Chinner kmem_free(args);
48130f712c9SDave Chinner return rval;
48230f712c9SDave Chinner }
48330f712c9SDave Chinner
48430f712c9SDave Chinner /*
48530f712c9SDave Chinner * Replace the inode number of a directory entry.
48630f712c9SDave Chinner */
48730f712c9SDave Chinner int
xfs_dir_replace(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t inum,xfs_extlen_t total)48830f712c9SDave Chinner xfs_dir_replace(
48932a9b7c6SBrian Foster struct xfs_trans *tp,
49032a9b7c6SBrian Foster struct xfs_inode *dp,
491996b2329SDarrick J. Wong const struct xfs_name *name, /* name of entry to replace */
49230f712c9SDave Chinner xfs_ino_t inum, /* new inode number */
49330f712c9SDave Chinner xfs_extlen_t total) /* bmap's total block count */
49430f712c9SDave Chinner {
49530f712c9SDave Chinner struct xfs_da_args *args;
49630f712c9SDave Chinner int rval;
497c098576fSShida Zhang bool v;
49830f712c9SDave Chinner
499c19b3b05SDave Chinner ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
50030f712c9SDave Chinner
50130f712c9SDave Chinner rval = xfs_dir_ino_validate(tp->t_mountp, inum);
50230f712c9SDave Chinner if (rval)
50330f712c9SDave Chinner return rval;
50430f712c9SDave Chinner
505707e0ddaSTetsuo Handa args = kmem_zalloc(sizeof(*args), KM_NOFS);
50630f712c9SDave Chinner if (!args)
5072451337dSDave Chinner return -ENOMEM;
50830f712c9SDave Chinner
50930f712c9SDave Chinner args->geo = dp->i_mount->m_dir_geo;
51030f712c9SDave Chinner args->name = name->name;
51130f712c9SDave Chinner args->namelen = name->len;
51230f712c9SDave Chinner args->filetype = name->type;
513d8d11fc7SChristoph Hellwig args->hashval = xfs_dir2_hashname(dp->i_mount, name);
51430f712c9SDave Chinner args->inumber = inum;
51530f712c9SDave Chinner args->dp = dp;
51630f712c9SDave Chinner args->total = total;
51730f712c9SDave Chinner args->whichfork = XFS_DATA_FORK;
51830f712c9SDave Chinner args->trans = tp;
51930f712c9SDave Chinner
520f7e67b20SChristoph Hellwig if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
52130f712c9SDave Chinner rval = xfs_dir2_sf_replace(args);
52230f712c9SDave Chinner goto out_free;
52330f712c9SDave Chinner }
52430f712c9SDave Chinner
52530f712c9SDave Chinner rval = xfs_dir2_isblock(args, &v);
52630f712c9SDave Chinner if (rval)
52730f712c9SDave Chinner goto out_free;
52830f712c9SDave Chinner if (v) {
52930f712c9SDave Chinner rval = xfs_dir2_block_replace(args);
53030f712c9SDave Chinner goto out_free;
53130f712c9SDave Chinner }
53230f712c9SDave Chinner
53330f712c9SDave Chinner rval = xfs_dir2_isleaf(args, &v);
53430f712c9SDave Chinner if (rval)
53530f712c9SDave Chinner goto out_free;
53630f712c9SDave Chinner if (v)
53730f712c9SDave Chinner rval = xfs_dir2_leaf_replace(args);
53830f712c9SDave Chinner else
53930f712c9SDave Chinner rval = xfs_dir2_node_replace(args);
54030f712c9SDave Chinner out_free:
54130f712c9SDave Chinner kmem_free(args);
54230f712c9SDave Chinner return rval;
54330f712c9SDave Chinner }
54430f712c9SDave Chinner
54530f712c9SDave Chinner /*
54630f712c9SDave Chinner * See if this entry can be added to the directory without allocating space.
54730f712c9SDave Chinner */
54830f712c9SDave Chinner int
xfs_dir_canenter(xfs_trans_t * tp,xfs_inode_t * dp,struct xfs_name * name)54930f712c9SDave Chinner xfs_dir_canenter(
55030f712c9SDave Chinner xfs_trans_t *tp,
55130f712c9SDave Chinner xfs_inode_t *dp,
55294f3cad5SEric Sandeen struct xfs_name *name) /* name of entry to add */
55330f712c9SDave Chinner {
554381eee69SBrian Foster return xfs_dir_createname(tp, dp, name, 0, 0);
55530f712c9SDave Chinner }
55630f712c9SDave Chinner
55730f712c9SDave Chinner /*
55830f712c9SDave Chinner * Utility routines.
55930f712c9SDave Chinner */
56030f712c9SDave Chinner
56130f712c9SDave Chinner /*
56230f712c9SDave Chinner * Add a block to the directory.
56330f712c9SDave Chinner *
56430f712c9SDave Chinner * This routine is for data and free blocks, not leaf/node blocks which are
56530f712c9SDave Chinner * handled by xfs_da_grow_inode.
56630f712c9SDave Chinner */
56730f712c9SDave Chinner int
xfs_dir2_grow_inode(struct xfs_da_args * args,int space,xfs_dir2_db_t * dbp)56830f712c9SDave Chinner xfs_dir2_grow_inode(
56930f712c9SDave Chinner struct xfs_da_args *args,
57030f712c9SDave Chinner int space, /* v2 dir's space XFS_DIR2_xxx_SPACE */
57130f712c9SDave Chinner xfs_dir2_db_t *dbp) /* out: block number added */
57230f712c9SDave Chinner {
57330f712c9SDave Chinner struct xfs_inode *dp = args->dp;
57430f712c9SDave Chinner struct xfs_mount *mp = dp->i_mount;
57530f712c9SDave Chinner xfs_fileoff_t bno; /* directory offset of new block */
57630f712c9SDave Chinner int count; /* count of filesystem blocks */
57730f712c9SDave Chinner int error;
57830f712c9SDave Chinner
57930f712c9SDave Chinner trace_xfs_dir2_grow_inode(args, space);
58030f712c9SDave Chinner
58130f712c9SDave Chinner /*
58230f712c9SDave Chinner * Set lowest possible block in the space requested.
58330f712c9SDave Chinner */
58430f712c9SDave Chinner bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE);
58530f712c9SDave Chinner count = args->geo->fsbcount;
58630f712c9SDave Chinner
58730f712c9SDave Chinner error = xfs_da_grow_inode_int(args, &bno, count);
58830f712c9SDave Chinner if (error)
58930f712c9SDave Chinner return error;
59030f712c9SDave Chinner
59130f712c9SDave Chinner *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno);
59230f712c9SDave Chinner
59330f712c9SDave Chinner /*
59430f712c9SDave Chinner * Update file's size if this is the data space and it grew.
59530f712c9SDave Chinner */
59630f712c9SDave Chinner if (space == XFS_DIR2_DATA_SPACE) {
59730f712c9SDave Chinner xfs_fsize_t size; /* directory file (data) size */
59830f712c9SDave Chinner
59930f712c9SDave Chinner size = XFS_FSB_TO_B(mp, bno + count);
60013d2c10bSChristoph Hellwig if (size > dp->i_disk_size) {
60113d2c10bSChristoph Hellwig dp->i_disk_size = size;
60230f712c9SDave Chinner xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
60330f712c9SDave Chinner }
60430f712c9SDave Chinner }
60530f712c9SDave Chinner return 0;
60630f712c9SDave Chinner }
60730f712c9SDave Chinner
60830f712c9SDave Chinner /*
60930f712c9SDave Chinner * See if the directory is a single-block form directory.
61030f712c9SDave Chinner */
61130f712c9SDave Chinner int
xfs_dir2_isblock(struct xfs_da_args * args,bool * isblock)61230f712c9SDave Chinner xfs_dir2_isblock(
61330f712c9SDave Chinner struct xfs_da_args *args,
614c098576fSShida Zhang bool *isblock)
61530f712c9SDave Chinner {
616c098576fSShida Zhang struct xfs_mount *mp = args->dp->i_mount;
617c098576fSShida Zhang xfs_fileoff_t eof;
618c098576fSShida Zhang int error;
61930f712c9SDave Chinner
620c098576fSShida Zhang error = xfs_bmap_last_offset(args->dp, &eof, XFS_DATA_FORK);
621c098576fSShida Zhang if (error)
622c098576fSShida Zhang return error;
623c098576fSShida Zhang
624c098576fSShida Zhang *isblock = false;
625c098576fSShida Zhang if (XFS_FSB_TO_B(mp, eof) != args->geo->blksize)
626c098576fSShida Zhang return 0;
627c098576fSShida Zhang
628c098576fSShida Zhang *isblock = true;
629c098576fSShida Zhang if (XFS_IS_CORRUPT(mp, args->dp->i_disk_size != args->geo->blksize))
6303c6f46eaSAmir Goldstein return -EFSCORRUPTED;
63130f712c9SDave Chinner return 0;
63230f712c9SDave Chinner }
63330f712c9SDave Chinner
63430f712c9SDave Chinner /*
63530f712c9SDave Chinner * See if the directory is a single-leaf form directory.
63630f712c9SDave Chinner */
63730f712c9SDave Chinner int
xfs_dir2_isleaf(struct xfs_da_args * args,bool * isleaf)63830f712c9SDave Chinner xfs_dir2_isleaf(
63930f712c9SDave Chinner struct xfs_da_args *args,
640c098576fSShida Zhang bool *isleaf)
64130f712c9SDave Chinner {
642c098576fSShida Zhang xfs_fileoff_t eof;
643c098576fSShida Zhang int error;
64430f712c9SDave Chinner
645c098576fSShida Zhang error = xfs_bmap_last_offset(args->dp, &eof, XFS_DATA_FORK);
646c098576fSShida Zhang if (error)
647c098576fSShida Zhang return error;
648c098576fSShida Zhang
649c098576fSShida Zhang *isleaf = false;
650c098576fSShida Zhang if (eof != args->geo->leafblk + args->geo->fsbcount)
651c098576fSShida Zhang return 0;
652c098576fSShida Zhang
653c098576fSShida Zhang *isleaf = true;
65430f712c9SDave Chinner return 0;
65530f712c9SDave Chinner }
65630f712c9SDave Chinner
65730f712c9SDave Chinner /*
65830f712c9SDave Chinner * Remove the given block from the directory.
65930f712c9SDave Chinner * This routine is used for data and free blocks, leaf/node are done
66030f712c9SDave Chinner * by xfs_da_shrink_inode.
66130f712c9SDave Chinner */
66230f712c9SDave Chinner int
xfs_dir2_shrink_inode(struct xfs_da_args * args,xfs_dir2_db_t db,struct xfs_buf * bp)66330f712c9SDave Chinner xfs_dir2_shrink_inode(
66432a9b7c6SBrian Foster struct xfs_da_args *args,
66530f712c9SDave Chinner xfs_dir2_db_t db,
66630f712c9SDave Chinner struct xfs_buf *bp)
66730f712c9SDave Chinner {
66830f712c9SDave Chinner xfs_fileoff_t bno; /* directory file offset */
66930f712c9SDave Chinner xfs_dablk_t da; /* directory file offset */
67030f712c9SDave Chinner int done; /* bunmap is finished */
67132a9b7c6SBrian Foster struct xfs_inode *dp;
67230f712c9SDave Chinner int error;
67332a9b7c6SBrian Foster struct xfs_mount *mp;
67432a9b7c6SBrian Foster struct xfs_trans *tp;
67530f712c9SDave Chinner
67630f712c9SDave Chinner trace_xfs_dir2_shrink_inode(args, db);
67730f712c9SDave Chinner
67830f712c9SDave Chinner dp = args->dp;
67930f712c9SDave Chinner mp = dp->i_mount;
68030f712c9SDave Chinner tp = args->trans;
68130f712c9SDave Chinner da = xfs_dir2_db_to_da(args->geo, db);
682ab7bb610SDave Chinner
683ab7bb610SDave Chinner /* Unmap the fsblock(s). */
6842af52842SBrian Foster error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, &done);
685ab7bb610SDave Chinner if (error) {
68630f712c9SDave Chinner /*
687ab7bb610SDave Chinner * ENOSPC actually can happen if we're in a removename with no
688ab7bb610SDave Chinner * space reservation, and the resulting block removal would
689ab7bb610SDave Chinner * cause a bmap btree split or conversion from extents to btree.
690ab7bb610SDave Chinner * This can only happen for un-fragmented directory blocks,
691ab7bb610SDave Chinner * since you need to be punching out the middle of an extent.
692ab7bb610SDave Chinner * In this case we need to leave the block in the file, and not
693ab7bb610SDave Chinner * binval it. So the block has to be in a consistent empty
694ab7bb610SDave Chinner * state and appropriately logged. We don't free up the buffer,
695ab7bb610SDave Chinner * the caller can tell it hasn't happened since it got an error
696ab7bb610SDave Chinner * back.
69730f712c9SDave Chinner */
69830f712c9SDave Chinner return error;
69930f712c9SDave Chinner }
70030f712c9SDave Chinner ASSERT(done);
70130f712c9SDave Chinner /*
70230f712c9SDave Chinner * Invalidate the buffer from the transaction.
70330f712c9SDave Chinner */
70430f712c9SDave Chinner xfs_trans_binval(tp, bp);
70530f712c9SDave Chinner /*
70630f712c9SDave Chinner * If it's not a data block, we're done.
70730f712c9SDave Chinner */
70830f712c9SDave Chinner if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET))
70930f712c9SDave Chinner return 0;
71030f712c9SDave Chinner /*
71130f712c9SDave Chinner * If the block isn't the last one in the directory, we're done.
71230f712c9SDave Chinner */
71313d2c10bSChristoph Hellwig if (dp->i_disk_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0))
71430f712c9SDave Chinner return 0;
71530f712c9SDave Chinner bno = da;
71630f712c9SDave Chinner if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
71730f712c9SDave Chinner /*
71830f712c9SDave Chinner * This can't really happen unless there's kernel corruption.
71930f712c9SDave Chinner */
72030f712c9SDave Chinner return error;
72130f712c9SDave Chinner }
72230f712c9SDave Chinner if (db == args->geo->datablk)
72330f712c9SDave Chinner ASSERT(bno == 0);
72430f712c9SDave Chinner else
72530f712c9SDave Chinner ASSERT(bno > 0);
72630f712c9SDave Chinner /*
72730f712c9SDave Chinner * Set the size to the new last block.
72830f712c9SDave Chinner */
72913d2c10bSChristoph Hellwig dp->i_disk_size = XFS_FSB_TO_B(mp, bno);
73030f712c9SDave Chinner xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
73130f712c9SDave Chinner return 0;
73230f712c9SDave Chinner }
733e5d7d51bSDarrick J. Wong
734e5d7d51bSDarrick J. Wong /* Returns true if the directory entry name is valid. */
735e5d7d51bSDarrick J. Wong bool
xfs_dir2_namecheck(const void * name,size_t length)736e5d7d51bSDarrick J. Wong xfs_dir2_namecheck(
737e5d7d51bSDarrick J. Wong const void *name,
738e5d7d51bSDarrick J. Wong size_t length)
739e5d7d51bSDarrick J. Wong {
740e5d7d51bSDarrick J. Wong /*
741e5d7d51bSDarrick J. Wong * MAXNAMELEN includes the trailing null, but (name/length) leave it
742e5d7d51bSDarrick J. Wong * out, so use >= for the length check.
743e5d7d51bSDarrick J. Wong */
744e5d7d51bSDarrick J. Wong if (length >= MAXNAMELEN)
745e5d7d51bSDarrick J. Wong return false;
746e5d7d51bSDarrick J. Wong
747e5d7d51bSDarrick J. Wong /* There shouldn't be any slashes or nulls here */
748e5d7d51bSDarrick J. Wong return !memchr(name, '/', length) && !memchr(name, 0, length);
749e5d7d51bSDarrick J. Wong }
750af952aebSDarrick J. Wong
751af952aebSDarrick J. Wong xfs_dahash_t
xfs_dir2_hashname(struct xfs_mount * mp,const struct xfs_name * name)752af952aebSDarrick J. Wong xfs_dir2_hashname(
753af952aebSDarrick J. Wong struct xfs_mount *mp,
754996b2329SDarrick J. Wong const struct xfs_name *name)
755af952aebSDarrick J. Wong {
756ebd9027dSDave Chinner if (unlikely(xfs_has_asciici(mp)))
757af952aebSDarrick J. Wong return xfs_ascii_ci_hashname(name);
758af952aebSDarrick J. Wong return xfs_da_hashname(name->name, name->len);
759af952aebSDarrick J. Wong }
760af952aebSDarrick J. Wong
761af952aebSDarrick J. Wong enum xfs_dacmp
xfs_dir2_compname(struct xfs_da_args * args,const unsigned char * name,int len)762af952aebSDarrick J. Wong xfs_dir2_compname(
763af952aebSDarrick J. Wong struct xfs_da_args *args,
764af952aebSDarrick J. Wong const unsigned char *name,
765af952aebSDarrick J. Wong int len)
766af952aebSDarrick J. Wong {
767ebd9027dSDave Chinner if (unlikely(xfs_has_asciici(args->dp->i_mount)))
768af952aebSDarrick J. Wong return xfs_ascii_ci_compname(args, name, len);
769af952aebSDarrick J. Wong return xfs_da_compname(args, name, len);
770af952aebSDarrick J. Wong }
771