fs/xfs/linux-2.6/xfs_vnode.c

   1 /*
   2  * Copyright (c) 2000-2003,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 #include "xfs.h"
  19
  20 uint64_t vn_generation;         /* vnode generation number */
  21 DEFINE_SPINLOCK(vnumber_lock);
  22
  23 /*
  24  * Dedicated vnode inactive/reclaim sync semaphores.
  25  * Prime number of hash buckets since address is used as the key.
  26  */
  27 #define NVSYNC                  37
  28 #define vptosync(v)             (&vsync[((unsigned long)v) % NVSYNC])
  29 STATIC wait_queue_head_t vsync[NVSYNC];
  30
  31 void
  32 vn_init(void)
  33 {
  34         int i;
  35
  36         for (i = 0; i < NVSYNC; i++)
  37                 init_waitqueue_head(&vsync[i]);
  38 }
  39
  40 void
  41 vn_iowait(
  42         struct vnode    *vp)
  43 {
  44         wait_queue_head_t *wq = vptosync(vp);
  45
  46         wait_event(*wq, (atomic_read(&vp->v_iocount) == 0));
  47 }
  48
  49 void
  50 vn_iowake(
  51         struct vnode    *vp)
  52 {
  53         if (atomic_dec_and_test(&vp->v_iocount))
  54                 wake_up(vptosync(vp));
  55 }
  56
  57 struct vnode *
  58 vn_initialize(
  59         struct inode    *inode)
  60 {
  61         struct vnode    *vp = LINVFS_GET_VP(inode);
  62
  63         XFS_STATS_INC(vn_active);
  64         XFS_STATS_INC(vn_alloc);
  65
  66         vp->v_flag = VMODIFIED;
  67         spinlock_init(&vp->v_lock, "v_lock");
  68
  69         spin_lock(&vnumber_lock);
  70         if (!++vn_generation)   /* v_number shouldn't be zero */
  71                 vn_generation++;
  72         vp->v_number = vn_generation;
  73         spin_unlock(&vnumber_lock);
  74
  75         ASSERT(VN_CACHED(vp) == 0);
  76
  77         /* Initialize the first behavior and the behavior chain head. */
  78         vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode");
  79
  80         atomic_set(&vp->v_iocount, 0);
  81
  82 #ifdef  XFS_VNODE_TRACE
  83         vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP);
  84 #endif  /* XFS_VNODE_TRACE */
  85
  86         vn_trace_exit(vp, "vn_initialize", (inst_t *)__return_address);
  87         return vp;
  88 }
  89
  90 /*
  91  * Revalidate the Linux inode from the vattr.
  92  * Note: i_size _not_ updated; we must hold the inode
  93  * semaphore when doing that - callers responsibility.
  94  */
  95 void
  96 vn_revalidate_core(
  97         struct vnode    *vp,
  98         vattr_t         *vap)
  99 {
 100         struct inode    *inode = LINVFS_GET_IP(vp);
 101
 102         inode->i_mode       = vap->va_mode;
 103         inode->i_nlink      = vap->va_nlink;
 104         inode->i_uid        = vap->va_uid;
 105         inode->i_gid        = vap->va_gid;
 106         inode->i_xid        = vap->va_xid;
 107         inode->i_blocks     = vap->va_nblocks;
 108         inode->i_mtime      = vap->va_mtime;
 109         inode->i_ctime      = vap->va_ctime;
 110         inode->i_blksize    = vap->va_blocksize;
 111         if (vap->va_xflags & XFS_XFLAG_IMMUTABLE)
 112                 inode->i_flags |= S_IMMUTABLE;
 113         else
 114                 inode->i_flags &= ~S_IMMUTABLE;
 115         if (vap->va_xflags & XFS_XFLAG_IUNLINK)
 116                 inode->i_flags |= S_IUNLINK;
 117         else
 118                 inode->i_flags &= ~S_IUNLINK;
 119         if (vap->va_xflags & XFS_XFLAG_BARRIER)
 120                 inode->i_flags |= S_BARRIER;
 121         else
 122                 inode->i_flags &= ~S_BARRIER;
 123         if (vap->va_xflags & XFS_XFLAG_APPEND)
 124                 inode->i_flags |= S_APPEND;
 125         else
 126                 inode->i_flags &= ~S_APPEND;
 127         if (vap->va_xflags & XFS_XFLAG_SYNC)
 128                 inode->i_flags |= S_SYNC;
 129         else
 130                 inode->i_flags &= ~S_SYNC;
 131         if (vap->va_xflags & XFS_XFLAG_NOATIME)
 132                 inode->i_flags |= S_NOATIME;
 133         else
 134                 inode->i_flags &= ~S_NOATIME;
 135 }
 136
 137 /*
 138  * Revalidate the Linux inode from the vnode.
 139  */
 140 int
 141 vn_revalidate(
 142         struct vnode    *vp)
 143 {
 144         vattr_t         va;
 145         int             error;
 146
 147         vn_trace_entry(vp, "vn_revalidate", (inst_t *)__return_address);
 148         ASSERT(vp->v_fbhv != NULL);
 149
 150         va.va_mask = XFS_AT_STAT|XFS_AT_XFLAGS;
 151         VOP_GETATTR(vp, &va, 0, NULL, error);
 152         if (!error) {
 153                 vn_revalidate_core(vp, &va);
 154                 VUNMODIFY(vp);
 155         }
 156         return -error;
 157 }
 158
 159 /*
 160  * Add a reference to a referenced vnode.
 161  */
 162 struct vnode *
 163 vn_hold(
 164         struct vnode    *vp)
 165 {
 166         struct inode    *inode;
 167
 168         XFS_STATS_INC(vn_hold);
 169
 170         VN_LOCK(vp);
 171         inode = igrab(LINVFS_GET_IP(vp));
 172         ASSERT(inode);
 173         VN_UNLOCK(vp, 0);
 174
 175         return vp;
 176 }
 177
 178 #ifdef  XFS_VNODE_TRACE
 179
 180 #define KTRACE_ENTER(vp, vk, s, line, ra)                       \
 181         ktrace_enter(   (vp)->v_trace,                          \
 182 /*  0 */                (void *)(__psint_t)(vk),                \
 183 /*  1 */                (void *)(s),                            \
 184 /*  2 */                (void *)(__psint_t) line,               \
 185 /*  3 */                (void *)(__psint_t)(vn_count(vp)),      \
 186 /*  4 */                (void *)(ra),                           \
 187 /*  5 */                (void *)(__psunsigned_t)(vp)->v_flag,   \
 188 /*  6 */                (void *)(__psint_t)current_cpu(),       \
 189 /*  7 */                (void *)(__psint_t)current_pid(),       \
 190 /*  8 */                (void *)__return_address,               \
 191 /*  9 */                NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 192
 193 /*
 194  * Vnode tracing code.
 195  */
 196 void
 197 vn_trace_entry(vnode_t *vp, const char *func, inst_t *ra)
 198 {
 199         KTRACE_ENTER(vp, VNODE_KTRACE_ENTRY, func, 0, ra);
 200 }
 201
 202 void
 203 vn_trace_exit(vnode_t *vp, const char *func, inst_t *ra)
 204 {
 205         KTRACE_ENTER(vp, VNODE_KTRACE_EXIT, func, 0, ra);
 206 }
 207
 208 void
 209 vn_trace_hold(vnode_t *vp, char *file, int line, inst_t *ra)
 210 {
 211         KTRACE_ENTER(vp, VNODE_KTRACE_HOLD, file, line, ra);
 212 }
 213
 214 void
 215 vn_trace_ref(vnode_t *vp, char *file, int line, inst_t *ra)
 216 {
 217         KTRACE_ENTER(vp, VNODE_KTRACE_REF, file, line, ra);
 218 }
 219
 220 void
 221 vn_trace_rele(vnode_t *vp, char *file, int line, inst_t *ra)
 222 {
 223         KTRACE_ENTER(vp, VNODE_KTRACE_RELE, file, line, ra);
 224 }
 225 #endif  /* XFS_VNODE_TRACE */