/*
- * Copyright (c) 2000-2006 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2005 Silicon Graphics, Inc.
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <linux/capability.h>
+
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_types.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
+#include "xfs_dir.h"
#include "xfs_dir2.h"
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
#include "xfs_dir2_sf.h"
#include "xfs_attr_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_inode_item.h"
+#include "xfs_dir_leaf.h"
#include "xfs_itable.h"
#include "xfs_btree.h"
#include "xfs_ialloc.h"
#include "xfs_log_priv.h"
#include "xfs_mac.h"
+
+/*
+ * The maximum pathlen is 1024 bytes. Since the minimum file system
+ * blocksize is 512 bytes, we can get a max of 2 extents back from
+ * bmapi.
+ */
+#define SYMLINK_MAPS 2
+
+/*
+ * For xfs, we check that the file isn't too big to be opened by this kernel.
+ * No other open action is required for regular files. Devices are handled
+ * through the specfs file system, pipes through fifofs. Device and
+ * fifo vnodes are "wrapped" by specfs and fifofs vnodes, respectively,
+ * when a new vnode is first looked up or created.
+ */
STATIC int
xfs_open(
bhv_desc_t *bdp,
cred_t *credp)
{
int mode;
- bhv_vnode_t *vp = BHV_TO_VNODE(bdp);
- xfs_inode_t *ip = XFS_BHVTOI(bdp);
+ vnode_t *vp;
+ xfs_inode_t *ip;
+
+ vp = BHV_TO_VNODE(bdp);
+ ip = XFS_BHVTOI(bdp);
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return XFS_ERROR(EIO);
return 0;
}
-STATIC int
-xfs_close(
- bhv_desc_t *bdp,
- int flags,
- lastclose_t lastclose,
- cred_t *credp)
-{
- bhv_vnode_t *vp = BHV_TO_VNODE(bdp);
- xfs_inode_t *ip = XFS_BHVTOI(bdp);
-
- if (XFS_FORCED_SHUTDOWN(ip->i_mount))
- return XFS_ERROR(EIO);
-
- if (lastclose != L_TRUE || !VN_ISREG(vp))
- return 0;
-
- /*
- * If we previously truncated this file and removed old data in
- * the process, we want to initiate "early" writeout on the last
- * close. This is an attempt to combat the notorious NULL files
- * problem which is particularly noticable from a truncate down,
- * buffered (re-)write (delalloc), followed by a crash. What we
- * are effectively doing here is significantly reducing the time
- * window where we'd otherwise be exposed to that problem.
- */
- if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
- return bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
- return 0;
-}
/*
* xfs_getattr
STATIC int
xfs_getattr(
bhv_desc_t *bdp,
- bhv_vattr_t *vap,
+ vattr_t *vap,
int flags,
cred_t *credp)
{
xfs_inode_t *ip;
xfs_mount_t *mp;
- bhv_vnode_t *vp;
+ vnode_t *vp;
vp = BHV_TO_VNODE(bdp);
vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
int
xfs_setattr(
bhv_desc_t *bdp,
- bhv_vattr_t *vap,
+ vattr_t *vap,
int flags,
cred_t *credp)
{
gid_t gid=0, igid=0;
xid_t xid=0, ixid=0;
int timeflags = 0;
- bhv_vnode_t *vp;
+ vnode_t *vp;
xfs_prid_t projid=0, iprojid=0;
int mandlock_before, mandlock_after;
struct xfs_dquot *udqp, *gdqp, *olddquot1, *olddquot2;
*/
tp = NULL;
lock_flags = XFS_ILOCK_EXCL;
+ ASSERT(flags & ATTR_NOLOCK ? flags & ATTR_DMI : 1);
if (flags & ATTR_NOLOCK)
need_iolock = 0;
if (!(mask & XFS_AT_SIZE)) {
code = xfs_igrow_start(ip, vap->va_size, credp);
}
xfs_iunlock(ip, XFS_ILOCK_EXCL);
- vn_iowait(vp); /* wait for the completion of any pending DIOs */
if (!code)
code = xfs_itruncate_data(ip, vap->va_size);
if (code) {
((ip->i_d.di_nlink != 0 ||
!(mp->m_flags & XFS_MOUNT_WSYNC))
? 1 : 0));
- if (code)
+ if (code) {
goto abort_return;
- /*
- * Truncated "down", so we're removing references
- * to old data here - if we now delay flushing for
- * a long time, we expose ourselves unduly to the
- * notorious NULL files problem. So, we mark this
- * vnode and flush it when the file is closed, and
- * do not wait the usual (long) time for writeout.
- */
- VTRUNCATE(vp);
+ }
}
/*
* Have to do this even if the file's size doesn't change.
di_flags |= XFS_DIFLAG_NODUMP;
if (vap->va_xflags & XFS_XFLAG_PROJINHERIT)
di_flags |= XFS_DIFLAG_PROJINHERIT;
- if (vap->va_xflags & XFS_XFLAG_NODEFRAG)
- di_flags |= XFS_DIFLAG_NODEFRAG;
if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
if (vap->va_xflags & XFS_XFLAG_RTINHERIT)
di_flags |= XFS_DIFLAG_RTINHERIT;
* If this is a synchronous mount, make sure that the
* transaction goes to disk before returning to the user.
* This is slightly sub-optimal in that truncates require
- * two sync transactions instead of one for wsync filesystems.
+ * two sync transactions instead of one for wsync filesytems.
* One for the truncate and one for the timestamps since we
* don't want to change the timestamps unless we're sure the
* truncate worked. Truncates are less than 1% of the laddis
*/
mandlock_after = MANDLOCK(vp, ip->i_d.di_mode);
if (mandlock_before != mandlock_after) {
- bhv_vop_vnode_change(vp, VCHANGE_FLAGS_ENF_LOCKING,
+ VOP_VNODE_CHANGE(vp, VCHANGE_FLAGS_ENF_LOCKING,
mandlock_after);
}
}
-/*
- * The maximum pathlen is 1024 bytes. Since the minimum file system
- * blocksize is 512 bytes, we can get a max of 2 extents back from
- * bmapi.
- */
-#define SYMLINK_MAPS 2
-
/*
* xfs_readlink
*
int count;
xfs_off_t offset;
int pathlen;
- bhv_vnode_t *vp;
+ vnode_t *vp;
int error = 0;
xfs_mount_t *mp;
int nmaps;
nmaps = SYMLINK_MAPS;
error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen),
- 0, NULL, 0, mval, &nmaps, NULL, NULL);
+ 0, NULL, 0, mval, &nmaps, NULL);
if (error) {
goto error_return;
/*
* If this inode is on the RT dev we need to flush that
- * cache as well.
+ * cache aswell.
*/
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME)
xfs_blkdev_issue_flush(ip->i_mount->m_rtdev_targp);
nimaps = 1;
xfs_ilock(ip, XFS_ILOCK_SHARED);
- error = XFS_BMAPI(mp, NULL, &ip->i_iocore, end_fsb, map_len, 0,
- NULL, 0, &imap, &nimaps, NULL, NULL);
+ error = xfs_bmapi(NULL, ip, end_fsb, map_len, 0,
+ NULL, 0, &imap, &nimaps, NULL);
xfs_iunlock(ip, XFS_ILOCK_SHARED);
if (!error && (nimaps != 0) &&
*/
done = 0;
XFS_BMAP_INIT(&free_list, &first_block);
- nmaps = ARRAY_SIZE(mval);
+ nmaps = sizeof(mval) / sizeof(mval[0]);
if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
- &free_list, NULL)))
+ &free_list)))
goto error0;
/*
* Invalidate the block(s).
* Unmap the dead block(s) to the free_list.
*/
if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
- &first_block, &free_list, NULL, &done)))
+ &first_block, &free_list, &done)))
goto error1;
ASSERT(done);
/*
*/
ntp = xfs_trans_dup(tp);
/*
- * Commit the transaction containing extent freeing and EFDs.
+ * Commit the transaction containing extent freeing and EFD's.
* If we get an error on the commit here or on the reserve below,
* we need to unlock the inode since the new transaction doesn't
* have the inode attached.
return 0;
}
+/*
+ *
+ */
STATIC int
xfs_inactive_attrs(
xfs_inode_t *ip,
bhv_desc_t *bdp)
{
xfs_inode_t *ip;
- bhv_vnode_t *vp;
+ vnode_t *vp;
xfs_mount_t *mp;
int error;
vp = BHV_TO_VNODE(bdp);
ip = XFS_BHVTOI(bdp);
- mp = ip->i_mount;
- if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0))
+ if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0)) {
return 0;
+ }
/* If this is a read-only mount, don't do this (would generate I/O) */
if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
return 0;
#endif
+ mp = ip->i_mount;
+
if (ip->i_d.di_nlink != 0) {
if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
if ((error = xfs_inactive_free_eofblocks(mp, ip)))
return error;
/* Update linux inode block count after free above */
- vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
+ LINVFS_GET_IP(vp)->i_blocks = XFS_FSB_TO_BB(mp,
ip->i_d.di_nblocks + ip->i_delayed_blks);
}
}
cred_t *credp)
{
xfs_inode_t *ip;
- bhv_vnode_t *vp;
- xfs_bmap_free_t free_list;
+ vnode_t *vp;
+ xfs_bmap_free_t free_list;
xfs_fsblock_t first_block;
int committed;
xfs_trans_t *tp;
if ((error = xfs_inactive_free_eofblocks(mp, ip)))
return VN_INACTIVE_CACHE;
/* Update linux inode block count after free above */
- vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
+ LINVFS_GET_IP(vp)->i_blocks = XFS_FSB_TO_BB(mp,
ip->i_d.di_nblocks + ip->i_delayed_blks);
}
goto out;
cmn_err(CE_NOTE,
"xfs_inactive: xfs_ifree() returned an error = %d on %s",
error, mp->m_fsname);
- xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
+ xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
}
xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
} else {
STATIC int
xfs_lookup(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
- bhv_vnode_t **vpp,
+ vname_t *dentry,
+ vnode_t **vpp,
int flags,
- bhv_vnode_t *rdir,
+ vnode_t *rdir,
cred_t *credp)
{
xfs_inode_t *dp, *ip;
xfs_ino_t e_inum;
int error;
uint lock_mode;
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
dir_vp = BHV_TO_VNODE(dir_bdp);
vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
STATIC int
xfs_create(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
- bhv_vattr_t *vap,
- bhv_vnode_t **vpp,
+ vname_t *dentry,
+ vattr_t *vap,
+ vnode_t **vpp,
cred_t *credp)
{
char *name = VNAME(dentry);
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
xfs_inode_t *dp, *ip;
- bhv_vnode_t *vp = NULL;
+ vnode_t *vp=NULL;
xfs_trans_t *tp;
xfs_mount_t *mp;
xfs_dev_t rdev;
if (error)
goto error_return;
- if (resblks == 0 && (error = xfs_dir_canenter(tp, dp, name, namelen)))
+ if (resblks == 0 &&
+ (error = XFS_DIR_CANENTER(mp, tp, dp, name, namelen)))
goto error_return;
rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
dp_joined_to_trans = B_TRUE;
- error = xfs_dir_createname(tp, dp, name, namelen, ip->i_ino,
- &first_block, &free_list, resblks ?
- resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
+ error = XFS_DIR_CREATENAME(mp, tp, dp, name, namelen, ip->i_ino,
+ &first_block, &free_list,
+ resblks ? resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
if (error) {
ASSERT(error != ENOSPC);
goto abort_return;
XFS_QM_DQRELE(mp, gdqp);
/*
- * Propagate the fact that the vnode changed after the
+ * Propogate the fact that the vnode changed after the
* xfs_inode locks have been released.
*/
- bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
+ VOP_VNODE_CHANGE(vp, VCHANGE_FLAGS_TRUNCATED, 3);
*vpp = vp;
STATIC int
xfs_lock_dir_and_entry(
xfs_inode_t *dp,
- bhv_vname_t *dentry,
+ vname_t *dentry,
xfs_inode_t *ip) /* inode of entry 'name' */
{
int attempts;
STATIC int
xfs_remove(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
+ vname_t *dentry,
cred_t *credp)
{
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
char *name = VNAME(dentry);
xfs_inode_t *dp, *ip;
xfs_trans_t *tp = NULL;
* for a log reservation. Since we'll have to wait for the
* inactive code to complete before returning from xfs_iget,
* we need to make sure that we don't have log space reserved
- * when we call xfs_iget. Instead we get an unlocked reference
+ * when we call xfs_iget. Instead we get an unlocked referece
* to the inode before getting our log reservation.
*/
error = xfs_get_dir_entry(dentry, &ip);
* Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
*/
XFS_BMAP_INIT(&free_list, &first_block);
- error = xfs_dir_removename(tp, dp, name, namelen, ip->i_ino,
- &first_block, &free_list, 0);
+ error = XFS_DIR_REMOVENAME(mp, tp, dp, name, namelen, ip->i_ino,
+ &first_block, &free_list, 0);
if (error) {
ASSERT(error != ENOENT);
REMOVE_DEBUG_TRACE(__LINE__);
/*
* Let interposed file systems know about removed links.
*/
- bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
+ VOP_LINK_REMOVED(XFS_ITOV(ip), dir_vp, link_zero);
IRELE(ip);
STATIC int
xfs_link(
bhv_desc_t *target_dir_bdp,
- bhv_vnode_t *src_vp,
- bhv_vname_t *dentry,
+ vnode_t *src_vp,
+ vname_t *dentry,
cred_t *credp)
{
xfs_inode_t *tdp, *sip;
xfs_fsblock_t first_block;
int cancel_flags;
int committed;
- bhv_vnode_t *target_dir_vp;
+ vnode_t *target_dir_vp;
int resblks;
char *target_name = VNAME(dentry);
int target_namelen;
vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address);
target_namelen = VNAMELEN(dentry);
- ASSERT(!VN_ISDIR(src_vp));
+ if (VN_ISDIR(src_vp))
+ return XFS_ERROR(EPERM);
sip = xfs_vtoi(src_vp);
tdp = XFS_BHVTOI(target_dir_bdp);
*/
if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
(tdp->i_d.di_projid != sip->i_d.di_projid))) {
- error = XFS_ERROR(EXDEV);
+ error = XFS_ERROR(EPERM);
goto error_return;
}
if (resblks == 0 &&
- (error = xfs_dir_canenter(tp, tdp, target_name, target_namelen)))
+ (error = XFS_DIR_CANENTER(mp, tp, tdp, target_name,
+ target_namelen)))
goto error_return;
XFS_BMAP_INIT(&free_list, &first_block);
- error = xfs_dir_createname(tp, tdp, target_name, target_namelen,
+ error = XFS_DIR_CREATENAME(mp, tp, tdp, target_name, target_namelen,
sip->i_ino, &first_block, &free_list,
resblks);
if (error)
xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
error = xfs_bumplink(tp, sip);
- if (error)
+ if (error) {
goto abort_return;
+ }
/*
* If this is a synchronous mount, make sure that the
}
error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES, NULL);
- if (error)
+ if (error) {
goto std_return;
+ }
/* Fall through to std_return with error = 0. */
std_return:
xfs_trans_cancel(tp, cancel_flags);
goto std_return;
}
-
-
/*
* xfs_mkdir
*
STATIC int
xfs_mkdir(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
- bhv_vattr_t *vap,
- bhv_vnode_t **vpp,
+ vname_t *dentry,
+ vattr_t *vap,
+ vnode_t **vpp,
cred_t *credp)
{
char *dir_name = VNAME(dentry);
xfs_inode_t *dp;
xfs_inode_t *cdp; /* inode of created dir */
- bhv_vnode_t *cvp; /* vnode of created dir */
+ vnode_t *cvp; /* vnode of created dir */
xfs_trans_t *tp;
xfs_mount_t *mp;
int cancel_flags;
int committed;
xfs_bmap_free_t free_list;
xfs_fsblock_t first_block;
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
boolean_t dp_joined_to_trans;
boolean_t created = B_FALSE;
int dm_event_sent = 0;
goto error_return;
if (resblks == 0 &&
- (error = xfs_dir_canenter(tp, dp, dir_name, dir_namelen)))
+ (error = XFS_DIR_CANENTER(mp, tp, dp, dir_name, dir_namelen)))
goto error_return;
/*
* create the directory inode.
XFS_BMAP_INIT(&free_list, &first_block);
- error = xfs_dir_createname(tp, dp, dir_name, dir_namelen, cdp->i_ino,
- &first_block, &free_list, resblks ?
- resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
+ error = XFS_DIR_CREATENAME(mp, tp, dp, dir_name, dir_namelen,
+ cdp->i_ino, &first_block, &free_list,
+ resblks ? resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
if (error) {
ASSERT(error != ENOSPC);
goto error1;
*/
dp->i_gen++;
- error = xfs_dir_init(tp, cdp, dp);
- if (error)
+ error = XFS_DIR_INIT(mp, tp, cdp, dp);
+ if (error) {
goto error2;
+ }
cdp->i_gen = 1;
error = xfs_bumplink(tp, dp);
- if (error)
+ if (error) {
goto error2;
+ }
cvp = XFS_ITOV(cdp);
STATIC int
xfs_rmdir(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
+ vname_t *dentry,
cred_t *credp)
{
char *name = VNAME(dentry);
xfs_fsblock_t first_block;
int cancel_flags;
int committed;
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
int dm_di_mode = 0;
int last_cdp_link;
int namelen;
* for a log reservation. Since we'll have to wait for the
* inactive code to complete before returning from xfs_iget,
* we need to make sure that we don't have log space reserved
- * when we call xfs_iget. Instead we get an unlocked reference
+ * when we call xfs_iget. Instead we get an unlocked referece
* to the inode before getting our log reservation.
*/
error = xfs_get_dir_entry(dentry, &cdp);
error = XFS_ERROR(ENOTEMPTY);
goto error_return;
}
- if (!xfs_dir_isempty(cdp)) {
+ if (!XFS_DIR_ISEMPTY(mp, cdp)) {
error = XFS_ERROR(ENOTEMPTY);
goto error_return;
}
- error = xfs_dir_removename(tp, dp, name, namelen, cdp->i_ino,
- &first_block, &free_list, resblks);
- if (error)
+ error = XFS_DIR_REMOVENAME(mp, tp, dp, name, namelen, cdp->i_ino,
+ &first_block, &free_list, resblks);
+ if (error) {
goto error1;
+ }
xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
/*
* Let interposed file systems know about removed links.
*/
- bhv_vop_link_removed(XFS_ITOV(cdp), dir_vp, last_cdp_link);
+ VOP_LINK_REMOVED(XFS_ITOV(cdp), dir_vp, last_cdp_link);
IRELE(cdp);
/* Fall through to std_return with error = 0 or the errno
* from xfs_trans_commit. */
- std_return:
+std_return:
if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_POSTREMOVE)) {
(void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
dir_vp, DM_RIGHT_NULL,
}
return error;
- error1:
+error1:
xfs_bmap_cancel(&free_list);
cancel_flags |= XFS_TRANS_ABORT;
/* FALLTHROUGH */
- error_return:
+error_return:
xfs_trans_cancel(tp, cancel_flags);
goto std_return;
}
/*
+ * xfs_readdir
+ *
* Read dp's entries starting at uiop->uio_offset and translate them into
* bufsize bytes worth of struct dirents starting at bufbase.
*/
(inst_t *)__return_address);
dp = XFS_BHVTOI(dir_bdp);
- if (XFS_FORCED_SHUTDOWN(dp->i_mount))
+ if (XFS_FORCED_SHUTDOWN(dp->i_mount)) {
return XFS_ERROR(EIO);
+ }
lock_mode = xfs_ilock_map_shared(dp);
- error = xfs_dir_getdents(tp, dp, uiop, eofp);
+ error = XFS_DIR_GETDENTS(dp->i_mount, tp, dp, uiop, eofp);
xfs_iunlock_map_shared(dp, lock_mode);
return error;
}
+/*
+ * xfs_symlink
+ *
+ */
STATIC int
xfs_symlink(
bhv_desc_t *dir_bdp,
- bhv_vname_t *dentry,
- bhv_vattr_t *vap,
+ vname_t *dentry,
+ vattr_t *vap,
char *target_path,
- bhv_vnode_t **vpp,
+ vnode_t **vpp,
cred_t *credp)
{
xfs_trans_t *tp;
xfs_bmap_free_t free_list;
xfs_fsblock_t first_block;
boolean_t dp_joined_to_trans;
- bhv_vnode_t *dir_vp;
+ vnode_t *dir_vp;
uint cancel_flags;
int committed;
xfs_fileoff_t first_fsb;
int len, total;
char *path;
- for (total = 0, path = target_path; total < pathlen;) {
+ for(total = 0, path = target_path; total < pathlen;) {
/*
* Skip any slashes.
*/
* Check for ability to enter directory entry, if no space reserved.
*/
if (resblks == 0 &&
- (error = xfs_dir_canenter(tp, dp, link_name, link_namelen)))
+ (error = XFS_DIR_CANENTER(mp, tp, dp, link_name, link_namelen)))
goto error_return;
/*
* Initialize the bmap freelist prior to calling either
error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
&first_block, resblks, mval, &nmaps,
- &free_list, NULL);
+ &free_list);
if (error) {
goto error1;
}
/*
* Create the directory entry for the symlink.
*/
- error = xfs_dir_createname(tp, dp, link_name, link_namelen, ip->i_ino,
- &first_block, &free_list, resblks);
- if (error)
+ error = XFS_DIR_CREATENAME(mp, tp, dp, link_name, link_namelen,
+ ip->i_ino, &first_block, &free_list, resblks);
+ if (error) {
goto error1;
+ }
xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
}
if (!error) {
- bhv_vnode_t *vp;
+ vnode_t *vp;
ASSERT(ip);
vp = XFS_ITOV(ip);
int
xfs_rwlock(
bhv_desc_t *bdp,
- bhv_vrwlock_t locktype)
+ vrwlock_t locktype)
{
xfs_inode_t *ip;
- bhv_vnode_t *vp;
+ vnode_t *vp;
vp = BHV_TO_VNODE(bdp);
if (VN_ISDIR(vp))
void
xfs_rwunlock(
bhv_desc_t *bdp,
- bhv_vrwlock_t locktype)
+ vrwlock_t locktype)
{
xfs_inode_t *ip;
- bhv_vnode_t *vp;
+ vnode_t *vp;
vp = BHV_TO_VNODE(bdp);
if (VN_ISDIR(vp))
return error;
}
+
int
xfs_set_dmattrs (
bhv_desc_t *bdp,
return error;
}
+
+/*
+ * xfs_reclaim
+ */
STATIC int
xfs_reclaim(
bhv_desc_t *bdp)
{
xfs_inode_t *ip;
- bhv_vnode_t *vp;
+ vnode_t *vp;
vp = BHV_TO_VNODE(bdp);
ip = XFS_BHVTOI(bdp);
int sync_mode)
{
xfs_ihash_t *ih = ip->i_hash;
- bhv_vnode_t *vp = XFS_ITOV_NULL(ip);
+ vnode_t *vp = XFS_ITOV_NULL(ip);
int error;
if (vp && VN_BAD(vp))
* Issue the xfs_bmapi() call to allocate the blocks
*/
XFS_BMAP_INIT(&free_list, &firstfsb);
- error = XFS_BMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
+ error = xfs_bmapi(tp, ip, startoffset_fsb,
allocatesize_fsb, bmapi_flag,
&firstfsb, 0, imapp, &nimaps,
- &free_list, NULL);
+ &free_list);
if (error) {
goto error0;
}
for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
offset_fsb = XFS_B_TO_FSBT(mp, offset);
nimap = 1;
- error = XFS_BMAPI(mp, NULL, &ip->i_iocore, offset_fsb, 1, 0,
- NULL, 0, &imap, &nimap, NULL, NULL);
+ error = xfs_bmapi(NULL, ip, offset_fsb, 1, 0, NULL, 0, &imap,
+ &nimap, NULL);
if (error || nimap < 1)
break;
ASSERT(imap.br_blockcount >= 1);
xfs_off_t len,
int attr_flags)
{
- bhv_vnode_t *vp;
+ vnode_t *vp;
int committed;
int done;
xfs_off_t end_dmi_offset;
return error;
}
+ ASSERT(attr_flags & ATTR_NOLOCK ? attr_flags & ATTR_DMI : 1);
if (attr_flags & ATTR_NOLOCK)
need_iolock = 0;
- if (need_iolock) {
+ if (need_iolock)
xfs_ilock(ip, XFS_IOLOCK_EXCL);
- vn_iowait(vp); /* wait for the completion of any pending DIOs */
- }
rounding = MAX((__uint8_t)(1 << mp->m_sb.sb_blocklog),
(__uint8_t)NBPP);
if (VN_CACHED(vp) != 0) {
xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
ctooff(offtoct(ioffset)), -1);
- bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
+ VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(ioffset)),
-1, FI_REMAPF_LOCKED);
}
*/
if (rt && !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
nimap = 1;
- error = XFS_BMAPI(mp, NULL, &ip->i_iocore, startoffset_fsb,
- 1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
+ error = xfs_bmapi(NULL, ip, startoffset_fsb, 1, 0, NULL, 0,
+ &imap, &nimap, NULL);
if (error)
goto out_unlock_iolock;
ASSERT(nimap == 0 || nimap == 1);
startoffset_fsb += mp->m_sb.sb_rextsize - mod;
}
nimap = 1;
- error = XFS_BMAPI(mp, NULL, &ip->i_iocore, endoffset_fsb - 1,
- 1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
+ error = xfs_bmapi(NULL, ip, endoffset_fsb - 1, 1, 0, NULL, 0,
+ &imap, &nimap, NULL);
if (error)
goto out_unlock_iolock;
ASSERT(nimap == 0 || nimap == 1);
* issue the bunmapi() call to free the blocks
*/
XFS_BMAP_INIT(&free_list, &firstfsb);
- error = XFS_BUNMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
+ error = xfs_bunmapi(tp, ip, startoffset_fsb,
endoffset_fsb - startoffset_fsb,
- 0, 2, &firstfsb, &free_list, NULL, &done);
+ 0, 2, &firstfsb, &free_list, &done);
if (error) {
goto error0;
}
xfs_off_t startoffset;
xfs_off_t llen;
xfs_trans_t *tp;
- bhv_vattr_t va;
- bhv_vnode_t *vp;
+ vattr_t va;
+ vnode_t *vp;
vp = BHV_TO_VNODE(bdp);
vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
return error;
}
-bhv_vnodeops_t xfs_vnodeops = {
+vnodeops_t xfs_vnodeops = {
BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
.vop_open = xfs_open,
- .vop_close = xfs_close,
.vop_read = xfs_read,
#ifdef HAVE_SENDFILE
.vop_sendfile = xfs_sendfile,
-#endif
-#ifdef HAVE_SPLICE
- .vop_splice_read = xfs_splice_read,
- .vop_splice_write = xfs_splice_write,
#endif
.vop_write = xfs_write,
.vop_ioctl = xfs_ioctl,
git://git.onelab.eu / linux-2.6.git / blobdiff