#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <sys/namei.h>
#include <sys/malloc.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/queue.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/ubc.h>
#include <miscfs/union/union.h>
#if DIAGNOSTIC
#include <sys/proc.h>
#endif
#define NHASH 32
#define UNION_HASH(u, l) \
(((((unsigned long) (u)) + ((unsigned long) l)) >> 8) & (NHASH-1))
static LIST_HEAD(unhead, union_node) unhead[NHASH];
static int unvplock[NHASH];
int
union_init()
{
int i;
for (i = 0; i < NHASH; i++)
LIST_INIT(&unhead[i]);
bzero((caddr_t) unvplock, sizeof(unvplock));
}
static int
union_list_lock(ix)
int ix;
{
if (unvplock[ix] & UN_LOCKED) {
unvplock[ix] |= UN_WANT;
sleep((caddr_t) &unvplock[ix], PINOD);
return (1);
}
unvplock[ix] |= UN_LOCKED;
return (0);
}
static void
union_list_unlock(ix)
int ix;
{
unvplock[ix] &= ~UN_LOCKED;
if (unvplock[ix] & UN_WANT) {
unvplock[ix] &= ~UN_WANT;
wakeup((caddr_t) &unvplock[ix]);
}
}
void
union_updatevp(un, uppervp, lowervp)
struct union_node *un;
struct vnode *uppervp;
struct vnode *lowervp;
{
int ohash = UNION_HASH(un->un_uppervp, un->un_lowervp);
int nhash = UNION_HASH(uppervp, lowervp);
int docache = (lowervp != NULLVP || uppervp != NULLVP);
int lhash, hhash, uhash;
if (nhash < ohash) {
lhash = nhash;
uhash = ohash;
} else {
lhash = ohash;
uhash = nhash;
}
if (lhash != uhash)
while (union_list_lock(lhash))
continue;
while (union_list_lock(uhash))
continue;
if (ohash != nhash || !docache) {
if (un->un_flags & UN_CACHED) {
un->un_flags &= ~UN_CACHED;
LIST_REMOVE(un, un_cache);
}
}
if (ohash != nhash)
union_list_unlock(ohash);
if (un->un_lowervp != lowervp) {
if (un->un_lowervp) {
vrele(un->un_lowervp);
if (un->un_path) {
_FREE(un->un_path, M_TEMP);
un->un_path = 0;
}
if (un->un_dirvp) {
vrele(un->un_dirvp);
un->un_dirvp = NULLVP;
}
}
un->un_lowervp = lowervp;
un->un_lowersz = VNOVAL;
}
if (un->un_uppervp != uppervp) {
if (un->un_uppervp)
vrele(un->un_uppervp);
un->un_uppervp = uppervp;
un->un_uppersz = VNOVAL;
}
if (docache && (ohash != nhash)) {
LIST_INSERT_HEAD(&unhead[nhash], un, un_cache);
un->un_flags |= UN_CACHED;
}
union_list_unlock(nhash);
}
void
union_newlower(un, lowervp)
struct union_node *un;
struct vnode *lowervp;
{
union_updatevp(un, un->un_uppervp, lowervp);
}
void
union_newupper(un, uppervp)
struct union_node *un;
struct vnode *uppervp;
{
union_updatevp(un, uppervp, un->un_lowervp);
}
void
union_newsize(vp, uppersz, lowersz)
struct vnode *vp;
off_t uppersz, lowersz;
{
struct union_node *un;
off_t sz;
if (vp->v_type != VREG)
return;
un = VTOUNION(vp);
sz = VNOVAL;
if ((uppersz != VNOVAL) && (un->un_uppersz != uppersz)) {
un->un_uppersz = uppersz;
if (sz == VNOVAL)
sz = un->un_uppersz;
}
if ((lowersz != VNOVAL) && (un->un_lowersz != lowersz)) {
un->un_lowersz = lowersz;
if (sz == VNOVAL)
sz = un->un_lowersz;
}
if (sz != VNOVAL) {
#ifdef UNION_DIAGNOSTIC
printf("union: %s size now %ld\n",
uppersz != VNOVAL ? "upper" : "lower", (long) sz);
#endif
if (UBCISVALID(vp))
ubc_setsize(vp, sz);
}
}
int
union_allocvp(vpp, mp, undvp, dvp, cnp, uppervp, lowervp, docache)
struct vnode **vpp;
struct mount *mp;
struct vnode *undvp;
struct vnode *dvp;
struct componentname *cnp;
struct vnode *uppervp;
struct vnode *lowervp;
int docache;
{
int error;
struct union_node *un;
struct union_node **pp;
struct vnode *xlowervp = NULLVP;
struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
int hash;
int vflag;
int try;
struct union_node *unp;
if (uppervp == NULLVP && lowervp == NULLVP)
panic("union: unidentifiable allocation");
if (uppervp && lowervp && (uppervp->v_type != lowervp->v_type)) {
xlowervp = lowervp;
lowervp = NULLVP;
}
vflag = 0;
if ((uppervp == um->um_uppervp) &&
((lowervp == NULLVP) || lowervp == um->um_lowervp)) {
if (lowervp == NULLVP) {
lowervp = um->um_lowervp;
if (lowervp != NULLVP)
VREF(lowervp);
}
vflag = VROOT;
}
loop:
if (!docache) {
un = 0;
} else for (try = 0; try < 3; try++) {
switch (try) {
case 0:
if (lowervp == NULLVP)
continue;
hash = UNION_HASH(uppervp, lowervp);
break;
case 1:
if (uppervp == NULLVP)
continue;
hash = UNION_HASH(uppervp, NULLVP);
break;
case 2:
if (lowervp == NULLVP)
continue;
hash = UNION_HASH(NULLVP, lowervp);
break;
}
while (union_list_lock(hash))
continue;
for (un = unhead[hash].lh_first; un != 0;
un = un->un_cache.le_next) {
if ((un->un_lowervp == lowervp ||
un->un_lowervp == NULLVP) &&
(un->un_uppervp == uppervp ||
un->un_uppervp == NULLVP) &&
(UNIONTOV(un)->v_mount == mp)) {
if (vget(UNIONTOV(un), 0,
cnp ? cnp->cn_proc : NULL)) {
union_list_unlock(hash);
goto loop;
}
break;
}
}
union_list_unlock(hash);
if (un)
break;
}
if (un) {
if ((dvp != NULLVP) && (uppervp == dvp)) {
#if DIAGNOSTIC
if ((un->un_flags & UN_LOCKED) == 0)
panic("union: . not locked");
else if (current_proc() && un->un_pid != current_proc()->p_pid &&
un->un_pid > -1 && current_proc()->p_pid > -1)
panic("union: allocvp not lock owner");
#endif
} else {
if (un->un_flags & UN_LOCKED) {
vrele(UNIONTOV(un));
un->un_flags |= UN_WANT;
sleep((caddr_t) &un->un_flags, PINOD);
goto loop;
}
un->un_flags |= UN_LOCKED;
#if DIAGNOSTIC
if (current_proc())
un->un_pid = current_proc()->p_pid;
else
un->un_pid = -1;
#endif
}
if (uppervp != un->un_uppervp) {
union_newupper(un, uppervp);
} else if (uppervp) {
vrele(uppervp);
}
if (un->un_uppervp) {
un->un_flags |= UN_ULOCK;
un->un_flags &= ~UN_KLOCK;
}
if (lowervp != un->un_lowervp) {
union_newlower(un, lowervp);
if (cnp && (lowervp != NULLVP)) {
un->un_hash = cnp->cn_hash;
MALLOC(un->un_path, caddr_t, cnp->cn_namelen+1,
M_TEMP, M_WAITOK);
bcopy(cnp->cn_nameptr, un->un_path,
cnp->cn_namelen);
un->un_path[cnp->cn_namelen] = '\0';
VREF(dvp);
un->un_dirvp = dvp;
}
} else if (lowervp) {
vrele(lowervp);
}
*vpp = UNIONTOV(un);
return (0);
}
if (docache) {
hash = UNION_HASH(uppervp, lowervp);
if (union_list_lock(hash))
goto loop;
}
MALLOC(unp, void *, sizeof(struct union_node), M_TEMP, M_WAITOK);
error = getnewvnode(VT_UNION, mp, union_vnodeop_p, vpp);
if (error) {
FREE(unp, M_TEMP);
if (uppervp) {
if (dvp == uppervp)
vrele(uppervp);
else
vput(uppervp);
}
if (lowervp)
vrele(lowervp);
goto out;
}
(*vpp)->v_data = unp;
(*vpp)->v_flag |= vflag;
if (uppervp)
(*vpp)->v_type = uppervp->v_type;
else
(*vpp)->v_type = lowervp->v_type;
if ((*vpp)->v_type == VREG)
ubc_info_init(*vpp);
un = VTOUNION(*vpp);
un->un_vnode = *vpp;
un->un_uppervp = uppervp;
un->un_uppersz = VNOVAL;
un->un_lowervp = lowervp;
un->un_lowersz = VNOVAL;
un->un_pvp = undvp;
if (undvp != NULLVP)
VREF(undvp);
un->un_dircache = 0;
un->un_openl = 0;
un->un_flags = UN_LOCKED;
if (un->un_uppervp)
un->un_flags |= UN_ULOCK;
#if DIAGNOSTIC
if (current_proc())
un->un_pid = current_proc()->p_pid;
else
un->un_pid = -1;
#endif
if (cnp && (lowervp != NULLVP)) {
un->un_hash = cnp->cn_hash;
un->un_path = _MALLOC(cnp->cn_namelen+1, M_TEMP, M_WAITOK);
bcopy(cnp->cn_nameptr, un->un_path, cnp->cn_namelen);
un->un_path[cnp->cn_namelen] = '\0';
VREF(dvp);
un->un_dirvp = dvp;
} else {
un->un_hash = 0;
un->un_path = 0;
un->un_dirvp = 0;
}
if (docache) {
LIST_INSERT_HEAD(&unhead[hash], un, un_cache);
un->un_flags |= UN_CACHED;
}
if (xlowervp)
vrele(xlowervp);
out:
if (docache)
union_list_unlock(hash);
return (error);
}
int
union_freevp(vp)
struct vnode *vp;
{
struct union_node *un = VTOUNION(vp);
if (un->un_flags & UN_CACHED) {
un->un_flags &= ~UN_CACHED;
LIST_REMOVE(un, un_cache);
}
if (un->un_pvp != NULLVP)
vrele(un->un_pvp);
if (un->un_uppervp != NULLVP)
vrele(un->un_uppervp);
if (un->un_lowervp != NULLVP)
vrele(un->un_lowervp);
if (un->un_dirvp != NULLVP)
vrele(un->un_dirvp);
if (un->un_path)
_FREE(un->un_path, M_TEMP);
FREE(vp->v_data, M_TEMP);
vp->v_data = 0;
return (0);
}
int
union_copyfile(fvp, tvp, cred, p)
struct vnode *fvp;
struct vnode *tvp;
struct ucred *cred;
struct proc *p;
{
char *buf;
struct uio uio;
struct iovec iov;
int error = 0;
uio.uio_procp = p;
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_offset = 0;
VOP_UNLOCK(fvp, 0, p);
VOP_LEASE(fvp, p, cred, LEASE_READ);
vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p);
VOP_UNLOCK(tvp, 0, p);
VOP_LEASE(tvp, p, cred, LEASE_WRITE);
vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p);
buf = _MALLOC(MAXPHYSIO, M_TEMP, M_WAITOK);
do {
off_t offset = uio.uio_offset;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
iov.iov_base = buf;
iov.iov_len = MAXPHYSIO;
uio.uio_resid = iov.iov_len;
uio.uio_rw = UIO_READ;
error = VOP_READ(fvp, &uio, 0, cred);
if (error == 0) {
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
iov.iov_base = buf;
iov.iov_len = MAXPHYSIO - uio.uio_resid;
uio.uio_offset = offset;
uio.uio_rw = UIO_WRITE;
uio.uio_resid = iov.iov_len;
if (uio.uio_resid == 0)
break;
do {
error = VOP_WRITE(tvp, &uio, 0, cred);
} while ((uio.uio_resid > 0) && (error == 0));
}
} while (error == 0);
_FREE(buf, M_TEMP);
return (error);
}
int
union_copyup(un, docopy, cred, p)
struct union_node *un;
int docopy;
struct ucred *cred;
struct proc *p;
{
int error;
struct vnode *lvp, *uvp;
error = union_vn_create(&uvp, un, p);
if (error)
return (error);
union_newupper(un, uvp);
un->un_flags |= UN_ULOCK;
lvp = un->un_lowervp;
if (docopy) {
vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p);
error = VOP_OPEN(lvp, FREAD, cred, p);
if (error == 0) {
error = union_copyfile(lvp, uvp, cred, p);
VOP_UNLOCK(lvp, 0, p);
(void) VOP_CLOSE(lvp, FREAD, cred, p);
}
#ifdef UNION_DIAGNOSTIC
if (error == 0)
uprintf("union: copied up %s\n", un->un_path);
#endif
}
un->un_flags &= ~UN_ULOCK;
VOP_UNLOCK(uvp, 0, p);
union_vn_close(uvp, FWRITE, cred, p);
vn_lock(uvp, LK_EXCLUSIVE | LK_RETRY, p);
un->un_flags |= UN_ULOCK;
if (error == 0) {
int i;
for (i = 0; i < un->un_openl; i++) {
(void) VOP_CLOSE(lvp, FREAD, cred, p);
(void) VOP_OPEN(uvp, FREAD, cred, p);
}
un->un_openl = 0;
}
return (error);
}
static int
union_relookup(um, dvp, vpp, cnp, cn, path, pathlen)
struct union_mount *um;
struct vnode *dvp;
struct vnode **vpp;
struct componentname *cnp;
struct componentname *cn;
char *path;
int pathlen;
{
int error;
cn->cn_namelen = pathlen;
cn->cn_pnbuf = _MALLOC_ZONE(cn->cn_namelen+1, M_NAMEI, M_WAITOK);
cn->cn_pnlen = cn->cn_namelen+1;
bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
cn->cn_pnbuf[cn->cn_namelen] = '\0';
cn->cn_nameiop = CREATE;
cn->cn_flags = (LOCKPARENT|HASBUF|SAVENAME|SAVESTART|ISLASTCN);
cn->cn_proc = cnp->cn_proc;
if (um->um_op == UNMNT_ABOVE)
cn->cn_cred = cnp->cn_cred;
else
cn->cn_cred = um->um_cred;
cn->cn_nameptr = cn->cn_pnbuf;
cn->cn_hash = cnp->cn_hash;
cn->cn_consume = cnp->cn_consume;
VREF(dvp);
error = relookup(dvp, vpp, cn);
if (!error)
vrele(dvp);
return (error);
}
int
union_mkshadow(um, dvp, cnp, vpp)
struct union_mount *um;
struct vnode *dvp;
struct componentname *cnp;
struct vnode **vpp;
{
int error;
struct vattr va;
struct proc *p = cnp->cn_proc;
struct componentname cn;
error = union_relookup(um, dvp, vpp, cnp, &cn,
cnp->cn_nameptr, cnp->cn_namelen);
if (error)
return (error);
if (*vpp) {
VOP_ABORTOP(dvp, &cn);
VOP_UNLOCK(dvp, 0, p);
vrele(*vpp);
*vpp = NULLVP;
return (EEXIST);
}
VATTR_NULL(&va);
va.va_type = VDIR;
va.va_mode = um->um_cmode;
VOP_LEASE(dvp, p, cn.cn_cred, LEASE_WRITE);
error = VOP_MKDIR(dvp, vpp, &cn, &va);
return (error);
}
int
union_mkwhiteout(um, dvp, cnp, path)
struct union_mount *um;
struct vnode *dvp;
struct componentname *cnp;
char *path;
{
int error;
struct vattr va;
struct proc *p = cnp->cn_proc;
struct vnode *wvp;
struct componentname cn;
VOP_UNLOCK(dvp, 0, p);
error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
if (error) {
vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
return (error);
}
if (wvp) {
VOP_ABORTOP(dvp, &cn);
vrele(dvp);
vrele(wvp);
return (EEXIST);
}
VOP_LEASE(dvp, p, p->p_ucred, LEASE_WRITE);
error = VOP_WHITEOUT(dvp, &cn, CREATE);
if (error)
VOP_ABORTOP(dvp, &cn);
vrele(dvp);
return (error);
}
int
union_vn_create(vpp, un, p)
struct vnode **vpp;
struct union_node *un;
struct proc *p;
{
struct vnode *vp;
struct ucred *cred = p->p_ucred;
struct vattr vat;
struct vattr *vap = &vat;
int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
int error;
int cmode = UN_FILEMODE & ~p->p_fd->fd_cmask;
char *cp;
struct componentname cn;
*vpp = NULLVP;
cn.cn_namelen = strlen(un->un_path);
cn.cn_pnbuf = (caddr_t) _MALLOC_ZONE(cn.cn_namelen+1,
M_NAMEI, M_WAITOK);
cn.cn_pnlen = cn.cn_namelen+1;
bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
cn.cn_nameiop = CREATE;
cn.cn_flags = (LOCKPARENT|HASBUF|SAVENAME|SAVESTART|ISLASTCN);
cn.cn_proc = p;
cn.cn_cred = p->p_ucred;
cn.cn_nameptr = cn.cn_pnbuf;
cn.cn_hash = un->un_hash;
cn.cn_consume = 0;
VREF(un->un_dirvp);
if (error = relookup(un->un_dirvp, &vp, &cn))
return (error);
vrele(un->un_dirvp);
if (vp) {
VOP_ABORTOP(un->un_dirvp, &cn);
if (un->un_dirvp == vp)
vrele(un->un_dirvp);
else
vput(un->un_dirvp);
vrele(vp);
return (EEXIST);
}
VATTR_NULL(vap);
vap->va_type = VREG;
vap->va_mode = cmode;
VOP_LEASE(un->un_dirvp, p, cred, LEASE_WRITE);
if (error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap))
return (error);
if (error = VOP_OPEN(vp, fmode, cred, p)) {
vput(vp);
return (error);
}
if (++vp->v_writecount <= 0)
panic("union: v_writecount");
*vpp = vp;
return (0);
}
int
union_vn_close(vp, fmode, cred, p)
struct vnode *vp;
int fmode;
struct ucred *cred;
struct proc *p;
{
if (fmode & FWRITE)
--vp->v_writecount;
return (VOP_CLOSE(vp, fmode, cred, p));
}
void
union_removed_upper(un)
struct union_node *un;
{
struct proc *p = current_proc();
union_newupper(un, NULLVP);
if (un->un_flags & UN_CACHED) {
un->un_flags &= ~UN_CACHED;
LIST_REMOVE(un, un_cache);
}
if (un->un_flags & UN_ULOCK) {
un->un_flags &= ~UN_ULOCK;
VOP_UNLOCK(un->un_uppervp, 0, p);
}
}
#if 0
struct vnode *
union_lowervp(vp)
struct vnode *vp;
{
struct union_node *un = VTOUNION(vp);
if ((un->un_lowervp != NULLVP) &&
(vp->v_type == un->un_lowervp->v_type)) {
if (vget(un->un_lowervp, 0, current_proc()) == 0)
return (un->un_lowervp);
}
return (NULLVP);
}
#endif
int
union_dowhiteout(un, cred, p)
struct union_node *un;
struct ucred *cred;
struct proc *p;
{
struct vattr va;
if (un->un_lowervp != NULLVP)
return (1);
if (VOP_GETATTR(un->un_uppervp, &va, cred, p) == 0 &&
(va.va_flags & OPAQUE))
return (1);
return (0);
}
static void
union_dircache_r(vp, vppp, cntp)
struct vnode *vp;
struct vnode ***vppp;
int *cntp;
{
struct union_node *un;
if (vp->v_op != union_vnodeop_p) {
if (vppp) {
VREF(vp);
*(*vppp)++ = vp;
if (--(*cntp) == 0)
panic("union: dircache table too small");
} else {
(*cntp)++;
}
return;
}
un = VTOUNION(vp);
if (un->un_uppervp != NULLVP)
union_dircache_r(un->un_uppervp, vppp, cntp);
if (un->un_lowervp != NULLVP)
union_dircache_r(un->un_lowervp, vppp, cntp);
}
struct vnode *
union_dircache(vp, p)
struct vnode *vp;
struct proc *p;
{
int cnt;
struct vnode *nvp;
struct vnode **vpp;
struct vnode **dircache;
struct union_node *un;
int error;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
dircache = VTOUNION(vp)->un_dircache;
nvp = NULLVP;
if (dircache == 0) {
cnt = 0;
union_dircache_r(vp, 0, &cnt);
cnt++;
dircache = (struct vnode **)
_MALLOC(cnt * sizeof(struct vnode *),
M_TEMP, M_WAITOK);
vpp = dircache;
union_dircache_r(vp, &vpp, &cnt);
*vpp = NULLVP;
vpp = dircache + 1;
} else {
vpp = dircache;
do {
if (*vpp++ == VTOUNION(vp)->un_uppervp)
break;
} while (*vpp != NULLVP);
}
if (*vpp == NULLVP)
goto out;
vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p);
VREF(*vpp);
error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, 0, *vpp, NULLVP, 0);
if (error)
goto out;
VTOUNION(vp)->un_dircache = 0;
un = VTOUNION(nvp);
un->un_dircache = dircache;
out:
VOP_UNLOCK(vp, 0, p);
return (nvp);
}