git.oblomov.eu Git - linux-2.6/blob - fs/xfs/linux-2.6/xfs_vnode.c

   1 /*
   2  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33 #include "xfs.h"
  34
  35
  36 uint64_t vn_generation;         /* vnode generation number */
  37 DEFINE_SPINLOCK(vnumber_lock);
  38
  39 /*
  40  * Dedicated vnode inactive/reclaim sync semaphores.
  41  * Prime number of hash buckets since address is used as the key.
  42  */
  43 #define NVSYNC                  37
  44 #define vptosync(v)             (&vsync[((unsigned long)v) % NVSYNC])
  45 STATIC wait_queue_head_t vsync[NVSYNC];
  46
  47
  48 void
  49 vn_init(void)
  50 {
  51         int i;
  52
  53         for (i = 0; i < NVSYNC; i++)
  54                 init_waitqueue_head(&vsync[i]);
  55 }
  56
  57 void
  58 vn_iowait(
  59         struct vnode    *vp)
  60 {
  61         wait_queue_head_t *wq = vptosync(vp);
  62
  63         wait_event(*wq, (atomic_read(&vp->v_iocount) == 0));
  64 }
  65
  66 void
  67 vn_iowake(
  68         struct vnode    *vp)
  69 {
  70         if (atomic_dec_and_test(&vp->v_iocount))
  71                 wake_up(vptosync(vp));
  72 }
  73
  74 struct vnode *
  75 vn_initialize(
  76         struct inode    *inode)
  77 {
  78         struct vnode    *vp = LINVFS_GET_VP(inode);
  79
  80         XFS_STATS_INC(vn_active);
  81         XFS_STATS_INC(vn_alloc);
  82
  83         vp->v_flag = VMODIFIED;
  84         spinlock_init(&vp->v_lock, "v_lock");
  85
  86         spin_lock(&vnumber_lock);
  87         if (!++vn_generation)   /* v_number shouldn't be zero */
  88                 vn_generation++;
  89         vp->v_number = vn_generation;
  90         spin_unlock(&vnumber_lock);
  91
  92         ASSERT(VN_CACHED(vp) == 0);
  93
  94         /* Initialize the first behavior and the behavior chain head. */
  95         vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode");
  96
  97         atomic_set(&vp->v_iocount, 0);
  98
  99 #ifdef  XFS_VNODE_TRACE
 100         vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP);
 101 #endif  /* XFS_VNODE_TRACE */
 102
 103         vn_trace_exit(vp, "vn_initialize", (inst_t *)__return_address);
 104         return vp;
 105 }
 106
 107 /*
 108  * Revalidate the Linux inode from the vattr.
 109  * Note: i_size _not_ updated; we must hold the inode
 110  * semaphore when doing that - callers responsibility.
 111  */
 112 void
 113 vn_revalidate_core(
 114         struct vnode    *vp,
 115         vattr_t         *vap)
 116 {
 117         struct inode    *inode = LINVFS_GET_IP(vp);
 118
 119         inode->i_mode       = vap->va_mode;
 120         inode->i_nlink      = vap->va_nlink;
 121         inode->i_uid        = vap->va_uid;
 122         inode->i_gid        = vap->va_gid;
 123         inode->i_blocks     = vap->va_nblocks;
 124         inode->i_mtime      = vap->va_mtime;
 125         inode->i_ctime      = vap->va_ctime;
 126         inode->i_atime      = vap->va_atime;
 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         struct vnode    *vp)
 151 {
 152         vattr_t         va;
 153         int             error;
 154
 155         vn_trace_entry(vp, "vn_revalidate", (inst_t *)__return_address);
 156         ASSERT(vp->v_fbhv != NULL);
 157
 158         va.va_mask = XFS_AT_STAT|XFS_AT_XFLAGS;
 159         VOP_GETATTR(vp, &va, 0, NULL, error);
 160         if (!error) {
 161                 vn_revalidate_core(vp, &va);
 162                 VUNMODIFY(vp);
 163         }
 164         return -error;
 165 }
 166
 167 /*
 168  * Add a reference to a referenced vnode.
 169  */
 170 struct vnode *
 171 vn_hold(
 172         struct vnode    *vp)
 173 {
 174         struct inode    *inode;
 175
 176         XFS_STATS_INC(vn_hold);
 177
 178         VN_LOCK(vp);
 179         inode = igrab(LINVFS_GET_IP(vp));
 180         ASSERT(inode);
 181         VN_UNLOCK(vp, 0);
 182
 183         return vp;
 184 }
 185
 186 #ifdef  XFS_VNODE_TRACE
 187
 188 #define KTRACE_ENTER(vp, vk, s, line, ra)                       \
 189         ktrace_enter(   (vp)->v_trace,                          \
 190 /*  0 */                (void *)(__psint_t)(vk),                \
 191 /*  1 */                (void *)(s),                            \
 192 /*  2 */                (void *)(__psint_t) line,               \
 193 /*  3 */                (void *)(__psint_t)(vn_count(vp)),      \
 194 /*  4 */                (void *)(ra),                           \
 195 /*  5 */                (void *)(__psunsigned_t)(vp)->v_flag,   \
 196 /*  6 */                (void *)(__psint_t)current_cpu(),       \
 197 /*  7 */                (void *)(__psint_t)current_pid(),       \
 198 /*  8 */                (void *)__return_address,               \
 199 /*  9 */                NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 200
 201 /*
 202  * Vnode tracing code.
 203  */
 204 void
 205 vn_trace_entry(vnode_t *vp, const char *func, inst_t *ra)
 206 {
 207         KTRACE_ENTER(vp, VNODE_KTRACE_ENTRY, func, 0, ra);
 208 }
 209
 210 void
 211 vn_trace_exit(vnode_t *vp, const char *func, inst_t *ra)
 212 {
 213         KTRACE_ENTER(vp, VNODE_KTRACE_EXIT, func, 0, ra);
 214 }
 215
 216 void
 217 vn_trace_hold(vnode_t *vp, char *file, int line, inst_t *ra)
 218 {
 219         KTRACE_ENTER(vp, VNODE_KTRACE_HOLD, file, line, ra);
 220 }
 221
 222 void
 223 vn_trace_ref(vnode_t *vp, char *file, int line, inst_t *ra)
 224 {
 225         KTRACE_ENTER(vp, VNODE_KTRACE_REF, file, line, ra);
 226 }
 227
 228 void
 229 vn_trace_rele(vnode_t *vp, char *file, int line, inst_t *ra)
 230 {
 231         KTRACE_ENTER(vp, VNODE_KTRACE_RELE, file, line, ra);
 232 }
 233 #endif  /* XFS_VNODE_TRACE */