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         bhv_vnode_t     *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         bhv_vnode_t     *vp)
  52 {
  53         if (atomic_dec_and_test(&vp->v_iocount))
  54                 wake_up(vptosync(vp));
  55 }
  56
  57 /*
  58  * Volume managers supporting multiple paths can send back ENODEV when the
  59  * final path disappears.  In this case continuing to fill the page cache
  60  * with dirty data which cannot be written out is evil, so prevent that.
  61  */
  62 void
  63 vn_ioerror(
  64         bhv_vnode_t     *vp,
  65         int             error,
  66         char            *f,
  67         int             l)
  68 {
  69         if (unlikely(error == -ENODEV))
  70                 bhv_vfs_force_shutdown(vp->v_vfsp, SHUTDOWN_DEVICE_REQ, f, l);
  71 }
  72
  73 bhv_vnode_t *
  74 vn_initialize(
  75         struct inode    *inode)
  76 {
  77         bhv_vnode_t     *vp = vn_from_inode(inode);
  78
  79         XFS_STATS_INC(vn_active);
  80         XFS_STATS_INC(vn_alloc);
  81
  82         vp->v_flag = VMODIFIED;
  83         spinlock_init(&vp->v_lock, "v_lock");
  84
  85         spin_lock(&vnumber_lock);
  86         if (!++vn_generation)   /* v_number shouldn't be zero */
  87                 vn_generation++;
  88         vp->v_number = vn_generation;
  89         spin_unlock(&vnumber_lock);
  90
  91         ASSERT(VN_CACHED(vp) == 0);
  92
  93         /* Initialize the first behavior and the behavior chain head. */
  94         vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode");
  95
  96         atomic_set(&vp->v_iocount, 0);
  97
  98 #ifdef  XFS_VNODE_TRACE
  99         vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP);
 100 #endif  /* XFS_VNODE_TRACE */
 101
 102         vn_trace_exit(vp, __FUNCTION__, (inst_t *)__return_address);
 103         return vp;
 104 }
 105
 106 /*
 107  * Revalidate the Linux inode from the vattr.
 108  * Note: i_size _not_ updated; we must hold the inode
 109  * semaphore when doing that - callers responsibility.
 110  */
 111 void
 112 vn_revalidate_core(
 113         bhv_vnode_t     *vp,
 114         bhv_vattr_t     *vap)
 115 {
 116         struct inode    *inode = vn_to_inode(vp);
 117
 118         inode->i_mode       = vap->va_mode;
 119         inode->i_nlink      = vap->va_nlink;
 120         inode->i_uid        = vap->va_uid;
 121         inode->i_gid        = vap->va_gid;
 122         inode->i_xid        = vap->va_xid;
 123         inode->i_blocks     = vap->va_nblocks;
 124         inode->i_mtime      = vap->va_mtime;
 125         inode->i_ctime      = vap->va_ctime;
 126         if (vap->va_xflags & XFS_XFLAG_IMMUTABLE)
 127                 inode->i_flags |= S_IMMUTABLE;
 128         else
 129                 inode->i_flags &= ~S_IMMUTABLE;
 130         if (vap->va_xflags & XFS_XFLAG_IUNLINK)
 131                 inode->i_flags |= S_IUNLINK;
 132         else
 133                 inode->i_flags &= ~S_IUNLINK;
 134         if (vap->va_xflags & XFS_XFLAG_BARRIER)
 135                 inode->i_flags |= S_BARRIER;
 136         else
 137                 inode->i_flags &= ~S_BARRIER;
 138         if (vap->va_xflags & XFS_XFLAG_APPEND)
 139                 inode->i_flags |= S_APPEND;
 140         else
 141                 inode->i_flags &= ~S_APPEND;
 142         if (vap->va_xflags & XFS_XFLAG_SYNC)
 143                 inode->i_flags |= S_SYNC;
 144         else
 145                 inode->i_flags &= ~S_SYNC;
 146         if (vap->va_xflags & XFS_XFLAG_NOATIME)
 147                 inode->i_flags |= S_NOATIME;
 148         else
 149                 inode->i_flags &= ~S_NOATIME;
 150 }
 151
 152 /*
 153  * Revalidate the Linux inode from the vnode.
 154  */
 155 int
 156 __vn_revalidate(
 157         bhv_vnode_t     *vp,
 158         bhv_vattr_t     *vattr)
 159 {
 160         int             error;
 161
 162         vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
 163         vattr->va_mask = XFS_AT_STAT | XFS_AT_XFLAGS;
 164         error = bhv_vop_getattr(vp, vattr, 0, NULL);
 165         if (likely(!error)) {
 166                 vn_revalidate_core(vp, vattr);
 167                 VUNMODIFY(vp);
 168         }
 169         return -error;
 170 }
 171
 172 int
 173 vn_revalidate(
 174         bhv_vnode_t     *vp)
 175 {
 176         bhv_vattr_t     vattr;
 177
 178         return __vn_revalidate(vp, &vattr);
 179 }
 180
 181 /*
 182  * Add a reference to a referenced vnode.
 183  */
 184 bhv_vnode_t *
 185 vn_hold(
 186         bhv_vnode_t     *vp)
 187 {
 188         struct inode    *inode;
 189
 190         XFS_STATS_INC(vn_hold);
 191
 192         VN_LOCK(vp);
 193         inode = igrab(vn_to_inode(vp));
 194         ASSERT(inode);
 195         VN_UNLOCK(vp, 0);
 196
 197         return vp;
 198 }
 199
 200 #ifdef  XFS_VNODE_TRACE
 201
 202 #define KTRACE_ENTER(vp, vk, s, line, ra)                       \
 203         ktrace_enter(   (vp)->v_trace,                          \
 204 /*  0 */                (void *)(__psint_t)(vk),                \
 205 /*  1 */                (void *)(s),                            \
 206 /*  2 */                (void *)(__psint_t) line,               \
 207 /*  3 */                (void *)(__psint_t)(vn_count(vp)),      \
 208 /*  4 */                (void *)(ra),                           \
 209 /*  5 */                (void *)(__psunsigned_t)(vp)->v_flag,   \
 210 /*  6 */                (void *)(__psint_t)current_cpu(),       \
 211 /*  7 */                (void *)(__psint_t)current_pid(),       \
 212 /*  8 */                (void *)__return_address,               \
 213 /*  9 */                NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 214
 215 /*
 216  * Vnode tracing code.
 217  */
 218 void
 219 vn_trace_entry(bhv_vnode_t *vp, const char *func, inst_t *ra)
 220 {
 221         KTRACE_ENTER(vp, VNODE_KTRACE_ENTRY, func, 0, ra);
 222 }
 223
 224 void
 225 vn_trace_exit(bhv_vnode_t *vp, const char *func, inst_t *ra)
 226 {
 227         KTRACE_ENTER(vp, VNODE_KTRACE_EXIT, func, 0, ra);
 228 }
 229
 230 void
 231 vn_trace_hold(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 232 {
 233         KTRACE_ENTER(vp, VNODE_KTRACE_HOLD, file, line, ra);
 234 }
 235
 236 void
 237 vn_trace_ref(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 238 {
 239         KTRACE_ENTER(vp, VNODE_KTRACE_REF, file, line, ra);
 240 }
 241
 242 void
 243 vn_trace_rele(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 244 {
 245         KTRACE_ENTER(vp, VNODE_KTRACE_RELE, file, line, ra);
 246 }
 247 #endif  /* XFS_VNODE_TRACE */