2 * Copyright (c) 1989, 1991, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95
34 * $FreeBSD: src/sys/ufs/ffs/ffs_vfsops.c,v 1.117.2.10 2002/06/23 22:34:52 iedowse Exp $
35 * $DragonFly: src/sys/vfs/ufs/ffs_vfsops.c,v 1.57 2007/06/17 05:08:52 dillon Exp $
38 #include "opt_quota.h"
40 #include <sys/param.h>
41 #include <sys/systm.h>
43 #include <sys/nlookup.h>
44 #include <sys/kernel.h>
45 #include <sys/vnode.h>
46 #include <sys/mount.h>
49 #include <sys/fcntl.h>
50 #include <sys/diskslice.h>
51 #include <sys/malloc.h>
56 #include "ufs_extern.h"
59 #include "ffs_extern.h"
62 #include <vm/vm_page.h>
63 #include <vm/vm_zone.h>
65 static MALLOC_DEFINE(M_FFSNODE
, "FFS node", "FFS vnode private part");
67 static int ffs_sbupdate (struct ufsmount
*, int);
68 static int ffs_reload (struct mount
*, struct ucred
*);
69 static int ffs_oldfscompat (struct fs
*);
70 static int ffs_mount (struct mount
*, char *, caddr_t
, struct ucred
*);
71 static int ffs_init (struct vfsconf
*);
73 static struct vfsops ufs_vfsops
= {
74 .vfs_mount
= ffs_mount
,
75 .vfs_unmount
= ffs_unmount
,
77 .vfs_quotactl
= ufs_quotactl
,
78 .vfs_statfs
= ffs_statfs
,
81 .vfs_fhtovp
= ffs_fhtovp
,
82 .vfs_checkexp
= ufs_check_export
,
83 .vfs_vptofh
= ffs_vptofh
,
85 .vfs_uninit
= ufs_uninit
88 VFS_SET(ufs_vfsops
, ufs
, 0);
90 extern struct vop_ops ffs_vnode_vops
;
91 extern struct vop_ops ffs_spec_vops
;
92 extern struct vop_ops ffs_fifo_vops
;
97 * Called when mounting local physical media
101 * mp mount point structure
102 * path NULL (flag for root mount!!!)
104 * p process (user credentials check [statfs])
107 * mp mount point structure
108 * path path to mount point
109 * data pointer to argument struct in user space
110 * p process (user credentials check)
113 * !0 error number (errno.h)
118 * mount point is locked
120 * mount point is locked
123 * A NULL path can be used for a flag since the mount
124 * system call will fail with EFAULT in copyinstr in
125 * nlookup() if it is a genuine NULL from the user.
128 ffs_mount(struct mount
*mp
, /* mount struct pointer */
129 char *path
, /* path to mount point */
130 caddr_t data
, /* arguments to FS specific mount */
131 struct ucred
*cred
) /* process requesting mount */
137 struct ufs_args args
;
138 struct ufsmount
*ump
= 0;
140 int flags
, ronly
= 0;
142 struct nlookupdata nd
;
143 struct vnode
*rootvp
;
149 * Use NULL path to flag a root mount
154 * Mounting root filesystem
158 if ((error
= bdevvp(rootdev
, &rootvp
))) {
159 kprintf("ffs_mountroot: can't find rootvp\n");
163 if( ( error
= ffs_mountfs(rootvp
, mp
, M_FFSNODE
)) != 0) {
164 /* fs specific cleanup (if any)*/
169 goto dostatfs
; /* success*/
175 * Mounting non-root filesystem or updating a filesystem
179 /* copy in user arguments*/
180 error
= copyin(data
, (caddr_t
)&args
, sizeof (struct ufs_args
));
182 goto error_1
; /* can't get arguments*/
185 * If updating, check whether changing from read-only to
186 * read/write; if there is no device name, that's all we do.
188 if (mp
->mnt_flag
& MNT_UPDATE
) {
191 devvp
= ump
->um_devvp
;
193 ronly
= fs
->fs_ronly
; /* MNT_RELOAD might change this */
194 if (ronly
== 0 && (mp
->mnt_flag
& MNT_RDONLY
)) {
196 * Flush any dirty data.
198 VFS_SYNC(mp
, MNT_WAIT
);
200 * Check for and optionally get rid of files open
204 if (mp
->mnt_flag
& MNT_FORCE
)
206 if (mp
->mnt_flag
& MNT_SOFTDEP
) {
207 error
= softdep_flushfiles(mp
, flags
);
209 error
= ffs_flushfiles(mp
, flags
);
213 if (!error
&& (mp
->mnt_flag
& MNT_RELOAD
)) {
214 error
= ffs_reload(mp
, NULL
);
219 if (ronly
&& (mp
->mnt_kern_flag
& MNTK_WANTRDWR
)) {
221 * If upgrade to read-write by non-root, then verify
222 * that user has necessary permissions on the device.
224 if (cred
->cr_uid
!= 0) {
225 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
226 if ((error
= VOP_ACCESS(devvp
, VREAD
| VWRITE
,
234 fs
->fs_flags
&= ~FS_UNCLEAN
;
235 if (fs
->fs_clean
== 0) {
236 fs
->fs_flags
|= FS_UNCLEAN
;
237 if (mp
->mnt_flag
& MNT_FORCE
) {
239 "WARNING: %s was not properly dismounted\n",
243 "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
250 /* check to see if we need to start softdep */
251 if (fs
->fs_flags
& FS_DOSOFTDEP
) {
252 error
= softdep_mount(devvp
, mp
, fs
);
259 * Soft updates is incompatible with "async",
260 * so if we are doing softupdates stop the user
261 * from setting the async flag in an update.
262 * Softdep_mount() clears it in an initial mount
265 if (mp
->mnt_flag
& MNT_SOFTDEP
) {
266 mp
->mnt_flag
&= ~MNT_ASYNC
;
268 /* if not updating name...*/
269 if (args
.fspec
== 0) {
271 * Process export requests. Jumping to "success"
272 * will return the vfs_export() error code.
274 error
= vfs_export(mp
, &ump
->um_export
, &args
.export
);
280 * Not an update, or updating the name: look up the name
281 * and verify that it refers to a sensible block device.
284 error
= nlookup_init(&nd
, args
.fspec
, UIO_USERSPACE
, NLC_FOLLOW
);
286 error
= nlookup(&nd
);
288 error
= cache_vref(&nd
.nl_nch
, nd
.nl_cred
, &devvp
);
293 if (!vn_isdisk(devvp
, &error
))
297 * If mount by non-root, then verify that user has necessary
298 * permissions on the device.
300 if (cred
->cr_uid
!= 0) {
302 if ((mp
->mnt_flag
& MNT_RDONLY
) == 0)
303 accessmode
|= VWRITE
;
304 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
305 if ((error
= VOP_ACCESS(devvp
, accessmode
, cred
)) != 0) {
312 if (mp
->mnt_flag
& MNT_UPDATE
) {
314 * UPDATE - make sure the resolved vnode represents the same
315 * device. Note that devvp->v_rdev may be NULL since we
316 * haven't opened it, so compare udev instead.
318 * Our current open/writecount state is associated with
319 * um_devvp, so continue using um_devvp and throw away devvp.
321 if (devvp
!= ump
->um_devvp
) {
322 if (devvp
->v_umajor
== ump
->um_devvp
->v_umajor
&&
323 devvp
->v_uminor
== ump
->um_devvp
->v_uminor
) {
325 devvp
= ump
->um_devvp
;
327 kprintf("cannot update mount, udev does"
328 " not match %08x:%08x vs %08x:%08x\n",
329 devvp
->v_umajor
, devvp
->v_uminor
,
330 ump
->um_devvp
->v_umajor
,
331 ump
->um_devvp
->v_uminor
);
332 error
= EINVAL
; /* needs translation */
338 * Update device name only on success
341 /* Save "mounted from" info for mount point (NULL pad)*/
342 copyinstr( args
.fspec
,
343 mp
->mnt_stat
.f_mntfromname
,
346 bzero( mp
->mnt_stat
.f_mntfromname
+ size
, MNAMELEN
- size
);
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
);
362 /* Save "last mounted on" info for mount point (NULL pad)*/
363 bzero(mp
->mnt_stat
.f_mntonname
,
364 sizeof(mp
->mnt_stat
.f_mntonname
));
366 copyinstr(path
, mp
->mnt_stat
.f_mntonname
,
367 sizeof(mp
->mnt_stat
.f_mntonname
) - 1,
371 error
= ffs_mountfs(devvp
, mp
, M_FFSNODE
);
379 * Initialize FS stat information in mount struct; uses
380 * mp->mnt_stat.f_mntfromname.
382 * This code is common to root and non-root mounts
384 (void)VFS_STATFS(mp
, &mp
->mnt_stat
, cred
);
389 error_2
: /* error with devvp held*/
391 /* release devvp before failing*/
394 error_1
: /* no state to back out*/
397 if (!error
&& path
&& (mp
->mnt_flag
& MNT_UPDATE
)) {
398 /* Update clean flag after changing read-onlyness. */
400 if (ronly
!= fs
->fs_ronly
) {
401 fs
->fs_ronly
= ronly
;
402 fs
->fs_clean
= ronly
&&
403 (fs
->fs_flags
& FS_UNCLEAN
) == 0 ? 1 : 0;
406 * The device must be re-opened as appropriate or
407 * the device close at unmount time will panic.
409 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
411 VOP_OPEN(devvp
, FREAD
, FSCRED
, NULL
);
412 VOP_CLOSE(devvp
, FREAD
|FWRITE
);
414 VOP_OPEN(devvp
, FREAD
|FWRITE
, FSCRED
, NULL
);
415 VOP_CLOSE(devvp
, FREAD
);
418 ffs_sbupdate(ump
, MNT_WAIT
);
425 * Reload all incore data for a filesystem (used after running fsck on
426 * the root filesystem and finding things to fix). The filesystem must
427 * be mounted read-only.
429 * Things to do to update the mount:
430 * 1) invalidate all cached meta-data.
431 * 2) re-read superblock from disk.
432 * 3) re-read summary information from disk.
433 * 4) invalidate all inactive vnodes.
434 * 5) invalidate all cached file data.
435 * 6) re-read inode data for all active vnodes.
438 static int ffs_reload_scan2(struct mount
*mp
, struct vnode
*vp
, void *data
);
449 ffs_reload(struct mount
*mp
, struct ucred
*cred
)
454 struct fs
*fs
, *newfs
;
455 struct partinfo dpart
;
457 int i
, blks
, size
, error
;
458 struct scaninfo scaninfo
;
461 if ((mp
->mnt_flag
& MNT_RDONLY
) == 0)
464 * Step 1: invalidate all cached meta-data.
466 devvp
= VFSTOUFS(mp
)->um_devvp
;
467 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
468 error
= vinvalbuf(devvp
, 0, 0, 0);
471 panic("ffs_reload: dirty1");
476 * The backing device must be VMIO-capable because we use getblk().
477 * NOTE: the MFS driver now returns a VMIO-enabled descriptor.
479 if (devvp
->v_object
== NULL
)
480 panic("ffs_reload: devvp has no VM object!");
483 * Step 2: re-read superblock from disk.
485 if (VOP_IOCTL(devvp
, DIOCGPART
, (caddr_t
)&dpart
, FREAD
, cred
) != 0)
488 size
= dpart
.media_blksize
;
489 if ((error
= bread(devvp
, SBOFF
, SBSIZE
, &bp
)) != 0) {
493 newfs
= (struct fs
*)bp
->b_data
;
494 if (newfs
->fs_magic
!= FS_MAGIC
|| newfs
->fs_bsize
> MAXBSIZE
||
495 newfs
->fs_bsize
< sizeof(struct fs
)) {
497 return (EIO
); /* XXX needs translation */
499 fs
= VFSTOUFS(mp
)->um_fs
;
501 * Copy pointer fields back into superblock before copying in XXX
502 * new superblock. These should really be in the ufsmount. XXX
503 * Note that important parameters (eg fs_ncg) are unchanged.
505 newfs
->fs_csp
= fs
->fs_csp
;
506 newfs
->fs_maxcluster
= fs
->fs_maxcluster
;
507 newfs
->fs_contigdirs
= fs
->fs_contigdirs
;
508 /* The filesystem is still read-only. */
510 bcopy(newfs
, fs
, (uint
)fs
->fs_sbsize
);
511 if (fs
->fs_sbsize
< SBSIZE
)
512 bp
->b_flags
|= B_INVAL
;
514 mp
->mnt_maxsymlinklen
= fs
->fs_maxsymlinklen
;
516 /* An old fsck may have zeroed these fields, so recheck them. */
517 if (fs
->fs_avgfilesize
<= 0) /* XXX */
518 fs
->fs_avgfilesize
= AVFILESIZ
; /* XXX */
519 if (fs
->fs_avgfpdir
<= 0) /* XXX */
520 fs
->fs_avgfpdir
= AFPDIR
; /* XXX */
523 * Step 3: re-read summary information from disk.
525 blks
= howmany(fs
->fs_cssize
, fs
->fs_fsize
);
527 for (i
= 0; i
< blks
; i
+= fs
->fs_frag
) {
529 if (i
+ fs
->fs_frag
> blks
)
530 size
= (blks
- i
) * fs
->fs_fsize
;
531 error
= bread(devvp
, fsbtodoff(fs
, fs
->fs_csaddr
+ i
), size
, &bp
);
536 bcopy(bp
->b_data
, space
, (uint
)size
);
537 space
= (char *)space
+ size
;
541 * We no longer know anything about clusters per cylinder group.
543 if (fs
->fs_contigsumsize
> 0) {
544 lp
= fs
->fs_maxcluster
;
545 for (i
= 0; i
< fs
->fs_ncg
; i
++)
546 *lp
++ = fs
->fs_contigsumsize
;
551 scaninfo
.devvp
= devvp
;
552 while (error
== 0 && scaninfo
.rescan
) {
554 error
= vmntvnodescan(mp
, VMSC_GETVX
,
555 NULL
, ffs_reload_scan2
, &scaninfo
);
561 ffs_reload_scan2(struct mount
*mp
, struct vnode
*vp
, void *data
)
563 struct scaninfo
*info
= data
;
574 if (vinvalbuf(vp
, 0, 0, 0))
575 panic("ffs_reload: dirty2");
577 * Step 6: re-read inode data for all active vnodes.
580 error
= bread(info
->devvp
,
581 fsbtodoff(info
->fs
, ino_to_fsba(info
->fs
, ip
->i_number
)),
582 (int)info
->fs
->fs_bsize
, &bp
);
587 ip
->i_din
= *((struct ufs1_dinode
*)bp
->b_data
+
588 ino_to_fsbo(info
->fs
, ip
->i_number
));
589 ip
->i_effnlink
= ip
->i_nlink
;
595 * Common code for mount and mountroot
598 ffs_mountfs(struct vnode
*devvp
, struct mount
*mp
, struct malloc_type
*mtype
)
600 struct ufsmount
*ump
;
604 struct partinfo dpart
;
606 int error
, i
, blks
, size
, ronly
;
608 uint64_t maxfilesize
; /* XXX */
611 * Disallow multiple mounts of the same device.
612 * Disallow mounting of a device that is currently in use
613 * Flush out any old buffers remaining from a previous use.
615 error
= vfs_mountedon(devvp
);
618 if (count_udev(devvp
->v_umajor
, devvp
->v_uminor
) > 0)
620 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
621 error
= vinvalbuf(devvp
, V_SAVE
, 0, 0);
626 ronly
= (mp
->mnt_flag
& MNT_RDONLY
) != 0;
627 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
628 error
= VOP_OPEN(devvp
, ronly
? FREAD
: FREAD
|FWRITE
, FSCRED
, NULL
);
633 if (dev
->si_iosize_max
!= 0)
634 mp
->mnt_iosize_max
= dev
->si_iosize_max
;
635 if (mp
->mnt_iosize_max
> MAXPHYS
)
636 mp
->mnt_iosize_max
= MAXPHYS
;
639 * Filesystem supports native FSMIDs
641 mp
->mnt_kern_flag
|= MNTK_FSMID
;
644 * The backing device must be VMIO-capable because we use getblk().
645 * NOTE: the MFS driver now returns a VMIO-enabled descriptor.
646 * The VOP_OPEN() call above should have associated a VM object
649 if (devvp
->v_object
== NULL
)
650 panic("ffs_reload: devvp has no VM object!");
652 if (VOP_IOCTL(devvp
, DIOCGPART
, (caddr_t
)&dpart
, FREAD
, proc0
.p_ucred
) != 0)
655 size
= dpart
.media_blksize
;
659 if ((error
= bread(devvp
, SBOFF
, SBSIZE
, &bp
)) != 0)
661 fs
= (struct fs
*)bp
->b_data
;
662 if (fs
->fs_magic
!= FS_MAGIC
|| fs
->fs_bsize
> MAXBSIZE
||
663 fs
->fs_bsize
< sizeof(struct fs
)) {
664 error
= EINVAL
; /* XXX needs translation */
668 fs
->fs_flags
&= ~FS_UNCLEAN
;
669 if (fs
->fs_clean
== 0) {
670 fs
->fs_flags
|= FS_UNCLEAN
;
671 if (ronly
|| (mp
->mnt_flag
& MNT_FORCE
)) {
673 "WARNING: %s was not properly dismounted\n",
677 "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
683 /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
684 if (fs
->fs_postblformat
== FS_42POSTBLFMT
&& !ronly
) {
685 error
= EROFS
; /* needs translation */
688 ump
= kmalloc(sizeof *ump
, M_UFSMNT
, M_WAITOK
);
689 bzero((caddr_t
)ump
, sizeof *ump
);
690 ump
->um_malloctype
= mtype
;
691 ump
->um_i_effnlink_valid
= 1;
692 ump
->um_fs
= kmalloc((u_long
)fs
->fs_sbsize
, M_UFSMNT
,
694 bcopy(bp
->b_data
, ump
->um_fs
, (uint
)fs
->fs_sbsize
);
695 if (fs
->fs_sbsize
< SBSIZE
)
696 bp
->b_flags
|= B_INVAL
;
700 fs
->fs_ronly
= ronly
;
701 size
= fs
->fs_cssize
;
702 blks
= howmany(size
, fs
->fs_fsize
);
703 if (fs
->fs_contigsumsize
> 0)
704 size
+= fs
->fs_ncg
* sizeof(int32_t);
705 size
+= fs
->fs_ncg
* sizeof(uint8_t);
706 space
= kmalloc((u_long
)size
, M_UFSMNT
, M_WAITOK
);
708 for (i
= 0; i
< blks
; i
+= fs
->fs_frag
) {
710 if (i
+ fs
->fs_frag
> blks
)
711 size
= (blks
- i
) * fs
->fs_fsize
;
712 if ((error
= bread(devvp
, fsbtodoff(fs
, fs
->fs_csaddr
+ i
),
714 kfree(fs
->fs_csp
, M_UFSMNT
);
717 bcopy(bp
->b_data
, space
, (uint
)size
);
718 space
= (char *)space
+ size
;
722 if (fs
->fs_contigsumsize
> 0) {
723 fs
->fs_maxcluster
= lp
= space
;
724 for (i
= 0; i
< fs
->fs_ncg
; i
++)
725 *lp
++ = fs
->fs_contigsumsize
;
728 size
= fs
->fs_ncg
* sizeof(uint8_t);
729 fs
->fs_contigdirs
= (uint8_t *)space
;
730 bzero(fs
->fs_contigdirs
, size
);
731 /* Compatibility for old filesystems XXX */
732 if (fs
->fs_avgfilesize
<= 0) /* XXX */
733 fs
->fs_avgfilesize
= AVFILESIZ
; /* XXX */
734 if (fs
->fs_avgfpdir
<= 0) /* XXX */
735 fs
->fs_avgfpdir
= AFPDIR
; /* XXX */
736 mp
->mnt_data
= (qaddr_t
)ump
;
737 mp
->mnt_stat
.f_fsid
.val
[0] = fs
->fs_id
[0];
738 mp
->mnt_stat
.f_fsid
.val
[1] = fs
->fs_id
[1];
739 if (fs
->fs_id
[0] == 0 || fs
->fs_id
[1] == 0 ||
740 vfs_getvfs(&mp
->mnt_stat
.f_fsid
))
742 mp
->mnt_maxsymlinklen
= fs
->fs_maxsymlinklen
;
743 mp
->mnt_flag
|= MNT_LOCAL
;
746 ump
->um_devvp
= devvp
;
747 ump
->um_nindir
= fs
->fs_nindir
;
748 ump
->um_bptrtodb
= fs
->fs_fsbtodb
;
749 ump
->um_seqinc
= fs
->fs_frag
;
750 for (i
= 0; i
< MAXQUOTAS
; i
++)
751 ump
->um_quotas
[i
] = NULLVP
;
752 dev
->si_mountpoint
= mp
;
755 /* restore "last mounted on" here */
756 bzero(fs
->fs_fsmnt
, sizeof(fs
->fs_fsmnt
));
757 ksnprintf(fs
->fs_fsmnt
, sizeof(fs
->fs_fsmnt
),
758 "%s", mp
->mnt_stat
.f_mntonname
);
760 if( mp
->mnt_flag
& MNT_ROOTFS
) {
762 * Root mount; update timestamp in mount structure.
763 * this will be used by the common root mount code
764 * to update the system clock.
766 mp
->mnt_time
= fs
->fs_time
;
769 ump
->um_savedmaxfilesize
= fs
->fs_maxfilesize
; /* XXX */
770 maxfilesize
= (uint64_t)0x40000000 * fs
->fs_bsize
- 1; /* XXX */
771 /* Enforce limit caused by vm object backing (32 bits vm_pindex_t). */
772 if (maxfilesize
> (uint64_t)0x80000000u
* PAGE_SIZE
- 1)
773 maxfilesize
= (uint64_t)0x80000000u
* PAGE_SIZE
- 1;
774 if (fs
->fs_maxfilesize
> maxfilesize
) /* XXX */
775 fs
->fs_maxfilesize
= maxfilesize
; /* XXX */
777 if ((fs
->fs_flags
& FS_DOSOFTDEP
) &&
778 (error
= softdep_mount(devvp
, mp
, fs
)) != 0) {
779 kfree(fs
->fs_csp
, M_UFSMNT
);
784 (void) ffs_sbupdate(ump
, MNT_WAIT
);
786 vfs_add_vnodeops(mp
, &ffs_vnode_vops
, &mp
->mnt_vn_norm_ops
);
787 vfs_add_vnodeops(mp
, &ffs_spec_vops
, &mp
->mnt_vn_spec_ops
);
788 vfs_add_vnodeops(mp
, &ffs_fifo_vops
, &mp
->mnt_vn_fifo_ops
);
792 dev
->si_mountpoint
= NULL
;
795 VOP_CLOSE(devvp
, ronly
? FREAD
: FREAD
|FWRITE
);
797 kfree(ump
->um_fs
, M_UFSMNT
);
798 kfree(ump
, M_UFSMNT
);
799 mp
->mnt_data
= (qaddr_t
)0;
805 * Sanity checks for old filesystems.
807 * XXX - goes away some day.
810 ffs_oldfscompat(struct fs
*fs
)
812 fs
->fs_npsect
= max(fs
->fs_npsect
, fs
->fs_nsect
); /* XXX */
813 fs
->fs_interleave
= max(fs
->fs_interleave
, 1); /* XXX */
814 if (fs
->fs_postblformat
== FS_42POSTBLFMT
) /* XXX */
815 fs
->fs_nrpos
= 8; /* XXX */
816 if (fs
->fs_inodefmt
< FS_44INODEFMT
) { /* XXX */
819 uint64_t sizepb
= fs
->fs_bsize
; /* XXX */
821 fs
->fs_maxfilesize
= fs
->fs_bsize
* NDADDR
- 1; /* XXX */
822 for (i
= 0; i
< NIADDR
; i
++) { /* XXX */
823 sizepb
*= NINDIR(fs
); /* XXX */
824 fs
->fs_maxfilesize
+= sizepb
; /* XXX */
827 fs
->fs_maxfilesize
= (u_quad_t
) 1LL << 39;
828 fs
->fs_qbmask
= ~fs
->fs_bmask
; /* XXX */
829 fs
->fs_qfmask
= ~fs
->fs_fmask
; /* XXX */
835 * unmount system call
838 ffs_unmount(struct mount
*mp
, int mntflags
)
840 struct ufsmount
*ump
;
845 if (mntflags
& MNT_FORCE
) {
848 if (mp
->mnt_flag
& MNT_SOFTDEP
) {
849 if ((error
= softdep_flushfiles(mp
, flags
)) != 0)
852 if ((error
= ffs_flushfiles(mp
, flags
)) != 0)
857 if (fs
->fs_ronly
== 0) {
858 fs
->fs_clean
= fs
->fs_flags
& FS_UNCLEAN
? 0 : 1;
859 error
= ffs_sbupdate(ump
, MNT_WAIT
);
865 ump
->um_devvp
->v_rdev
->si_mountpoint
= NULL
;
867 vinvalbuf(ump
->um_devvp
, V_SAVE
, 0, 0);
868 error
= VOP_CLOSE(ump
->um_devvp
, fs
->fs_ronly
? FREAD
: FREAD
|FWRITE
);
870 vrele(ump
->um_devvp
);
872 kfree(fs
->fs_csp
, M_UFSMNT
);
874 kfree(ump
, M_UFSMNT
);
875 mp
->mnt_data
= (qaddr_t
)0;
876 mp
->mnt_flag
&= ~MNT_LOCAL
;
881 * Flush out all the files in a filesystem.
884 ffs_flushfiles(struct mount
*mp
, int flags
)
886 struct ufsmount
*ump
;
891 if (mp
->mnt_flag
& MNT_QUOTA
) {
893 error
= vflush(mp
, 0, SKIPSYSTEM
|flags
);
896 /* Find out how many quota files we have open. */
897 for (i
= 0; i
< MAXQUOTAS
; i
++) {
898 if (ump
->um_quotas
[i
] == NULLVP
)
903 * Here we fall through to vflush again to ensure
904 * that we have gotten rid of all the system vnodes.
909 * Flush all the files.
911 if ((error
= vflush(mp
, 0, flags
)) != 0)
914 * Flush filesystem metadata.
916 vn_lock(ump
->um_devvp
, LK_EXCLUSIVE
| LK_RETRY
);
917 error
= VOP_FSYNC(ump
->um_devvp
, MNT_WAIT
);
918 vn_unlock(ump
->um_devvp
);
923 * Get filesystem statistics.
926 ffs_statfs(struct mount
*mp
, struct statfs
*sbp
, struct ucred
*cred
)
928 struct ufsmount
*ump
;
933 if (fs
->fs_magic
!= FS_MAGIC
)
935 sbp
->f_bsize
= fs
->fs_fsize
;
936 sbp
->f_iosize
= fs
->fs_bsize
;
937 sbp
->f_blocks
= fs
->fs_dsize
;
938 sbp
->f_bfree
= fs
->fs_cstotal
.cs_nbfree
* fs
->fs_frag
+
939 fs
->fs_cstotal
.cs_nffree
;
940 sbp
->f_bavail
= freespace(fs
, fs
->fs_minfree
);
941 sbp
->f_files
= fs
->fs_ncg
* fs
->fs_ipg
- ROOTINO
;
942 sbp
->f_ffree
= fs
->fs_cstotal
.cs_nifree
;
943 if (sbp
!= &mp
->mnt_stat
) {
944 sbp
->f_type
= mp
->mnt_vfc
->vfc_typenum
;
945 bcopy((caddr_t
)mp
->mnt_stat
.f_mntfromname
,
946 (caddr_t
)&sbp
->f_mntfromname
[0], MNAMELEN
);
952 * Go through the disk queues to initiate sandbagged IO;
953 * go through the inodes to write those that have been modified;
954 * initiate the writing of the super block if it has been modified.
956 * Note: we are always called with the filesystem marked `MPBUSY'.
960 static int ffs_sync_scan1(struct mount
*mp
, struct vnode
*vp
, void *data
);
961 static int ffs_sync_scan2(struct mount
*mp
, struct vnode
*vp
, void *data
);
964 ffs_sync(struct mount
*mp
, int waitfor
)
966 struct ufsmount
*ump
= VFSTOUFS(mp
);
969 struct scaninfo scaninfo
;
972 if (fs
->fs_fmod
!= 0 && fs
->fs_ronly
!= 0) { /* XXX */
973 kprintf("fs = %s\n", fs
->fs_fsmnt
);
974 panic("ffs_sync: rofs mod");
978 * Write back each (modified) inode.
980 scaninfo
.allerror
= 0;
982 scaninfo
.waitfor
= waitfor
;
983 while (scaninfo
.rescan
) {
985 vmntvnodescan(mp
, VMSC_GETVP
|VMSC_NOWAIT
,
986 ffs_sync_scan1
, ffs_sync_scan2
, &scaninfo
);
990 * Force stale filesystem control information to be flushed.
992 if (waitfor
!= MNT_LAZY
) {
993 if (ump
->um_mountp
->mnt_flag
& MNT_SOFTDEP
)
994 waitfor
= MNT_NOWAIT
;
995 vn_lock(ump
->um_devvp
, LK_EXCLUSIVE
| LK_RETRY
);
996 if ((error
= VOP_FSYNC(ump
->um_devvp
, waitfor
)) != 0)
997 scaninfo
.allerror
= error
;
998 vn_unlock(ump
->um_devvp
);
1004 * Write back modified superblock.
1006 if (fs
->fs_fmod
!= 0 && (error
= ffs_sbupdate(ump
, waitfor
)) != 0)
1007 scaninfo
.allerror
= error
;
1008 return (scaninfo
.allerror
);
1012 ffs_sync_scan1(struct mount
*mp
, struct vnode
*vp
, void *data
)
1017 * Depend on the mount list's vnode lock to keep things stable
1018 * enough for a quick test. Since there might be hundreds of
1019 * thousands of vnodes, we cannot afford even a subroutine
1020 * call unless there's a good chance that we have work to do.
1023 /* Restart out whole search if this guy is locked
1024 * or is being reclaimed.
1026 if (vp
->v_type
== VNON
|| ((ip
->i_flag
&
1027 (IN_ACCESS
| IN_CHANGE
| IN_MODIFIED
| IN_UPDATE
)) == 0 &&
1028 RB_EMPTY(&vp
->v_rbdirty_tree
))) {
1035 ffs_sync_scan2(struct mount
*mp
, struct vnode
*vp
, void *data
)
1037 struct scaninfo
*info
= data
;
1042 * We have to recheck after having obtained the vnode interlock.
1045 if (vp
->v_type
== VNON
|| vp
->v_type
== VBAD
||
1047 (IN_ACCESS
| IN_CHANGE
| IN_MODIFIED
| IN_UPDATE
)) == 0 &&
1048 RB_EMPTY(&vp
->v_rbdirty_tree
))) {
1051 if (vp
->v_type
!= VCHR
) {
1052 if ((error
= VOP_FSYNC(vp
, info
->waitfor
)) != 0)
1053 info
->allerror
= error
;
1056 * We must reference the vp to prevent it from
1057 * getting ripped out from under ffs_update, since
1058 * we are not holding a vnode lock.
1060 /* ffs_update(vp, waitfor == MNT_WAIT); */
1067 * Look up a FFS dinode number to find its incore vnode, otherwise read it
1068 * in from disk. If it is in core, wait for the lock bit to clear, then
1069 * return the inode locked. Detection and handling of mount points must be
1070 * done by the calling routine.
1074 ffs_vget(struct mount
*mp
, ino_t ino
, struct vnode
**vpp
)
1078 struct ufsmount
*ump
;
1087 if ((*vpp
= ufs_ihashget(dev
, ino
)) != NULL
) {
1092 * If this MALLOC() is performed after the getnewvnode()
1093 * it might block, leaving a vnode with a NULL v_data to be
1094 * found by ffs_sync() if a sync happens to fire right then,
1095 * which will cause a panic because ffs_sync() blindly
1096 * dereferences vp->v_data (as well it should).
1098 * XXX this may no longer be true since getnewvnode returns a
1099 * VX locked vnode now.
1101 MALLOC(ip
, struct inode
*, sizeof(struct inode
),
1102 ump
->um_malloctype
, M_WAITOK
);
1104 /* Allocate a new vnode/inode. */
1105 error
= getnewvnode(VT_UFS
, mp
, &vp
, VLKTIMEOUT
, LK_CANRECURSE
);
1108 kfree(ip
, ump
->um_malloctype
);
1111 bzero((caddr_t
)ip
, sizeof(struct inode
));
1113 ip
->i_fs
= fs
= ump
->um_fs
;
1119 for (i
= 0; i
< MAXQUOTAS
; i
++)
1120 ip
->i_dquot
[i
] = NODQUOT
;
1125 * Insert it into the inode hash table and check for a collision.
1126 * If a collision occurs, throw away the vnode and try again.
1128 if (ufs_ihashins(ip
) != 0) {
1129 kprintf("debug: ufs ihashins collision, retrying inode %ld\n",
1130 (long)ip
->i_number
);
1133 kfree(ip
, ump
->um_malloctype
);
1138 /* Read in the disk contents for the inode, copy into the inode. */
1139 error
= bread(ump
->um_devvp
, fsbtodoff(fs
, ino_to_fsba(fs
, ino
)),
1140 (int)fs
->fs_bsize
, &bp
);
1143 * The inode does not contain anything useful, so it would
1144 * be misleading to leave it on its hash chain. With mode
1145 * still zero, it will be unlinked and returned to the free
1154 ip
->i_din
= *((struct ufs1_dinode
*)bp
->b_data
+ ino_to_fsbo(fs
, ino
));
1155 if (DOINGSOFTDEP(vp
))
1156 softdep_load_inodeblock(ip
);
1158 ip
->i_effnlink
= ip
->i_nlink
;
1162 * Initialize the vnode from the inode, check for aliases.
1163 * Note that the underlying vnode may have changed.
1165 error
= ufs_vinit(mp
, &vp
);
1173 * Finish inode initialization now that aliasing has been resolved.
1175 ip
->i_devvp
= ump
->um_devvp
;
1178 * Set up a generation number for this inode if it does not
1179 * already have one. This should only happen on old filesystems.
1181 if (ip
->i_gen
== 0) {
1182 ip
->i_gen
= krandom() / 2 + 1;
1183 if ((vp
->v_mount
->mnt_flag
& MNT_RDONLY
) == 0)
1184 ip
->i_flag
|= IN_MODIFIED
;
1187 * Ensure that uid and gid are correct. This is a temporary
1188 * fix until fsck has been changed to do the update.
1190 if (fs
->fs_inodefmt
< FS_44INODEFMT
) { /* XXX */
1191 ip
->i_uid
= ip
->i_din
.di_ouid
; /* XXX */
1192 ip
->i_gid
= ip
->i_din
.di_ogid
; /* XXX */
1196 * return a VX locked and refd vnode (VX == same as normal vget()
1197 * vnode so we are ok)
1204 * File handle to vnode
1206 * Have to be really careful about stale file handles:
1207 * - check that the inode number is valid
1208 * - call ffs_vget() to get the locked inode
1209 * - check for an unallocated inode (i_mode == 0)
1210 * - check that the given client host has export rights and return
1211 * those rights via. exflagsp and credanonp
1214 ffs_fhtovp(struct mount
*mp
, struct fid
*fhp
, struct vnode
**vpp
)
1219 ufhp
= (struct ufid
*)fhp
;
1220 fs
= VFSTOUFS(mp
)->um_fs
;
1221 if (ufhp
->ufid_ino
< ROOTINO
||
1222 ufhp
->ufid_ino
>= fs
->fs_ncg
* fs
->fs_ipg
)
1224 return (ufs_fhtovp(mp
, ufhp
, vpp
));
1228 * Vnode pointer to File handle
1232 ffs_vptofh(struct vnode
*vp
, struct fid
*fhp
)
1238 ufhp
= (struct ufid
*)fhp
;
1239 ufhp
->ufid_len
= sizeof(struct ufid
);
1240 ufhp
->ufid_ino
= ip
->i_number
;
1241 ufhp
->ufid_gen
= ip
->i_gen
;
1246 * Initialize the filesystem; just use ufs_init.
1249 ffs_init(struct vfsconf
*vfsp
)
1251 softdep_initialize();
1252 return (ufs_init(vfsp
));
1256 * Write a superblock and associated information back to disk.
1259 ffs_sbupdate(struct ufsmount
*mp
, int waitfor
)
1261 struct fs
*dfs
, *fs
= mp
->um_fs
;
1265 int i
, size
, error
, allerror
= 0;
1268 * First write back the summary information.
1270 * NOTE: the getblk is relative to the device vnode so bio1
1271 * contains the device block number.
1273 blks
= howmany(fs
->fs_cssize
, fs
->fs_fsize
);
1275 for (i
= 0; i
< blks
; i
+= fs
->fs_frag
) {
1276 size
= fs
->fs_bsize
;
1277 if (i
+ fs
->fs_frag
> blks
)
1278 size
= (blks
- i
) * fs
->fs_fsize
;
1279 bp
= getblk(mp
->um_devvp
, fsbtodoff(fs
, fs
->fs_csaddr
+ i
),
1281 bcopy(space
, bp
->b_data
, (uint
)size
);
1282 space
= (char *)space
+ size
;
1283 if (waitfor
!= MNT_WAIT
)
1285 else if ((error
= bwrite(bp
)) != 0)
1289 * Now write back the superblock itself. If any errors occurred
1290 * up to this point, then fail so that the superblock avoids
1291 * being written out as clean.
1295 bp
= getblk(mp
->um_devvp
, SBOFF
, (int)fs
->fs_sbsize
, 0, 0);
1297 fs
->fs_time
= time_second
;
1298 bcopy((caddr_t
)fs
, bp
->b_data
, (uint
)fs
->fs_sbsize
);
1299 /* Restore compatibility to old filesystems. XXX */
1300 dfs
= (struct fs
*)bp
->b_data
; /* XXX */
1301 if (fs
->fs_postblformat
== FS_42POSTBLFMT
) /* XXX */
1302 dfs
->fs_nrpos
= -1; /* XXX */
1303 if (fs
->fs_inodefmt
< FS_44INODEFMT
) { /* XXX */
1304 int32_t *lp
, tmp
; /* XXX */
1306 lp
= (int32_t *)&dfs
->fs_qbmask
; /* XXX */
1307 tmp
= lp
[4]; /* XXX */
1308 for (i
= 4; i
> 0; i
--) /* XXX */
1309 lp
[i
] = lp
[i
-1]; /* XXX */
1310 lp
[0] = tmp
; /* XXX */
1312 dfs
->fs_maxfilesize
= mp
->um_savedmaxfilesize
; /* XXX */
1313 if (waitfor
!= MNT_WAIT
)
1315 else if ((error
= bwrite(bp
)) != 0)