[XFS] First stage of behavior code cleanup - removes a bunch of unused macros

related to read/write locking the behavior change.

SGI Modid: 2.5.x-xfs:slinx:141401a

fs/xfs/linux/xfs_behavior.c

@@ -121,9 +121,7 @@ bhv_lookup_unlocked(bhv_head_t *bhp, void *ops)
 {
 	bhv_desc_t	*bdp;
 
-	BHV_READ_LOCK(bhp);
 	bdp = bhv_lookup(bhp, ops);
-	BHV_READ_UNLOCK(bhp);
 
 	return bdp;
 }
@@ -140,18 +138,12 @@ bhv_base_unlocked(bhv_head_t *bhp)
 {
 	bhv_desc_t	*curdesc;
 
-	BHV_READ_LOCK(bhp);
 	for (curdesc = bhp->bh_first;
 	     curdesc != NULL;
 	     curdesc = curdesc->bd_next) {
-
-		if (curdesc->bd_next == NULL) {
-			BHV_READ_UNLOCK(bhp);
+		if (curdesc->bd_next == NULL)
 			return curdesc;
-		}
 	}
-
-	BHV_READ_UNLOCK(bhp);
 	return NULL;
 }
 

fs/xfs/linux/xfs_behavior.h

@@ -152,13 +152,6 @@ typedef bhv_identity_t bhv_position_t;
 #define BHV_IDENTITY(bdp)	((bhv_identity_t *)(bdp)->bd_ops)
 #define BHV_POSITION(bdp)	(BHV_IDENTITY(bdp)->bi_position)
 
-
-#define BHV_READ_LOCK(bhp)
-#define BHV_READ_UNLOCK(bhp)
-#define BHV_NOT_READ_LOCKED(bhp)	1
-#define BHV_IS_WRITE_LOCKED(bhp)	1
-#define BHV_NOT_WRITE_LOCKED(bhp)	1
-
 extern void bhv_head_init(bhv_head_t *, char *);
 extern void bhv_head_destroy(bhv_head_t *);
 extern void bhv_head_reinit(bhv_head_t *);
@@ -180,8 +173,6 @@ extern void bhv_insert_initial(bhv_head_t *, bhv_desc_t *);
 	(bdp)->bd_next = NULL;				\
  }
 
-#define BHV_DESC_INIT(so,A,B)	bhv_desc_init(&(so->so_bhv),so,A,B)
-
 /*
  * Remove a behavior descriptor from a behavior chain.
  */

fs/xfs/linux/xfs_ioctl.c

@@ -130,7 +130,6 @@ xfs_find_handle(
 		int		lock_mode;
 
 		/* need to get access to the xfs_inode to read the generation */
-		VN_BHV_READ_LOCK(&(vp)->v_bh);
 		bhv = VNODE_TO_FIRST_BHV(vp);
 		ASSERT(bhv);
 		ip = XFS_BHVTOI(bhv);
@@ -145,7 +144,6 @@ xfs_find_handle(
 		handle.ha_fid.xfs_fid_ino = ip->i_ino;
 
 		xfs_iunlock_map_shared(ip, lock_mode);
-		VN_BHV_READ_UNLOCK(&(vp)->v_bh);
 
 		hsize = XFS_HSIZE(handle);
 	}

fs/xfs/linux/xfs_vfs.h

@@ -97,40 +97,28 @@ typedef struct vfsops {
 
 #define VFS_UNMOUNT(vfsp,f,cr, rv)	\
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
-	rv = (*(VFS_FOPS(vfsp)->vfs_unmount))((vfsp)->vfs_fbhv, f, cr);		\
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
+	rv = (*(VFS_FOPS(vfsp)->vfs_unmount))((vfsp)->vfs_fbhv, f, cr);	\
 }
 #define VFS_ROOT(vfsp, vpp, rv)		\
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
 	rv = (*(VFS_FOPS(vfsp)->vfs_root))((vfsp)->vfs_fbhv, vpp);	\
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
 }
 #define VFS_STATVFS(vfsp, sp, vp, rv)	\
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
-	rv = (*(VFS_FOPS(vfsp)->vfs_statvfs))((vfsp)->vfs_fbhv, sp, vp);	\
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
+	rv = (*(VFS_FOPS(vfsp)->vfs_statvfs))((vfsp)->vfs_fbhv, sp, vp);\
 }
 #define VFS_SYNC(vfsp, flag, cr, rv) \
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
 	rv = (*(VFS_FOPS(vfsp)->vfs_sync))((vfsp)->vfs_fbhv, flag, cr); \
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
 }
 #define VFS_VGET(vfsp, vpp, fidp, rv) \
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
 	rv = (*(VFS_FOPS(vfsp)->vfs_vget))((vfsp)->vfs_fbhv, vpp, fidp);  \
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
 }
 
 #define VFS_INIT_VNODE(vfsp, vp, bhv, unlock) \
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
 	(*(VFS_FOPS(vfsp)->vfs_init_vnode))((vfsp)->vfs_fbhv, vp, bhv, unlock);\
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
 }
 
 /* No behavior lock here */
