manual update from upstream:
[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_single_sync_task);
255         return vfsp;
256 }
257
258 void
259 vfs_deallocate(
260         struct vfs              *vfsp)
261 {
262         bhv_head_destroy(VFS_BHVHEAD(vfsp));
263         kmem_free(vfsp, sizeof(vfs_t));
264 }
265
266 void
267 vfs_insertops(
268         struct vfs              *vfsp,
269         struct bhv_vfsops       *vfsops)
270 {
271         struct bhv_desc         *bdp;
272
273         bdp = kmem_alloc(sizeof(struct bhv_desc), KM_SLEEP);
274         bhv_desc_init(bdp, NULL, vfsp, vfsops);
275         bhv_insert(&vfsp->vfs_bh, bdp);
276 }
277
278 void
279 vfs_insertbhv(
280         struct vfs              *vfsp,
281         struct bhv_desc         *bdp,
282         struct vfsops           *vfsops,
283         void                    *mount)
284 {
285         bhv_desc_init(bdp, mount, vfsp, vfsops);
286         bhv_insert_initial(&vfsp->vfs_bh, bdp);
287 }
288
289 void
290 bhv_remove_vfsops(
291         struct vfs              *vfsp,
292         int                     pos)
293 {
294         struct bhv_desc         *bhv;
295
296         bhv = bhv_lookup_range(&vfsp->vfs_bh, pos, pos);
297         if (!bhv)
298                 return;
299         bhv_remove(&vfsp->vfs_bh, bhv);
300         kmem_free(bhv, sizeof(*bhv));
301 }
302
303 void
304 bhv_remove_all_vfsops(
305         struct vfs              *vfsp,
306         int                     freebase)
307 {
308         struct xfs_mount        *mp;
309
310         bhv_remove_vfsops(vfsp, VFS_POSITION_QM);
311         bhv_remove_vfsops(vfsp, VFS_POSITION_DM);
312         if (!freebase)
313                 return;
314         mp = XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfsp), &xfs_vfsops));
315         VFS_REMOVEBHV(vfsp, &mp->m_bhv);
316         xfs_mount_free(mp, 0);
317 }
318
319 void
320 bhv_insert_all_vfsops(
321         struct vfs              *vfsp)
322 {
323         struct xfs_mount        *mp;
324
325         mp = xfs_mount_init();
326         vfs_insertbhv(vfsp, &mp->m_bhv, &xfs_vfsops, mp);
327         vfs_insertdmapi(vfsp);
328         vfs_insertquota(vfsp);
329 }