xref: /netbsd-src/sys/fs/sysvbfs/sysvbfs_vfsops.c (revision b1c86f5f087524e68db12794ee9c3e3da1ab17a0)
1 /*	$NetBSD: sysvbfs_vfsops.c,v 1.35 2010/07/25 10:00:48 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.35 2010/07/25 10:00:48 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/disklabel.h>
43 #include <sys/fcntl.h>
44 #include <sys/malloc.h>
45 #include <sys/kauth.h>
46 #include <sys/proc.h>
47 
48 /* v-node */
49 #include <sys/namei.h>
50 #include <sys/vnode.h>
51 /* devsw */
52 #include <sys/conf.h>
53 
54 #include <fs/sysvbfs/sysvbfs.h>	/* external interface */
55 #include <fs/sysvbfs/bfs.h>	/* internal interface */
56 
57 #ifdef SYSVBFS_VNOPS_DEBUG
58 #define	DPRINTF(fmt, args...)	printf(fmt, ##args)
59 #else
60 #define	DPRINTF(arg...)		((void)0)
61 #endif
62 
63 MALLOC_JUSTDEFINE(M_SYSVBFS_VFS, "sysvbfs vfs", "sysvbfs vfs structures");
64 
65 struct pool sysvbfs_node_pool;
66 
67 int sysvbfs_mountfs(struct vnode *, struct mount *, struct lwp *);
68 
69 int
70 sysvbfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
71 {
72 	struct lwp *l = curlwp;
73 	struct sysvbfs_args *args = data;
74 	struct sysvbfs_mount *bmp = NULL;
75 	struct vnode *devvp = NULL;
76 	int error;
77 	bool update;
78 
79 	DPRINTF("%s: mnt_flag=%x\n", __func__, mp->mnt_flag);
80 
81 	if (*data_len < sizeof *args)
82 		return EINVAL;
83 
84 	if (mp->mnt_flag & MNT_GETARGS) {
85 		if ((bmp = (void *)mp->mnt_data) == NULL)
86 			return EIO;
87 		args->fspec = NULL;
88 		*data_len = sizeof *args;
89 		return 0;
90 	}
91 
92 
93 	DPRINTF("%s: args->fspec=%s\n", __func__, args->fspec);
94 	update = mp->mnt_flag & MNT_UPDATE;
95 	if (args->fspec == NULL) {
96 		/* nothing to do. */
97 		return EINVAL;
98 	}
99 
100 	if (args->fspec != NULL) {
101 		/* Look up the name and verify that it's sane. */
102 		error = namei_simple_user(args->fspec,
103 					NSM_FOLLOW_NOEMULROOT, &devvp);
104 		if (error != 0)
105 			return (error);
106 
107 		if (!update) {
108 			/*
109 			 * Be sure this is a valid block device
110 			 */
111 			if (devvp->v_type != VBLK)
112 				error = ENOTBLK;
113 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
114 				error = ENXIO;
115 		} else {
116 			/*
117 			 * Be sure we're still naming the same device
118 			 * used for our initial mount
119 			 */
120 			if (devvp != bmp->devvp)
121 				error = EINVAL;
122 		}
123 	}
124 
125 	/*
126 	 * If mount by non-root, then verify that user has necessary
127 	 * permissions on the device.
128 	 *
129 	 * Permission to update a mount is checked higher, so here we presume
130 	 * updating the mount is okay (for example, as far as securelevel goes)
131 	 * which leaves us with the normal check.
132 	 */
133 	if (error == 0) {
134 		int accessmode = VREAD;
135 		if (update ?
136 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
137 		    (mp->mnt_flag & MNT_RDONLY) == 0)
138 			accessmode |= VWRITE;
139 
140 		error = genfs_can_mount(devvp, accessmode, l->l_cred);
141 	}
142 
143 	if (error) {
144 		vrele(devvp);
145 		return error;
146 	}
147 
148 	if (!update) {
149 		if ((error = sysvbfs_mountfs(devvp, mp, l)) != 0) {
150 			vrele(devvp);
151 			return error;
152 		}
153 	} else 	if (mp->mnt_flag & MNT_RDONLY) {
154 		/* XXX: r/w -> read only */
155 	}
156 
157 	return set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE,
158 	    mp->mnt_op->vfs_name, mp, l);
159 }
160 
161 int
162 sysvbfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
163 {
164 	kauth_cred_t cred = l->l_cred;
165 	struct sysvbfs_mount *bmp;
166 	struct partinfo dpart;
167 	int error, oflags;
168 	bool devopen = false;
169 
170 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
171 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
172 	if (error)
173 		goto out;
174 
175 	/* Open block device */
176 	oflags = FREAD;
177 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
178 		oflags |= FWRITE;
179 	if ((error = VOP_OPEN(devvp, oflags, NOCRED)) != 0)
180 		goto out;
181 	devopen = true;
182 
183 	/* Get partition information */
184 	if ((error = VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred)) != 0) {
185 		goto out;
186 	}
187 
188 	bmp = malloc(sizeof(struct sysvbfs_mount), M_SYSVBFS_VFS, M_WAITOK);
189 	if (bmp == NULL) {
190 		error = ENOMEM;
191 		goto out;
192 	}
193 	bmp->devvp = devvp;
194 	bmp->mountp = mp;
195 	if ((error = sysvbfs_bfs_init(&bmp->bfs, devvp)) != 0) {
196 		free(bmp, M_SYSVBFS_VFS);
197 		goto out;
198 	}
199 	LIST_INIT(&bmp->bnode_head);
200 
201 	mp->mnt_data = bmp;
202 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)devvp->v_rdev;
203 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_SYSVBFS);
204 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
205 	mp->mnt_stat.f_namemax = BFS_FILENAME_MAXLEN;
206 	mp->mnt_flag |= MNT_LOCAL;
207 	mp->mnt_dev_bshift = BFS_BSHIFT;
208 	mp->mnt_fs_bshift = BFS_BSHIFT;
209 
210 	DPRINTF("fstype=%d dtype=%d bsize=%d\n", dpart.part->p_fstype,
211 	    dpart.disklab->d_type, dpart.disklab->d_secsize);
212 
213  out:
214 	if (devopen && error)
215 		VOP_CLOSE(devvp, oflags, NOCRED);
216 	VOP_UNLOCK(devvp);
217 	return error;
218 }
219 
220 int
221 sysvbfs_start(struct mount *mp, int flags)
222 {
223 
224 	DPRINTF("%s:\n", __func__);
225 	/* Nothing to do. */
226 	return 0;
227 }
228 
229 int
230 sysvbfs_unmount(struct mount *mp, int mntflags)
231 {
232 	struct sysvbfs_mount *bmp = (void *)mp->mnt_data;
233 	int error;
234 
235 	DPRINTF("%s: %p\n", __func__, bmp);
236 
237 	if ((error = vflush(mp, NULLVP,
238 	    mntflags & MNT_FORCE ? FORCECLOSE : 0)) != 0)
239 		return error;
240 
241 	vn_lock(bmp->devvp, LK_EXCLUSIVE | LK_RETRY);
242 	error = VOP_CLOSE(bmp->devvp, FREAD, NOCRED);
243 	vput(bmp->devvp);
244 
245 	sysvbfs_bfs_fini(bmp->bfs);
246 
247 	free(bmp, M_SYSVBFS_VFS);
248 	mp->mnt_data = NULL;
249 	mp->mnt_flag &= ~MNT_LOCAL;
250 
251 	return 0;
252 }
253 
254 int
255 sysvbfs_root(struct mount *mp, struct vnode **vpp)
256 {
257 	struct vnode *vp;
258 	int error;
259 
260 	DPRINTF("%s:\n", __func__);
261 	if ((error = VFS_VGET(mp, BFS_ROOT_INODE, &vp)) != 0)
262 		return error;
263 	*vpp = vp;
264 
265 	return 0;
266 }
267 
268 int
269 sysvbfs_statvfs(struct mount *mp, struct statvfs *f)
270 {
271 	struct sysvbfs_mount *bmp = mp->mnt_data;
272 	struct bfs *bfs = bmp->bfs;
273 	int free_block;
274 	size_t data_block;
275 
276 	data_block = (bfs->data_end - bfs->data_start) >> BFS_BSHIFT;
277 	if (bfs_inode_alloc(bfs, 0, 0, &free_block) != 0)
278 		free_block = 0;
279 	else
280 		free_block = (bfs->data_end >> BFS_BSHIFT) - free_block;
281 
282 	DPRINTF("%s: %d %d %d\n", __func__, bfs->data_start,
283 	    bfs->data_end, free_block);
284 
285 	f->f_bsize = BFS_BSIZE;
286 	f->f_frsize = BFS_BSIZE;
287 	f->f_iosize = BFS_BSIZE;
288 	f->f_blocks = data_block;
289 	f->f_bfree = free_block;
290 	f->f_bavail = f->f_bfree;
291 	f->f_bresvd = 0;
292 	f->f_files = bfs->n_inode;
293 	f->f_ffree = bfs->max_inode - f->f_files;
294 	f->f_favail = f->f_ffree;
295 	f->f_fresvd = 0;
296 	copy_statvfs_info(f, mp);
297 
298 	return 0;
299 }
300 
301 int
302 sysvbfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
303 {
304 	struct sysvbfs_mount *bmp = mp->mnt_data;
305 	struct sysvbfs_node *bnode;
306 	struct vnode *v;
307 	int err, error;
308 
309 	DPRINTF("%s:\n", __func__);
310 	error = 0;
311 	mutex_enter(&mntvnode_lock);
312 	for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL;
313 	    bnode = LIST_NEXT(bnode, link)) {
314 		v = bnode->vnode;
315 	    	mutex_enter(&v->v_interlock);
316 		mutex_exit(&mntvnode_lock);
317 		err = vget(v, LK_EXCLUSIVE | LK_NOWAIT);
318 		if (err == 0) {
319 			err = VOP_FSYNC(v, cred, FSYNC_WAIT, 0, 0);
320 			vput(v);
321 		}
322 		if (err != 0)
323 			error = err;
324 		mutex_enter(&mntvnode_lock);
325 	}
326 	mutex_exit(&mntvnode_lock);
327 
328 	return error;
329 }
330 
331 int
332 sysvbfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
333 {
334 	struct sysvbfs_mount *bmp = mp->mnt_data;
335 	struct bfs *bfs = bmp->bfs;
336 	struct vnode *vp;
337 	struct sysvbfs_node *bnode;
338 	struct bfs_inode *inode;
339 	int error;
340 
341 	DPRINTF("%s: i-node=%lld\n", __func__, (long long)ino);
342 	/* Lookup requested i-node */
343 	if (!bfs_inode_lookup(bfs, ino, &inode)) {
344 		DPRINTF("bfs_inode_lookup failed.\n");
345 		return ENOENT;
346 	}
347 
348  retry:
349 	mutex_enter(&mntvnode_lock);
350 	for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL;
351 	    bnode = LIST_NEXT(bnode, link)) {
352 		if (bnode->inode->number == ino) {
353 			vp = bnode->vnode;
354 			mutex_enter(&vp->v_interlock);
355 			mutex_exit(&mntvnode_lock);
356 			if (vget(vp, LK_EXCLUSIVE) == 0) {
357 				*vpp = vp;
358 				return 0;
359 			} else {
360 				goto retry;
361 			}
362 		}
363 	}
364 	mutex_exit(&mntvnode_lock);
365 
366 	/* Allocate v-node. */
367 	if ((error = getnewvnode(VT_SYSVBFS, mp, sysvbfs_vnodeop_p, &vp)) !=
368 	    0) {
369 		DPRINTF("%s: getnewvnode error.\n", __func__);
370 		return error;
371 	}
372 	/* Lock vnode here */
373 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
374 
375 	/* Allocate i-node */
376 	vp->v_data = pool_get(&sysvbfs_node_pool, PR_WAITOK);
377 	memset(vp->v_data, 0, sizeof(struct sysvbfs_node));
378 	bnode = vp->v_data;
379 	mutex_enter(&mntvnode_lock);
380 	LIST_INSERT_HEAD(&bmp->bnode_head, bnode, link);
381 	mutex_exit(&mntvnode_lock);
382 	bnode->vnode = vp;
383 	bnode->bmp = bmp;
384 	bnode->inode = inode;
385 	bnode->lockf = NULL; /* advlock */
386 
387 	if (ino == BFS_ROOT_INODE) {	/* BFS is flat filesystem */
388 		vp->v_type = VDIR;
389 		vp->v_vflag |= VV_ROOT;
390 	} else {
391 		vp->v_type = VREG;
392 	}
393 
394 	genfs_node_init(vp, &sysvbfs_genfsops);
395 	uvm_vnp_setsize(vp, bfs_file_size(inode));
396 	*vpp = vp;
397 
398 	return 0;
399 }
400 
401 int
402 sysvbfs_fhtovp(struct mount *mp, struct fid *fid, struct vnode **vpp)
403 {
404 
405 	DPRINTF("%s:\n", __func__);
406 	/* notyet */
407 	return EOPNOTSUPP;
408 }
409 
410 int
411 sysvbfs_vptofh(struct vnode *vpp, struct fid *fid, size_t *fh_size)
412 {
413 
414 	DPRINTF("%s:\n", __func__);
415 	/* notyet */
416 	return EOPNOTSUPP;
417 }
418 
419 MALLOC_DECLARE(M_BFS);
420 MALLOC_DECLARE(M_SYSVBFS_VNODE);
421 
422 void
423 sysvbfs_init(void)
424 {
425 
426 	DPRINTF("%s:\n", __func__);
427 	malloc_type_attach(M_SYSVBFS_VFS);
428 	malloc_type_attach(M_BFS);
429 	malloc_type_attach(M_SYSVBFS_VNODE);
430 	pool_init(&sysvbfs_node_pool, sizeof(struct sysvbfs_node), 0, 0, 0,
431 	    "sysvbfs_node_pool", &pool_allocator_nointr, IPL_NONE);
432 }
433 
434 void
435 sysvbfs_reinit(void)
436 {
437 
438 	/* Nothing to do. */
439 	DPRINTF("%s:\n", __func__);
440 }
441 
442 void
443 sysvbfs_done(void)
444 {
445 
446 	DPRINTF("%s:\n", __func__);
447 	pool_destroy(&sysvbfs_node_pool);
448 	malloc_type_detach(M_BFS);
449 	malloc_type_detach(M_SYSVBFS_VFS);
450 	malloc_type_detach(M_SYSVBFS_VNODE);
451 }
452 
453 int
454 sysvbfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
455     kauth_cred_t cred)
456 {
457 
458 	return 0;
459 }
460