xref: /dflybsd-src/sys/vfs/hpfs/hpfs_vfsops.c (revision 43c45e8f849b4b1b18e5935b2b2e908fe8a11a8d) 
1 /*-
2  * Copyright (c) 1998, 1999 Semen Ustimenko (semenu@FreeBSD.org)
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/fs/hpfs/hpfs_vfsops.c,v 1.3.2.2 2001/12/25 01:44:45 dillon Exp $
27  * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.28 2005/07/26 15:43:35 hmp Exp $
28  */
29 
30 
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/nlookup.h>
34 #include <sys/conf.h>
35 #include <sys/proc.h>
36 #include <sys/kernel.h>
37 #include <sys/vnode.h>
38 #include <sys/mount.h>
39 #include <sys/buf.h>
40 #include <sys/fcntl.h>
41 #include <sys/malloc.h>
42 
43 #include <vm/vm.h>
44 #include <vm/vm_param.h>
45 #if defined(__NetBSD__)
46 #include <vm/vm_prot.h>
47 #endif
48 #include <vm/vm_page.h>
49 #include <vm/vm_object.h>
50 #include <vm/vm_extern.h>
51 #include <sys/buf2.h>
52 
53 #if defined(__NetBSD__)
54 #include <miscfs/specfs/specdev.h>
55 #endif
56 
57 #include "hpfs.h"
58 #include "hpfsmount.h"
59 #include "hpfs_subr.h"
60 
61 extern struct vnodeopv_entry_desc hpfs_vnodeop_entries[];
62 
63 MALLOC_DEFINE(M_HPFSMNT, "HPFS mount", "HPFS mount structure");
64 MALLOC_DEFINE(M_HPFSNO, "HPFS node", "HPFS node structure");
65 
66 static int	hpfs_root (struct mount *, struct vnode **);
67 static int	hpfs_statfs (struct mount *, struct statfs *,
68 				 struct thread *);
69 static int	hpfs_unmount (struct mount *, int, struct thread *);
70 static int	hpfs_vget (struct mount *mp, ino_t ino,
71 			       struct vnode **vpp);
72 static int	hpfs_mountfs (struct vnode *, struct mount *,
73 				  struct hpfs_args *, struct thread *);
74 static int	hpfs_vptofh (struct vnode *, struct fid *);
75 static int	hpfs_fhtovp (struct mount *, struct fid *,
76 				 struct vnode **);
77 
78 
79 struct sockaddr;
80 static int	hpfs_mount (struct mount *, char *, caddr_t, struct thread *);
81 static int	hpfs_init (struct vfsconf *);
82 static int	hpfs_checkexp (struct mount *, struct sockaddr *,
83 				   int *, struct ucred **);
84 
85 /*ARGSUSED*/
86 static int
87 hpfs_checkexp(struct mount *mp,
88 	      struct sockaddr *nam,
89 	      int *exflagsp, struct ucred **credanonp)
90 {
91 	struct netcred *np;
92 	struct hpfsmount *hpm = VFSTOHPFS(mp);
93 
94 	/*
95 	 * Get the export permission structure for this <mp, client> tuple.
96 	 */
97 	np = vfs_export_lookup(mp, &hpm->hpm_export, nam);
98 	if (np == NULL)
99 		return (EACCES);
100 
101 	*exflagsp = np->netc_exflags;
102 	*credanonp = &np->netc_anon;
103 	return (0);
104 }
105 
106 static int
107 hpfs_init(struct vfsconf *vcp)
108 {
109 	dprintf(("hpfs_init():\n"));
110 
111 	hpfs_hphashinit();
112 	return 0;
113 }
114 
115 static int
116 hpfs_mount(struct mount *mp,
117 	   char *path, caddr_t data,
118 	   struct thread *td)
119 {
120 	u_int		size;
121 	int		error;
122 	struct vnode	*devvp;
123 	struct hpfs_args args;
124 	struct hpfsmount *hpmp = 0;
125 	struct nlookupdata nd;
126 
127 	dprintf(("hpfs_mount():\n"));
128 	/*
129 	 ***
130 	 * Mounting non-root file system or updating a file system
131 	 ***
132 	 */
133 
134 	/* copy in user arguments*/
135 	error = copyin(data, (caddr_t)&args, sizeof (struct hpfs_args));
136 	if (error)
137 		goto error_1;		/* can't get arguments*/
138 
139 	/*
140 	 * If updating, check whether changing from read-only to
141 	 * read/write; if there is no device name, that's all we do.
142 	 */
143 	if (mp->mnt_flag & MNT_UPDATE) {
144 		dprintf(("hpfs_mount: MNT_UPDATE: "));
145 
146 		hpmp = VFSTOHPFS(mp);
147 
148 		if (args.fspec == 0) {
149 			dprintf(("export 0x%x\n",args.export.ex_flags));
150 			error = vfs_export(mp, &hpmp->hpm_export, &args.export);
151 			if (error) {
152 				printf("hpfs_mount: vfs_export failed %d\n",
153 					error);
154 			}
155 			goto success;
156 		} else {
157 			dprintf(("name [FAILED]\n"));
158 			error = EINVAL;
159 			goto success;
160 		}
161 		dprintf(("\n"));
162 	}
163 
164 	/*
165 	 * Not an update, or updating the name: look up the name
166 	 * and verify that it refers to a sensible block device.
167 	 */
168 	devvp = NULL;
169 	error = nlookup_init(&nd, args.fspec, UIO_USERSPACE, NLC_FOLLOW);
170 	if (error == 0)
171 		error = nlookup(&nd);
172 	if (error == 0)
173 		error = cache_vref(nd.nl_ncp, nd.nl_cred, &devvp);
174 	nlookup_done(&nd);
175 	if (error)
176 		goto error_1;
177 
178 	if (!vn_isdisk(devvp, &error))
179 		goto error_2;
180 
181 	/*
182 	 ********************
183 	 * NEW MOUNT
184 	 ********************
185 	 */
186 
187 	/* Save "mounted from" info for mount point (NULL pad)*/
188 	copyinstr(	args.fspec,			/* device name*/
189 			mp->mnt_stat.f_mntfromname,	/* save area*/
190 			MNAMELEN - 1,			/* max size*/
191 			&size);				/* real size*/
192 	bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
193 
194 	error = hpfs_mountfs(devvp, mp, &args, td);
195 	if (error)
196 		goto error_2;
197 
198 	/*
199 	 * Initialize FS stat information in mount struct; uses
200 	 * mp->mnt_stat.f_mntfromname.
201 	 *
202 	 * This code is common to root and non-root mounts
203 	 */
204 	VFS_STATFS(mp, &mp->mnt_stat, td);
205 	return (error);
206 
207 error_2:	/* error with devvp held*/
208 
209 	/* release devvp before failing*/
210 	vrele(devvp);
211 
212 error_1:	/* no state to back out*/
213 
214 success:
215 	return (error);
216 }
217 
218 /*
219  * Common code for mount and mountroot
220  */
221 int
222 hpfs_mountfs(struct vnode *devvp, struct mount *mp, struct hpfs_args *argsp,
223 	     struct thread *td)
224 {
225 	int error, ncount, ronly;
226 	struct sublock *sup;
227 	struct spblock *spp;
228 	struct hpfsmount *hpmp;
229 	struct buf *bp = NULL;
230 	struct vnode *vp;
231 	dev_t dev;
232 
233 	dprintf(("hpfs_mountfs():\n"));
234 	/*
235 	 * Disallow multiple mounts of the same device.
236 	 * Disallow mounting of a device that is currently in use
237 	 * (except for root, which might share swap device for miniroot).
238 	 * Flush out any old buffers remaining from a previous use.
239 	 */
240 	error = vfs_mountedon(devvp);
241 	if (error)
242 		return (error);
243 	ncount = count_udev(devvp->v_udev);
244 	if (devvp->v_object)
245 		ncount -= 1;
246 	if (ncount > 0)
247 		return (EBUSY);
248 
249 	VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td);
250 	error = vinvalbuf(devvp, V_SAVE, td, 0, 0);
251 	VOP__UNLOCK(devvp, 0, td);
252 	if (error)
253 		return (error);
254 
255 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
256 	VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td);
257 	error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, NULL, td);
258 	VOP__UNLOCK(devvp, 0, td);
259 	if (error)
260 		return (error);
261 	dev = devvp->v_rdev;
262 
263 	/*
264 	 * Do actual mount
265 	 */
266 	hpmp = malloc(sizeof(struct hpfsmount), M_HPFSMNT, M_WAITOK);
267 	bzero(hpmp, sizeof(struct hpfsmount));
268 
269 	/* Read in SuperBlock */
270 	error = bread(devvp, SUBLOCK, SUSIZE, &bp);
271 	if (error)
272 		goto failed;
273 	bcopy(bp->b_data, &hpmp->hpm_su, sizeof(struct sublock));
274 	brelse(bp); bp = NULL;
275 
276 	/* Read in SpareBlock */
277 	error = bread(devvp, SPBLOCK, SPSIZE, &bp);
278 	if (error)
279 		goto failed;
280 	bcopy(bp->b_data, &hpmp->hpm_sp, sizeof(struct spblock));
281 	brelse(bp); bp = NULL;
282 
283 	sup = &hpmp->hpm_su;
284 	spp = &hpmp->hpm_sp;
285 
286 	/* Check magic */
287 	if (sup->su_magic != SU_MAGIC) {
288 		printf("hpfs_mountfs: SuperBlock MAGIC DOESN'T MATCH\n");
289 		error = EINVAL;
290 		goto failed;
291 	}
292 	if (spp->sp_magic != SP_MAGIC) {
293 		printf("hpfs_mountfs: SpareBlock MAGIC DOESN'T MATCH\n");
294 		error = EINVAL;
295 		goto failed;
296 	}
297 
298 	mp->mnt_data = (qaddr_t)hpmp;
299 	hpmp->hpm_devvp = devvp;
300 	hpmp->hpm_dev = dev;
301 	hpmp->hpm_mp = mp;
302 	hpmp->hpm_uid = argsp->uid;
303 	hpmp->hpm_gid = argsp->gid;
304 	hpmp->hpm_mode = argsp->mode;
305 
306 	error = hpfs_bminit(hpmp);
307 	if (error)
308 		goto failed;
309 
310 	error = hpfs_cpinit(hpmp, argsp);
311 	if (error) {
312 		hpfs_bmdeinit(hpmp);
313 		goto failed;
314 	}
315 	vfs_add_vnodeops(mp, &mp->mnt_vn_norm_ops, hpfs_vnodeop_entries);
316 
317 	error = hpfs_root(mp, &vp);
318 	if (error) {
319 		hpfs_cpdeinit(hpmp);
320 		hpfs_bmdeinit(hpmp);
321 		goto failed;
322 	}
323 
324 	vput(vp);
325 
326 	mp->mnt_stat.f_fsid.val[0] = (long)dev2udev(dev);
327 	mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
328 	mp->mnt_maxsymlinklen = 0;
329 	mp->mnt_flag |= MNT_LOCAL;
330 	dev->si_mountpoint = mp;
331 	return (0);
332 
333 failed:
334 	if (bp)
335 		brelse (bp);
336 	mp->mnt_data = (qaddr_t)NULL;
337 	dev->si_mountpoint = NULL;
338 	(void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, td);
339 	return (error);
340 }
341 
342 
343 static int
344 hpfs_unmount(struct mount *mp, int mntflags, struct thread *td)
345 {
346 	int error, flags, ronly;
347 	struct hpfsmount *hpmp = VFSTOHPFS(mp);
348 
349 	dprintf(("hpfs_unmount():\n"));
350 
351 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
352 
353 	flags = 0;
354 	if(mntflags & MNT_FORCE)
355 		flags |= FORCECLOSE;
356 
357 	dprintf(("hpfs_unmount: vflushing...\n"));
358 
359 	error = vflush(mp, 0, flags);
360 	if (error) {
361 		printf("hpfs_unmount: vflush failed: %d\n",error);
362 		return (error);
363 	}
364 
365 	hpmp->hpm_devvp->v_rdev->si_mountpoint = NULL;
366 
367 	vinvalbuf(hpmp->hpm_devvp, V_SAVE, td, 0, 0);
368 	error = VOP_CLOSE(hpmp->hpm_devvp, ronly ? FREAD : FREAD|FWRITE, td);
369 
370 	vrele(hpmp->hpm_devvp);
371 
372 	dprintf(("hpfs_umount: freeing memory...\n"));
373 	hpfs_cpdeinit(hpmp);
374 	hpfs_bmdeinit(hpmp);
375 	mp->mnt_data = (qaddr_t)0;
376 	mp->mnt_flag &= ~MNT_LOCAL;
377 	FREE(hpmp, M_HPFSMNT);
378 
379 	return (0);
380 }
381 
382 static int
383 hpfs_root(struct mount *mp, struct vnode **vpp)
384 {
385 	int error = 0;
386 	struct hpfsmount *hpmp = VFSTOHPFS(mp);
387 
388 	dprintf(("hpfs_root():\n"));
389 	error = VFS_VGET(mp, (ino_t)hpmp->hpm_su.su_rootfno, vpp);
390 	if(error) {
391 		printf("hpfs_root: VFS_VGET failed: %d\n",error);
392 		return (error);
393 	}
394 
395 	return (error);
396 }
397 
398 static int
399 hpfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
400 {
401 	struct hpfsmount *hpmp = VFSTOHPFS(mp);
402 
403 	dprintf(("hpfs_statfs(): HPFS%d.%d\n",
404 		hpmp->hpm_su.su_hpfsver, hpmp->hpm_su.su_fnctver));
405 
406 	sbp->f_type = mp->mnt_vfc->vfc_typenum;
407 	sbp->f_bsize = DEV_BSIZE;
408 	sbp->f_iosize = DEV_BSIZE;
409 	sbp->f_blocks = hpmp->hpm_su.su_btotal;
410 	sbp->f_bfree = sbp->f_bavail = hpmp->hpm_bavail;
411 	sbp->f_ffree = 0;
412 	sbp->f_files = 0;
413 	if (sbp != &mp->mnt_stat) {
414 		bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
415 			(caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
416 	}
417 	sbp->f_flags = mp->mnt_flag;
418 
419 	return (0);
420 }
421 
422 
423 /*ARGSUSED*/
424 static int
425 hpfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
426 {
427 	struct vnode *nvp;
428 	struct hpfid *hpfhp = (struct hpfid *)fhp;
429 	int error;
430 
431 	if ((error = VFS_VGET(mp, hpfhp->hpfid_ino, &nvp)) != 0) {
432 		*vpp = NULLVP;
433 		return (error);
434 	}
435 	/* XXX as unlink/rmdir/mkdir/creat are not currently possible
436 	 * with HPFS, we don't need to check anything else for now */
437 	*vpp = nvp;
438 
439 	return (0);
440 }
441 
442 static int
443 hpfs_vptofh(struct vnode *vp, struct fid *fhp)
444 {
445 	struct hpfsnode *hpp;
446 	struct hpfid *hpfhp;
447 
448 	hpp = VTOHP(vp);
449 	hpfhp = (struct hpfid *)fhp;
450 	hpfhp->hpfid_len = sizeof(struct hpfid);
451 	hpfhp->hpfid_ino = hpp->h_no;
452 	/* hpfhp->hpfid_gen = hpp->h_gen; */
453 	return (0);
454 }
455 
456 static int
457 hpfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
458 {
459 	struct hpfsmount *hpmp = VFSTOHPFS(mp);
460 	struct vnode *vp;
461 	struct hpfsnode *hp;
462 	struct buf *bp;
463 	struct thread *td = curthread;	/* XXX */
464 	int error;
465 
466 	dprintf(("hpfs_vget(0x%x): ",ino));
467 
468 	*vpp = NULL;
469 	hp = NULL;
470 	vp = NULL;
471 
472 	if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) {
473 		dprintf(("hashed\n"));
474 		return (0);
475 	}
476 
477 	/*
478 	 * We have to lock node creation for a while,
479 	 * but then we have to call getnewvnode(),
480 	 * this may cause hpfs_reclaim() to be called,
481 	 * this may need to VOP_VGET() parent dir for
482 	 * update reasons, and if parent is not in
483 	 * hash, we have to lock node creation...
484 	 * To solve this, we MALLOC, getnewvnode and init while
485 	 * not locked (probability of node appearence
486 	 * at that time is little, and anyway - we'll
487 	 * check for it).
488 	 */
489 	MALLOC(hp, struct hpfsnode *, sizeof(struct hpfsnode),
490 		M_HPFSNO, M_WAITOK);
491 
492 	error = getnewvnode(VT_HPFS, hpmp->hpm_mp, &vp, VLKTIMEOUT, 0);
493 	if (error) {
494 		printf("hpfs_vget: can't get new vnode\n");
495 		FREE(hp, M_HPFSNO);
496 		return (error);
497 	}
498 
499 	dprintf(("prenew "));
500 
501 	vp->v_data = hp;
502 
503 	if (ino == (ino_t)hpmp->hpm_su.su_rootfno)
504 		vp->v_flag |= VROOT;
505 
506 	lwkt_token_init(&hp->h_interlock);
507 
508 	hp->h_flag = H_INVAL;
509 	hp->h_vp = vp;
510 	hp->h_hpmp = hpmp;
511 	hp->h_no = ino;
512 	hp->h_dev = hpmp->hpm_dev;
513 	hp->h_uid = hpmp->hpm_uid;
514 	hp->h_gid = hpmp->hpm_uid;
515 	hp->h_mode = hpmp->hpm_mode;
516 	hp->h_devvp = hpmp->hpm_devvp;
517 	vref(hp->h_devvp);
518 
519 	do {
520 		if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) {
521 			dprintf(("hashed2\n"));
522 			vx_put(vp);
523 			return (0);
524 		}
525 	} while(LOCKMGR(&hpfs_hphash_lock,LK_EXCLUSIVE|LK_SLEEPFAIL,NULL,NULL));
526 
527 	hpfs_hphashins(hp);
528 
529 	LOCKMGR(&hpfs_hphash_lock, LK_RELEASE, NULL, NULL);
530 
531 	error = bread(hpmp->hpm_devvp, ino, FNODESIZE, &bp);
532 	if (error) {
533 		printf("hpfs_vget: can't read ino %d\n",ino);
534 		vx_put(vp);
535 		return (error);
536 	}
537 	bcopy(bp->b_data, &hp->h_fn, sizeof(struct fnode));
538 	brelse(bp);
539 
540 	if (hp->h_fn.fn_magic != FN_MAGIC) {
541 		printf("hpfs_vget: MAGIC DOESN'T MATCH\n");
542 		vx_put(vp);
543 		return (EINVAL);
544 	}
545 
546 	vp->v_type = hp->h_fn.fn_flag ? VDIR:VREG;
547 	hp->h_flag &= ~H_INVAL;
548 
549 	/* Return the locked and refd vnode */
550 	*vpp = vp;
551 
552 	return (0);
553 }
554 
555 static struct vfsops hpfs_vfsops = {
556 	.vfs_mount =    	hpfs_mount,
557 	.vfs_unmount =  	hpfs_unmount,
558 	.vfs_root =     	hpfs_root,
559 	.vfs_statfs =   	hpfs_statfs,
560 	.vfs_sync =     	vfs_stdsync,
561 	.vfs_vget =     	hpfs_vget,
562 	.vfs_fhtovp =   	hpfs_fhtovp,
563 	.vfs_checkexp =  	hpfs_checkexp,
564 	.vfs_vptofh =   	hpfs_vptofh,
565 	.vfs_init =     	hpfs_init,
566 	.vfs_uninit =   	hpfs_hphash_uninit
567 };
568 
569 VFS_SET(hpfs_vfsops, hpfs, 0);
570 
571