| /* |
| * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. All Rights Reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of version 2 of the GNU General Public License as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it would be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| * |
| * Further, this software is distributed without any warranty that it is |
| * free of the rightful claim of any third person regarding infringement |
| * or the like. Any license provided herein, whether implied or |
| * otherwise, applies only to this software file. Patent licenses, if |
| * any, provided herein do not apply to combinations of this program with |
| * other software, or any other product whatsoever. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write the Free Software Foundation, Inc., 59 |
| * Temple Place - Suite 330, Boston MA 02111-1307, USA. |
| * |
| * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, |
| * Mountain View, CA 94043, or: |
| * |
| * http://www.sgi.com |
| * |
| * For further information regarding this notice, see: |
| * |
| * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ |
| */ |
| |
| #include "xfs.h" |
| |
| #include "xfs_macros.h" |
| #include "xfs_types.h" |
| #include "xfs_inum.h" |
| #include "xfs_log.h" |
| #include "xfs_trans.h" |
| #include "xfs_sb.h" |
| #include "xfs_dir.h" |
| #include "xfs_dir2.h" |
| #include "xfs_dmapi.h" |
| #include "xfs_mount.h" |
| #include "xfs_alloc_btree.h" |
| #include "xfs_bmap_btree.h" |
| #include "xfs_ialloc_btree.h" |
| #include "xfs_alloc.h" |
| #include "xfs_btree.h" |
| #include "xfs_attr_sf.h" |
| #include "xfs_dir_sf.h" |
| #include "xfs_dir2_sf.h" |
| #include "xfs_dinode.h" |
| #include "xfs_inode.h" |
| #include "xfs_bmap.h" |
| #include "xfs_da_btree.h" |
| #include "xfs_dir_leaf.h" |
| #include "xfs_error.h" |
| |
| /* |
| * xfs_dir.c |
| * |
| * Provide the external interfaces to manage directories. |
| */ |
| |
| /*======================================================================== |
| * Function prototypes for the kernel. |
| *========================================================================*/ |
| |
| /* |
| * Functions for the dirops interfaces. |
| */ |
| static void xfs_dir_mount(struct xfs_mount *mp); |
| |
| static int xfs_dir_isempty(struct xfs_inode *dp); |
| |
| static int xfs_dir_init(struct xfs_trans *trans, |
| struct xfs_inode *dir, |
| struct xfs_inode *parent_dir); |
| |
| static int xfs_dir_createname(struct xfs_trans *trans, |
| struct xfs_inode *dp, |
| char *name_string, |
| int name_len, |
| xfs_ino_t inode_number, |
| xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, |
| xfs_extlen_t total); |
| |
| static int xfs_dir_lookup(struct xfs_trans *tp, |
| struct xfs_inode *dp, |
| char *name_string, |
| int name_length, |
| xfs_ino_t *inode_number); |
| |
| static int xfs_dir_removename(struct xfs_trans *trans, |
| struct xfs_inode *dp, |
| char *name_string, |
| int name_length, |
| xfs_ino_t ino, |
| xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, |
| xfs_extlen_t total); |
| |
| static int xfs_dir_getdents(struct xfs_trans *tp, |
| struct xfs_inode *dp, |
| struct uio *uiop, |
| int *eofp); |
| |
| static int xfs_dir_replace(struct xfs_trans *tp, |
| struct xfs_inode *dp, |
| char *name_string, |
| int name_length, |
| xfs_ino_t inode_number, |
| xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, |
| xfs_extlen_t total); |
| |
| static int xfs_dir_canenter(struct xfs_trans *tp, |
| struct xfs_inode *dp, |
| char *name_string, |
| int name_length); |
| |
| static int xfs_dir_shortform_validate_ondisk(xfs_mount_t *mp, |
| xfs_dinode_t *dip); |
| |
| xfs_dirops_t xfsv1_dirops = { |
| .xd_mount = xfs_dir_mount, |
| .xd_isempty = xfs_dir_isempty, |
| .xd_init = xfs_dir_init, |
| .xd_createname = xfs_dir_createname, |
| .xd_lookup = xfs_dir_lookup, |
| .xd_removename = xfs_dir_removename, |
| .xd_getdents = xfs_dir_getdents, |
| .xd_replace = xfs_dir_replace, |
| .xd_canenter = xfs_dir_canenter, |
| .xd_shortform_validate_ondisk = xfs_dir_shortform_validate_ondisk, |
| .xd_shortform_to_single = xfs_dir_shortform_to_leaf, |
| }; |
| |
| /* |
| * Internal routines when dirsize == XFS_LBSIZE(mp). |
| */ |
| STATIC int xfs_dir_leaf_lookup(xfs_da_args_t *args); |
| STATIC int xfs_dir_leaf_removename(xfs_da_args_t *args, int *number_entries, |
| int *total_namebytes); |
| STATIC int xfs_dir_leaf_getdents(xfs_trans_t *trans, xfs_inode_t *dp, |
| uio_t *uio, int *eofp, |
| xfs_dirent_t *dbp, |
| xfs_dir_put_t put); |
| STATIC int xfs_dir_leaf_replace(xfs_da_args_t *args); |
| |
| /* |
| * Internal routines when dirsize > XFS_LBSIZE(mp). |
| */ |
| STATIC int xfs_dir_node_addname(xfs_da_args_t *args); |
| STATIC int xfs_dir_node_lookup(xfs_da_args_t *args); |
| STATIC int xfs_dir_node_removename(xfs_da_args_t *args); |
| STATIC int xfs_dir_node_getdents(xfs_trans_t *trans, xfs_inode_t *dp, |
| uio_t *uio, int *eofp, |
| xfs_dirent_t *dbp, |
| xfs_dir_put_t put); |
| STATIC int xfs_dir_node_replace(xfs_da_args_t *args); |
| |
| #if defined(XFS_DIR_TRACE) |
| ktrace_t *xfs_dir_trace_buf; |
| #endif |
| |
| |
| /*======================================================================== |
| * Overall external interface routines. |
| *========================================================================*/ |
| |
| xfs_dahash_t xfs_dir_hash_dot, xfs_dir_hash_dotdot; |
| |
| /* |
| * One-time startup routine called from xfs_init(). |
| */ |
| void |
| xfs_dir_startup(void) |
| { |
| xfs_dir_hash_dot = xfs_da_hashname(".", 1); |
| xfs_dir_hash_dotdot = xfs_da_hashname("..", 2); |
| } |
| |
| /* |
| * Initialize directory-related fields in the mount structure. |
| */ |
| static void |
| xfs_dir_mount(xfs_mount_t *mp) |
| { |
| uint shortcount, leafcount, count; |
| |
| mp->m_dirversion = 1; |
| if (mp->m_flags & XFS_MOUNT_COMPAT_ATTR) { |
| shortcount = (mp->m_attroffset - |
| (uint)sizeof(xfs_dir_sf_hdr_t)) / |
| (uint)sizeof(xfs_dir_sf_entry_t); |
| leafcount = (XFS_LBSIZE(mp) - |
| (uint)sizeof(xfs_dir_leaf_hdr_t)) / |
| ((uint)sizeof(xfs_dir_leaf_entry_t) + |
| (uint)sizeof(xfs_dir_leaf_name_t)); |
| } else { |
| shortcount = (XFS_BMDR_SPACE_CALC(MINABTPTRS) - |
| (uint)sizeof(xfs_dir_sf_hdr_t)) / |
| (uint)sizeof(xfs_dir_sf_entry_t); |
| leafcount = (XFS_LBSIZE(mp) - |
| (uint)sizeof(xfs_dir_leaf_hdr_t)) / |
| ((uint)sizeof(xfs_dir_leaf_entry_t) + |
| (uint)sizeof(xfs_dir_leaf_name_t)); |
| } |
| count = shortcount > leafcount ? shortcount : leafcount; |
| mp->m_dircook_elog = xfs_da_log2_roundup(count + 1); |
| ASSERT(mp->m_dircook_elog <= mp->m_sb.sb_blocklog); |
| mp->m_dir_node_ents = mp->m_attr_node_ents = |
| (XFS_LBSIZE(mp) - (uint)sizeof(xfs_da_node_hdr_t)) / |
| (uint)sizeof(xfs_da_node_entry_t); |
| mp->m_dir_magicpct = (XFS_LBSIZE(mp) * 37) / 100; |
| mp->m_dirblksize = mp->m_sb.sb_blocksize; |
| mp->m_dirblkfsbs = 1; |
| } |
| |
| /* |
| * Return 1 if directory contains only "." and "..". |
| */ |
| static int |
| xfs_dir_isempty(xfs_inode_t *dp) |
| { |
| xfs_dir_sf_hdr_t *hdr; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| if (dp->i_d.di_size == 0) |
| return(1); |
| if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp)) |
| return(0); |
| hdr = (xfs_dir_sf_hdr_t *)dp->i_df.if_u1.if_data; |
| return(hdr->count == 0); |
| } |
| |
| /* |
| * Initialize a directory with its "." and ".." entries. |
| */ |
| static int |
| xfs_dir_init(xfs_trans_t *trans, xfs_inode_t *dir, xfs_inode_t *parent_dir) |
| { |
| xfs_da_args_t args; |
| int error; |
| |
| memset((char *)&args, 0, sizeof(args)); |
| args.dp = dir; |
| args.trans = trans; |
| |
| ASSERT((dir->i_d.di_mode & S_IFMT) == S_IFDIR); |
| if ((error = xfs_dir_ino_validate(trans->t_mountp, parent_dir->i_ino))) |
| return error; |
| |
| return(xfs_dir_shortform_create(&args, parent_dir->i_ino)); |
| } |
| |
| /* |
| * Generic handler routine to add a name to a directory. |
| * Transitions directory from shortform to Btree as necessary. |
| */ |
| static int /* error */ |
| xfs_dir_createname(xfs_trans_t *trans, xfs_inode_t *dp, char *name, |
| int namelen, xfs_ino_t inum, xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, xfs_extlen_t total) |
| { |
| xfs_da_args_t args; |
| int retval, newsize, done; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| |
| if ((retval = xfs_dir_ino_validate(trans->t_mountp, inum))) |
| return (retval); |
| |
| XFS_STATS_INC(xs_dir_create); |
| /* |
| * Fill in the arg structure for this request. |
| */ |
| args.name = name; |
| args.namelen = namelen; |
| args.hashval = xfs_da_hashname(name, namelen); |
| args.inumber = inum; |
| args.dp = dp; |
| args.firstblock = firstblock; |
| args.flist = flist; |
| args.total = total; |
| args.whichfork = XFS_DATA_FORK; |
| args.trans = trans; |
| args.justcheck = 0; |
| args.addname = args.oknoent = 1; |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| done = 0; |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| newsize = XFS_DIR_SF_ENTSIZE_BYNAME(args.namelen); |
| if ((dp->i_d.di_size + newsize) <= XFS_IFORK_DSIZE(dp)) { |
| retval = xfs_dir_shortform_addname(&args); |
| done = 1; |
| } else { |
| if (total == 0) |
| return XFS_ERROR(ENOSPC); |
| retval = xfs_dir_shortform_to_leaf(&args); |
| done = retval != 0; |
| } |
| } |
| if (!done && xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_addname(&args); |
| done = retval != ENOSPC; |
| if (!done) { |
| if (total == 0) |
| return XFS_ERROR(ENOSPC); |
| retval = xfs_dir_leaf_to_node(&args); |
| done = retval != 0; |
| } |
| } |
| if (!done) { |
| retval = xfs_dir_node_addname(&args); |
| } |
| return(retval); |
| } |
| |
| /* |
| * Generic handler routine to check if a name can be added to a directory, |
| * without adding any blocks to the directory. |
| */ |
| static int /* error */ |
| xfs_dir_canenter(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen) |
| { |
| xfs_da_args_t args; |
| int retval, newsize; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| /* |
| * Fill in the arg structure for this request. |
| */ |
| args.name = name; |
| args.namelen = namelen; |
| args.hashval = xfs_da_hashname(name, namelen); |
| args.inumber = 0; |
| args.dp = dp; |
| args.firstblock = NULL; |
| args.flist = NULL; |
| args.total = 0; |
| args.whichfork = XFS_DATA_FORK; |
| args.trans = trans; |
| args.justcheck = args.addname = args.oknoent = 1; |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| newsize = XFS_DIR_SF_ENTSIZE_BYNAME(args.namelen); |
| if ((dp->i_d.di_size + newsize) <= XFS_IFORK_DSIZE(dp)) |
| retval = 0; |
| else |
| retval = XFS_ERROR(ENOSPC); |
| } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_addname(&args); |
| } else { |
| retval = xfs_dir_node_addname(&args); |
| } |
| return(retval); |
| } |
| |
| /* |
| * Generic handler routine to remove a name from a directory. |
| * Transitions directory from Btree to shortform as necessary. |
| */ |
| static int /* error */ |
| xfs_dir_removename(xfs_trans_t *trans, xfs_inode_t *dp, char *name, |
| int namelen, xfs_ino_t ino, xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, xfs_extlen_t total) |
| { |
| xfs_da_args_t args; |
| int count, totallen, newsize, retval; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| XFS_STATS_INC(xs_dir_remove); |
| /* |
| * Fill in the arg structure for this request. |
| */ |
| args.name = name; |
| args.namelen = namelen; |
| args.hashval = xfs_da_hashname(name, namelen); |
| args.inumber = ino; |
| args.dp = dp; |
| args.firstblock = firstblock; |
| args.flist = flist; |
| args.total = total; |
| args.whichfork = XFS_DATA_FORK; |
| args.trans = trans; |
| args.justcheck = args.addname = args.oknoent = 0; |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| retval = xfs_dir_shortform_removename(&args); |
| } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_removename(&args, &count, &totallen); |
| if (retval == 0) { |
| newsize = XFS_DIR_SF_ALLFIT(count, totallen); |
| if (newsize <= XFS_IFORK_DSIZE(dp)) { |
| retval = xfs_dir_leaf_to_shortform(&args); |
| } |
| } |
| } else { |
| retval = xfs_dir_node_removename(&args); |
| } |
| return(retval); |
| } |
| |
| static int /* error */ |
| xfs_dir_lookup(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen, |
| xfs_ino_t *inum) |
| { |
| xfs_da_args_t args; |
| int retval; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| |
| XFS_STATS_INC(xs_dir_lookup); |
| /* |
| * Fill in the arg structure for this request. |
| */ |
| args.name = name; |
| args.namelen = namelen; |
| args.hashval = xfs_da_hashname(name, namelen); |
| args.inumber = 0; |
| args.dp = dp; |
| args.firstblock = NULL; |
| args.flist = NULL; |
| args.total = 0; |
| args.whichfork = XFS_DATA_FORK; |
| args.trans = trans; |
| args.justcheck = args.addname = 0; |
| args.oknoent = 1; |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| retval = xfs_dir_shortform_lookup(&args); |
| } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_lookup(&args); |
| } else { |
| retval = xfs_dir_node_lookup(&args); |
| } |
| if (retval == EEXIST) |
| retval = 0; |
| *inum = args.inumber; |
| return(retval); |
| } |
| |
| /* |
| * Implement readdir. |
| */ |
| static int /* error */ |
| xfs_dir_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio, int *eofp) |
| { |
| xfs_dirent_t *dbp; |
| int alignment, retval; |
| xfs_dir_put_t put; |
| |
| XFS_STATS_INC(xs_dir_getdents); |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| |
| /* |
| * If our caller has given us a single contiguous memory buffer, |
| * just work directly within that buffer. If it's in user memory, |
| * lock it down first. |
| */ |
| alignment = sizeof(xfs_off_t) - 1; |
| if ((uio->uio_iovcnt == 1) && |
| (((__psint_t)uio->uio_iov[0].iov_base & alignment) == 0) && |
| ((uio->uio_iov[0].iov_len & alignment) == 0)) { |
| dbp = NULL; |
| put = xfs_dir_put_dirent64_direct; |
| } else { |
| dbp = kmem_alloc(sizeof(*dbp) + MAXNAMELEN, KM_SLEEP); |
| put = xfs_dir_put_dirent64_uio; |
| } |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| *eofp = 0; |
| |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| retval = xfs_dir_shortform_getdents(dp, uio, eofp, dbp, put); |
| } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_getdents(trans, dp, uio, eofp, dbp, put); |
| } else { |
| retval = xfs_dir_node_getdents(trans, dp, uio, eofp, dbp, put); |
| } |
| if (dbp != NULL) |
| kmem_free(dbp, sizeof(*dbp) + MAXNAMELEN); |
| |
| return(retval); |
| } |
| |
| static int /* error */ |
| xfs_dir_replace(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen, |
| xfs_ino_t inum, xfs_fsblock_t *firstblock, |
| xfs_bmap_free_t *flist, xfs_extlen_t total) |
| { |
| xfs_da_args_t args; |
| int retval; |
| |
| ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR); |
| |
| if ((retval = xfs_dir_ino_validate(trans->t_mountp, inum))) |
| return retval; |
| |
| /* |
| * Fill in the arg structure for this request. |
| */ |
| args.name = name; |
| args.namelen = namelen; |
| args.hashval = xfs_da_hashname(name, namelen); |
| args.inumber = inum; |
| args.dp = dp; |
| args.firstblock = firstblock; |
| args.flist = flist; |
| args.total = total; |
| args.whichfork = XFS_DATA_FORK; |
| args.trans = trans; |
| args.justcheck = args.addname = args.oknoent = 0; |
| |
| /* |
| * Decide on what work routines to call based on the inode size. |
| */ |
| if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { |
| retval = xfs_dir_shortform_replace(&args); |
| } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) { |
| retval = xfs_dir_leaf_replace(&args); |
| } else { |
| retval = xfs_dir_node_replace(&args); |
| } |
| |
| return(retval); |
| } |
| |
| static int |
| xfs_dir_shortform_validate_ondisk(xfs_mount_t *mp, xfs_dinode_t *dp) |
| { |
| xfs_ino_t ino; |
| int namelen_sum; |
| int count; |
| xfs_dir_shortform_t *sf; |
| xfs_dir_sf_entry_t *sfe; |
| int i; |
| |
| |
| |
| if ((INT_GET(dp->di_core.di_mode, ARCH_CONVERT) & S_IFMT) != S_IFDIR) { |
| return 0; |
| } |
| if (INT_GET(dp->di_core.di_format, ARCH_CONVERT) != XFS_DINODE_FMT_LOCAL) { |
| return 0; |
| } |
| if (INT_GET(dp->di_core.di_size, ARCH_CONVERT) < sizeof(sf->hdr)) { |
| xfs_fs_cmn_err(CE_WARN, mp, "Invalid shortform size: dp 0x%p", |
| dp); |
| return 1; |
| } |
| sf = (xfs_dir_shortform_t *)(&dp->di_u.di_dirsf); |
| ino = XFS_GET_DIR_INO8(sf->hdr.parent); |
| if (xfs_dir_ino_validate(mp, ino)) |
| return 1; |
| |
| count = sf->hdr.count; |
| if ((count < 0) || ((count * 10) > XFS_LITINO(mp))) { |
| xfs_fs_cmn_err(CE_WARN, mp, |
| "Invalid shortform count: dp 0x%p", dp); |
| return(1); |
| } |
| |
| if (count == 0) { |
| return 0; |
| } |
| |
| namelen_sum = 0; |
| sfe = &sf->list[0]; |
| for (i = sf->hdr.count - 1; i >= 0; i--) { |
| ino = XFS_GET_DIR_INO8(sfe->inumber); |
| xfs_dir_ino_validate(mp, ino); |
| if (sfe->namelen >= XFS_LITINO(mp)) { |
| xfs_fs_cmn_err(CE_WARN, mp, |
| "Invalid shortform namelen: dp 0x%p", dp); |
| return 1; |
| } |
| namelen_sum += sfe->namelen; |
| sfe = XFS_DIR_SF_NEXTENTRY(sfe); |
| } |
| if (namelen_sum >= XFS_LITINO(mp)) { |
| xfs_fs_cmn_err(CE_WARN, mp, |
| "Invalid shortform namelen: dp 0x%p", dp); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| /*======================================================================== |
| * External routines when dirsize == XFS_LBSIZE(dp->i_mount). |
| *========================================================================*/ |
| |
| /* |
| * Add a name to the leaf directory structure |
| * This is the external routine. |
| */ |
| int |
| xfs_dir_leaf_addname(xfs_da_args_t *args) |
| { |
| int index, retval; |
| xfs_dabuf_t *bp; |
| |
| retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp, |
| XFS_DATA_FORK); |
| if (retval) |
| return(retval); |
| ASSERT(bp != NULL); |
| |
| retval = xfs_dir_leaf_lookup_int(bp, args, &index); |
| if (retval == ENOENT) |
| retval = xfs_dir_leaf_add(bp, args, index); |
| xfs_da_buf_done(bp); |
| return(retval); |
| } |
| |
| /* |
| * Remove a name from the leaf directory structure |
| * This is the external routine. |
| */ |
| STATIC int |
| xfs_dir_leaf_removename(xfs_da_args_t *args, int *count, int *totallen) |
| { |
| xfs_dir_leafblock_t *leaf; |
| int index, retval; |
| xfs_dabuf_t *bp; |
| |
| retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp, |
| XFS_DATA_FORK); |
| if (retval) |
| return(retval); |
| ASSERT(bp != NULL); |
| leaf = bp->data; |
| ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR_LEAF_MAGIC); |
| retval = xfs_dir_leaf_lookup_int(bp, args, &index); |
| if (retval == EEXIST) { |
| (void)xfs_dir_leaf_remove(args->trans, bp, index); |
| *count = INT_GET(leaf->hdr.count, ARCH_CONVERT); |
| *totallen = INT_GET(leaf->hdr.namebytes, ARCH_CONVERT); |
| retval = 0; |
| } |
| xfs_da_buf_done(bp); |
| return(retval); |
| } |
| |
| /* |
| * Look up a name in a leaf directory structure. |
| * This is the external routine. |
| */ |
| STATIC int |
| xfs_dir_leaf_lookup(xfs_da_args_t *args) |
| { |
| int index, retval; |
| xfs_dabuf_t *bp; |
| |
| retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp, |
| XFS_DATA_FORK); |
| if (retval) |
| return(retval); |
| ASSERT(bp != NULL); |
| retval = xfs_dir_leaf_lookup_int(bp, args, &index); |
| xfs_da_brelse(args->trans, bp); |
| return(retval); |
| } |
| |
| /* |
| * Copy out directory entries for getdents(), for leaf directories. |
| */ |
| STATIC int |
| xfs_dir_leaf_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio, |
| int *eofp, xfs_dirent_t *dbp, xfs_dir_put_t put) |
| { |
| xfs_dabuf_t *bp; |
| int retval, eob; |
| |
| retval = xfs_da_read_buf(dp->i_transp, dp, 0, -1, &bp, XFS_DATA_FORK); |
| if (retval) |
| return(retval); |
| ASSERT(bp != NULL); |
| retval = xfs_dir_leaf_getdents_int(bp, dp, 0, uio, &eob, dbp, put, -1); |
| xfs_da_brelse(trans, bp); |
| *eofp = (eob == 0); |
| return(retval); |
| } |
| |
| /* |
| * Look up a name in a leaf directory structure, replace the inode number. |
| * This is the external routine. |
| */ |
| STATIC int |
| xfs_dir_leaf_replace(xfs_da_args_t *args) |
| { |
| int index, retval; |
| xfs_dabuf_t *bp; |
| xfs_ino_t inum; |
| xfs_dir_leafblock_t *leaf; |
| xfs_dir_leaf_entry_t *entry; |
| xfs_dir_leaf_name_t *namest; |
| |
| inum = args->inumber; |
| retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp, |
| XFS_DATA_FORK); |
| if (retval) |
| return(retval); |
| ASSERT(bp != NULL); |
| retval = xfs_dir_leaf_lookup_int(bp, args, &index); |
| if (retval == EEXIST) { |
| leaf = bp->data; |
| entry = &leaf->entries[index]; |
| namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT)); |
| /* XXX - replace assert? */ |
| XFS_DIR_SF_PUT_DIRINO(&inum, &namest->inumber); |
| xfs_da_log_buf(args->trans, bp, |
| XFS_DA_LOGRANGE(leaf, namest, sizeof(namest->inumber))); |
| xfs_da_buf_done(bp); |
| retval = 0; |
| } else |
| xfs_da_brelse(args->trans, bp); |
| return(retval); |
| } |
| |
| |
| /*======================================================================== |
| * External routines when dirsize > XFS_LBSIZE(mp). |
| *========================================================================*/ |
| |
| /* |
| * Add a name to a Btree-format directory. |
| * |
| * This will involve walking down the Btree, and may involve splitting |
| * leaf nodes and even splitting intermediate nodes up to and including |
| * the root node (a special case of an intermediate node). |
| */ |
| STATIC int |
| xfs_dir_node_addname(xfs_da_args_t *args) |
| { |
| xfs_da_state_t *state; |
| xfs_da_state_blk_t *blk; |
| int retval, error; |
| |
| /* |
| * Fill in bucket of arguments/results/context to carry around. |
| */ |
| state = xfs_da_state_alloc(); |
| state->args = args; |
| state->mp = args->dp->i_mount; |
| state->blocksize = state->mp->m_sb.sb_blocksize; |
| state->node_ents = state->mp->m_dir_node_ents; |
| |
| /* |
| * Search to see if name already exists, and get back a pointer |
| * to where it should go. |
| */ |
| error = xfs_da_node_lookup_int(state, &retval); |
| if (error) |
| retval = error; |
| if (retval != ENOENT) |
| goto error; |
| blk = &state->path.blk[ state->path.active-1 ]; |
| ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC); |
| retval = xfs_dir_leaf_add(blk->bp, args, blk->index); |
| if (retval == 0) { |
| /* |
| * Addition succeeded, update Btree hashvals. |
| */ |
| if (!args->justcheck) |
| xfs_da_fixhashpath(state, &state->path); |
| } else { |
| /* |
| * Addition failed, split as many Btree elements as required. |
| */ |
| if (args->total == 0) { |
| ASSERT(retval == ENOSPC); |
| goto error; |
| } |
| retval = xfs_da_split(state); |
| } |
| error: |
| xfs_da_state_free(state); |
| |
| return(retval); |
| } |
| |
| /* |
| * Remove a name from a B-tree directory. |
| * |
| * This will involve walking down the Btree, and may involve joining |
| * leaf nodes and even joining intermediate nodes up to and including |
| * the root node (a special case of an intermediate node). |
| */ |
| STATIC int |
| xfs_dir_node_removename(xfs_da_args_t *args) |
| { |
| xfs_da_state_t *state; |
| xfs_da_state_blk_t *blk; |
| int retval, error; |
| |
| state = xfs_da_state_alloc(); |
| state->args = args; |
| state->mp = args->dp->i_mount; |
| state->blocksize = state->mp->m_sb.sb_blocksize; |
| state->node_ents = state->mp->m_dir_node_ents; |
| |
| /* |
| * Search to see if name exists, and get back a pointer to it. |
| */ |
| error = xfs_da_node_lookup_int(state, &retval); |
| if (error) |
| retval = error; |
| if (retval != EEXIST) { |
| xfs_da_state_free(state); |
| return(retval); |
| } |
| |
| /* |
| * Remove the name and update the hashvals in the tree. |
| */ |
| blk = &state->path.blk[ state->path.active-1 ]; |
| ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC); |
| retval = xfs_dir_leaf_remove(args->trans, blk->bp, blk->index); |
| xfs_da_fixhashpath(state, &state->path); |
| |
| /* |
| * Check to see if the tree needs to be collapsed. |
| */ |
| error = 0; |
| if (retval) { |
| error = xfs_da_join(state); |
| } |
| |
| xfs_da_state_free(state); |
| if (error) |
| return(error); |
| return(0); |
| } |
| |
| /* |
| * Look up a filename in a int directory. |
| * Use an internal routine to actually do all the work. |
| */ |
| STATIC int |
| xfs_dir_node_lookup(xfs_da_args_t *args) |
| { |
| xfs_da_state_t *state; |
| int retval, error, i; |
| |
| state = xfs_da_state_alloc(); |
| state->args = args; |
| state->mp = args->dp->i_mount; |
| state->blocksize = state->mp->m_sb.sb_blocksize; |
| state->node_ents = state->mp->m_dir_node_ents; |
| |
| /* |
| * Search to see if name exists, |
| * and get back a pointer to it. |
| */ |
| error = xfs_da_node_lookup_int(state, &retval); |
| if (error) { |
| retval = error; |
| } |
| |
| /* |
| * If not in a transaction, we have to release all the buffers. |
| */ |
| for (i = 0; i < state->path.active; i++) { |
| xfs_da_brelse(args->trans, state->path.blk[i].bp); |
| state->path.blk[i].bp = NULL; |
| } |
| |
| xfs_da_state_free(state); |
| return(retval); |
| } |
| |
| STATIC int |
| xfs_dir_node_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio, |
| int *eofp, xfs_dirent_t *dbp, xfs_dir_put_t put) |
| { |
| xfs_da_intnode_t *node; |
| xfs_da_node_entry_t *btree; |
| xfs_dir_leafblock_t *leaf = NULL; |
| xfs_dablk_t bno, nextbno; |
| xfs_dahash_t cookhash; |
| xfs_mount_t *mp; |
| int error, eob, i; |
| xfs_dabuf_t *bp; |
| xfs_daddr_t nextda; |
| |
| /* |
| * Pick up our context. |
| */ |
| mp = dp->i_mount; |
| bp = NULL; |
| bno = XFS_DA_COOKIE_BNO(mp, uio->uio_offset); |
| cookhash = XFS_DA_COOKIE_HASH(mp, uio->uio_offset); |
| |
| xfs_dir_trace_g_du("node: start", dp, uio); |
| |
| /* |
| * Re-find our place, even if we're confused about what our place is. |
| * |
| * First we check the block number from the magic cookie, it is a |
| * cache of where we ended last time. If we find a leaf block, and |
| * the starting hashval in that block is less than our desired |
| * hashval, then we run with it. |
| */ |
| if (bno > 0) { |
| error = xfs_da_read_buf(trans, dp, bno, -2, &bp, XFS_DATA_FORK); |
| if ((error != 0) && (error != EFSCORRUPTED)) |
| return(error); |
| if (bp) |
| leaf = bp->data; |
| if (bp && INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) != XFS_DIR_LEAF_MAGIC) { |
| xfs_dir_trace_g_dub("node: block not a leaf", |
| dp, uio, bno); |
| xfs_da_brelse(trans, bp); |
| bp = NULL; |
| } |
| if (bp && INT_GET(leaf->entries[0].hashval, ARCH_CONVERT) > cookhash) { |
| xfs_dir_trace_g_dub("node: leaf hash too large", |
| dp, uio, bno); |
| xfs_da_brelse(trans, bp); |
| bp = NULL; |
| } |
| if (bp && |
| cookhash > INT_GET(leaf->entries[INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT)) { |
| xfs_dir_trace_g_dub("node: leaf hash too small", |
| dp, uio, bno); |
| xfs_da_brelse(trans, bp); |
| bp = NULL; |
| } |
| } |
| |
| /* |
| * If we did not find a leaf block from the blockno in the cookie, |
| * or we there was no blockno in the cookie (eg: first time thru), |
| * the we start at the top of the Btree and re-find our hashval. |
| */ |
| if (bp == NULL) { |
| xfs_dir_trace_g_du("node: start at root" , dp, uio); |
| bno = 0; |
| for (;;) { |
| error = xfs_da_read_buf(trans, dp, bno, -1, &bp, |
| XFS_DATA_FORK); |
| if (error) |
| return(error); |
| if (bp == NULL) |
| return(XFS_ERROR(EFSCORRUPTED)); |
| node = bp->data; |
| if (INT_GET(node->hdr.info.magic, ARCH_CONVERT) != XFS_DA_NODE_MAGIC) |
| break; |
| btree = &node->btree[0]; |
| xfs_dir_trace_g_dun("node: node detail", dp, uio, node); |
| for (i = 0; i < INT_GET(node->hdr.count, ARCH_CONVERT); btree++, i++) { |
| if (INT_GET(btree->hashval, ARCH_CONVERT) >= cookhash) { |
| bno = INT_GET(btree->before, ARCH_CONVERT); |
| break; |
| } |
| } |
| if (i == INT_GET(node->hdr.count, ARCH_CONVERT)) { |
| xfs_da_brelse(trans, bp); |
| xfs_dir_trace_g_du("node: hash beyond EOF", |
| dp, uio); |
| uio->uio_offset = XFS_DA_MAKE_COOKIE(mp, 0, 0, |
| XFS_DA_MAXHASH); |
| *eofp = 1; |
| return(0); |
| } |
| xfs_dir_trace_g_dub("node: going to block", |
| dp, uio, bno); |
| xfs_da_brelse(trans, bp); |
| } |
| } |
| ASSERT(cookhash != XFS_DA_MAXHASH); |
| |
| /* |
| * We've dropped down to the (first) leaf block that contains the |
| * hashval we are interested in. Continue rolling upward thru the |
| * leaf blocks until we fill up our buffer. |
| */ |
| for (;;) { |
| leaf = bp->data; |
| if (unlikely(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) != XFS_DIR_LEAF_MAGIC)) { |
| xfs_dir_trace_g_dul("node: not a leaf", dp, uio, leaf); |
| xfs_da_brelse(trans, bp); |
| XFS_CORRUPTION_ERROR("xfs_dir_node_getdents(1)", |
| XFS_ERRLEVEL_LOW, mp, leaf); |
| return XFS_ERROR(EFSCORRUPTED); |
| } |
| xfs_dir_trace_g_dul("node: leaf detail", dp, uio, leaf); |
| if ((nextbno = INT_GET(leaf->hdr.info.forw, ARCH_CONVERT))) { |
| nextda = xfs_da_reada_buf(trans, dp, nextbno, |
| XFS_DATA_FORK); |
| } else |
| nextda = -1; |
| error = xfs_dir_leaf_getdents_int(bp, dp, bno, uio, &eob, dbp, |
| put, nextda); |
| xfs_da_brelse(trans, bp); |
| bno = nextbno; |
| if (eob) { |
| xfs_dir_trace_g_dub("node: E-O-B", dp, uio, bno); |
| *eofp = 0; |
| return(error); |
| } |
| if (bno == 0) |
| break; |
| error = xfs_da_read_buf(trans, dp, bno, nextda, &bp, |
| XFS_DATA_FORK); |
| if (error) |
| return(error); |
| if (unlikely(bp == NULL)) { |
| XFS_ERROR_REPORT("xfs_dir_node_getdents(2)", |
| XFS_ERRLEVEL_LOW, mp); |
| return(XFS_ERROR(EFSCORRUPTED)); |
| } |
| } |
| *eofp = 1; |
| xfs_dir_trace_g_du("node: E-O-F", dp, uio); |
| return(0); |
| } |
| |
| /* |
| * Look up a filename in an int directory, replace the inode number. |
| * Use an internal routine to actually do the lookup. |
| */ |
| STATIC int |
| xfs_dir_node_replace(xfs_da_args_t *args) |
| { |
| xfs_da_state_t *state; |
| xfs_da_state_blk_t *blk; |
| xfs_dir_leafblock_t *leaf; |
| xfs_dir_leaf_entry_t *entry; |
| xfs_dir_leaf_name_t *namest; |
| xfs_ino_t inum; |
| int retval, error, i; |
| xfs_dabuf_t *bp; |
| |
| state = xfs_da_state_alloc(); |
| state->args = args; |
| state->mp = args->dp->i_mount; |
| state->blocksize = state->mp->m_sb.sb_blocksize; |
| state->node_ents = state->mp->m_dir_node_ents; |
| inum = args->inumber; |
| |
| /* |
| * Search to see if name exists, |
| * and get back a pointer to it. |
| */ |
| error = xfs_da_node_lookup_int(state, &retval); |
| if (error) { |
| retval = error; |
| } |
| |
| if (retval == EEXIST) { |
| blk = &state->path.blk[state->path.active - 1]; |
| ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC); |
| bp = blk->bp; |
| leaf = bp->data; |
| entry = &leaf->entries[blk->index]; |
| namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT)); |
| /* XXX - replace assert ? */ |
| XFS_DIR_SF_PUT_DIRINO(&inum, &namest->inumber); |
| xfs_da_log_buf(args->trans, bp, |
| XFS_DA_LOGRANGE(leaf, namest, sizeof(namest->inumber))); |
| xfs_da_buf_done(bp); |
| blk->bp = NULL; |
| retval = 0; |
| } else { |
| i = state->path.active - 1; |
| xfs_da_brelse(args->trans, state->path.blk[i].bp); |
| state->path.blk[i].bp = NULL; |
| } |
| for (i = 0; i < state->path.active - 1; i++) { |
| xfs_da_brelse(args->trans, state->path.blk[i].bp); |
| state->path.blk[i].bp = NULL; |
| } |
| |
| xfs_da_state_free(state); |
| return(retval); |
| } |
| |
| #if defined(XFS_DIR_TRACE) |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_du(char *where, xfs_inode_t *dp, uio_t *uio) |
| { |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DU, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| NULL, NULL, NULL, NULL, NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_dub(char *where, xfs_inode_t *dp, uio_t *uio, xfs_dablk_t bno) |
| { |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUB, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| (void *)(unsigned long)bno, |
| NULL, NULL, NULL, NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio, |
| xfs_da_intnode_t *node) |
| { |
| int last = INT_GET(node->hdr.count, ARCH_CONVERT) - 1; |
| |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUN, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| (void *)(unsigned long) |
| INT_GET(node->hdr.info.forw, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(node->hdr.count, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(node->btree[0].hashval, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(node->btree[last].hashval, ARCH_CONVERT), |
| NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_dul(char *where, xfs_inode_t *dp, uio_t *uio, |
| xfs_dir_leafblock_t *leaf) |
| { |
| int last = INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1; |
| |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUL, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| (void *)(unsigned long) |
| INT_GET(leaf->hdr.info.forw, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(leaf->hdr.count, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(leaf->entries[0].hashval, ARCH_CONVERT), |
| (void *)(unsigned long) |
| INT_GET(leaf->entries[last].hashval, ARCH_CONVERT), |
| NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_due(char *where, xfs_inode_t *dp, uio_t *uio, |
| xfs_dir_leaf_entry_t *entry) |
| { |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUE, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| (void *)(unsigned long) |
| INT_GET(entry->hashval, ARCH_CONVERT), |
| NULL, NULL, NULL, NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for an inode and a uio. |
| */ |
| void |
| xfs_dir_trace_g_duc(char *where, xfs_inode_t *dp, uio_t *uio, xfs_off_t cookie) |
| { |
| xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUC, where, |
| (void *)dp, (void *)dp->i_mount, |
| (void *)((unsigned long)(uio->uio_offset >> 32)), |
| (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)), |
| (void *)(unsigned long)uio->uio_resid, |
| (void *)((unsigned long)(cookie >> 32)), |
| (void *)((unsigned long)(cookie & 0xFFFFFFFF)), |
| NULL, NULL, NULL, NULL, NULL); |
| } |
| |
| /* |
| * Add a trace buffer entry for the arguments given to the routine, |
| * generic form. |
| */ |
| void |
| xfs_dir_trace_enter(int type, char *where, |
| void * a0, void * a1, |
| void * a2, void * a3, |
| void * a4, void * a5, |
| void * a6, void * a7, |
| void * a8, void * a9, |
| void * a10, void * a11) |
| { |
| ASSERT(xfs_dir_trace_buf); |
| ktrace_enter(xfs_dir_trace_buf, (void *)(unsigned long)type, |
| (void *)where, |
| (void *)a0, (void *)a1, (void *)a2, |
| (void *)a3, (void *)a4, (void *)a5, |
| (void *)a6, (void *)a7, (void *)a8, |
| (void *)a9, (void *)a10, (void *)a11, |
| NULL, NULL); |
| } |
| #endif /* XFS_DIR_TRACE */ |