@@ -139,9 +127,7 @@ typedef struct vfsops {
 
 #define VFS_DMAPI_FSYS_VECTOR(vfsp, df, rv) \
 {	\
-	BHV_READ_LOCK(&(vfsp)->vfs_bh); \
 	rv = (*(VFS_FOPS(vfsp)->vfs_dmapi_fsys_vector))((vfsp)->vfs_fbhv, df);	      \
-	BHV_READ_UNLOCK(&(vfsp)->vfs_bh); \
 }
 
 

fs/xfs/linux/xfs_vnode.h

@@ -98,11 +98,6 @@ typedef enum {
 
 #define VNODE_TO_FIRST_BHV(vp)		(BHV_HEAD_FIRST(&(vp)->v_bh))
 #define VN_BHV_HEAD(vp)			((bhv_head_t *)(&((vp)->v_bh)))
-#define VN_BHV_READ_LOCK(bhp)		BHV_READ_LOCK(bhp)
-#define VN_BHV_READ_UNLOCK(bhp)		BHV_READ_UNLOCK(bhp)
-#define VN_BHV_WRITE_LOCK(bhp)		BHV_WRITE_LOCK(bhp)
-#define VN_BHV_NOT_READ_LOCKED(bhp)	BHV_NOT_READ_LOCKED(bhp)
-#define VN_BHV_NOT_WRITE_LOCKED(bhp)	BHV_NOT_WRITE_LOCKED(bhp)
 #define vn_bhv_head_init(bhp,name)	bhv_head_init(bhp,name)
 #define vn_bhv_remove(bhp,bdp)		bhv_remove(bhp,bdp)
 #define vn_bhv_lookup(bhp,ops)		bhv_lookup(bhp,ops)
@@ -274,187 +269,130 @@ typedef struct vnodeops {
 
 #define VOP_READ(vp,file,iov,segs,offset,cr,rv)				\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_read, vp)((vp)->v_fbhv,file,iov,segs,offset,cr); \
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_WRITE(vp,file,iov,segs,offset,cr,rv)			\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_write, vp)((vp)->v_fbhv,file,iov,segs,offset,cr);\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_SENDFILE(vp,f,of,cnt,act,targ,cr,rv)			\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_sendfile, vp)((vp)->v_fbhv,f,of,cnt,act,targ,cr);\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_BMAP(vp,of,sz,rw,b,n,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_bmap, vp)((vp)->v_fbhv,of,sz,rw,b,n);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_OPEN(vp, cr, rv)						\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_open, vp)((vp)->v_fbhv, cr);			\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_GETATTR(vp, vap, f, cr, rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_getattr, vp)((vp)->v_fbhv, vap, f, cr);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_SETATTR(vp, vap, f, cr, rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_setattr, vp)((vp)->v_fbhv, vap, f, cr);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_ACCESS(vp, mode, cr, rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_access, vp)((vp)->v_fbhv, mode, cr);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_LOOKUP(vp,d,vpp,f,rdir,cr,rv)				\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_lookup, vp)((vp)->v_fbhv,d,vpp,f,rdir,cr);	\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_CREATE(dvp,d,vap,vpp,cr,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(dvp)->v_bh);					\
 	rv = _VOP_(vop_create, dvp)((dvp)->v_fbhv,d,vap,vpp,cr);	\
