[XFS] remove unessecary vnode flags
[linux-2.6] / fs / xfs / linux-2.6 / xfs_vfs.c
1 /*
2  * Copyright (c) 2000-2004 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 #include "xfs_fs.h"
35 #include "xfs_macros.h"
36 #include "xfs_inum.h"
37 #include "xfs_log.h"
38 #include "xfs_clnt.h"
39 #include "xfs_trans.h"
40 #include "xfs_sb.h"
41 #include "xfs_ag.h"
42 #include "xfs_dir.h"
43 #include "xfs_dir2.h"
44 #include "xfs_imap.h"
45 #include "xfs_alloc.h"
46 #include "xfs_dmapi.h"
47 #include "xfs_mount.h"
48 #include "xfs_quota.h"
49
50 int
51 vfs_mount(
52         struct bhv_desc         *bdp,
53         struct xfs_mount_args   *args,
54         struct cred             *cr)
55 {
56         struct bhv_desc         *next = bdp;
57
58         ASSERT(next);
59         while (! (bhvtovfsops(next))->vfs_mount)
60                 next = BHV_NEXT(next);
61         return ((*bhvtovfsops(next)->vfs_mount)(next, args, cr));
62 }
63
64 int
65 vfs_parseargs(
66         struct bhv_desc         *bdp,
67         char                    *s,
68         struct xfs_mount_args   *args,
69         int                     f)
70 {
71         struct bhv_desc         *next = bdp;
72
73         ASSERT(next);
74         while (! (bhvtovfsops(next))->vfs_parseargs)
75                 next = BHV_NEXT(next);
76         return ((*bhvtovfsops(next)->vfs_parseargs)(next, s, args, f));
77 }
78
79 int
80 vfs_showargs(
81         struct bhv_desc         *bdp,
82         struct seq_file         *m)
83 {
84         struct bhv_desc         *next = bdp;
85
86         ASSERT(next);
87         while (! (bhvtovfsops(next))->vfs_showargs)
88                 next = BHV_NEXT(next);
89         return ((*bhvtovfsops(next)->vfs_showargs)(next, m));
90 }
91
92 int
93 vfs_unmount(
94         struct bhv_desc         *bdp,
95         int                     fl,
96         struct cred             *cr)
97 {
98         struct bhv_desc         *next = bdp;
99
100         ASSERT(next);
101         while (! (bhvtovfsops(next))->vfs_unmount)
102                 next = BHV_NEXT(next);
103         return ((*bhvtovfsops(next)->vfs_unmount)(next, fl, cr));
104 }
105
106 int
107 vfs_mntupdate(
108         struct bhv_desc         *bdp,
109         int                     *fl,
110         struct xfs_mount_args   *args)
111 {
112         struct bhv_desc         *next = bdp;
113
114         ASSERT(next);
115         while (! (bhvtovfsops(next))->vfs_mntupdate)
116                 next = BHV_NEXT(next);
117         return ((*bhvtovfsops(next)->vfs_mntupdate)(next, fl, args));
118 }
119
120 int
121 vfs_root(
122         struct bhv_desc         *bdp,
123         struct vnode            **vpp)
124 {
125         struct bhv_desc         *next = bdp;
126
127         ASSERT(next);
128         while (! (bhvtovfsops(next))->vfs_root)
129                 next = BHV_NEXT(next);
130         return ((*bhvtovfsops(next)->vfs_root)(next, vpp));
131 }
132
133 int
134 vfs_statvfs(
135         struct bhv_desc         *bdp,
136         xfs_statfs_t            *sp,
137         struct vnode            *vp)
138 {
139         struct bhv_desc         *next = bdp;
140
141         ASSERT(next);
142         while (! (bhvtovfsops(next))->vfs_statvfs)
143                 next = BHV_NEXT(next);
144         return ((*bhvtovfsops(next)->vfs_statvfs)(next, sp, vp));
145 }
146
147 int
148 vfs_sync(
149         struct bhv_desc         *bdp,
150         int                     fl,
151         struct cred             *cr)
152 {
153         struct bhv_desc         *next = bdp;
154
155         ASSERT(next);
156         while (! (bhvtovfsops(next))->vfs_sync)
157                 next = BHV_NEXT(next);
158         return ((*bhvtovfsops(next)->vfs_sync)(next, fl, cr));
159 }
160
161 int
162 vfs_vget(
163         struct bhv_desc         *bdp,
164         struct vnode            **vpp,
165         struct fid              *fidp)
166 {
167         struct bhv_desc         *next = bdp;
168
169         ASSERT(next);
170         while (! (bhvtovfsops(next))->vfs_vget)
171                 next = BHV_NEXT(next);
172         return ((*bhvtovfsops(next)->vfs_vget)(next, vpp, fidp));
173 }
174
175 int
176 vfs_dmapiops(
177         struct bhv_desc         *bdp,
178         caddr_t                 addr)
179 {
180         struct bhv_desc         *next = bdp;
181
182         ASSERT(next);
183         while (! (bhvtovfsops(next))->vfs_dmapiops)
184                 next = BHV_NEXT(next);
185         return ((*bhvtovfsops(next)->vfs_dmapiops)(next, addr));
186 }
187
188 int
189 vfs_quotactl(
190         struct bhv_desc         *bdp,
191         int                     cmd,
192         int                     id,
193         caddr_t                 addr)
194 {
195         struct bhv_desc         *next = bdp;
196
197         ASSERT(next);
198         while (! (bhvtovfsops(next))->vfs_quotactl)
199                 next = BHV_NEXT(next);
200         return ((*bhvtovfsops(next)->vfs_quotactl)(next, cmd, id, addr));
201 }
202
203 void
204 vfs_init_vnode(
205         struct bhv_desc         *bdp,
206         struct vnode            *vp,
207         struct bhv_desc         *bp,
208         int                     unlock)
209 {
210         struct bhv_desc         *next = bdp;
211
212         ASSERT(next);
213         while (! (bhvtovfsops(next))->vfs_init_vnode)
214                 next = BHV_NEXT(next);
215         ((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, bp, unlock));
216 }
217
218 void
219 vfs_force_shutdown(
220         struct bhv_desc         *bdp,
221         int                     fl,
222         char                    *file,
223         int                     line)
224 {
225         struct bhv_desc         *next = bdp;
226
227         ASSERT(next);
228         while (! (bhvtovfsops(next))->vfs_force_shutdown)
229                 next = BHV_NEXT(next);
230         ((*bhvtovfsops(next)->vfs_force_shutdown)(next, fl, file, line));
231 }
232
233 void
234 vfs_freeze(
235         struct bhv_desc         *bdp)
236 {
237         struct bhv_desc         *next = bdp;
238
239         ASSERT(next);
240         while (! (bhvtovfsops(next))->vfs_freeze)
241                 next = BHV_NEXT(next);
242         ((*bhvtovfsops(next)->vfs_freeze)(next));
243 }
244
245 vfs_t *
246 vfs_allocate( void )
247 {
248         struct vfs              *vfsp;
249
250         vfsp = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
251         bhv_head_init(VFS_BHVHEAD(vfsp), "vfs");
252         INIT_LIST_HEAD(&vfsp->vfs_sync_list);
253         spin_lock_init(&vfsp->vfs_sync_lock);
254         init_waitqueue_head(&vfsp->vfs_wait_sync_task);
255         init_waitqueue_head(&vfsp->vfs_wait_single_sync_task);
256         return vfsp;
257 }
258
259 void
260 vfs_deallocate(
261         struct vfs              *vfsp)
262 {
263         bhv_head_destroy(VFS_BHVHEAD(vfsp));
264         kmem_free(vfsp, sizeof(vfs_t));
265 }
266
267 void
268 vfs_insertops(
269         struct vfs              *vfsp,
270         struct bhv_vfsops       *vfsops)
271 {
272         struct bhv_desc         *bdp;
273
274         bdp = kmem_alloc(sizeof(struct bhv_desc), KM_SLEEP);
275         bhv_desc_init(bdp, NULL, vfsp, vfsops);
276         bhv_insert(&vfsp->vfs_bh, bdp);
277 }
278
279 void
280 vfs_insertbhv(
281         struct vfs              *vfsp,
282         struct bhv_desc         *bdp,
283         struct vfsops           *vfsops,
284         void                    *mount)
285 {
286         bhv_desc_init(bdp, mount, vfsp, vfsops);
287         bhv_insert_initial(&vfsp->vfs_bh, bdp);
288 }
289
290 void
291 bhv_remove_vfsops(
292         struct vfs              *vfsp,
293         int                     pos)
294 {
295         struct bhv_desc         *bhv;
296
297         bhv = bhv_lookup_range(&vfsp->vfs_bh, pos, pos);
298         if (!bhv)
299                 return;
300         bhv_remove(&vfsp->vfs_bh, bhv);
301         kmem_free(bhv, sizeof(*bhv));
302 }
303
304 void
305 bhv_remove_all_vfsops(
306         struct vfs              *vfsp,
307         int                     freebase)
308 {
309         struct xfs_mount        *mp;
310
311         bhv_remove_vfsops(vfsp, VFS_POSITION_QM);
312         bhv_remove_vfsops(vfsp, VFS_POSITION_DM);
313         if (!freebase)
314                 return;
315         mp = XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfsp), &xfs_vfsops));
316         VFS_REMOVEBHV(vfsp, &mp->m_bhv);
317         xfs_mount_free(mp, 0);
318 }
319
320 void
321 bhv_insert_all_vfsops(
322         struct vfs              *vfsp)
323 {
324         struct xfs_mount        *mp;
325
326         mp = xfs_mount_init();
327         vfs_insertbhv(vfsp, &mp->m_bhv, &xfs_vfsops, mp);
328         vfs_insertdmapi(vfsp);
329         vfs_insertquota(vfsp);
330 }