* Copyright (c) 1994, 1995 The Regents of the University of California.
* Copyright (c) 1994, 1995 Jan-Simon Pendry.
* This code is derived from software donated to Berkeley by
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* @(#)union_vfsops.c 8.20 (Berkeley) 5/20/95
#include <sys/filedesc.h>
#include <miscfs/union/union.h>
union_mount(mp
, path
, data
, ndp
, p
)
struct vnode
*lowerrootvp
= NULLVP
;
struct vnode
*upperrootvp
= NULLVP
;
struct union_mount
*um
= 0;
printf("union_mount(mp = %x)\n", mp
);
if (mp
->mnt_flag
& MNT_UPDATE
) {
* 1. a way to convert between rdonly and rdwr mounts.
* 2. support for nfs exports.
if (error
= copyin(data
, (caddr_t
)&args
, sizeof(struct union_args
)))
lowerrootvp
= mp
->mnt_vnodecovered
;
NDINIT(ndp
, LOOKUP
, FOLLOW
|WANTPARENT
,
UIO_USERSPACE
, args
.target
, p
);
upperrootvp
= ndp
->ni_vp
;
if (upperrootvp
->v_type
!= VDIR
) {
um
= (struct union_mount
*) malloc(sizeof(struct union_mount
),
M_UFSMNT
, M_WAITOK
); /* XXX */
* Keep a held reference to the target vnodes.
* They are vrele'd in union_unmount.
* Depending on the _BELOW flag, the filesystems are
* viewed in a different order. In effect, this is the
* same as providing a mount under option to the mount syscall.
um
->um_op
= args
.mntflags
& UNMNT_OPMASK
;
um
->um_lowervp
= lowerrootvp
;
um
->um_uppervp
= upperrootvp
;
um
->um_lowervp
= upperrootvp
;
um
->um_uppervp
= lowerrootvp
;
um
->um_uppervp
= upperrootvp
;
um
->um_lowervp
= lowerrootvp
;
* Unless the mount is readonly, ensure that the top layer
* supports whiteout operations
if ((mp
->mnt_flag
& MNT_RDONLY
) == 0) {
error
= VOP_WHITEOUT(um
->um_uppervp
, (struct componentname
*) 0, LOOKUP
);
um
->um_cred
= p
->p_ucred
;
um
->um_cmode
= UN_DIRMODE
&~ p
->p_fd
->fd_cmask
;
* Depending on what you think the MNT_LOCAL flag might mean,
* you may want the && to be || on the conditional below.
* At the moment it has been defined that the filesystem is
* only local if it is all local, ie the MNT_LOCAL flag implies
* that the entire namespace is local. If you think the MNT_LOCAL
* flag implies that some of the files might be stored locally
* then you will want to change the conditional.
if (um
->um_op
== UNMNT_ABOVE
) {
if (((um
->um_lowervp
== NULLVP
) ||
(um
->um_lowervp
->v_mount
->mnt_flag
& MNT_LOCAL
)) &&
(um
->um_uppervp
->v_mount
->mnt_flag
& MNT_LOCAL
))
mp
->mnt_flag
|= MNT_LOCAL
;
* Copy in the upper layer's RDONLY flag. This is for the benefit
* of lookup() which explicitly checks the flag, rather than asking
* the filesystem for it's own opinion. This means, that an update
* mount of the underlying filesystem to go from rdonly to rdwr
* will leave the unioned view as read-only.
mp
->mnt_flag
|= (um
->um_uppervp
->v_mount
->mnt_flag
& MNT_RDONLY
);
mp
->mnt_data
= (qaddr_t
) um
;
(void) copyinstr(path
, mp
->mnt_stat
.f_mntonname
, MNAMELEN
- 1, &size
);
bzero(mp
->mnt_stat
.f_mntonname
+ size
, MNAMELEN
- size
);
bcopy(cp
, mp
->mnt_stat
.f_mntfromname
, len
);
cp
= mp
->mnt_stat
.f_mntfromname
+ len
;
(void) copyinstr(args
.target
, cp
, len
- 1, &size
);
bzero(cp
+ size
, len
- size
);
printf("union_mount: from %s, on %s\n",
mp
->mnt_stat
.f_mntfromname
, mp
->mnt_stat
.f_mntonname
);
* VFS start. Nothing needed here - the start routine
* on the underlying filesystem(s) will have been called
* when that filesystem was mounted.
union_start(mp
, flags
, p
)
* Free reference to union layer
union_unmount(mp
, mntflags
, p
)
struct union_mount
*um
= MOUNTTOUNIONMOUNT(mp
);
printf("union_unmount(mp = %x)\n", mp
);
if (mntflags
& MNT_FORCE
)
if (error
= union_root(mp
, &um_rootvp
))
* Keep flushing vnodes from the mount list.
* This is needed because of the un_pvp held
* reference to the parent vnode.
* If more vnodes have been freed on a given pass,
* the try again. The loop will iterate at most
* (d) times, where (d) is the maximum tree depth
for (freeing
= 0; vflush(mp
, um_rootvp
, flags
) != 0;) {
/* count #vnodes held on mount list */
for (n
= 0, vp
= mp
->mnt_vnodelist
.lh_first
;
vp
= vp
->v_mntvnodes
.le_next
)
/* if this is unchanged then stop */
/* otherwise try once more time */
/* At this point the root vnode should have a single reference */
if (um_rootvp
->v_usecount
> 1) {
vprint("union root", um_rootvp
);
* Discard references to upper and lower target vnodes.
* Release reference on underlying root vnode
* And blow it away for future re-use
* Finally, throw away the union_mount structure
free(mp
->mnt_data
, M_UFSMNT
); /* XXX */
struct proc
*p
= curproc
; /* XXX */
struct union_mount
*um
= MOUNTTOUNIONMOUNT(mp
);
* Return locked reference to root.
if ((um
->um_op
== UNMNT_BELOW
) &&
VOP_ISLOCKED(um
->um_uppervp
)) {
vn_lock(um
->um_uppervp
, LK_EXCLUSIVE
| LK_RETRY
, p
);
error
= union_allocvp(vpp
, mp
,
(struct componentname
*) 0,
VTOUNION(*vpp
)->un_flags
&= ~UN_ULOCK
;
struct union_mount
*um
= MOUNTTOUNIONMOUNT(mp
);
printf("union_statfs(mp = %x, lvp = %x, uvp = %x)\n", mp
,
bzero(&mstat
, sizeof(mstat
));
error
= VFS_STATFS(um
->um_lowervp
->v_mount
, &mstat
, p
);
/* now copy across the "interesting" information and fake the rest */
sbp
->f_type
= mstat
.f_type
;
sbp
->f_flags
= mstat
.f_flags
;
sbp
->f_bsize
= mstat
.f_bsize
;
sbp
->f_iosize
= mstat
.f_iosize
;
sbp
->f_blocks
= mstat
.f_blocks
;
sbp
->f_bfree
= mstat
.f_bfree
;
sbp
->f_bavail
= mstat
.f_bavail
;
sbp
->f_files
= mstat
.f_files
;
sbp
->f_ffree
= mstat
.f_ffree
;
error
= VFS_STATFS(um
->um_uppervp
->v_mount
, &mstat
, p
);
sbp
->f_flags
= mstat
.f_flags
;
sbp
->f_bsize
= mstat
.f_bsize
;
sbp
->f_iosize
= mstat
.f_iosize
;
* if the lower and upper blocksizes differ, then frig the
* block counts so that the sizes reported by df make some
* kind of sense. none of this makes sense though.
if (mstat
.f_bsize
!= lbsize
)
sbp
->f_blocks
= sbp
->f_blocks
* lbsize
/ mstat
.f_bsize
;
* The "total" fields count total resources in all layers,
* the "free" fields count only those resources which are
* free in the upper layer (since only the upper layer
sbp
->f_blocks
+= mstat
.f_blocks
;
sbp
->f_bfree
= mstat
.f_bfree
;
sbp
->f_bavail
= mstat
.f_bavail
;
sbp
->f_files
+= mstat
.f_files
;
sbp
->f_ffree
= mstat
.f_ffree
;
if (sbp
!= &mp
->mnt_stat
) {
sbp
->f_type
= mp
->mnt_vfc
->vfc_typenum
;
bcopy(&mp
->mnt_stat
.f_fsid
, &sbp
->f_fsid
, sizeof(sbp
->f_fsid
));
bcopy(mp
->mnt_stat
.f_mntonname
, sbp
->f_mntonname
, MNAMELEN
);
bcopy(mp
->mnt_stat
.f_mntfromname
, sbp
->f_mntfromname
, MNAMELEN
);
* XXX - Assumes no data cached at union layer.
#define union_sync ((int (*) __P((struct mount *, int, struct ucred *, \
#define union_fhtovp ((int (*) __P((struct mount *, struct fid *, \
struct mbuf *, struct vnode **, int *, struct ucred **)))eopnotsupp)
int union_init
__P((struct vfsconf
*));
#define union_quotactl ((int (*) __P((struct mount *, int, uid_t, caddr_t, \
struct proc *)))eopnotsupp)
#define union_sysctl ((int (*) __P((int *, u_int, void *, size_t *, void *, \
size_t, struct proc *)))eopnotsupp)
#define union_vget ((int (*) __P((struct mount *, ino_t, struct vnode **))) \
#define union_vptofh ((int (*) __P((struct vnode *, struct fid *)))eopnotsupp)
struct vfsops union_vfsops
= {