-	VN_BHV_READ_UNLOCK(&(dvp)->v_bh);				\
 }
 #define VOP_REMOVE(dvp,d,cr,rv)						\
 {									\
-	VN_BHV_READ_LOCK(&(dvp)->v_bh);					\
 	rv = _VOP_(vop_remove, dvp)((dvp)->v_fbhv,d,cr);		\
-	VN_BHV_READ_UNLOCK(&(dvp)->v_bh);				\
 }
 #define VOP_LINK(tdvp,fvp,d,cr,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(tdvp)->v_bh);				\
 	rv = _VOP_(vop_link, tdvp)((tdvp)->v_fbhv,fvp,d,cr);		\
-	VN_BHV_READ_UNLOCK(&(tdvp)->v_bh);				\
 }
 #define VOP_RENAME(fvp,fnm,tdvp,tnm,cr,rv)				\
 {									\
-	VN_BHV_READ_LOCK(&(fvp)->v_bh);					\
 	rv = _VOP_(vop_rename, fvp)((fvp)->v_fbhv,fnm,tdvp,tnm,cr);	\
-	VN_BHV_READ_UNLOCK(&(fvp)->v_bh);				\
 }
 #define VOP_MKDIR(dp,d,vap,vpp,cr,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(dp)->v_bh);					\
 	rv = _VOP_(vop_mkdir, dp)((dp)->v_fbhv,d,vap,vpp,cr);		\
-	VN_BHV_READ_UNLOCK(&(dp)->v_bh);				\
 }
 #define	VOP_RMDIR(dp,d,cr,rv)	 					\
 {									\
-	VN_BHV_READ_LOCK(&(dp)->v_bh);					\
 	rv = _VOP_(vop_rmdir, dp)((dp)->v_fbhv,d,cr);			\
-	VN_BHV_READ_UNLOCK(&(dp)->v_bh);				\
 }
 #define VOP_READDIR(vp,uiop,cr,eofp,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_readdir, vp)((vp)->v_fbhv,uiop,cr,eofp);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_SYMLINK(dvp,d,vap,tnm,vpp,cr,rv)				\
 {									\
-	VN_BHV_READ_LOCK(&(dvp)->v_bh);					\
-	rv = _VOP_(vop_symlink, dvp) ((dvp)->v_fbhv,d,vap,tnm,vpp,cr); \
-	VN_BHV_READ_UNLOCK(&(dvp)->v_bh);				\
+	rv = _VOP_(vop_symlink, dvp) ((dvp)->v_fbhv,d,vap,tnm,vpp,cr);	\
 }
 #define VOP_READLINK(vp,uiop,cr,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_readlink, vp)((vp)->v_fbhv,uiop,cr);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_FSYNC(vp,f,cr,b,e,rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_fsync, vp)((vp)->v_fbhv,f,cr,b,e);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_INACTIVE(vp, cr, rv)					\
-{	/* vnode not reference-able, so no need to lock chain */	\
+{									\
 	rv = _VOP_(vop_inactive, vp)((vp)->v_fbhv, cr);			\
 }
 #define VOP_RELEASE(vp, rv)						\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_release, vp)((vp)->v_fbhv);			\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_FID2(vp, fidp, rv)						\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_fid2, vp)((vp)->v_fbhv, fidp);			\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_RWLOCK(vp,i)						\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	(void)_VOP_(vop_rwlock, vp)((vp)->v_fbhv, i);			\
-	/* "allow" is done by rwunlock */				\
 }
 #define VOP_RWLOCK_TRY(vp,i)						\
 	_VOP_(vop_rwlock, vp)((vp)->v_fbhv, i)
 
 #define VOP_RWUNLOCK(vp,i)						\
