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