fs/xfs/linux-2.6/xfs_vnode.h

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #ifndef __XFS_VNODE_H__
  19 #define __XFS_VNODE_H__
  20
  21 struct file;
  22 struct bhv_vfs;
  23 struct bhv_vattr;
  24 struct xfs_iomap;
  25 struct attrlist_cursor_kern;
  26
  27 typedef struct dentry   bhv_vname_t;
  28 typedef __u64           bhv_vnumber_t;
  29
  30 typedef enum bhv_vflags {
  31         VMODIFIED       = 0x08, /* XFS inode state possibly differs */
  32                                 /* to the Linux inode state. */
  33         VTRUNCATED      = 0x40, /* truncated down so flush-on-close */
  34 } bhv_vflags_t;
  35
  36 /*
  37  * MP locking protocols:
  38  *      v_flag, v_vfsp                          VN_LOCK/VN_UNLOCK
  39  */
  40 typedef struct bhv_vnode {
  41         bhv_vflags_t    v_flag;                 /* vnode flags (see above) */
  42         bhv_vfs_t       *v_vfsp;                /* ptr to containing VFS */
  43         bhv_vnumber_t   v_number;               /* in-core vnode number */
  44         bhv_head_t      v_bh;                   /* behavior head */
  45         spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
  46         atomic_t        v_iocount;              /* outstanding I/O count */
  47 #ifdef XFS_VNODE_TRACE
  48         struct ktrace   *v_trace;               /* trace header structure    */
  49 #endif
  50         struct inode    v_inode;                /* Linux inode */
  51         /* inode MUST be last */
  52 } bhv_vnode_t;
  53
  54 #define VN_ISLNK(vp)    S_ISLNK((vp)->v_inode.i_mode)
  55 #define VN_ISREG(vp)    S_ISREG((vp)->v_inode.i_mode)
  56 #define VN_ISDIR(vp)    S_ISDIR((vp)->v_inode.i_mode)
  57 #define VN_ISCHR(vp)    S_ISCHR((vp)->v_inode.i_mode)
  58 #define VN_ISBLK(vp)    S_ISBLK((vp)->v_inode.i_mode)
  59
  60 #define VNODE_POSITION_BASE     BHV_POSITION_BASE       /* chain bottom */
  61 #define VNODE_POSITION_TOP      BHV_POSITION_TOP        /* chain top */
  62 #define VNODE_POSITION_INVALID  BHV_POSITION_INVALID    /* invalid pos. num */
  63
  64 typedef enum {
  65         VN_BHV_UNKNOWN,         /* not specified */
  66         VN_BHV_XFS,             /* xfs */
  67         VN_BHV_DM,              /* data migration */
  68         VN_BHV_QM,              /* quota manager */
  69         VN_BHV_IO,              /* IO path */
  70         VN_BHV_END              /* housekeeping end-of-range */
  71 } vn_bhv_t;
  72
  73 #define VNODE_POSITION_XFS      (VNODE_POSITION_BASE)
  74 #define VNODE_POSITION_DM       (VNODE_POSITION_BASE+10)
  75 #define VNODE_POSITION_QM       (VNODE_POSITION_BASE+20)
  76 #define VNODE_POSITION_IO       (VNODE_POSITION_BASE+30)
  77
  78 /*
  79  * Macros for dealing with the behavior descriptor inside of the vnode.
  80  */
  81 #define BHV_TO_VNODE(bdp)       ((bhv_vnode_t *)BHV_VOBJ(bdp))
  82 #define BHV_TO_VNODE_NULL(bdp)  ((bhv_vnode_t *)BHV_VOBJNULL(bdp))
  83
  84 #define VN_BHV_HEAD(vp)                 ((bhv_head_t *)(&((vp)->v_bh)))
  85 #define vn_bhv_head_init(bhp,name)      bhv_head_init(bhp,name)
  86 #define vn_bhv_remove(bhp,bdp)          bhv_remove(bhp,bdp)
  87
  88 /*
  89  * Vnode to Linux inode mapping.
  90  */
  91 static inline struct bhv_vnode *vn_from_inode(struct inode *inode)
  92 {
  93         return container_of(inode, bhv_vnode_t, v_inode);
  94 }
  95 static inline struct inode *vn_to_inode(struct bhv_vnode *vnode)
  96 {
  97         return &vnode->v_inode;
  98 }
  99
 100 /*
 101  * Values for the vop_rwlock/rwunlock flags parameter.
 102  */
 103 typedef enum bhv_vrwlock {
 104         VRWLOCK_NONE,
 105         VRWLOCK_READ,
 106         VRWLOCK_WRITE,
 107         VRWLOCK_WRITE_DIRECT,
 108         VRWLOCK_TRY_READ,
 109         VRWLOCK_TRY_WRITE
 110 } bhv_vrwlock_t;
 111
 112 /*
 113  * Return values for bhv_vop_inactive.  A return value of
 114  * VN_INACTIVE_NOCACHE implies that the file system behavior
 115  * has disassociated its state and bhv_desc_t from the vnode.
 116  */
 117 #define VN_INACTIVE_CACHE       0
 118 #define VN_INACTIVE_NOCACHE     1
 119
 120 /*
 121  * Values for the cmd code given to vop_vnode_change.
 122  */
 123 typedef enum bhv_vchange {
 124         VCHANGE_FLAGS_FRLOCKS           = 0,
 125         VCHANGE_FLAGS_ENF_LOCKING       = 1,
 126         VCHANGE_FLAGS_TRUNCATED         = 2,
 127         VCHANGE_FLAGS_PAGE_DIRTY        = 3,
 128         VCHANGE_FLAGS_IOEXCL_COUNT      = 4
 129 } bhv_vchange_t;
 130
 131 typedef int     (*vop_open_t)(bhv_desc_t *, struct cred *);
 132 typedef ssize_t (*vop_read_t)(bhv_desc_t *, struct kiocb *,
 133                                 const struct iovec *, unsigned int,
 134                                 loff_t *, int, struct cred *);
 135 typedef ssize_t (*vop_write_t)(bhv_desc_t *, struct kiocb *,
 136                                 const struct iovec *, unsigned int,
 137                                 loff_t *, int, struct cred *);
 138 typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *, loff_t *,
 139                                 struct pipe_inode_info *, size_t, int, int,
 140                                 struct cred *);
 141 typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct pipe_inode_info *,
 142                                 struct file *, loff_t *, size_t, int, int,
 143                                 struct cred *);
 144 typedef int     (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
 145                                 int, unsigned int, void __user *);
 146 typedef int     (*vop_getattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
 147                                 struct cred *);
 148 typedef int     (*vop_setattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
 149                                 struct cred *);
 150 typedef int     (*vop_access_t)(bhv_desc_t *, int, struct cred *);
 151 typedef int     (*vop_lookup_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t **,
 152                                 int, bhv_vnode_t *, struct cred *);
 153 typedef int     (*vop_create_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
 154                                 bhv_vnode_t **, struct cred *);
 155 typedef int     (*vop_remove_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
 156 typedef int     (*vop_link_t)(bhv_desc_t *, bhv_vnode_t *, bhv_vname_t *,
 157                                 struct cred *);
 158 typedef int     (*vop_rename_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t *,
 159                                 bhv_vname_t *, struct cred *);
 160 typedef int     (*vop_mkdir_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
 161                                 bhv_vnode_t **, struct cred *);
 162 typedef int     (*vop_rmdir_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
 163 typedef int     (*vop_readdir_t)(bhv_desc_t *, void *dirent, size_t bufsize,
 164                                  xfs_off_t *offset, filldir_t filldir);
 165 typedef int     (*vop_symlink_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr*,
 166                                 char *, bhv_vnode_t **, struct cred *);
 167 typedef int     (*vop_readlink_t)(bhv_desc_t *, char *);
 168 typedef int     (*vop_fsync_t)(bhv_desc_t *, int, struct cred *,
 169                                 xfs_off_t, xfs_off_t);
 170 typedef int     (*vop_inactive_t)(bhv_desc_t *, struct cred *);
 171 typedef int     (*vop_fid2_t)(bhv_desc_t *, struct fid *);
 172 typedef int     (*vop_release_t)(bhv_desc_t *);
 173 typedef int     (*vop_rwlock_t)(bhv_desc_t *, bhv_vrwlock_t);
 174 typedef void    (*vop_rwunlock_t)(bhv_desc_t *, bhv_vrwlock_t);
 175 typedef int     (*vop_bmap_t)(bhv_desc_t *, xfs_off_t, ssize_t, int,
 176                                 struct xfs_iomap *, int *);
 177 typedef int     (*vop_reclaim_t)(bhv_desc_t *);
 178 typedef int     (*vop_attr_get_t)(bhv_desc_t *, const char *, char *, int *,
 179                                 int, struct cred *);
 180 typedef int     (*vop_attr_set_t)(bhv_desc_t *, const char *, char *, int,
 181                                 int, struct cred *);
 182 typedef int     (*vop_attr_remove_t)(bhv_desc_t *, const char *,
 183                                 int, struct cred *);
 184 typedef int     (*vop_attr_list_t)(bhv_desc_t *, char *, int, int,
 185                                 struct attrlist_cursor_kern *, struct cred *);
 186 typedef void    (*vop_link_removed_t)(bhv_desc_t *, bhv_vnode_t *, int);
 187 typedef void    (*vop_vnode_change_t)(bhv_desc_t *, bhv_vchange_t, __psint_t);
 188 typedef void    (*vop_ptossvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 189 typedef int     (*vop_pflushinvalvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 190 typedef int     (*vop_pflushvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t,
 191                                 uint64_t, int);
 192 typedef int     (*vop_iflush_t)(bhv_desc_t *, int);
 193
 194
 195 typedef struct bhv_vnodeops {
 196         bhv_position_t  vn_position;    /* position within behavior chain */
 197         vop_open_t              vop_open;
 198         vop_read_t              vop_read;
 199         vop_write_t             vop_write;
 200         vop_splice_read_t       vop_splice_read;
 201         vop_splice_write_t      vop_splice_write;
 202         vop_ioctl_t             vop_ioctl;
 203         vop_getattr_t           vop_getattr;
 204         vop_setattr_t           vop_setattr;
 205         vop_access_t            vop_access;
 206         vop_lookup_t            vop_lookup;
 207         vop_create_t            vop_create;
 208         vop_remove_t            vop_remove;
 209         vop_link_t              vop_link;
 210         vop_rename_t            vop_rename;
 211         vop_mkdir_t             vop_mkdir;
 212         vop_rmdir_t             vop_rmdir;
 213         vop_readdir_t           vop_readdir;
 214         vop_symlink_t           vop_symlink;
 215         vop_readlink_t          vop_readlink;
 216         vop_fsync_t             vop_fsync;
 217         vop_inactive_t          vop_inactive;
 218         vop_fid2_t              vop_fid2;
 219         vop_rwlock_t            vop_rwlock;
 220         vop_rwunlock_t          vop_rwunlock;
 221         vop_bmap_t              vop_bmap;
 222         vop_reclaim_t           vop_reclaim;
 223         vop_attr_get_t          vop_attr_get;
 224         vop_attr_set_t          vop_attr_set;
 225         vop_attr_remove_t       vop_attr_remove;
 226         vop_attr_list_t         vop_attr_list;
 227         vop_link_removed_t      vop_link_removed;
 228         vop_vnode_change_t      vop_vnode_change;
 229         vop_ptossvp_t           vop_tosspages;
 230         vop_pflushinvalvp_t     vop_flushinval_pages;
 231         vop_pflushvp_t          vop_flush_pages;
 232         vop_release_t           vop_release;
 233         vop_iflush_t            vop_iflush;
 234 } bhv_vnodeops_t;
 235
 236 /*
 237  * Virtual node operations, operating from head bhv.
 238  */
 239 #define VNHEAD(vp)      ((vp)->v_bh.bh_first)
 240 #define VOP(op, vp)     (*((bhv_vnodeops_t *)VNHEAD(vp)->bd_ops)->op)
 241 #define bhv_vop_open(vp, cr)            VOP(vop_open, vp)(VNHEAD(vp),cr)
 242 #define bhv_vop_read(vp,file,iov,segs,offset,ioflags,cr)                \
 243                 VOP(vop_read, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
 244 #define bhv_vop_write(vp,file,iov,segs,offset,ioflags,cr)               \
 245                 VOP(vop_write, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
 246 #define bhv_vop_splice_read(vp,f,o,pipe,cnt,fl,iofl,cr)                 \
 247                 VOP(vop_splice_read, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
 248 #define bhv_vop_splice_write(vp,f,o,pipe,cnt,fl,iofl,cr)                \
 249                 VOP(vop_splice_write, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
 250 #define bhv_vop_bmap(vp,of,sz,rw,b,n)                                   \
 251                 VOP(vop_bmap, vp)(VNHEAD(vp),of,sz,rw,b,n)
 252 #define bhv_vop_getattr(vp, vap,f,cr)                                   \
 253                 VOP(vop_getattr, vp)(VNHEAD(vp), vap,f,cr)
 254 #define bhv_vop_setattr(vp, vap,f,cr)                                   \
 255                 VOP(vop_setattr, vp)(VNHEAD(vp), vap,f,cr)
 256 #define bhv_vop_access(vp, mode,cr)     VOP(vop_access, vp)(VNHEAD(vp), mode,cr)
 257 #define bhv_vop_lookup(vp,d,vpp,f,rdir,cr)                              \
 258                 VOP(vop_lookup, vp)(VNHEAD(vp),d,vpp,f,rdir,cr)
 259 #define bhv_vop_create(dvp,d,vap,vpp,cr)                                \
 260                 VOP(vop_create, dvp)(VNHEAD(dvp),d,vap,vpp,cr)
 261 #define bhv_vop_remove(dvp,d,cr)        VOP(vop_remove, dvp)(VNHEAD(dvp),d,cr)
 262 #define bhv_vop_link(dvp,fvp,d,cr)      VOP(vop_link, dvp)(VNHEAD(dvp),fvp,d,cr)
 263 #define bhv_vop_rename(fvp,fnm,tdvp,tnm,cr)                             \
 264                 VOP(vop_rename, fvp)(VNHEAD(fvp),fnm,tdvp,tnm,cr)
 265 #define bhv_vop_mkdir(dp,d,vap,vpp,cr)                                  \
 266                 VOP(vop_mkdir, dp)(VNHEAD(dp),d,vap,vpp,cr)
 267 #define bhv_vop_rmdir(dp,d,cr)          VOP(vop_rmdir, dp)(VNHEAD(dp),d,cr)
 268 #define bhv_vop_readdir(vp,dirent,bufsize,offset,filldir)               \
 269                 VOP(vop_readdir, vp)(VNHEAD(vp),dirent,bufsize,offset,filldir)
 270 #define bhv_vop_symlink(dvp,d,vap,tnm,vpp,cr)                           \
 271                 VOP(vop_symlink, dvp)(VNHEAD(dvp),d,vap,tnm,vpp,cr)
 272 #define bhv_vop_readlink(vp,link)                                       \
 273                 VOP(vop_readlink, vp)(VNHEAD(vp), link)
 274 #define bhv_vop_fsync(vp,f,cr,b,e)      VOP(vop_fsync, vp)(VNHEAD(vp),f,cr,b,e)
 275 #define bhv_vop_inactive(vp,cr)         VOP(vop_inactive, vp)(VNHEAD(vp),cr)
 276 #define bhv_vop_release(vp)             VOP(vop_release, vp)(VNHEAD(vp))
 277 #define bhv_vop_fid2(vp,fidp)           VOP(vop_fid2, vp)(VNHEAD(vp),fidp)
 278 #define bhv_vop_rwlock(vp,i)            VOP(vop_rwlock, vp)(VNHEAD(vp),i)
 279 #define bhv_vop_rwlock_try(vp,i)        VOP(vop_rwlock, vp)(VNHEAD(vp),i)
 280 #define bhv_vop_rwunlock(vp,i)          VOP(vop_rwunlock, vp)(VNHEAD(vp),i)
 281 #define bhv_vop_frlock(vp,c,fl,flags,offset,fr)                         \
 282                 VOP(vop_frlock, vp)(VNHEAD(vp),c,fl,flags,offset,fr)
 283 #define bhv_vop_reclaim(vp)             VOP(vop_reclaim, vp)(VNHEAD(vp))
 284 #define bhv_vop_attr_get(vp, name, val, vallenp, fl, cred)              \
 285                 VOP(vop_attr_get, vp)(VNHEAD(vp),name,val,vallenp,fl,cred)
 286 #define bhv_vop_attr_set(vp, name, val, vallen, fl, cred)               \
 287                 VOP(vop_attr_set, vp)(VNHEAD(vp),name,val,vallen,fl,cred)
 288 #define bhv_vop_attr_remove(vp, name, flags, cred)                      \
 289                 VOP(vop_attr_remove, vp)(VNHEAD(vp),name,flags,cred)
 290 #define bhv_vop_attr_list(vp, buf, buflen, fl, cursor, cred)            \
 291                 VOP(vop_attr_list, vp)(VNHEAD(vp),buf,buflen,fl,cursor,cred)
 292 #define bhv_vop_link_removed(vp, dvp, linkzero)                         \
 293                 VOP(vop_link_removed, vp)(VNHEAD(vp), dvp, linkzero)
 294 #define bhv_vop_vnode_change(vp, cmd, val)                              \
 295                 VOP(vop_vnode_change, vp)(VNHEAD(vp), cmd, val)
 296 #define bhv_vop_toss_pages(vp, first, last, fiopt)                      \
 297                 VOP(vop_tosspages, vp)(VNHEAD(vp), first, last, fiopt)
 298 #define bhv_vop_flushinval_pages(vp, first, last, fiopt)                \
 299                 VOP(vop_flushinval_pages, vp)(VNHEAD(vp),first,last,fiopt)
 300 #define bhv_vop_flush_pages(vp, first, last, flags, fiopt)              \
 301                 VOP(vop_flush_pages, vp)(VNHEAD(vp),first,last,flags,fiopt)
 302 #define bhv_vop_ioctl(vp, inode, filp, fl, cmd, arg)                    \
 303                 VOP(vop_ioctl, vp)(VNHEAD(vp),inode,filp,fl,cmd,arg)
 304 #define bhv_vop_iflush(vp, flags)       VOP(vop_iflush, vp)(VNHEAD(vp), flags)
 305
 306 /*
 307  * Flags for read/write calls - same values as IRIX
 308  */
 309 #define IO_ISAIO        0x00001         /* don't wait for completion */
 310 #define IO_ISDIRECT     0x00004         /* bypass page cache */
 311 #define IO_INVIS        0x00020         /* don't update inode timestamps */
 312
 313 /*
 314  * Flags for vop_iflush call
 315  */
 316 #define FLUSH_SYNC              1       /* wait for flush to complete   */
 317 #define FLUSH_INODE             2       /* flush the inode itself       */
 318 #define FLUSH_LOG               4       /* force the last log entry for
 319                                          * this inode out to disk       */
 320
 321 /*
 322  * Flush/Invalidate options for vop_toss/flush/flushinval_pages.
 323  */
 324 #define FI_NONE                 0       /* none */
 325 #define FI_REMAPF               1       /* Do a remapf prior to the operation */
 326 #define FI_REMAPF_LOCKED        2       /* Do a remapf prior to the operation.
 327                                            Prevent VM access to the pages until
 328                                            the operation completes. */
 329
 330 /*
 331  * Vnode attributes.  va_mask indicates those attributes the caller
 332  * wants to set or extract.
 333  */
 334 typedef struct bhv_vattr {
 335         int             va_mask;        /* bit-mask of attributes present */
 336         mode_t          va_mode;        /* file access mode and type */
 337         xfs_nlink_t     va_nlink;       /* number of references to file */
 338         uid_t           va_uid;         /* owner user id */
 339         gid_t           va_gid;         /* owner group id */
 340         xfs_ino_t       va_nodeid;      /* file id */
 341         xfs_off_t       va_size;        /* file size in bytes */
 342         u_long          va_blocksize;   /* blocksize preferred for i/o */
 343         struct timespec va_atime;       /* time of last access */
 344         struct timespec va_mtime;       /* time of last modification */
 345         struct timespec va_ctime;       /* time file changed */
 346         u_int           va_gen;         /* generation number of file */
 347         xfs_dev_t       va_rdev;        /* device the special file represents */
 348         __int64_t       va_nblocks;     /* number of blocks allocated */
 349         u_long          va_xflags;      /* random extended file flags */
 350         u_long          va_extsize;     /* file extent size */
 351         u_long          va_nextents;    /* number of extents in file */
 352         u_long          va_anextents;   /* number of attr extents in file */
 353         prid_t          va_projid;      /* project id */
 354 } bhv_vattr_t;
 355
 356 /*
 357  * setattr or getattr attributes
 358  */
 359 #define XFS_AT_TYPE             0x00000001
 360 #define XFS_AT_MODE             0x00000002
 361 #define XFS_AT_UID              0x00000004
 362 #define XFS_AT_GID              0x00000008
 363 #define XFS_AT_FSID             0x00000010
 364 #define XFS_AT_NODEID           0x00000020
 365 #define XFS_AT_NLINK            0x00000040
 366 #define XFS_AT_SIZE             0x00000080
 367 #define XFS_AT_ATIME            0x00000100
 368 #define XFS_AT_MTIME            0x00000200
 369 #define XFS_AT_CTIME            0x00000400
 370 #define XFS_AT_RDEV             0x00000800
 371 #define XFS_AT_BLKSIZE          0x00001000
 372 #define XFS_AT_NBLOCKS          0x00002000
 373 #define XFS_AT_VCODE            0x00004000
 374 #define XFS_AT_MAC              0x00008000
 375 #define XFS_AT_UPDATIME         0x00010000
 376 #define XFS_AT_UPDMTIME         0x00020000
 377 #define XFS_AT_UPDCTIME         0x00040000
 378 #define XFS_AT_ACL              0x00080000
 379 #define XFS_AT_CAP              0x00100000
 380 #define XFS_AT_INF              0x00200000
 381 #define XFS_AT_XFLAGS           0x00400000
 382 #define XFS_AT_EXTSIZE          0x00800000
 383 #define XFS_AT_NEXTENTS         0x01000000
 384 #define XFS_AT_ANEXTENTS        0x02000000
 385 #define XFS_AT_PROJID           0x04000000
 386 #define XFS_AT_SIZE_NOPERM      0x08000000
 387 #define XFS_AT_GENCOUNT         0x10000000
 388
 389 #define XFS_AT_ALL      (XFS_AT_TYPE|XFS_AT_MODE|XFS_AT_UID|XFS_AT_GID|\
 390                 XFS_AT_FSID|XFS_AT_NODEID|XFS_AT_NLINK|XFS_AT_SIZE|\
 391                 XFS_AT_ATIME|XFS_AT_MTIME|XFS_AT_CTIME|XFS_AT_RDEV|\
 392                 XFS_AT_BLKSIZE|XFS_AT_NBLOCKS|XFS_AT_VCODE|XFS_AT_MAC|\
 393                 XFS_AT_ACL|XFS_AT_CAP|XFS_AT_INF|XFS_AT_XFLAGS|XFS_AT_EXTSIZE|\
 394                 XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|XFS_AT_PROJID|XFS_AT_GENCOUNT)
 395
 396 #define XFS_AT_STAT     (XFS_AT_TYPE|XFS_AT_MODE|XFS_AT_UID|XFS_AT_GID|\
 397                 XFS_AT_FSID|XFS_AT_NODEID|XFS_AT_NLINK|XFS_AT_SIZE|\
 398                 XFS_AT_ATIME|XFS_AT_MTIME|XFS_AT_CTIME|XFS_AT_RDEV|\
 399                 XFS_AT_BLKSIZE|XFS_AT_NBLOCKS|XFS_AT_PROJID)
 400
 401 #define XFS_AT_TIMES    (XFS_AT_ATIME|XFS_AT_MTIME|XFS_AT_CTIME)
 402
 403 #define XFS_AT_UPDTIMES (XFS_AT_UPDATIME|XFS_AT_UPDMTIME|XFS_AT_UPDCTIME)
 404
 405 #define XFS_AT_NOSET    (XFS_AT_NLINK|XFS_AT_RDEV|XFS_AT_FSID|XFS_AT_NODEID|\
 406                 XFS_AT_TYPE|XFS_AT_BLKSIZE|XFS_AT_NBLOCKS|XFS_AT_VCODE|\
 407                 XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS|XFS_AT_GENCOUNT)
 408
 409 /*
 410  *  Modes.
 411  */
 412 #define VSUID   S_ISUID         /* set user id on execution */
 413 #define VSGID   S_ISGID         /* set group id on execution */
 414 #define VSVTX   S_ISVTX         /* save swapped text even after use */
 415 #define VREAD   S_IRUSR         /* read, write, execute permissions */
 416 #define VWRITE  S_IWUSR
 417 #define VEXEC   S_IXUSR
 418
 419 #define MODEMASK S_IALLUGO      /* mode bits plus permission bits */
 420
 421 /*
 422  * Check whether mandatory file locking is enabled.
 423  */
 424 #define MANDLOCK(vp, mode)      \
 425         (VN_ISREG(vp) && ((mode) & (VSGID|(VEXEC>>3))) == VSGID)
 426
 427 extern void     vn_init(void);
 428 extern bhv_vnode_t      *vn_initialize(struct inode *);
 429 extern int      vn_revalidate(struct bhv_vnode *);
 430 extern int      __vn_revalidate(struct bhv_vnode *, bhv_vattr_t *);
 431 extern void     vn_revalidate_core(struct bhv_vnode *, bhv_vattr_t *);
 432
 433 extern void     vn_iowait(struct bhv_vnode *vp);
 434 extern void     vn_iowake(struct bhv_vnode *vp);
 435
 436 extern void     vn_ioerror(struct bhv_vnode *vp, int error, char *f, int l);
 437
 438 static inline int vn_count(struct bhv_vnode *vp)
 439 {
 440         return atomic_read(&vn_to_inode(vp)->i_count);
 441 }
 442
 443 /*
 444  * Vnode reference counting functions (and macros for compatibility).
 445  */
 446 extern bhv_vnode_t      *vn_hold(struct bhv_vnode *);
 447
 448 #if defined(XFS_VNODE_TRACE)
 449 #define VN_HOLD(vp)             \
 450         ((void)vn_hold(vp),     \
 451           vn_trace_hold(vp, __FILE__, __LINE__, (inst_t *)__return_address))
 452 #define VN_RELE(vp)             \
 453           (vn_trace_rele(vp, __FILE__, __LINE__, (inst_t *)__return_address), \
 454            iput(vn_to_inode(vp)))
 455 #else
 456 #define VN_HOLD(vp)             ((void)vn_hold(vp))
 457 #define VN_RELE(vp)             (iput(vn_to_inode(vp)))
 458 #endif
 459
 460 static inline struct bhv_vnode *vn_grab(struct bhv_vnode *vp)
 461 {
 462         struct inode *inode = igrab(vn_to_inode(vp));
 463         return inode ? vn_from_inode(inode) : NULL;
 464 }
 465
 466 /*
 467  * Vname handling macros.
 468  */
 469 #define VNAME(dentry)           ((char *) (dentry)->d_name.name)
 470 #define VNAMELEN(dentry)        ((dentry)->d_name.len)
 471 #define VNAME_TO_VNODE(dentry)  (vn_from_inode((dentry)->d_inode))
 472
 473 /*
 474  * Vnode spinlock manipulation.
 475  */
 476 #define VN_LOCK(vp)             mutex_spinlock(&(vp)->v_lock)
 477 #define VN_UNLOCK(vp, s)        mutex_spinunlock(&(vp)->v_lock, s)
 478
 479 STATIC_INLINE void vn_flagset(struct bhv_vnode *vp, uint flag)
 480 {
 481         spin_lock(&vp->v_lock);
 482         vp->v_flag |= flag;
 483         spin_unlock(&vp->v_lock);
 484 }
 485
 486 STATIC_INLINE uint vn_flagclr(struct bhv_vnode *vp, uint flag)
 487 {
 488         uint    cleared;
 489
 490         spin_lock(&vp->v_lock);
 491         cleared = (vp->v_flag & flag);
 492         vp->v_flag &= ~flag;
 493         spin_unlock(&vp->v_lock);
 494         return cleared;
 495 }
 496
 497 #define VMODIFY(vp)     vn_flagset(vp, VMODIFIED)
 498 #define VUNMODIFY(vp)   vn_flagclr(vp, VMODIFIED)
 499 #define VTRUNCATE(vp)   vn_flagset(vp, VTRUNCATED)
 500 #define VUNTRUNCATE(vp) vn_flagclr(vp, VTRUNCATED)
 501
 502 /*
 503  * Dealing with bad inodes
 504  */
 505 static inline void vn_mark_bad(struct bhv_vnode *vp)
 506 {
 507         make_bad_inode(vn_to_inode(vp));
 508 }
 509
 510 static inline int VN_BAD(struct bhv_vnode *vp)
 511 {
 512         return is_bad_inode(vn_to_inode(vp));
 513 }
 514
 515 /*
 516  * Extracting atime values in various formats
 517  */
 518 static inline void vn_atime_to_bstime(bhv_vnode_t *vp, xfs_bstime_t *bs_atime)
 519 {
 520         bs_atime->tv_sec = vp->v_inode.i_atime.tv_sec;
 521         bs_atime->tv_nsec = vp->v_inode.i_atime.tv_nsec;
 522 }
 523
 524 static inline void vn_atime_to_timespec(bhv_vnode_t *vp, struct timespec *ts)
 525 {
 526         *ts = vp->v_inode.i_atime;
 527 }
 528
 529 static inline void vn_atime_to_time_t(bhv_vnode_t *vp, time_t *tt)
 530 {
 531         *tt = vp->v_inode.i_atime.tv_sec;
 532 }
 533
 534 /*
 535  * Some useful predicates.
 536  */
 537 #define VN_MAPPED(vp)   mapping_mapped(vn_to_inode(vp)->i_mapping)
 538 #define VN_CACHED(vp)   (vn_to_inode(vp)->i_mapping->nrpages)
 539 #define VN_DIRTY(vp)    mapping_tagged(vn_to_inode(vp)->i_mapping, \
 540                                         PAGECACHE_TAG_DIRTY)
 541 #define VN_TRUNC(vp)    ((vp)->v_flag & VTRUNCATED)
 542
 543 /*
 544  * Flags to vop_setattr/getattr.
 545  */
 546 #define ATTR_UTIME      0x01    /* non-default utime(2) request */
 547 #define ATTR_DMI        0x08    /* invocation from a DMI function */
 548 #define ATTR_LAZY       0x80    /* set/get attributes lazily */
 549 #define ATTR_NONBLOCK   0x100   /* return EAGAIN if operation would block */
 550 #define ATTR_NOLOCK     0x200   /* Don't grab any conflicting locks */
 551 #define ATTR_NOSIZETOK  0x400   /* Don't get the SIZE token */
 552
 553 /*
 554  * Flags to vop_fsync/reclaim.
 555  */
 556 #define FSYNC_NOWAIT    0       /* asynchronous flush */
 557 #define FSYNC_WAIT      0x1     /* synchronous fsync or forced reclaim */
 558 #define FSYNC_INVAL     0x2     /* flush and invalidate cached data */
 559 #define FSYNC_DATA      0x4     /* synchronous fsync of data only */
 560
 561 /*
 562  * Tracking vnode activity.
 563  */
 564 #if defined(XFS_VNODE_TRACE)
 565
 566 #define VNODE_TRACE_SIZE        16              /* number of trace entries */
 567 #define VNODE_KTRACE_ENTRY      1
 568 #define VNODE_KTRACE_EXIT       2
 569 #define VNODE_KTRACE_HOLD       3
 570 #define VNODE_KTRACE_REF        4
 571 #define VNODE_KTRACE_RELE       5
 572
 573 extern void vn_trace_entry(struct bhv_vnode *, const char *, inst_t *);
 574 extern void vn_trace_exit(struct bhv_vnode *, const char *, inst_t *);
 575 extern void vn_trace_hold(struct bhv_vnode *, char *, int, inst_t *);
 576 extern void vn_trace_ref(struct bhv_vnode *, char *, int, inst_t *);
 577 extern void vn_trace_rele(struct bhv_vnode *, char *, int, inst_t *);
 578
 579 #define VN_TRACE(vp)            \
 580         vn_trace_ref(vp, __FILE__, __LINE__, (inst_t *)__return_address)
 581 #else
 582 #define vn_trace_entry(a,b,c)
 583 #define vn_trace_exit(a,b,c)
 584 #define vn_trace_hold(a,b,c,d)
 585 #define vn_trace_ref(a,b,c,d)
 586 #define vn_trace_rele(a,b,c,d)
 587 #define VN_TRACE(vp)
 588 #endif
 589
 590 #endif  /* __XFS_VNODE_H__ */