1 /* $NetBSD: sysvbfs_vfsops.c,v 1.46 2015/01/02 16:51:02 hannken Exp $ */
2
3 /*-
4 * Copyright (c) 2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by UCHIYAMA Yasushi.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: sysvbfs_vfsops.c,v 1.46 2015/01/02 16:51:02 hannken Exp $");
34
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/pool.h>
39 #include <sys/time.h>
40 #include <sys/ucred.h>
41 #include <sys/mount.h>
42 #include <sys/fcntl.h>
43 #include <sys/malloc.h>
44 #include <sys/kauth.h>
45 #include <sys/proc.h>
46
47 /* v-node */
48 #include <sys/namei.h>
49 #include <sys/vnode.h>
50 /* devsw */
51 #include <sys/conf.h>
52
53 #include <fs/sysvbfs/sysvbfs.h> /* external interface */
54 #include <fs/sysvbfs/bfs.h> /* internal interface */
55
56 #ifdef SYSVBFS_VNOPS_DEBUG
57 #define DPRINTF(fmt, args...) printf(fmt, ##args)
58 #else
59 #define DPRINTF(arg...) ((void)0)
60 #endif
61
62 MALLOC_JUSTDEFINE(M_SYSVBFS_VFS, "sysvbfs vfs", "sysvbfs vfs structures");
63
64 struct pool sysvbfs_node_pool;
65
66 int sysvbfs_mountfs(struct vnode *, struct mount *, struct lwp *);
67
68 int
sysvbfs_mount(struct mount * mp,const char * path,void * data,size_t * data_len)69 sysvbfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
70 {
71 struct lwp *l = curlwp;
72 struct sysvbfs_args *args = data;
73 struct sysvbfs_mount *bmp = NULL;
74 struct vnode *devvp = NULL;
75 int error = 0;
76 bool update;
77
78 DPRINTF("%s: mnt_flag=%x\n", __func__, mp->mnt_flag);
79
80 if (args == NULL)
81 return EINVAL;
82 if (*data_len < sizeof *args)
83 return EINVAL;
84
85 if (mp->mnt_flag & MNT_GETARGS) {
86 if ((bmp = (struct sysvbfs_mount *)mp->mnt_data) == NULL)
87 return EIO;
88 args->fspec = NULL;
89 *data_len = sizeof *args;
90 return 0;
91 }
92
93
94 DPRINTF("%s: args->fspec=%s\n", __func__, args->fspec);
95 update = mp->mnt_flag & MNT_UPDATE;
96 if (args->fspec == NULL) {
97 /* nothing to do. */
98 return EINVAL;
99 }
100
101 if (args->fspec != NULL) {
102 /* Look up the name and verify that it's sane. */
103 error = namei_simple_user(args->fspec,
104 NSM_FOLLOW_NOEMULROOT, &devvp);
105 if (error != 0)
106 return (error);
107
108 if (!update) {
109 /*
110 * Be sure this is a valid block device
111 */
112 if (devvp->v_type != VBLK)
113 error = ENOTBLK;
114 else if (bdevsw_lookup(devvp->v_rdev) == NULL)
115 error = ENXIO;
116 } else {
117 /*
118 * Be sure we're still naming the same device
119 * used for our initial mount
120 */
121 bmp = (struct sysvbfs_mount *)mp->mnt_data;
122 if (devvp != bmp->devvp)
123 error = EINVAL;
124 }
125 }
126
127 /*
128 * If mount by non-root, then verify that user has necessary
129 * permissions on the device.
130 *
131 * Permission to update a mount is checked higher, so here we presume
132 * updating the mount is okay (for example, as far as securelevel goes)
133 * which leaves us with the normal check.
134 */
135 if (error == 0) {
136 int accessmode = VREAD;
137 if (update ?
138 (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
139 (mp->mnt_flag & MNT_RDONLY) == 0)
140 accessmode |= VWRITE;
141
142 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
143 KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp,
144 KAUTH_ARG(accessmode));
145 }
146
147 if (error) {
148 vrele(devvp);
149 return error;
150 }
151
152 if (!update) {
153 if ((error = sysvbfs_mountfs(devvp, mp, l)) != 0) {
154 vrele(devvp);
155 return error;
156 }
157 } else if (mp->mnt_flag & MNT_RDONLY) {
158 /* XXX: r/w -> read only */
159 }
160
161 return set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE,
162 mp->mnt_op->vfs_name, mp, l);
163 }
164
165 int
sysvbfs_mountfs(struct vnode * devvp,struct mount * mp,struct lwp * l)166 sysvbfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
167 {
168 kauth_cred_t cred = l->l_cred;
169 struct sysvbfs_mount *bmp;
170 int error, oflags;
171
172 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
173 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
174 if (error)
175 goto out;
176
177 /* Open block device */
178 oflags = FREAD;
179 if ((mp->mnt_flag & MNT_RDONLY) == 0)
180 oflags |= FWRITE;
181 if ((error = VOP_OPEN(devvp, oflags, NOCRED)) != 0)
182 goto out;
183
184 bmp = malloc(sizeof(*bmp), M_SYSVBFS_VFS, M_WAITOK | M_ZERO);
185 bmp->devvp = devvp;
186 bmp->mountp = mp;
187 if ((error = sysvbfs_bfs_init(&bmp->bfs, devvp)) != 0) {
188 free(bmp, M_SYSVBFS_VFS);
189 VOP_CLOSE(devvp, oflags, NOCRED);
190 goto out;
191 }
192
193 mp->mnt_data = bmp;
194 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)devvp->v_rdev;
195 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_SYSVBFS);
196 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
197 mp->mnt_stat.f_namemax = BFS_FILENAME_MAXLEN;
198 mp->mnt_flag |= MNT_LOCAL;
199 mp->mnt_dev_bshift = BFS_BSHIFT;
200 mp->mnt_fs_bshift = BFS_BSHIFT;
201
202 out:
203 VOP_UNLOCK(devvp);
204 return error;
205 }
206
207 int
sysvbfs_start(struct mount * mp,int flags)208 sysvbfs_start(struct mount *mp, int flags)
209 {
210
211 DPRINTF("%s:\n", __func__);
212 /* Nothing to do. */
213 return 0;
214 }
215
216 int
sysvbfs_unmount(struct mount * mp,int mntflags)217 sysvbfs_unmount(struct mount *mp, int mntflags)
218 {
219 struct sysvbfs_mount *bmp = (void *)mp->mnt_data;
220 int error;
221
222 DPRINTF("%s: %p\n", __func__, bmp);
223
224 if ((error = vflush(mp, NULLVP,
225 mntflags & MNT_FORCE ? FORCECLOSE : 0)) != 0)
226 return error;
227
228 vn_lock(bmp->devvp, LK_EXCLUSIVE | LK_RETRY);
229 error = VOP_CLOSE(bmp->devvp, FREAD, NOCRED);
230 vput(bmp->devvp);
231
232 sysvbfs_bfs_fini(bmp->bfs);
233
234 free(bmp, M_SYSVBFS_VFS);
235 mp->mnt_data = NULL;
236 mp->mnt_flag &= ~MNT_LOCAL;
237
238 return 0;
239 }
240
241 int
sysvbfs_root(struct mount * mp,struct vnode ** vpp)242 sysvbfs_root(struct mount *mp, struct vnode **vpp)
243 {
244 struct vnode *vp;
245 int error;
246
247 DPRINTF("%s:\n", __func__);
248 if ((error = VFS_VGET(mp, BFS_ROOT_INODE, &vp)) != 0)
249 return error;
250 *vpp = vp;
251
252 return 0;
253 }
254
255 int
sysvbfs_statvfs(struct mount * mp,struct statvfs * f)256 sysvbfs_statvfs(struct mount *mp, struct statvfs *f)
257 {
258 struct sysvbfs_mount *bmp = mp->mnt_data;
259 struct bfs *bfs = bmp->bfs;
260 int free_block;
261 size_t data_block;
262
263 data_block = (bfs->data_end - bfs->data_start) >> BFS_BSHIFT;
264 if (bfs_inode_alloc(bfs, 0, 0, &free_block) != 0)
265 free_block = 0;
266 else
267 free_block = (bfs->data_end >> BFS_BSHIFT) - free_block;
268
269 DPRINTF("%s: %d %d %d\n", __func__, bfs->data_start,
270 bfs->data_end, free_block);
271
272 f->f_bsize = BFS_BSIZE;
273 f->f_frsize = BFS_BSIZE;
274 f->f_iosize = BFS_BSIZE;
275 f->f_blocks = data_block;
276 f->f_bfree = free_block;
277 f->f_bavail = f->f_bfree;
278 f->f_bresvd = 0;
279 f->f_files = bfs->max_inode;
280 f->f_ffree = bfs->max_inode - bfs->n_inode;
281 f->f_favail = f->f_ffree;
282 f->f_fresvd = 0;
283 copy_statvfs_info(f, mp);
284
285 return 0;
286 }
287
288 int
sysvbfs_sync(struct mount * mp,int waitfor,kauth_cred_t cred)289 sysvbfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
290 {
291 struct vnode_iterator *marker;
292 struct vnode *vp;
293 int err, error;
294
295 DPRINTF("%s:\n", __func__);
296 error = 0;
297 vfs_vnode_iterator_init(mp, &marker);
298 while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL)) != NULL) {
299 err = vn_lock(vp, LK_EXCLUSIVE);
300 if (err) {
301 vrele(vp);
302 continue;
303 }
304 err = VOP_FSYNC(vp, cred, FSYNC_WAIT, 0, 0);
305 vput(vp);
306 if (err != 0)
307 error = err;
308 }
309 vfs_vnode_iterator_destroy(marker);
310
311 return error;
312 }
313
314 int
sysvbfs_loadvnode(struct mount * mp,struct vnode * vp,const void * key,size_t key_len,const void ** new_key)315 sysvbfs_loadvnode(struct mount *mp, struct vnode *vp,
316 const void *key, size_t key_len, const void **new_key)
317 {
318 struct sysvbfs_mount *bmp;
319 struct bfs *bfs;
320 struct sysvbfs_node *bnode;
321 struct bfs_inode *inode;
322 uint16_t ino;
323
324 KASSERT(key_len == sizeof(ino));
325 memcpy(&ino, key, key_len);
326
327 DPRINTF("%s: i-node=%u\n", __func__, ino);
328
329 bmp = mp->mnt_data;
330 bfs = bmp->bfs;
331
332 /* Lookup requested i-node */
333 if (!bfs_inode_lookup(bfs, ino, &inode)) {
334 DPRINTF("%s: bfs_inode_lookup failed.\n", __func__);
335 return ENOENT;
336 }
337
338 bnode = pool_get(&sysvbfs_node_pool, PR_WAITOK);
339 memset(bnode, 0, sizeof(*bnode));
340
341 vp->v_tag = VT_SYSVBFS;
342 vp->v_op = sysvbfs_vnodeop_p;
343 vp->v_data = bnode;
344 if (ino == BFS_ROOT_INODE) { /* BFS is flat filesystem */
345 vp->v_type = VDIR;
346 vp->v_vflag |= VV_ROOT;
347 } else {
348 vp->v_type = VREG;
349 }
350
351 bnode->vnode = vp;
352 bnode->bmp = bmp;
353 bnode->inode = inode;
354 bnode->lockf = NULL; /* advlock */
355
356 genfs_node_init(vp, &sysvbfs_genfsops);
357 uvm_vnp_setsize(vp, bfs_file_size(inode));
358
359 *new_key = &bnode->inode->number;
360
361 return 0;
362 }
363
364 int
sysvbfs_vget(struct mount * mp,ino_t ino,struct vnode ** vpp)365 sysvbfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
366 {
367 int error;
368 uint16_t number;
369 struct vnode *vp;
370
371 KASSERT(ino <= UINT16_MAX);
372 number = ino;
373
374 DPRINTF("%s: i-node=%u\n", __func__, number);
375
376 error = vcache_get(mp, &number, sizeof(number), &vp);
377 if (error)
378 return error;
379 error = vn_lock(vp, LK_EXCLUSIVE);
380 if (error) {
381 vrele(vp);
382 return error;
383 }
384
385 *vpp = vp;
386
387 return 0;
388 }
389
390 int
sysvbfs_fhtovp(struct mount * mp,struct fid * fid,struct vnode ** vpp)391 sysvbfs_fhtovp(struct mount *mp, struct fid *fid, struct vnode **vpp)
392 {
393
394 DPRINTF("%s:\n", __func__);
395 /* notyet */
396 return EOPNOTSUPP;
397 }
398
399 int
sysvbfs_vptofh(struct vnode * vpp,struct fid * fid,size_t * fh_size)400 sysvbfs_vptofh(struct vnode *vpp, struct fid *fid, size_t *fh_size)
401 {
402
403 DPRINTF("%s:\n", __func__);
404 /* notyet */
405 return EOPNOTSUPP;
406 }
407
408 MALLOC_DECLARE(M_BFS);
409 MALLOC_DECLARE(M_SYSVBFS_VNODE);
410
411 void
sysvbfs_init(void)412 sysvbfs_init(void)
413 {
414
415 DPRINTF("%s:\n", __func__);
416 malloc_type_attach(M_SYSVBFS_VFS);
417 malloc_type_attach(M_BFS);
418 malloc_type_attach(M_SYSVBFS_VNODE);
419 pool_init(&sysvbfs_node_pool, sizeof(struct sysvbfs_node), 0, 0, 0,
420 "sysvbfs_node_pool", &pool_allocator_nointr, IPL_NONE);
421 }
422
423 void
sysvbfs_reinit(void)424 sysvbfs_reinit(void)
425 {
426
427 /* Nothing to do. */
428 DPRINTF("%s:\n", __func__);
429 }
430
431 void
sysvbfs_done(void)432 sysvbfs_done(void)
433 {
434
435 DPRINTF("%s:\n", __func__);
436 pool_destroy(&sysvbfs_node_pool);
437 malloc_type_detach(M_BFS);
438 malloc_type_detach(M_SYSVBFS_VFS);
439 malloc_type_detach(M_SYSVBFS_VNODE);
440 }
441
442 int
sysvbfs_gop_alloc(struct vnode * vp,off_t off,off_t len,int flags,kauth_cred_t cred)443 sysvbfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
444 kauth_cred_t cred)
445 {
446
447 return 0;
448 }
449