47#include <sys/buf.h>
48#include <sys/conf.h>
49#include <sys/fcntl.h>
50#include <sys/disklabel.h>
51#include <sys/malloc.h>
52
53#include <ufs/ufs/extattr.h>
54#include <ufs/ufs/quota.h>
55#include <ufs/ufs/ufsmount.h>
56#include <ufs/ufs/inode.h>
57#include <ufs/ufs/ufs_extern.h>
58
59#include <ufs/ffs/fs.h>
60#include <ufs/ffs/ffs_extern.h>
61
62#include <vm/vm.h>
63#include <vm/vm_page.h>
64
65static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part");
66
67static int ffs_sbupdate __P((struct ufsmount *, int));
68static int ffs_reload __P((struct mount *,struct ucred *,struct proc *));
69static int ffs_oldfscompat __P((struct fs *));
70static int ffs_mount __P((struct mount *, char *, caddr_t,
71 struct nameidata *, struct proc *));
72static int ffs_init __P((struct vfsconf *));
73
74static struct vfsops ufs_vfsops = {
75 ffs_mount,
76 ufs_start,
77 ffs_unmount,
78 ufs_root,
79 ufs_quotactl,
80 ffs_statfs,
81 ffs_sync,
82 ffs_vget,
83 ffs_fhtovp,
84 ufs_check_export,
85 ffs_vptofh,
86 ffs_init,
87 vfs_stduninit,
88#ifdef FFS_EXTATTR
89 ufs_extattrctl,
90#else
91 vfs_stdextattrctl,
92#endif
93};
94
95VFS_SET(ufs_vfsops, ufs, 0);
96
97/*
98 * ffs_mount
99 *
100 * Called when mounting local physical media
101 *
102 * PARAMETERS:
103 * mountroot
104 * mp mount point structure
105 * path NULL (flag for root mount!!!)
106 * data <unused>
107 * ndp <unused>
108 * p process (user credentials check [statfs])
109 *
110 * mount
111 * mp mount point structure
112 * path path to mount point
113 * data pointer to argument struct in user space
114 * ndp mount point namei() return (used for
115 * credentials on reload), reused to look
116 * up block device.
117 * p process (user credentials check)
118 *
119 * RETURNS: 0 Success
120 * !0 error number (errno.h)
121 *
122 * LOCK STATE:
123 *
124 * ENTRY
125 * mount point is locked
126 * EXIT
127 * mount point is locked
128 *
129 * NOTES:
130 * A NULL path can be used for a flag since the mount
131 * system call will fail with EFAULT in copyinstr in
132 * namei() if it is a genuine NULL from the user.
133 */
134static int
135ffs_mount( mp, path, data, ndp, p)
136 struct mount *mp; /* mount struct pointer*/
137 char *path; /* path to mount point*/
138 caddr_t data; /* arguments to FS specific mount*/
139 struct nameidata *ndp; /* mount point credentials*/
140 struct proc *p; /* process requesting mount*/
141{
142 size_t size;
143 int err = 0;
144 struct vnode *devvp;
145
146 struct ufs_args args;
147 struct ufsmount *ump = 0;
148 register struct fs *fs;
149 int error, flags, ronly = 0;
150 mode_t accessmode;
151
152 /*
153 * Use NULL path to flag a root mount
154 */
155 if( path == NULL) {
156 /*
157 ***
158 * Mounting root file system
159 ***
160 */
161
162 if ((err = bdevvp(rootdev, &rootvp))) {
163 printf("ffs_mountroot: can't find rootvp\n");
164 return (err);
165 }
166
167 if( ( err = ffs_mountfs(rootvp, mp, p, M_FFSNODE)) != 0) {
168 /* fs specific cleanup (if any)*/
169 goto error_1;
170 }
171
172 goto dostatfs; /* success*/
173
174 }
175
176 /*
177 ***
178 * Mounting non-root file system or updating a file system
179 ***
180 */
181
182 /* copy in user arguments*/
183 err = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
184 if (err)
185 goto error_1; /* can't get arguments*/
186
187 /*
188 * If updating, check whether changing from read-only to
189 * read/write; if there is no device name, that's all we do.
190 */
191 if (mp->mnt_flag & MNT_UPDATE) {
192 ump = VFSTOUFS(mp);
193 fs = ump->um_fs;
194 devvp = ump->um_devvp;
195 err = 0;
196 ronly = fs->fs_ronly; /* MNT_RELOAD might change this */
197 if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
198 flags = WRITECLOSE;
199 if (mp->mnt_flag & MNT_FORCE)
200 flags |= FORCECLOSE;
201 if (mp->mnt_flag & MNT_SOFTDEP) {
202 err = softdep_flushfiles(mp, flags, p);
203 } else {
204 err = ffs_flushfiles(mp, flags, p);
205 }
206 ronly = 1;
207 }
208 if (!err && (mp->mnt_flag & MNT_RELOAD))
209 err = ffs_reload(mp, ndp->ni_cnd.cn_cred, p);
210 if (err) {
211 goto error_1;
212 }
213 if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
214 /*
215 * If upgrade to read-write by non-root, then verify
216 * that user has necessary permissions on the device.
217 */
218 if (p->p_ucred->cr_uid != 0) {
219 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
220 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
221 p->p_ucred, p)) != 0) {
222 VOP_UNLOCK(devvp, 0, p);
223 return (error);
224 }
225 VOP_UNLOCK(devvp, 0, p);
226 }
227
228 fs->fs_flags &= ~FS_UNCLEAN;
229 if (fs->fs_clean == 0) {
230 fs->fs_flags |= FS_UNCLEAN;
231 if (mp->mnt_flag & MNT_FORCE) {
232 printf(
233"WARNING: %s was not properly dismounted\n",
234 fs->fs_fsmnt);
235 } else {
236 printf(
237"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
238 fs->fs_fsmnt);
239 err = EPERM;
240 goto error_1;
241 }
242 }
243
244 /* check to see if we need to start softdep */
245 if (fs->fs_flags & FS_DOSOFTDEP) {
246 err = softdep_mount(devvp, mp, fs, p->p_ucred);
247 if (err)
248 goto error_1;
249 }
250
251 ronly = 0;
252 }
253 /*
254 * Soft updates is incompatible with "async",
255 * so if we are doing softupdates stop the user
256 * from setting the async flag in an update.
257 * Softdep_mount() clears it in an initial mount
258 * or ro->rw remount.
259 */
260 if (mp->mnt_flag & MNT_SOFTDEP) {
261 mp->mnt_flag &= ~MNT_ASYNC;
262 }
263 /* if not updating name...*/
264 if (args.fspec == 0) {
265 /*
266 * Process export requests. Jumping to "success"
267 * will return the vfs_export() error code.
268 */
269 err = vfs_export(mp, &ump->um_export, &args.export);
270 goto success;
271 }
272 }
273
274 /*
275 * Not an update, or updating the name: look up the name
276 * and verify that it refers to a sensible block device.
277 */
278 NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
279 err = namei(ndp);
280 if (err) {
281 /* can't get devvp!*/
282 goto error_1;
283 }
284
285 NDFREE(ndp, NDF_ONLY_PNBUF);
286 devvp = ndp->ni_vp;
287
288 if (!vn_isdisk(devvp, &err))
289 goto error_2;
290
291 /*
292 * If mount by non-root, then verify that user has necessary
293 * permissions on the device.
294 */
295 if (p->p_ucred->cr_uid != 0) {
296 accessmode = VREAD;
297 if ((mp->mnt_flag & MNT_RDONLY) == 0)
298 accessmode |= VWRITE;
299 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
300 if ((error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) != 0) {
301 vput(devvp);
302 return (error);
303 }
304 VOP_UNLOCK(devvp, 0, p);
305 }
306
307 if (mp->mnt_flag & MNT_UPDATE) {
308 /*
309 ********************
310 * UPDATE
311 * If it's not the same vnode, or at least the same device
312 * then it's not correct.
313 ********************
314 */
315
316 if (devvp != ump->um_devvp) {
317 if ( devvp->v_rdev == ump->um_devvp->v_rdev) {
318 vrele(devvp);
319 } else {
320 err = EINVAL; /* needs translation */
321 }
322 } else
323 vrele(devvp);
324 /*
325 * Update device name only on success
326 */
327 if( !err) {
328 /* Save "mounted from" info for mount point (NULL pad)*/
329 copyinstr( args.fspec,
330 mp->mnt_stat.f_mntfromname,
331 MNAMELEN - 1,
332 &size);
333 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
334 }
335 } else {
336 /*
337 ********************
338 * NEW MOUNT
339 ********************
340 */
341
342 /*
343 * Since this is a new mount, we want the names for
344 * the device and the mount point copied in. If an
345 * error occurs, the mountpoint is discarded by the
346 * upper level code.
347 */
348 /* Save "last mounted on" info for mount point (NULL pad)*/
349 copyinstr( path, /* mount point*/
350 mp->mnt_stat.f_mntonname, /* save area*/
351 MNAMELEN - 1, /* max size*/
352 &size); /* real size*/
353 bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
354
355 /* Save "mounted from" info for mount point (NULL pad)*/
356 copyinstr( args.fspec, /* device name*/
357 mp->mnt_stat.f_mntfromname, /* save area*/
358 MNAMELEN - 1, /* max size*/
359 &size); /* real size*/
360 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
361
362 err = ffs_mountfs(devvp, mp, p, M_FFSNODE);
363 }
364 if (err) {
365 goto error_2;
366 }
367
368dostatfs:
369 /*
370 * Initialize FS stat information in mount struct; uses both
371 * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
372 *
373 * This code is common to root and non-root mounts
374 */
375 (void)VFS_STATFS(mp, &mp->mnt_stat, p);
376
377 goto success;
378
379
380error_2: /* error with devvp held*/
381
382 /* release devvp before failing*/
383 vrele(devvp);
384
385error_1: /* no state to back out*/
386
387success:
388 if (!err && path && (mp->mnt_flag & MNT_UPDATE)) {
389 /* Update clean flag after changing read-onlyness. */
390 fs = ump->um_fs;
391 if (ronly != fs->fs_ronly) {
392 fs->fs_ronly = ronly;
393 fs->fs_clean = ronly &&
394 (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;
395 ffs_sbupdate(ump, MNT_WAIT);
396 }
397 }
398 return (err);
399}
400
401/*
402 * Reload all incore data for a filesystem (used after running fsck on
403 * the root filesystem and finding things to fix). The filesystem must
404 * be mounted read-only.
405 *
406 * Things to do to update the mount:
407 * 1) invalidate all cached meta-data.
408 * 2) re-read superblock from disk.
409 * 3) re-read summary information from disk.
410 * 4) invalidate all inactive vnodes.
411 * 5) invalidate all cached file data.
412 * 6) re-read inode data for all active vnodes.
413 */
414static int
415ffs_reload(mp, cred, p)
416 register struct mount *mp;
417 struct ucred *cred;
418 struct proc *p;
419{
420 register struct vnode *vp, *nvp, *devvp;
421 struct inode *ip;
422 struct csum *space;
423 struct buf *bp;
424 struct fs *fs, *newfs;
425 struct partinfo dpart;
426 dev_t dev;
427 int i, blks, size, error;
428 int32_t *lp;
429
430 if ((mp->mnt_flag & MNT_RDONLY) == 0)
431 return (EINVAL);
432 /*
433 * Step 1: invalidate all cached meta-data.
434 */
435 devvp = VFSTOUFS(mp)->um_devvp;
436 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
437 error = vinvalbuf(devvp, 0, cred, p, 0, 0);
438 VOP_UNLOCK(devvp, 0, p);
439 if (error)
440 panic("ffs_reload: dirty1");
441
442 dev = devvp->v_rdev;
443
444 /*
445 * Only VMIO the backing device if the backing device is a real
446 * block device. See ffs_mountmfs() for more details.
447 */
448 if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
449 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
450 vfs_object_create(devvp, p, p->p_ucred);
451 simple_lock(&devvp->v_interlock);
452 VOP_UNLOCK(devvp, LK_INTERLOCK, p);
453 }
454
455 /*
456 * Step 2: re-read superblock from disk.
457 */
458 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
459 size = DEV_BSIZE;
460 else
461 size = dpart.disklab->d_secsize;
462 if ((error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, NOCRED,&bp)) != 0)
463 return (error);
464 newfs = (struct fs *)bp->b_data;
465 if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
466 newfs->fs_bsize < sizeof(struct fs)) {
467 brelse(bp);
468 return (EIO); /* XXX needs translation */
469 }
470 fs = VFSTOUFS(mp)->um_fs;
471 /*
472 * Copy pointer fields back into superblock before copying in XXX
473 * new superblock. These should really be in the ufsmount. XXX
474 * Note that important parameters (eg fs_ncg) are unchanged.
475 */
476 bcopy(&fs->fs_csp[0], &newfs->fs_csp[0], sizeof(fs->fs_csp));
477 newfs->fs_maxcluster = fs->fs_maxcluster;
478 bcopy(newfs, fs, (u_int)fs->fs_sbsize);
479 if (fs->fs_sbsize < SBSIZE)
480 bp->b_flags |= B_INVAL;
481 brelse(bp);
482 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
483 ffs_oldfscompat(fs);
484
485 /*
486 * Step 3: re-read summary information from disk.
487 */
488 blks = howmany(fs->fs_cssize, fs->fs_fsize);
489 space = fs->fs_csp[0];
490 for (i = 0; i < blks; i += fs->fs_frag) {
491 size = fs->fs_bsize;
492 if (i + fs->fs_frag > blks)
493 size = (blks - i) * fs->fs_fsize;
494 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
495 NOCRED, &bp);
496 if (error)
497 return (error);
498 bcopy(bp->b_data, fs->fs_csp[fragstoblks(fs, i)], (u_int)size);
499 brelse(bp);
500 }
501 /*
502 * We no longer know anything about clusters per cylinder group.
503 */
504 if (fs->fs_contigsumsize > 0) {
505 lp = fs->fs_maxcluster;
506 for (i = 0; i < fs->fs_ncg; i++)
507 *lp++ = fs->fs_contigsumsize;
508 }
509
510loop:
511 simple_lock(&mntvnode_slock);
512 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
513 if (vp->v_mount != mp) {
514 simple_unlock(&mntvnode_slock);
515 goto loop;
516 }
517 nvp = vp->v_mntvnodes.le_next;
518 /*
519 * Step 4: invalidate all inactive vnodes.
520 */
521 if (vrecycle(vp, &mntvnode_slock, p))
522 goto loop;
523 /*
524 * Step 5: invalidate all cached file data.
525 */
526 simple_lock(&vp->v_interlock);
527 simple_unlock(&mntvnode_slock);
528 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
529 goto loop;
530 }
531 if (vinvalbuf(vp, 0, cred, p, 0, 0))
532 panic("ffs_reload: dirty2");
533 /*
534 * Step 6: re-read inode data for all active vnodes.
535 */
536 ip = VTOI(vp);
537 error =
538 bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
539 (int)fs->fs_bsize, NOCRED, &bp);
540 if (error) {
541 vput(vp);
542 return (error);
543 }
544 ip->i_din = *((struct dinode *)bp->b_data +
545 ino_to_fsbo(fs, ip->i_number));
546 ip->i_effnlink = ip->i_nlink;
547 brelse(bp);
548 vput(vp);
549 simple_lock(&mntvnode_slock);
550 }
551 simple_unlock(&mntvnode_slock);
552 return (0);
553}
554
555/*
556 * Common code for mount and mountroot
557 */
558int
559ffs_mountfs(devvp, mp, p, malloctype)
560 register struct vnode *devvp;
561 struct mount *mp;
562 struct proc *p;
563 struct malloc_type *malloctype;
564{
565 register struct ufsmount *ump;
566 struct buf *bp;
567 register struct fs *fs;
568 dev_t dev;
569 struct partinfo dpart;
570 caddr_t base, space;
571 int error, i, blks, size, ronly;
572 int32_t *lp;
573 struct ucred *cred;
574 u_int64_t maxfilesize; /* XXX */
575 size_t strsize;
576 int ncount;
577
578 dev = devvp->v_rdev;
579 cred = p ? p->p_ucred : NOCRED;
580 /*
581 * Disallow multiple mounts of the same device.
582 * Disallow mounting of a device that is currently in use
583 * (except for root, which might share swap device for miniroot).
584 * Flush out any old buffers remaining from a previous use.
585 */
586 error = vfs_mountedon(devvp);
587 if (error)
588 return (error);
589 ncount = vcount(devvp);
590
591 if (ncount > 1 && devvp != rootvp)
592 return (EBUSY);
593 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
594 error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0);
595 VOP_UNLOCK(devvp, 0, p);
596 if (error)
597 return (error);
598
599 /*
600 * Only VMIO the backing device if the backing device is a real
601 * block device. This excludes the original MFS implementation.
602 * Note that it is optional that the backing device be VMIOed. This
603 * increases the opportunity for metadata caching.
604 */
605 if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
606 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
607 vfs_object_create(devvp, p, p->p_ucred);
608 simple_lock(&devvp->v_interlock);
609 VOP_UNLOCK(devvp, LK_INTERLOCK, p);
610 }
611
612 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
613 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
614 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
615 VOP_UNLOCK(devvp, 0, p);
616 if (error)
617 return (error);
618 if (devvp->v_rdev->si_iosize_max > mp->mnt_iosize_max)
619 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
620 if (mp->mnt_iosize_max > MAXPHYS)
621 mp->mnt_iosize_max = MAXPHYS;
622
623 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0)
624 size = DEV_BSIZE;
625 else
626 size = dpart.disklab->d_secsize;
627
628 bp = NULL;
629 ump = NULL;
630 if ((error = bread(devvp, SBLOCK, SBSIZE, cred, &bp)) != 0)
631 goto out;
632 fs = (struct fs *)bp->b_data;
633 if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
634 fs->fs_bsize < sizeof(struct fs)) {
635 error = EINVAL; /* XXX needs translation */
636 goto out;
637 }
638 fs->fs_fmod = 0;
639 fs->fs_flags &= ~FS_UNCLEAN;
640 if (fs->fs_clean == 0) {
641 fs->fs_flags |= FS_UNCLEAN;
642 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
643 printf(
644"WARNING: %s was not properly dismounted\n",
645 fs->fs_fsmnt);
646 } else {
647 printf(
648"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
649 fs->fs_fsmnt);
650 error = EPERM;
651 goto out;
652 }
653 }
654 /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
655 if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
656 error = EROFS; /* needs translation */
657 goto out;
658 }
659 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
660 bzero((caddr_t)ump, sizeof *ump);
661 ump->um_malloctype = malloctype;
662 ump->um_i_effnlink_valid = 1;
663 ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
664 M_WAITOK);
665 ump->um_blkatoff = ffs_blkatoff;
666 ump->um_truncate = ffs_truncate;
667 ump->um_update = ffs_update;
668 ump->um_valloc = ffs_valloc;
669 ump->um_vfree = ffs_vfree;
670 bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
671 if (fs->fs_sbsize < SBSIZE)
672 bp->b_flags |= B_INVAL;
673 brelse(bp);
674 bp = NULL;
675 fs = ump->um_fs;
676 fs->fs_ronly = ronly;
677 size = fs->fs_cssize;
678 blks = howmany(size, fs->fs_fsize);
679 if (fs->fs_contigsumsize > 0)
680 size += fs->fs_ncg * sizeof(int32_t);
681 base = space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
682 for (i = 0; i < blks; i += fs->fs_frag) {
683 size = fs->fs_bsize;
684 if (i + fs->fs_frag > blks)
685 size = (blks - i) * fs->fs_fsize;
686 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
687 cred, &bp)) != 0) {
688 free(base, M_UFSMNT);
689 goto out;
690 }
691 bcopy(bp->b_data, space, (u_int)size);
692 fs->fs_csp[fragstoblks(fs, i)] = (struct csum *)space;
693 space += size;
694 brelse(bp);
695 bp = NULL;
696 }
697 if (fs->fs_contigsumsize > 0) {
698 fs->fs_maxcluster = lp = (int32_t *)space;
699 for (i = 0; i < fs->fs_ncg; i++)
700 *lp++ = fs->fs_contigsumsize;
701 }
702 mp->mnt_data = (qaddr_t)ump;
703 mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
704 mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
705 if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
706 vfs_getvfs(&mp->mnt_stat.f_fsid))
707 vfs_getnewfsid(mp);
708 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
709 mp->mnt_flag |= MNT_LOCAL;
710 ump->um_mountp = mp;
711 ump->um_dev = dev;
712 ump->um_devvp = devvp;
713 ump->um_nindir = fs->fs_nindir;
714 ump->um_bptrtodb = fs->fs_fsbtodb;
715 ump->um_seqinc = fs->fs_frag;
716 for (i = 0; i < MAXQUOTAS; i++)
717 ump->um_quotas[i] = NULLVP;
718#ifdef FFS_EXTATTR
719 ufs_extattr_uepm_init(&ump->um_extattr);
720#endif
721 devvp->v_specmountpoint = mp;
722 ffs_oldfscompat(fs);
723
724 /*
725 * Set FS local "last mounted on" information (NULL pad)
726 */
727 copystr( mp->mnt_stat.f_mntonname, /* mount point*/
728 fs->fs_fsmnt, /* copy area*/
729 sizeof(fs->fs_fsmnt) - 1, /* max size*/
730 &strsize); /* real size*/
731 bzero( fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
732
733 if( mp->mnt_flag & MNT_ROOTFS) {
734 /*
735 * Root mount; update timestamp in mount structure.
736 * this will be used by the common root mount code
737 * to update the system clock.
738 */
739 mp->mnt_time = fs->fs_time;
740 }
741
742 ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */
743 maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */
744 if (fs->fs_maxfilesize > maxfilesize) /* XXX */
745 fs->fs_maxfilesize = maxfilesize; /* XXX */
746 if (ronly == 0) {
747 if ((fs->fs_flags & FS_DOSOFTDEP) &&
748 (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
749 free(base, M_UFSMNT);
750 goto out;
751 }
752 fs->fs_fmod = 1;
753 fs->fs_clean = 0;
754 (void) ffs_sbupdate(ump, MNT_WAIT);
755 }
756 return (0);
757out:
758 devvp->v_specmountpoint = NULL;
759 if (bp)
760 brelse(bp);
761 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
762 if (ump) {
763 free(ump->um_fs, M_UFSMNT);
764 free(ump, M_UFSMNT);
765 mp->mnt_data = (qaddr_t)0;
766 }
767 return (error);
768}
769
770/*
771 * Sanity checks for old file systems.
772 *
773 * XXX - goes away some day.
774 */
775static int
776ffs_oldfscompat(fs)
777 struct fs *fs;
778{
779
780 fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
781 fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
782 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
783 fs->fs_nrpos = 8; /* XXX */
784 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
785#if 0
786 int i; /* XXX */
787 u_int64_t sizepb = fs->fs_bsize; /* XXX */
788 /* XXX */
789 fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
790 for (i = 0; i < NIADDR; i++) { /* XXX */
791 sizepb *= NINDIR(fs); /* XXX */
792 fs->fs_maxfilesize += sizepb; /* XXX */
793 } /* XXX */
794#endif
795 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
796 fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
797 fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
798 } /* XXX */
799 return (0);
800}
801
802/*
803 * unmount system call
804 */
805int
806ffs_unmount(mp, mntflags, p)
807 struct mount *mp;
808 int mntflags;
809 struct proc *p;
810{
811 register struct ufsmount *ump;
812 register struct fs *fs;
813 int error, flags;
814
815 flags = 0;
816 if (mntflags & MNT_FORCE) {
817 flags |= FORCECLOSE;
818 }
819#ifdef FFS_EXTATTR
820 if ((error = ufs_extattr_stop(mp, p))) {
821 printf("ffs_unmonut: ufs_extattr_stop returned %d\n", error);
822 }
823#endif
824 if (mp->mnt_flag & MNT_SOFTDEP) {
825 if ((error = softdep_flushfiles(mp, flags, p)) != 0)
826 return (error);
827 } else {
828 if ((error = ffs_flushfiles(mp, flags, p)) != 0)
829 return (error);
830 }
831 ump = VFSTOUFS(mp);
832 fs = ump->um_fs;
833 if (fs->fs_ronly == 0) {
834 fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1;
835 error = ffs_sbupdate(ump, MNT_WAIT);
836 if (error) {
837 fs->fs_clean = 0;
838 return (error);
839 }
840 }
841 ump->um_devvp->v_specmountpoint = NULL;
842
843 vinvalbuf(ump->um_devvp, V_SAVE, NOCRED, p, 0, 0);
844 error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
845 NOCRED, p);
846
847 vrele(ump->um_devvp);
848
849 free(fs->fs_csp[0], M_UFSMNT);
850 free(fs, M_UFSMNT);
851 free(ump, M_UFSMNT);
852 mp->mnt_data = (qaddr_t)0;
853 mp->mnt_flag &= ~MNT_LOCAL;
854 return (error);
855}
856
857/*
858 * Flush out all the files in a filesystem.
859 */
860int
861ffs_flushfiles(mp, flags, p)
862 register struct mount *mp;
863 int flags;
864 struct proc *p;
865{
866 register struct ufsmount *ump;
867 int error;
868
869 ump = VFSTOUFS(mp);
870#ifdef QUOTA
871 if (mp->mnt_flag & MNT_QUOTA) {
872 int i;
873 error = vflush(mp, NULLVP, SKIPSYSTEM|flags);
874 if (error)
875 return (error);
876 for (i = 0; i < MAXQUOTAS; i++) {
877 if (ump->um_quotas[i] == NULLVP)
878 continue;
879 quotaoff(p, mp, i);
880 }
881 /*
882 * Here we fall through to vflush again to ensure
883 * that we have gotten rid of all the system vnodes.
884 */
885 }
886#endif
887 /*
888 * Flush all the files.
889 */
890 if ((error = vflush(mp, NULL, flags)) != 0)
891 return (error);
892 /*
893 * Flush filesystem metadata.
894 */
895 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
896 error = VOP_FSYNC(ump->um_devvp, p->p_ucred, MNT_WAIT, p);
897 VOP_UNLOCK(ump->um_devvp, 0, p);
898 return (error);
899}
900
901/*
902 * Get file system statistics.
903 */
904int
905ffs_statfs(mp, sbp, p)
906 struct mount *mp;
907 register struct statfs *sbp;
908 struct proc *p;
909{
910 register struct ufsmount *ump;
911 register struct fs *fs;
912
913 ump = VFSTOUFS(mp);
914 fs = ump->um_fs;
915 if (fs->fs_magic != FS_MAGIC)
916 panic("ffs_statfs");
917 sbp->f_bsize = fs->fs_fsize;
918 sbp->f_iosize = fs->fs_bsize;
919 sbp->f_blocks = fs->fs_dsize;
920 sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
921 fs->fs_cstotal.cs_nffree;
922 sbp->f_bavail = freespace(fs, fs->fs_minfree);
923 sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
924 sbp->f_ffree = fs->fs_cstotal.cs_nifree;
925 if (sbp != &mp->mnt_stat) {
926 sbp->f_type = mp->mnt_vfc->vfc_typenum;
927 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
928 (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
929 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
930 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
931 }
932 return (0);
933}
934
935/*
936 * Go through the disk queues to initiate sandbagged IO;
937 * go through the inodes to write those that have been modified;
938 * initiate the writing of the super block if it has been modified.
939 *
940 * Note: we are always called with the filesystem marked `MPBUSY'.
941 */
942int
943ffs_sync(mp, waitfor, cred, p)
944 struct mount *mp;
945 int waitfor;
946 struct ucred *cred;
947 struct proc *p;
948{
949 struct vnode *nvp, *vp;
950 struct inode *ip;
951 struct ufsmount *ump = VFSTOUFS(mp);
952 struct fs *fs;
953 int error, allerror = 0;
954
955 fs = ump->um_fs;
956 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
957 printf("fs = %s\n", fs->fs_fsmnt);
958 panic("ffs_sync: rofs mod");
959 }
960 /*
961 * Write back each (modified) inode.
962 */
963 simple_lock(&mntvnode_slock);
964loop:
965 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
966 /*
967 * If the vnode that we are about to sync is no longer
968 * associated with this mount point, start over.
969 */
970 if (vp->v_mount != mp)
971 goto loop;
972 simple_lock(&vp->v_interlock);
973 nvp = vp->v_mntvnodes.le_next;
974 ip = VTOI(vp);
975 if (vp->v_type == VNON || ((ip->i_flag &
976 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
977 TAILQ_EMPTY(&vp->v_dirtyblkhd))) {
978 simple_unlock(&vp->v_interlock);
979 continue;
980 }
981 if (vp->v_type != VCHR) {
982 simple_unlock(&mntvnode_slock);
983 error =
984 vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p);
985 if (error) {
986 simple_lock(&mntvnode_slock);
987 if (error == ENOENT)
988 goto loop;
989 continue;
990 }
991 if ((error = VOP_FSYNC(vp, cred, waitfor, p)) != 0)
992 allerror = error;
993 VOP_UNLOCK(vp, 0, p);
994 vrele(vp);
995 simple_lock(&mntvnode_slock);
996 } else {
997 simple_unlock(&mntvnode_slock);
998 simple_unlock(&vp->v_interlock);
999 /* UFS_UPDATE(vp, waitfor == MNT_WAIT); */
1000 UFS_UPDATE(vp, 0);
1001 simple_lock(&mntvnode_slock);
1002 }
1003 }
1004 simple_unlock(&mntvnode_slock);
1005 /*
1006 * Force stale file system control information to be flushed.
1007 */
1008 if (waitfor != MNT_LAZY) {
1009 if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
1010 waitfor = MNT_NOWAIT;
1011 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
1012 if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0)
1013 allerror = error;
1014 VOP_UNLOCK(ump->um_devvp, 0, p);
1015 }
1016#ifdef QUOTA
1017 qsync(mp);
1018#endif
1019 /*
1020 * Write back modified superblock.
1021 */
1022 if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1023 allerror = error;
1024 return (allerror);
1025}
1026
1027/*
1028 * Look up a FFS dinode number to find its incore vnode, otherwise read it
1029 * in from disk. If it is in core, wait for the lock bit to clear, then
1030 * return the inode locked. Detection and handling of mount points must be
1031 * done by the calling routine.
1032 */
1033static int ffs_inode_hash_lock;
1034
1035int
1036ffs_vget(mp, ino, vpp)
1037 struct mount *mp;
1038 ino_t ino;
1039 struct vnode **vpp;
1040{
1041 struct fs *fs;
1042 struct inode *ip;
1043 struct ufsmount *ump;
1044 struct buf *bp;
1045 struct vnode *vp;
1046 dev_t dev;
1047 int error;
1048
1049 ump = VFSTOUFS(mp);
1050 dev = ump->um_dev;
1051restart:
1052 if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
1053 return (0);
1054 }
1055
1056 /*
1057 * Lock out the creation of new entries in the FFS hash table in
1058 * case getnewvnode() or MALLOC() blocks, otherwise a duplicate
1059 * may occur!
1060 */
1061 if (ffs_inode_hash_lock) {
1062 while (ffs_inode_hash_lock) {
1063 ffs_inode_hash_lock = -1;
1064 tsleep(&ffs_inode_hash_lock, PVM, "ffsvgt", 0);
1065 }
1066 goto restart;
1067 }
1068 ffs_inode_hash_lock = 1;
1069
1070 /*
1071 * If this MALLOC() is performed after the getnewvnode()
1072 * it might block, leaving a vnode with a NULL v_data to be
1073 * found by ffs_sync() if a sync happens to fire right then,
1074 * which will cause a panic because ffs_sync() blindly
1075 * dereferences vp->v_data (as well it should).
1076 */
1077 MALLOC(ip, struct inode *, sizeof(struct inode),
1078 ump->um_malloctype, M_WAITOK);
1079
1080 /* Allocate a new vnode/inode. */
1081 error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp);
1082 if (error) {
1083 if (ffs_inode_hash_lock < 0)
1084 wakeup(&ffs_inode_hash_lock);
1085 ffs_inode_hash_lock = 0;
1086 *vpp = NULL;
1087 FREE(ip, ump->um_malloctype);
1088 return (error);
1089 }
1090 bzero((caddr_t)ip, sizeof(struct inode));
1091 lockinit(&ip->i_lock, PINOD, "inode", 0, LK_CANRECURSE);
1092 vp->v_data = ip;
1093 ip->i_vnode = vp;
1094 ip->i_fs = fs = ump->um_fs;
1095 ip->i_dev = dev;
1096 ip->i_number = ino;
1097#ifdef QUOTA
1098 {
1099 int i;
1100 for (i = 0; i < MAXQUOTAS; i++)
1101 ip->i_dquot[i] = NODQUOT;
1102 }
1103#endif
1104 /*
1105 * Put it onto its hash chain and lock it so that other requests for
1106 * this inode will block if they arrive while we are sleeping waiting
1107 * for old data structures to be purged or for the contents of the
1108 * disk portion of this inode to be read.
1109 */
1110 ufs_ihashins(ip);
1111
1112 if (ffs_inode_hash_lock < 0)
1113 wakeup(&ffs_inode_hash_lock);
1114 ffs_inode_hash_lock = 0;
1115
1116 /* Read in the disk contents for the inode, copy into the inode. */
1117 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1118 (int)fs->fs_bsize, NOCRED, &bp);
1119 if (error) {
1120 /*
1121 * The inode does not contain anything useful, so it would
1122 * be misleading to leave it on its hash chain. With mode
1123 * still zero, it will be unlinked and returned to the free
1124 * list by vput().
1125 */
1126 brelse(bp);
1127 vput(vp);
1128 *vpp = NULL;
1129 return (error);
1130 }
1131 ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
1132 if (DOINGSOFTDEP(vp))
1133 softdep_load_inodeblock(ip);
1134 else
1135 ip->i_effnlink = ip->i_nlink;
1136 bqrelse(bp);
1137
1138 /*
1139 * Initialize the vnode from the inode, check for aliases.
1140 * Note that the underlying vnode may have changed.
1141 */
1142 error = ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1143 if (error) {
1144 vput(vp);
1145 *vpp = NULL;
1146 return (error);
1147 }
1148 /*
1149 * Finish inode initialization now that aliasing has been resolved.
1150 */
1151 ip->i_devvp = ump->um_devvp;
1152 VREF(ip->i_devvp);
1153 /*
1154 * Set up a generation number for this inode if it does not
1155 * already have one. This should only happen on old filesystems.
1156 */
1157 if (ip->i_gen == 0) {
1158 ip->i_gen = random() / 2 + 1;
1159 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1160 ip->i_flag |= IN_MODIFIED;
1161 }
1162 /*
1163 * Ensure that uid and gid are correct. This is a temporary
1164 * fix until fsck has been changed to do the update.
1165 */
1166 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1167 ip->i_uid = ip->i_din.di_ouid; /* XXX */
1168 ip->i_gid = ip->i_din.di_ogid; /* XXX */
1169 } /* XXX */
1170
1171 *vpp = vp;
1172 return (0);
1173}
1174
1175/*
1176 * File handle to vnode
1177 *
1178 * Have to be really careful about stale file handles:
1179 * - check that the inode number is valid
1180 * - call ffs_vget() to get the locked inode
1181 * - check for an unallocated inode (i_mode == 0)
1182 * - check that the given client host has export rights and return
1183 * those rights via. exflagsp and credanonp
1184 */
1185int
1186ffs_fhtovp(mp, fhp, vpp)
1187 register struct mount *mp;
1188 struct fid *fhp;
1189 struct vnode **vpp;
1190{
1191 register struct ufid *ufhp;
1192 struct fs *fs;
1193
1194 ufhp = (struct ufid *)fhp;
1195 fs = VFSTOUFS(mp)->um_fs;
1196 if (ufhp->ufid_ino < ROOTINO ||
1197 ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1198 return (ESTALE);
1199 return (ufs_fhtovp(mp, ufhp, vpp));
1200}
1201
1202/*
1203 * Vnode pointer to File handle
1204 */
1205/* ARGSUSED */
1206int
1207ffs_vptofh(vp, fhp)
1208 struct vnode *vp;
1209 struct fid *fhp;
1210{
1211 register struct inode *ip;
1212 register struct ufid *ufhp;
1213
1214 ip = VTOI(vp);
1215 ufhp = (struct ufid *)fhp;
1216 ufhp->ufid_len = sizeof(struct ufid);
1217 ufhp->ufid_ino = ip->i_number;
1218 ufhp->ufid_gen = ip->i_gen;
1219 return (0);
1220}
1221
1222/*
1223 * Initialize the filesystem; just use ufs_init.
1224 */
1225static int
1226ffs_init(vfsp)
1227 struct vfsconf *vfsp;
1228{
1229
1230 softdep_initialize();
1231 return (ufs_init(vfsp));
1232}
1233
1234/*
1235 * Write a superblock and associated information back to disk.
1236 */
1237static int
1238ffs_sbupdate(mp, waitfor)
1239 struct ufsmount *mp;
1240 int waitfor;
1241{
1242 register struct fs *dfs, *fs = mp->um_fs;
1243 register struct buf *bp;
1244 int blks;
1245 caddr_t space;
1246 int i, size, error, allerror = 0;
1247
1248 /*
1249 * First write back the summary information.
1250 */
1251 blks = howmany(fs->fs_cssize, fs->fs_fsize);
1252 space = (caddr_t)fs->fs_csp[0];
1253 for (i = 0; i < blks; i += fs->fs_frag) {
1254 size = fs->fs_bsize;
1255 if (i + fs->fs_frag > blks)
1256 size = (blks - i) * fs->fs_fsize;
1257 bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1258 size, 0, 0);
1259 bcopy(space, bp->b_data, (u_int)size);
1260 space += size;
1261 if (waitfor != MNT_WAIT)
1262 bawrite(bp);
1263 else if ((error = bwrite(bp)) != 0)
1264 allerror = error;
1265 }
1266 /*
1267 * Now write back the superblock itself. If any errors occurred
1268 * up to this point, then fail so that the superblock avoids
1269 * being written out as clean.
1270 */
1271 if (allerror)
1272 return (allerror);
1273 bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0);
1274 fs->fs_fmod = 0;
1275 fs->fs_time = time_second;
1276 bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1277 /* Restore compatibility to old file systems. XXX */
1278 dfs = (struct fs *)bp->b_data; /* XXX */
1279 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
1280 dfs->fs_nrpos = -1; /* XXX */
1281 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1282 int32_t *lp, tmp; /* XXX */
1283 /* XXX */
1284 lp = (int32_t *)&dfs->fs_qbmask; /* XXX */
1285 tmp = lp[4]; /* XXX */
1286 for (i = 4; i > 0; i--) /* XXX */
1287 lp[i] = lp[i-1]; /* XXX */
1288 lp[0] = tmp; /* XXX */
1289 } /* XXX */
1290 dfs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */
1291 if (waitfor != MNT_WAIT)
1292 bawrite(bp);
1293 else if ((error = bwrite(bp)) != 0)
1294 allerror = error;
1295 return (allerror);
1296}
| 48#include <sys/buf.h>
49#include <sys/conf.h>
50#include <sys/fcntl.h>
51#include <sys/disklabel.h>
52#include <sys/malloc.h>
53
54#include <ufs/ufs/extattr.h>
55#include <ufs/ufs/quota.h>
56#include <ufs/ufs/ufsmount.h>
57#include <ufs/ufs/inode.h>
58#include <ufs/ufs/ufs_extern.h>
59
60#include <ufs/ffs/fs.h>
61#include <ufs/ffs/ffs_extern.h>
62
63#include <vm/vm.h>
64#include <vm/vm_page.h>
65
66static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part");
67
68static int ffs_sbupdate __P((struct ufsmount *, int));
69static int ffs_reload __P((struct mount *,struct ucred *,struct proc *));
70static int ffs_oldfscompat __P((struct fs *));
71static int ffs_mount __P((struct mount *, char *, caddr_t,
72 struct nameidata *, struct proc *));
73static int ffs_init __P((struct vfsconf *));
74
75static struct vfsops ufs_vfsops = {
76 ffs_mount,
77 ufs_start,
78 ffs_unmount,
79 ufs_root,
80 ufs_quotactl,
81 ffs_statfs,
82 ffs_sync,
83 ffs_vget,
84 ffs_fhtovp,
85 ufs_check_export,
86 ffs_vptofh,
87 ffs_init,
88 vfs_stduninit,
89#ifdef FFS_EXTATTR
90 ufs_extattrctl,
91#else
92 vfs_stdextattrctl,
93#endif
94};
95
96VFS_SET(ufs_vfsops, ufs, 0);
97
98/*
99 * ffs_mount
100 *
101 * Called when mounting local physical media
102 *
103 * PARAMETERS:
104 * mountroot
105 * mp mount point structure
106 * path NULL (flag for root mount!!!)
107 * data <unused>
108 * ndp <unused>
109 * p process (user credentials check [statfs])
110 *
111 * mount
112 * mp mount point structure
113 * path path to mount point
114 * data pointer to argument struct in user space
115 * ndp mount point namei() return (used for
116 * credentials on reload), reused to look
117 * up block device.
118 * p process (user credentials check)
119 *
120 * RETURNS: 0 Success
121 * !0 error number (errno.h)
122 *
123 * LOCK STATE:
124 *
125 * ENTRY
126 * mount point is locked
127 * EXIT
128 * mount point is locked
129 *
130 * NOTES:
131 * A NULL path can be used for a flag since the mount
132 * system call will fail with EFAULT in copyinstr in
133 * namei() if it is a genuine NULL from the user.
134 */
135static int
136ffs_mount( mp, path, data, ndp, p)
137 struct mount *mp; /* mount struct pointer*/
138 char *path; /* path to mount point*/
139 caddr_t data; /* arguments to FS specific mount*/
140 struct nameidata *ndp; /* mount point credentials*/
141 struct proc *p; /* process requesting mount*/
142{
143 size_t size;
144 int err = 0;
145 struct vnode *devvp;
146
147 struct ufs_args args;
148 struct ufsmount *ump = 0;
149 register struct fs *fs;
150 int error, flags, ronly = 0;
151 mode_t accessmode;
152
153 /*
154 * Use NULL path to flag a root mount
155 */
156 if( path == NULL) {
157 /*
158 ***
159 * Mounting root file system
160 ***
161 */
162
163 if ((err = bdevvp(rootdev, &rootvp))) {
164 printf("ffs_mountroot: can't find rootvp\n");
165 return (err);
166 }
167
168 if( ( err = ffs_mountfs(rootvp, mp, p, M_FFSNODE)) != 0) {
169 /* fs specific cleanup (if any)*/
170 goto error_1;
171 }
172
173 goto dostatfs; /* success*/
174
175 }
176
177 /*
178 ***
179 * Mounting non-root file system or updating a file system
180 ***
181 */
182
183 /* copy in user arguments*/
184 err = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
185 if (err)
186 goto error_1; /* can't get arguments*/
187
188 /*
189 * If updating, check whether changing from read-only to
190 * read/write; if there is no device name, that's all we do.
191 */
192 if (mp->mnt_flag & MNT_UPDATE) {
193 ump = VFSTOUFS(mp);
194 fs = ump->um_fs;
195 devvp = ump->um_devvp;
196 err = 0;
197 ronly = fs->fs_ronly; /* MNT_RELOAD might change this */
198 if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
199 flags = WRITECLOSE;
200 if (mp->mnt_flag & MNT_FORCE)
201 flags |= FORCECLOSE;
202 if (mp->mnt_flag & MNT_SOFTDEP) {
203 err = softdep_flushfiles(mp, flags, p);
204 } else {
205 err = ffs_flushfiles(mp, flags, p);
206 }
207 ronly = 1;
208 }
209 if (!err && (mp->mnt_flag & MNT_RELOAD))
210 err = ffs_reload(mp, ndp->ni_cnd.cn_cred, p);
211 if (err) {
212 goto error_1;
213 }
214 if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
215 /*
216 * If upgrade to read-write by non-root, then verify
217 * that user has necessary permissions on the device.
218 */
219 if (p->p_ucred->cr_uid != 0) {
220 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
221 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
222 p->p_ucred, p)) != 0) {
223 VOP_UNLOCK(devvp, 0, p);
224 return (error);
225 }
226 VOP_UNLOCK(devvp, 0, p);
227 }
228
229 fs->fs_flags &= ~FS_UNCLEAN;
230 if (fs->fs_clean == 0) {
231 fs->fs_flags |= FS_UNCLEAN;
232 if (mp->mnt_flag & MNT_FORCE) {
233 printf(
234"WARNING: %s was not properly dismounted\n",
235 fs->fs_fsmnt);
236 } else {
237 printf(
238"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
239 fs->fs_fsmnt);
240 err = EPERM;
241 goto error_1;
242 }
243 }
244
245 /* check to see if we need to start softdep */
246 if (fs->fs_flags & FS_DOSOFTDEP) {
247 err = softdep_mount(devvp, mp, fs, p->p_ucred);
248 if (err)
249 goto error_1;
250 }
251
252 ronly = 0;
253 }
254 /*
255 * Soft updates is incompatible with "async",
256 * so if we are doing softupdates stop the user
257 * from setting the async flag in an update.
258 * Softdep_mount() clears it in an initial mount
259 * or ro->rw remount.
260 */
261 if (mp->mnt_flag & MNT_SOFTDEP) {
262 mp->mnt_flag &= ~MNT_ASYNC;
263 }
264 /* if not updating name...*/
265 if (args.fspec == 0) {
266 /*
267 * Process export requests. Jumping to "success"
268 * will return the vfs_export() error code.
269 */
270 err = vfs_export(mp, &ump->um_export, &args.export);
271 goto success;
272 }
273 }
274
275 /*
276 * Not an update, or updating the name: look up the name
277 * and verify that it refers to a sensible block device.
278 */
279 NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
280 err = namei(ndp);
281 if (err) {
282 /* can't get devvp!*/
283 goto error_1;
284 }
285
286 NDFREE(ndp, NDF_ONLY_PNBUF);
287 devvp = ndp->ni_vp;
288
289 if (!vn_isdisk(devvp, &err))
290 goto error_2;
291
292 /*
293 * If mount by non-root, then verify that user has necessary
294 * permissions on the device.
295 */
296 if (p->p_ucred->cr_uid != 0) {
297 accessmode = VREAD;
298 if ((mp->mnt_flag & MNT_RDONLY) == 0)
299 accessmode |= VWRITE;
300 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
301 if ((error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) != 0) {
302 vput(devvp);
303 return (error);
304 }
305 VOP_UNLOCK(devvp, 0, p);
306 }
307
308 if (mp->mnt_flag & MNT_UPDATE) {
309 /*
310 ********************
311 * UPDATE
312 * If it's not the same vnode, or at least the same device
313 * then it's not correct.
314 ********************
315 */
316
317 if (devvp != ump->um_devvp) {
318 if ( devvp->v_rdev == ump->um_devvp->v_rdev) {
319 vrele(devvp);
320 } else {
321 err = EINVAL; /* needs translation */
322 }
323 } else
324 vrele(devvp);
325 /*
326 * Update device name only on success
327 */
328 if( !err) {
329 /* Save "mounted from" info for mount point (NULL pad)*/
330 copyinstr( args.fspec,
331 mp->mnt_stat.f_mntfromname,
332 MNAMELEN - 1,
333 &size);
334 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
335 }
336 } else {
337 /*
338 ********************
339 * NEW MOUNT
340 ********************
341 */
342
343 /*
344 * Since this is a new mount, we want the names for
345 * the device and the mount point copied in. If an
346 * error occurs, the mountpoint is discarded by the
347 * upper level code.
348 */
349 /* Save "last mounted on" info for mount point (NULL pad)*/
350 copyinstr( path, /* mount point*/
351 mp->mnt_stat.f_mntonname, /* save area*/
352 MNAMELEN - 1, /* max size*/
353 &size); /* real size*/
354 bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
355
356 /* Save "mounted from" info for mount point (NULL pad)*/
357 copyinstr( args.fspec, /* device name*/
358 mp->mnt_stat.f_mntfromname, /* save area*/
359 MNAMELEN - 1, /* max size*/
360 &size); /* real size*/
361 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
362
363 err = ffs_mountfs(devvp, mp, p, M_FFSNODE);
364 }
365 if (err) {
366 goto error_2;
367 }
368
369dostatfs:
370 /*
371 * Initialize FS stat information in mount struct; uses both
372 * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
373 *
374 * This code is common to root and non-root mounts
375 */
376 (void)VFS_STATFS(mp, &mp->mnt_stat, p);
377
378 goto success;
379
380
381error_2: /* error with devvp held*/
382
383 /* release devvp before failing*/
384 vrele(devvp);
385
386error_1: /* no state to back out*/
387
388success:
389 if (!err && path && (mp->mnt_flag & MNT_UPDATE)) {
390 /* Update clean flag after changing read-onlyness. */
391 fs = ump->um_fs;
392 if (ronly != fs->fs_ronly) {
393 fs->fs_ronly = ronly;
394 fs->fs_clean = ronly &&
395 (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;
396 ffs_sbupdate(ump, MNT_WAIT);
397 }
398 }
399 return (err);
400}
401
402/*
403 * Reload all incore data for a filesystem (used after running fsck on
404 * the root filesystem and finding things to fix). The filesystem must
405 * be mounted read-only.
406 *
407 * Things to do to update the mount:
408 * 1) invalidate all cached meta-data.
409 * 2) re-read superblock from disk.
410 * 3) re-read summary information from disk.
411 * 4) invalidate all inactive vnodes.
412 * 5) invalidate all cached file data.
413 * 6) re-read inode data for all active vnodes.
414 */
415static int
416ffs_reload(mp, cred, p)
417 register struct mount *mp;
418 struct ucred *cred;
419 struct proc *p;
420{
421 register struct vnode *vp, *nvp, *devvp;
422 struct inode *ip;
423 struct csum *space;
424 struct buf *bp;
425 struct fs *fs, *newfs;
426 struct partinfo dpart;
427 dev_t dev;
428 int i, blks, size, error;
429 int32_t *lp;
430
431 if ((mp->mnt_flag & MNT_RDONLY) == 0)
432 return (EINVAL);
433 /*
434 * Step 1: invalidate all cached meta-data.
435 */
436 devvp = VFSTOUFS(mp)->um_devvp;
437 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
438 error = vinvalbuf(devvp, 0, cred, p, 0, 0);
439 VOP_UNLOCK(devvp, 0, p);
440 if (error)
441 panic("ffs_reload: dirty1");
442
443 dev = devvp->v_rdev;
444
445 /*
446 * Only VMIO the backing device if the backing device is a real
447 * block device. See ffs_mountmfs() for more details.
448 */
449 if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
450 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
451 vfs_object_create(devvp, p, p->p_ucred);
452 simple_lock(&devvp->v_interlock);
453 VOP_UNLOCK(devvp, LK_INTERLOCK, p);
454 }
455
456 /*
457 * Step 2: re-read superblock from disk.
458 */
459 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
460 size = DEV_BSIZE;
461 else
462 size = dpart.disklab->d_secsize;
463 if ((error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, NOCRED,&bp)) != 0)
464 return (error);
465 newfs = (struct fs *)bp->b_data;
466 if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
467 newfs->fs_bsize < sizeof(struct fs)) {
468 brelse(bp);
469 return (EIO); /* XXX needs translation */
470 }
471 fs = VFSTOUFS(mp)->um_fs;
472 /*
473 * Copy pointer fields back into superblock before copying in XXX
474 * new superblock. These should really be in the ufsmount. XXX
475 * Note that important parameters (eg fs_ncg) are unchanged.
476 */
477 bcopy(&fs->fs_csp[0], &newfs->fs_csp[0], sizeof(fs->fs_csp));
478 newfs->fs_maxcluster = fs->fs_maxcluster;
479 bcopy(newfs, fs, (u_int)fs->fs_sbsize);
480 if (fs->fs_sbsize < SBSIZE)
481 bp->b_flags |= B_INVAL;
482 brelse(bp);
483 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
484 ffs_oldfscompat(fs);
485
486 /*
487 * Step 3: re-read summary information from disk.
488 */
489 blks = howmany(fs->fs_cssize, fs->fs_fsize);
490 space = fs->fs_csp[0];
491 for (i = 0; i < blks; i += fs->fs_frag) {
492 size = fs->fs_bsize;
493 if (i + fs->fs_frag > blks)
494 size = (blks - i) * fs->fs_fsize;
495 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
496 NOCRED, &bp);
497 if (error)
498 return (error);
499 bcopy(bp->b_data, fs->fs_csp[fragstoblks(fs, i)], (u_int)size);
500 brelse(bp);
501 }
502 /*
503 * We no longer know anything about clusters per cylinder group.
504 */
505 if (fs->fs_contigsumsize > 0) {
506 lp = fs->fs_maxcluster;
507 for (i = 0; i < fs->fs_ncg; i++)
508 *lp++ = fs->fs_contigsumsize;
509 }
510
511loop:
512 simple_lock(&mntvnode_slock);
513 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
514 if (vp->v_mount != mp) {
515 simple_unlock(&mntvnode_slock);
516 goto loop;
517 }
518 nvp = vp->v_mntvnodes.le_next;
519 /*
520 * Step 4: invalidate all inactive vnodes.
521 */
522 if (vrecycle(vp, &mntvnode_slock, p))
523 goto loop;
524 /*
525 * Step 5: invalidate all cached file data.
526 */
527 simple_lock(&vp->v_interlock);
528 simple_unlock(&mntvnode_slock);
529 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
530 goto loop;
531 }
532 if (vinvalbuf(vp, 0, cred, p, 0, 0))
533 panic("ffs_reload: dirty2");
534 /*
535 * Step 6: re-read inode data for all active vnodes.
536 */
537 ip = VTOI(vp);
538 error =
539 bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
540 (int)fs->fs_bsize, NOCRED, &bp);
541 if (error) {
542 vput(vp);
543 return (error);
544 }
545 ip->i_din = *((struct dinode *)bp->b_data +
546 ino_to_fsbo(fs, ip->i_number));
547 ip->i_effnlink = ip->i_nlink;
548 brelse(bp);
549 vput(vp);
550 simple_lock(&mntvnode_slock);
551 }
552 simple_unlock(&mntvnode_slock);
553 return (0);
554}
555
556/*
557 * Common code for mount and mountroot
558 */
559int
560ffs_mountfs(devvp, mp, p, malloctype)
561 register struct vnode *devvp;
562 struct mount *mp;
563 struct proc *p;
564 struct malloc_type *malloctype;
565{
566 register struct ufsmount *ump;
567 struct buf *bp;
568 register struct fs *fs;
569 dev_t dev;
570 struct partinfo dpart;
571 caddr_t base, space;
572 int error, i, blks, size, ronly;
573 int32_t *lp;
574 struct ucred *cred;
575 u_int64_t maxfilesize; /* XXX */
576 size_t strsize;
577 int ncount;
578
579 dev = devvp->v_rdev;
580 cred = p ? p->p_ucred : NOCRED;
581 /*
582 * Disallow multiple mounts of the same device.
583 * Disallow mounting of a device that is currently in use
584 * (except for root, which might share swap device for miniroot).
585 * Flush out any old buffers remaining from a previous use.
586 */
587 error = vfs_mountedon(devvp);
588 if (error)
589 return (error);
590 ncount = vcount(devvp);
591
592 if (ncount > 1 && devvp != rootvp)
593 return (EBUSY);
594 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
595 error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0);
596 VOP_UNLOCK(devvp, 0, p);
597 if (error)
598 return (error);
599
600 /*
601 * Only VMIO the backing device if the backing device is a real
602 * block device. This excludes the original MFS implementation.
603 * Note that it is optional that the backing device be VMIOed. This
604 * increases the opportunity for metadata caching.
605 */
606 if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
607 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
608 vfs_object_create(devvp, p, p->p_ucred);
609 simple_lock(&devvp->v_interlock);
610 VOP_UNLOCK(devvp, LK_INTERLOCK, p);
611 }
612
613 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
614 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
615 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
616 VOP_UNLOCK(devvp, 0, p);
617 if (error)
618 return (error);
619 if (devvp->v_rdev->si_iosize_max > mp->mnt_iosize_max)
620 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
621 if (mp->mnt_iosize_max > MAXPHYS)
622 mp->mnt_iosize_max = MAXPHYS;
623
624 if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0)
625 size = DEV_BSIZE;
626 else
627 size = dpart.disklab->d_secsize;
628
629 bp = NULL;
630 ump = NULL;
631 if ((error = bread(devvp, SBLOCK, SBSIZE, cred, &bp)) != 0)
632 goto out;
633 fs = (struct fs *)bp->b_data;
634 if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
635 fs->fs_bsize < sizeof(struct fs)) {
636 error = EINVAL; /* XXX needs translation */
637 goto out;
638 }
639 fs->fs_fmod = 0;
640 fs->fs_flags &= ~FS_UNCLEAN;
641 if (fs->fs_clean == 0) {
642 fs->fs_flags |= FS_UNCLEAN;
643 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
644 printf(
645"WARNING: %s was not properly dismounted\n",
646 fs->fs_fsmnt);
647 } else {
648 printf(
649"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
650 fs->fs_fsmnt);
651 error = EPERM;
652 goto out;
653 }
654 }
655 /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
656 if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
657 error = EROFS; /* needs translation */
658 goto out;
659 }
660 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
661 bzero((caddr_t)ump, sizeof *ump);
662 ump->um_malloctype = malloctype;
663 ump->um_i_effnlink_valid = 1;
664 ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
665 M_WAITOK);
666 ump->um_blkatoff = ffs_blkatoff;
667 ump->um_truncate = ffs_truncate;
668 ump->um_update = ffs_update;
669 ump->um_valloc = ffs_valloc;
670 ump->um_vfree = ffs_vfree;
671 bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
672 if (fs->fs_sbsize < SBSIZE)
673 bp->b_flags |= B_INVAL;
674 brelse(bp);
675 bp = NULL;
676 fs = ump->um_fs;
677 fs->fs_ronly = ronly;
678 size = fs->fs_cssize;
679 blks = howmany(size, fs->fs_fsize);
680 if (fs->fs_contigsumsize > 0)
681 size += fs->fs_ncg * sizeof(int32_t);
682 base = space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
683 for (i = 0; i < blks; i += fs->fs_frag) {
684 size = fs->fs_bsize;
685 if (i + fs->fs_frag > blks)
686 size = (blks - i) * fs->fs_fsize;
687 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
688 cred, &bp)) != 0) {
689 free(base, M_UFSMNT);
690 goto out;
691 }
692 bcopy(bp->b_data, space, (u_int)size);
693 fs->fs_csp[fragstoblks(fs, i)] = (struct csum *)space;
694 space += size;
695 brelse(bp);
696 bp = NULL;
697 }
698 if (fs->fs_contigsumsize > 0) {
699 fs->fs_maxcluster = lp = (int32_t *)space;
700 for (i = 0; i < fs->fs_ncg; i++)
701 *lp++ = fs->fs_contigsumsize;
702 }
703 mp->mnt_data = (qaddr_t)ump;
704 mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
705 mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
706 if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
707 vfs_getvfs(&mp->mnt_stat.f_fsid))
708 vfs_getnewfsid(mp);
709 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
710 mp->mnt_flag |= MNT_LOCAL;
711 ump->um_mountp = mp;
712 ump->um_dev = dev;
713 ump->um_devvp = devvp;
714 ump->um_nindir = fs->fs_nindir;
715 ump->um_bptrtodb = fs->fs_fsbtodb;
716 ump->um_seqinc = fs->fs_frag;
717 for (i = 0; i < MAXQUOTAS; i++)
718 ump->um_quotas[i] = NULLVP;
719#ifdef FFS_EXTATTR
720 ufs_extattr_uepm_init(&ump->um_extattr);
721#endif
722 devvp->v_specmountpoint = mp;
723 ffs_oldfscompat(fs);
724
725 /*
726 * Set FS local "last mounted on" information (NULL pad)
727 */
728 copystr( mp->mnt_stat.f_mntonname, /* mount point*/
729 fs->fs_fsmnt, /* copy area*/
730 sizeof(fs->fs_fsmnt) - 1, /* max size*/
731 &strsize); /* real size*/
732 bzero( fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
733
734 if( mp->mnt_flag & MNT_ROOTFS) {
735 /*
736 * Root mount; update timestamp in mount structure.
737 * this will be used by the common root mount code
738 * to update the system clock.
739 */
740 mp->mnt_time = fs->fs_time;
741 }
742
743 ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */
744 maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */
745 if (fs->fs_maxfilesize > maxfilesize) /* XXX */
746 fs->fs_maxfilesize = maxfilesize; /* XXX */
747 if (ronly == 0) {
748 if ((fs->fs_flags & FS_DOSOFTDEP) &&
749 (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
750 free(base, M_UFSMNT);
751 goto out;
752 }
753 fs->fs_fmod = 1;
754 fs->fs_clean = 0;
755 (void) ffs_sbupdate(ump, MNT_WAIT);
756 }
757 return (0);
758out:
759 devvp->v_specmountpoint = NULL;
760 if (bp)
761 brelse(bp);
762 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
763 if (ump) {
764 free(ump->um_fs, M_UFSMNT);
765 free(ump, M_UFSMNT);
766 mp->mnt_data = (qaddr_t)0;
767 }
768 return (error);
769}
770
771/*
772 * Sanity checks for old file systems.
773 *
774 * XXX - goes away some day.
775 */
776static int
777ffs_oldfscompat(fs)
778 struct fs *fs;
779{
780
781 fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
782 fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
783 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
784 fs->fs_nrpos = 8; /* XXX */
785 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
786#if 0
787 int i; /* XXX */
788 u_int64_t sizepb = fs->fs_bsize; /* XXX */
789 /* XXX */
790 fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
791 for (i = 0; i < NIADDR; i++) { /* XXX */
792 sizepb *= NINDIR(fs); /* XXX */
793 fs->fs_maxfilesize += sizepb; /* XXX */
794 } /* XXX */
795#endif
796 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
797 fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
798 fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
799 } /* XXX */
800 return (0);
801}
802
803/*
804 * unmount system call
805 */
806int
807ffs_unmount(mp, mntflags, p)
808 struct mount *mp;
809 int mntflags;
810 struct proc *p;
811{
812 register struct ufsmount *ump;
813 register struct fs *fs;
814 int error, flags;
815
816 flags = 0;
817 if (mntflags & MNT_FORCE) {
818 flags |= FORCECLOSE;
819 }
820#ifdef FFS_EXTATTR
821 if ((error = ufs_extattr_stop(mp, p))) {
822 printf("ffs_unmonut: ufs_extattr_stop returned %d\n", error);
823 }
824#endif
825 if (mp->mnt_flag & MNT_SOFTDEP) {
826 if ((error = softdep_flushfiles(mp, flags, p)) != 0)
827 return (error);
828 } else {
829 if ((error = ffs_flushfiles(mp, flags, p)) != 0)
830 return (error);
831 }
832 ump = VFSTOUFS(mp);
833 fs = ump->um_fs;
834 if (fs->fs_ronly == 0) {
835 fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1;
836 error = ffs_sbupdate(ump, MNT_WAIT);
837 if (error) {
838 fs->fs_clean = 0;
839 return (error);
840 }
841 }
842 ump->um_devvp->v_specmountpoint = NULL;
843
844 vinvalbuf(ump->um_devvp, V_SAVE, NOCRED, p, 0, 0);
845 error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
846 NOCRED, p);
847
848 vrele(ump->um_devvp);
849
850 free(fs->fs_csp[0], M_UFSMNT);
851 free(fs, M_UFSMNT);
852 free(ump, M_UFSMNT);
853 mp->mnt_data = (qaddr_t)0;
854 mp->mnt_flag &= ~MNT_LOCAL;
855 return (error);
856}
857
858/*
859 * Flush out all the files in a filesystem.
860 */
861int
862ffs_flushfiles(mp, flags, p)
863 register struct mount *mp;
864 int flags;
865 struct proc *p;
866{
867 register struct ufsmount *ump;
868 int error;
869
870 ump = VFSTOUFS(mp);
871#ifdef QUOTA
872 if (mp->mnt_flag & MNT_QUOTA) {
873 int i;
874 error = vflush(mp, NULLVP, SKIPSYSTEM|flags);
875 if (error)
876 return (error);
877 for (i = 0; i < MAXQUOTAS; i++) {
878 if (ump->um_quotas[i] == NULLVP)
879 continue;
880 quotaoff(p, mp, i);
881 }
882 /*
883 * Here we fall through to vflush again to ensure
884 * that we have gotten rid of all the system vnodes.
885 */
886 }
887#endif
888 /*
889 * Flush all the files.
890 */
891 if ((error = vflush(mp, NULL, flags)) != 0)
892 return (error);
893 /*
894 * Flush filesystem metadata.
895 */
896 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
897 error = VOP_FSYNC(ump->um_devvp, p->p_ucred, MNT_WAIT, p);
898 VOP_UNLOCK(ump->um_devvp, 0, p);
899 return (error);
900}
901
902/*
903 * Get file system statistics.
904 */
905int
906ffs_statfs(mp, sbp, p)
907 struct mount *mp;
908 register struct statfs *sbp;
909 struct proc *p;
910{
911 register struct ufsmount *ump;
912 register struct fs *fs;
913
914 ump = VFSTOUFS(mp);
915 fs = ump->um_fs;
916 if (fs->fs_magic != FS_MAGIC)
917 panic("ffs_statfs");
918 sbp->f_bsize = fs->fs_fsize;
919 sbp->f_iosize = fs->fs_bsize;
920 sbp->f_blocks = fs->fs_dsize;
921 sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
922 fs->fs_cstotal.cs_nffree;
923 sbp->f_bavail = freespace(fs, fs->fs_minfree);
924 sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
925 sbp->f_ffree = fs->fs_cstotal.cs_nifree;
926 if (sbp != &mp->mnt_stat) {
927 sbp->f_type = mp->mnt_vfc->vfc_typenum;
928 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
929 (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
930 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
931 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
932 }
933 return (0);
934}
935
936/*
937 * Go through the disk queues to initiate sandbagged IO;
938 * go through the inodes to write those that have been modified;
939 * initiate the writing of the super block if it has been modified.
940 *
941 * Note: we are always called with the filesystem marked `MPBUSY'.
942 */
943int
944ffs_sync(mp, waitfor, cred, p)
945 struct mount *mp;
946 int waitfor;
947 struct ucred *cred;
948 struct proc *p;
949{
950 struct vnode *nvp, *vp;
951 struct inode *ip;
952 struct ufsmount *ump = VFSTOUFS(mp);
953 struct fs *fs;
954 int error, allerror = 0;
955
956 fs = ump->um_fs;
957 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
958 printf("fs = %s\n", fs->fs_fsmnt);
959 panic("ffs_sync: rofs mod");
960 }
961 /*
962 * Write back each (modified) inode.
963 */
964 simple_lock(&mntvnode_slock);
965loop:
966 for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
967 /*
968 * If the vnode that we are about to sync is no longer
969 * associated with this mount point, start over.
970 */
971 if (vp->v_mount != mp)
972 goto loop;
973 simple_lock(&vp->v_interlock);
974 nvp = vp->v_mntvnodes.le_next;
975 ip = VTOI(vp);
976 if (vp->v_type == VNON || ((ip->i_flag &
977 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
978 TAILQ_EMPTY(&vp->v_dirtyblkhd))) {
979 simple_unlock(&vp->v_interlock);
980 continue;
981 }
982 if (vp->v_type != VCHR) {
983 simple_unlock(&mntvnode_slock);
984 error =
985 vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p);
986 if (error) {
987 simple_lock(&mntvnode_slock);
988 if (error == ENOENT)
989 goto loop;
990 continue;
991 }
992 if ((error = VOP_FSYNC(vp, cred, waitfor, p)) != 0)
993 allerror = error;
994 VOP_UNLOCK(vp, 0, p);
995 vrele(vp);
996 simple_lock(&mntvnode_slock);
997 } else {
998 simple_unlock(&mntvnode_slock);
999 simple_unlock(&vp->v_interlock);
1000 /* UFS_UPDATE(vp, waitfor == MNT_WAIT); */
1001 UFS_UPDATE(vp, 0);
1002 simple_lock(&mntvnode_slock);
1003 }
1004 }
1005 simple_unlock(&mntvnode_slock);
1006 /*
1007 * Force stale file system control information to be flushed.
1008 */
1009 if (waitfor != MNT_LAZY) {
1010 if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
1011 waitfor = MNT_NOWAIT;
1012 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
1013 if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0)
1014 allerror = error;
1015 VOP_UNLOCK(ump->um_devvp, 0, p);
1016 }
1017#ifdef QUOTA
1018 qsync(mp);
1019#endif
1020 /*
1021 * Write back modified superblock.
1022 */
1023 if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1024 allerror = error;
1025 return (allerror);
1026}
1027
1028/*
1029 * Look up a FFS dinode number to find its incore vnode, otherwise read it
1030 * in from disk. If it is in core, wait for the lock bit to clear, then
1031 * return the inode locked. Detection and handling of mount points must be
1032 * done by the calling routine.
1033 */
1034static int ffs_inode_hash_lock;
1035
1036int
1037ffs_vget(mp, ino, vpp)
1038 struct mount *mp;
1039 ino_t ino;
1040 struct vnode **vpp;
1041{
1042 struct fs *fs;
1043 struct inode *ip;
1044 struct ufsmount *ump;
1045 struct buf *bp;
1046 struct vnode *vp;
1047 dev_t dev;
1048 int error;
1049
1050 ump = VFSTOUFS(mp);
1051 dev = ump->um_dev;
1052restart:
1053 if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
1054 return (0);
1055 }
1056
1057 /*
1058 * Lock out the creation of new entries in the FFS hash table in
1059 * case getnewvnode() or MALLOC() blocks, otherwise a duplicate
1060 * may occur!
1061 */
1062 if (ffs_inode_hash_lock) {
1063 while (ffs_inode_hash_lock) {
1064 ffs_inode_hash_lock = -1;
1065 tsleep(&ffs_inode_hash_lock, PVM, "ffsvgt", 0);
1066 }
1067 goto restart;
1068 }
1069 ffs_inode_hash_lock = 1;
1070
1071 /*
1072 * If this MALLOC() is performed after the getnewvnode()
1073 * it might block, leaving a vnode with a NULL v_data to be
1074 * found by ffs_sync() if a sync happens to fire right then,
1075 * which will cause a panic because ffs_sync() blindly
1076 * dereferences vp->v_data (as well it should).
1077 */
1078 MALLOC(ip, struct inode *, sizeof(struct inode),
1079 ump->um_malloctype, M_WAITOK);
1080
1081 /* Allocate a new vnode/inode. */
1082 error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp);
1083 if (error) {
1084 if (ffs_inode_hash_lock < 0)
1085 wakeup(&ffs_inode_hash_lock);
1086 ffs_inode_hash_lock = 0;
1087 *vpp = NULL;
1088 FREE(ip, ump->um_malloctype);
1089 return (error);
1090 }
1091 bzero((caddr_t)ip, sizeof(struct inode));
1092 lockinit(&ip->i_lock, PINOD, "inode", 0, LK_CANRECURSE);
1093 vp->v_data = ip;
1094 ip->i_vnode = vp;
1095 ip->i_fs = fs = ump->um_fs;
1096 ip->i_dev = dev;
1097 ip->i_number = ino;
1098#ifdef QUOTA
1099 {
1100 int i;
1101 for (i = 0; i < MAXQUOTAS; i++)
1102 ip->i_dquot[i] = NODQUOT;
1103 }
1104#endif
1105 /*
1106 * Put it onto its hash chain and lock it so that other requests for
1107 * this inode will block if they arrive while we are sleeping waiting
1108 * for old data structures to be purged or for the contents of the
1109 * disk portion of this inode to be read.
1110 */
1111 ufs_ihashins(ip);
1112
1113 if (ffs_inode_hash_lock < 0)
1114 wakeup(&ffs_inode_hash_lock);
1115 ffs_inode_hash_lock = 0;
1116
1117 /* Read in the disk contents for the inode, copy into the inode. */
1118 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1119 (int)fs->fs_bsize, NOCRED, &bp);
1120 if (error) {
1121 /*
1122 * The inode does not contain anything useful, so it would
1123 * be misleading to leave it on its hash chain. With mode
1124 * still zero, it will be unlinked and returned to the free
1125 * list by vput().
1126 */
1127 brelse(bp);
1128 vput(vp);
1129 *vpp = NULL;
1130 return (error);
1131 }
1132 ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
1133 if (DOINGSOFTDEP(vp))
1134 softdep_load_inodeblock(ip);
1135 else
1136 ip->i_effnlink = ip->i_nlink;
1137 bqrelse(bp);
1138
1139 /*
1140 * Initialize the vnode from the inode, check for aliases.
1141 * Note that the underlying vnode may have changed.
1142 */
1143 error = ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1144 if (error) {
1145 vput(vp);
1146 *vpp = NULL;
1147 return (error);
1148 }
1149 /*
1150 * Finish inode initialization now that aliasing has been resolved.
1151 */
1152 ip->i_devvp = ump->um_devvp;
1153 VREF(ip->i_devvp);
1154 /*
1155 * Set up a generation number for this inode if it does not
1156 * already have one. This should only happen on old filesystems.
1157 */
1158 if (ip->i_gen == 0) {
1159 ip->i_gen = random() / 2 + 1;
1160 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1161 ip->i_flag |= IN_MODIFIED;
1162 }
1163 /*
1164 * Ensure that uid and gid are correct. This is a temporary
1165 * fix until fsck has been changed to do the update.
1166 */
1167 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1168 ip->i_uid = ip->i_din.di_ouid; /* XXX */
1169 ip->i_gid = ip->i_din.di_ogid; /* XXX */
1170 } /* XXX */
1171
1172 *vpp = vp;
1173 return (0);
1174}
1175
1176/*
1177 * File handle to vnode
1178 *
1179 * Have to be really careful about stale file handles:
1180 * - check that the inode number is valid
1181 * - call ffs_vget() to get the locked inode
1182 * - check for an unallocated inode (i_mode == 0)
1183 * - check that the given client host has export rights and return
1184 * those rights via. exflagsp and credanonp
1185 */
1186int
1187ffs_fhtovp(mp, fhp, vpp)
1188 register struct mount *mp;
1189 struct fid *fhp;
1190 struct vnode **vpp;
1191{
1192 register struct ufid *ufhp;
1193 struct fs *fs;
1194
1195 ufhp = (struct ufid *)fhp;
1196 fs = VFSTOUFS(mp)->um_fs;
1197 if (ufhp->ufid_ino < ROOTINO ||
1198 ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1199 return (ESTALE);
1200 return (ufs_fhtovp(mp, ufhp, vpp));
1201}
1202
1203/*
1204 * Vnode pointer to File handle
1205 */
1206/* ARGSUSED */
1207int
1208ffs_vptofh(vp, fhp)
1209 struct vnode *vp;
1210 struct fid *fhp;
1211{
1212 register struct inode *ip;
1213 register struct ufid *ufhp;
1214
1215 ip = VTOI(vp);
1216 ufhp = (struct ufid *)fhp;
1217 ufhp->ufid_len = sizeof(struct ufid);
1218 ufhp->ufid_ino = ip->i_number;
1219 ufhp->ufid_gen = ip->i_gen;
1220 return (0);
1221}
1222
1223/*
1224 * Initialize the filesystem; just use ufs_init.
1225 */
1226static int
1227ffs_init(vfsp)
1228 struct vfsconf *vfsp;
1229{
1230
1231 softdep_initialize();
1232 return (ufs_init(vfsp));
1233}
1234
1235/*
1236 * Write a superblock and associated information back to disk.
1237 */
1238static int
1239ffs_sbupdate(mp, waitfor)
1240 struct ufsmount *mp;
1241 int waitfor;
1242{
1243 register struct fs *dfs, *fs = mp->um_fs;
1244 register struct buf *bp;
1245 int blks;
1246 caddr_t space;
1247 int i, size, error, allerror = 0;
1248
1249 /*
1250 * First write back the summary information.
1251 */
1252 blks = howmany(fs->fs_cssize, fs->fs_fsize);
1253 space = (caddr_t)fs->fs_csp[0];
1254 for (i = 0; i < blks; i += fs->fs_frag) {
1255 size = fs->fs_bsize;
1256 if (i + fs->fs_frag > blks)
1257 size = (blks - i) * fs->fs_fsize;
1258 bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1259 size, 0, 0);
1260 bcopy(space, bp->b_data, (u_int)size);
1261 space += size;
1262 if (waitfor != MNT_WAIT)
1263 bawrite(bp);
1264 else if ((error = bwrite(bp)) != 0)
1265 allerror = error;
1266 }
1267 /*
1268 * Now write back the superblock itself. If any errors occurred
1269 * up to this point, then fail so that the superblock avoids
1270 * being written out as clean.
1271 */
1272 if (allerror)
1273 return (allerror);
1274 bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0);
1275 fs->fs_fmod = 0;
1276 fs->fs_time = time_second;
1277 bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1278 /* Restore compatibility to old file systems. XXX */
1279 dfs = (struct fs *)bp->b_data; /* XXX */
1280 if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
1281 dfs->fs_nrpos = -1; /* XXX */
1282 if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1283 int32_t *lp, tmp; /* XXX */
1284 /* XXX */
1285 lp = (int32_t *)&dfs->fs_qbmask; /* XXX */
1286 tmp = lp[4]; /* XXX */
1287 for (i = 4; i > 0; i--) /* XXX */
1288 lp[i] = lp[i-1]; /* XXX */
1289 lp[0] = tmp; /* XXX */
1290 } /* XXX */
1291 dfs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */
1292 if (waitfor != MNT_WAIT)
1293 bawrite(bp);
1294 else if ((error = bwrite(bp)) != 0)
1295 allerror = error;
1296 return (allerror);
1297}
|