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 #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 }
331
|
This page was automatically generated by the
LXR engine.
|