Merge branch 'master' of /usr/src/ntfs-2.6/
[linux-2.6] / 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 */