mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-24 11:40:53 +07:00
1da177e4c3
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
1224 lines
33 KiB
C
1224 lines
33 KiB
C
/*
|
|
* Copyright (c) 2000-2001 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;
|
|
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));
|
|
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 */
|