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