-{	/* "prevent" was done by rwlock */				\
+{									\
 	(void)_VOP_(vop_rwunlock, vp)((vp)->v_fbhv, i);			\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_RECLAIM(vp, rv)						\
-{	/* vnode not reference-able, so no need to lock chain */	\
+{									\
 	rv = _VOP_(vop_reclaim, vp)((vp)->v_fbhv);			\
 }
 #define VOP_ATTR_GET(vp, name, val, vallenp, fl, cred, rv)		\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_attr_get, vp)((vp)->v_fbhv,name,val,vallenp,fl,cred); \
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_ATTR_SET(vp, name, val, vallen, fl, cred, rv)		\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_attr_set, vp)((vp)->v_fbhv,name,val,vallen,fl,cred); \
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_ATTR_REMOVE(vp, name, flags, cred, rv)			\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_attr_remove, vp)((vp)->v_fbhv,name,flags,cred);	\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_ATTR_LIST(vp, buf, buflen, fl, cursor, cred, rv)		\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_attr_list, vp)((vp)->v_fbhv,buf,buflen,fl,cursor,cred);\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_LINK_REMOVED(vp, dvp, linkzero)				\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	(void)_VOP_(vop_link_removed, vp)((vp)->v_fbhv, dvp, linkzero); \
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_VNODE_CHANGE(vp, cmd, val)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	(void)_VOP_(vop_vnode_change, vp)((vp)->v_fbhv,cmd,val);	\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 /*
  * These are page cache functions that now go thru VOPs.
@@ -462,39 +400,29 @@ typedef struct vnodeops {
  */
 #define VOP_TOSS_PAGES(vp, first, last, fiopt)				\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	_VOP_(vop_tosspages, vp)((vp)->v_fbhv,first, last, fiopt);	\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 /*
  * 'last' parameter is unused and left in for IRIX compatibility
  */
 #define VOP_FLUSHINVAL_PAGES(vp, first, last, fiopt)			\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	_VOP_(vop_flushinval_pages, vp)((vp)->v_fbhv,first,last,fiopt); \
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 /*
  * 'last' parameter is unused and left in for IRIX compatibility
  */
 #define VOP_FLUSH_PAGES(vp, first, last, flags, fiopt, rv)		\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_flush_pages, vp)((vp)->v_fbhv,first,last,flags,fiopt);\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_IOCTL(vp, inode, filp, cmd, arg, rv)			\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_ioctl, vp)((vp)->v_fbhv,inode,filp,cmd,arg);	\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 #define VOP_IFLUSH(vp, flags, rv)					\
 {									\
-	VN_BHV_READ_LOCK(&(vp)->v_bh);					\
 	rv = _VOP_(vop_iflush, vp)((vp)->v_fbhv, flags);		\
-	VN_BHV_READ_UNLOCK(&(vp)->v_bh);				\
 }
 
 /*

fs/xfs/xfs_dfrag.c

@@ -69,15 +69,12 @@ xfs_swapext(
 	}
 
 	bhp = VN_BHV_HEAD(vp);
-	VN_BHV_READ_LOCK(bhp);
 	bdp = vn_bhv_lookup(bhp, &xfs_vnodeops);
 	if (bdp == NULL) {
-		VN_BHV_READ_UNLOCK(bhp);
 		error = XFS_ERROR(EBADF);
 		goto error0;
 	} else {
 		ip = XFS_BHVTOI(bdp);
-		VN_BHV_READ_UNLOCK(bhp);
 	}
 
 	if (((tfp = fget((int)sx.sx_fdtmp)) == NULL) ||
@@ -87,15 +84,12 @@ xfs_swapext(
 	}
 
 	tbhp = VN_BHV_HEAD(tvp);
-	VN_BHV_READ_LOCK(tbhp);
 	tbdp = vn_bhv_lookup(tbhp, &xfs_vnodeops);
 	if (tbdp == NULL) {
-		VN_BHV_READ_UNLOCK(tbhp);
 		error = XFS_ERROR(EBADF);
 		goto error0;
 	} else {
 		tip = XFS_BHVTOI(tbdp);
-		VN_BHV_READ_UNLOCK(tbhp);
 	}
 
 	if (ip->i_ino == tip->i_ino) {

fs/xfs/xfsidbg.c

@@ -4162,8 +4162,6 @@ xfsidbg_xinodes_quiesce(xfs_mount_t *mp)
 			}
 			if (!(ip->i_flags & XFS_IQUIESCE)) {
 				kdb_printf("ip 0x%p not quiesced\n", ip);
-			} else if (!BHV_IS_WRITE_LOCKED(VN_BHV_HEAD(XFS_ITOV(ip)))) {
-				kdb_printf("ip 0x%p not write locked\n", ip);
 			}
 			ip = ip->i_mnext;
 		} while (ip != mp->m_inodes);