mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-24 11:29:10 +00:00
- Remove UMAP filesystem. It was disconnected from build three years ago,
and it is seriously broken. Discussed on: freebsd-arch@ Approved by: re (mux)
This commit is contained in:
Rong-En Fan
parent
b038594e17
commit
534046e301
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=171023
@ -14,6 +14,12 @@
|
||||
# The file is partitioned: OLD_FILES first, then OLD_LIBS and OLD_DIRS last.
|
||||
#
|
||||
|
||||
# 20070625: umapfs removal
|
||||
OLD_FILES+=rescue/mount_umapfs
|
||||
OLD_FILES+=sbin/mount_umapfs
|
||||
OLD_FILES+=usr/include/fs/umapfs/umap.h
|
||||
OLD_FILES+=usr/share/man/man8/mount_umapfs.8.gz
|
||||
OLD_DIRS+=usr/include/fs/umapfs
|
||||
# 20070618: shared library version bump
|
||||
OLD_LIBS+=lib/libalias.so.5
|
||||
OLD_LIBS+=lib/libbsnmp.so.3
|
||||
|
||||
@ -146,8 +146,6 @@
|
||||
..
|
||||
udf
|
||||
..
|
||||
umapfs
|
||||
..
|
||||
unionfs
|
||||
..
|
||||
..
|
||||
|
||||
@ -43,8 +43,7 @@ LSUBDIRS= cam/scsi \
|
||||
dev/ic dev/iicbus ${_dev_ieee488} dev/lmc dev/ofw \
|
||||
dev/pbio ${_dev_powermac_nvram} dev/ppbus dev/smbus dev/speaker dev/usb dev/utopia dev/vkbd dev/wi \
|
||||
fs/devfs fs/fdescfs fs/fifofs fs/msdosfs fs/ntfs fs/nullfs \
|
||||
${_fs_nwfs} fs/portalfs fs/procfs fs/smbfs fs/udf fs/umapfs \
|
||||
fs/unionfs \
|
||||
${_fs_nwfs} fs/portalfs fs/procfs fs/smbfs fs/udf fs/unionfs \
|
||||
geom/cache geom/concat geom/eli geom/gate geom/journal geom/label \
|
||||
geom/mirror geom/nop geom/raid3 geom/shsec geom/stripe \
|
||||
netatm/ipatm netatm/sigpvc netatm/spans netatm/uni \
|
||||
|
||||
@ -113,7 +113,7 @@ CRUNCH_PROGS_sbin= atacontrol badsect bsdlabel \
|
||||
kldconfig kldload kldstat kldunload ldconfig \
|
||||
md5 mdconfig mdmfs mknod mount mount_cd9660 \
|
||||
mount_msdosfs mount_nfs mount_ntfs mount_nullfs \
|
||||
mount_udf mount_umapfs mount_unionfs newfs \
|
||||
mount_udf mount_unionfs newfs \
|
||||
newfs_msdos nos-tun ping reboot \
|
||||
restore rcorder route routed rtquery rtsol savecore \
|
||||
slattach spppcontrol startslip swapon sysctl tunefs umount
|
||||
|
||||
@ -59,7 +59,6 @@ SUBDIR= adjkerntz \
|
||||
mount_ntfs \
|
||||
mount_nullfs \
|
||||
mount_udf \
|
||||
mount_umapfs \
|
||||
mount_unionfs \
|
||||
natd \
|
||||
newfs \
|
||||
|
||||
@ -420,7 +420,6 @@ However, for the following file system types:
|
||||
.Cm portalfs ,
|
||||
.Cm smbfs ,
|
||||
.Cm udf ,
|
||||
.Cm umapfs ,
|
||||
and
|
||||
.Cm unionfs ,
|
||||
.Nm
|
||||
@ -513,7 +512,6 @@ support for a particular file system might be provided either on a static
|
||||
.Xr mount_smbfs 8 ,
|
||||
.Xr mount_std 8 ,
|
||||
.Xr mount_udf 8 ,
|
||||
.Xr mount_umapfs 8 ,
|
||||
.Xr mount_unionfs 8 ,
|
||||
.Xr umount 8
|
||||
.Sh CAVEATS
|
||||
|
||||
@ -135,8 +135,7 @@ use_mountprog(const char *vfstype)
|
||||
unsigned int i;
|
||||
const char *fs[] = {
|
||||
"cd9660", "mfs", "msdosfs", "nfs", "nfs4", "ntfs",
|
||||
"nwfs", "nullfs", "portalfs", "smbfs", "udf", "umapfs",
|
||||
"unionfs",
|
||||
"nwfs", "nullfs", "portalfs", "smbfs", "udf", "unionfs",
|
||||
NULL
|
||||
};
|
||||
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
# @(#)Makefile 8.3 (Berkeley) 3/27/94
|
||||
# $FreeBSD$
|
||||
|
||||
PROG= mount_umapfs
|
||||
SRCS= mount_umapfs.c getmntopts.c
|
||||
MAN= mount_umapfs.8
|
||||
|
||||
MOUNT= ${.CURDIR}/../mount
|
||||
CFLAGS+=-I${MOUNT}
|
||||
WARNS?= 0
|
||||
|
||||
.PATH: ${MOUNT}
|
||||
|
||||
.include <bsd.prog.mk>
|
||||
@ -1,146 +0,0 @@
|
||||
.\" Copyright (c) 1992, 1993, 1994
|
||||
.\" The Regents of the University of California. All rights reserved.
|
||||
.\" All rights reserved.
|
||||
.\"
|
||||
.\" This code is derived from software donated to Berkeley by
|
||||
.\" Jan-Simon Pendry and from John Heidemann of the UCLA Ficus project.
|
||||
.\"
|
||||
.\" Redistribution and use in source and binary forms, with or without
|
||||
.\" modification, are permitted provided that the following conditions
|
||||
.\" are met:
|
||||
.\" 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.
|
||||
.\" 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
|
||||
.\" SUCH DAMAGE.
|
||||
.\"
|
||||
.\" @(#)mount_umap.8 8.4 (Berkeley) 5/1/95
|
||||
.\" $FreeBSD$
|
||||
.\"
|
||||
.Dd May 1, 1995
|
||||
.Dt MOUNT_UMAPFS 8
|
||||
.Os
|
||||
.Sh NAME
|
||||
.Nm mount_umapfs
|
||||
.Nd sample file system layer
|
||||
.Sh SYNOPSIS
|
||||
.Nm
|
||||
.Op Fl o Ar options
|
||||
.Fl u Ar uid-mapfile
|
||||
.Fl g Ar gid-mapfile
|
||||
.Ar target
|
||||
.Ar mount-point
|
||||
.Sh DESCRIPTION
|
||||
The
|
||||
.Nm
|
||||
utility is used to mount a sub-tree of an existing file system
|
||||
that uses a different set of uids and gids than the local system.
|
||||
Such a file system could be mounted from a remote site via NFS or
|
||||
it could be a file system on removable media brought from some
|
||||
foreign location that uses a different password file.
|
||||
.Pp
|
||||
The
|
||||
.Nm
|
||||
utility uses a set of files provided by the user to make correspondences
|
||||
between uids and gids in the sub-tree's original environment and
|
||||
some other set of ids in the local environment.
|
||||
For instance, user
|
||||
smith might have uid 1000 in the original environment, while having
|
||||
uid 2000 in the local environment.
|
||||
The
|
||||
.Nm
|
||||
utility allows the subtree from smith's original environment to be
|
||||
mapped in such a way that all files with owning uid 1000 look like
|
||||
they are actually owned by uid 2000.
|
||||
.Pp
|
||||
The options are as follows:
|
||||
.Bl -tag -width indent
|
||||
.It Fl o
|
||||
Options are specified with a
|
||||
.Fl o
|
||||
flag followed by a comma separated string of options.
|
||||
See the
|
||||
.Xr mount 8
|
||||
man page for possible options and their meanings.
|
||||
.It Ar target
|
||||
Should be the current location of the sub-tree in the
|
||||
local system's name space.
|
||||
.It Ar mount-point
|
||||
Should be a directory
|
||||
where the mapped subtree is to be placed.
|
||||
.It Fl u Ar uid-mapfile
|
||||
.It Fl g Ar gid-mapfile
|
||||
Describe the mappings to be made between identifiers.
|
||||
Briefly, the format of these files is a count of the number of
|
||||
mappings on the first line, with each subsequent line containing
|
||||
a single mapping.
|
||||
Each of these mappings consists of an id in
|
||||
the local environment and the corresponding id from the original environment,
|
||||
separated by white space.
|
||||
.Ar Uid-mapfile
|
||||
should contain all uid
|
||||
mappings, and
|
||||
.Ar gid-mapfile
|
||||
should contain all gid mappings.
|
||||
Any uids not mapped in
|
||||
.Ar uid-mapfile
|
||||
will be treated as user NOBODY,
|
||||
and any gids not mapped in
|
||||
.Ar gid-mapfile
|
||||
will be treated as group
|
||||
NULLGROUP.
|
||||
At most 64 uids can be mapped for a given subtree, and
|
||||
at most 16 groups can be mapped by a given subtree.
|
||||
.El
|
||||
.Pp
|
||||
The mapfiles can be located anywhere in the file hierarchy, but they
|
||||
must be owned by root, and they must be writable only by root.
|
||||
The
|
||||
.Nm
|
||||
utility will refuse to map the sub-tree if the ownership or permissions on
|
||||
these files are improper.
|
||||
It will also balk if the count of mappings
|
||||
in the first line of the map files is not correct.
|
||||
.Pp
|
||||
The layer created by the
|
||||
.Nm
|
||||
utility is meant to serve as a simple example of file system layering.
|
||||
It is not meant for production use.
|
||||
The implementation is not very
|
||||
sophisticated.
|
||||
.Sh SEE ALSO
|
||||
.Xr mount 8 ,
|
||||
.Xr mount_nullfs 8
|
||||
.Sh HISTORY
|
||||
The
|
||||
.Nm
|
||||
utility first appeared in
|
||||
.Bx 4.4 .
|
||||
.Sh BUGS
|
||||
THIS FILE SYSTEM TYPE IS NOT YET FULLY SUPPORTED (READ: IT DOESN'T WORK)
|
||||
AND USING IT MAY, IN FACT, DESTROY DATA ON YOUR SYSTEM.
|
||||
USE AT YOUR
|
||||
OWN RISK.
|
||||
BEWARE OF DOG.
|
||||
SLIPPERY WHEN WET.
|
||||
.Pp
|
||||
This code also needs an owner in order to be less dangerous - serious
|
||||
hackers can apply by sending mail to
|
||||
.Aq hackers@FreeBSD.org
|
||||
and announcing
|
||||
their intent to take it over.
|
||||
@ -1,235 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1992, 1993, 1994
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software donated to Berkeley by
|
||||
* Jan-Simon Pendry.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 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.
|
||||
* 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
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char copyright[] =
|
||||
"@(#) Copyright (c) 1992, 1993, 1994\n\
|
||||
The Regents of the University of California. All rights reserved.\n";
|
||||
#endif /* not lint */
|
||||
|
||||
#ifndef lint
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)mount_umap.c 8.5 (Berkeley) 4/26/95";
|
||||
#endif
|
||||
static const char rcsid[] =
|
||||
"$FreeBSD$";
|
||||
#endif /* not lint */
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <fs/umapfs/umap.h>
|
||||
|
||||
#include <err.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sysexits.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "mntopts.h"
|
||||
|
||||
#define ROOTUSER 0
|
||||
/*
|
||||
* This define controls whether any user but the superuser can own and
|
||||
* write mapfiles. If other users can, system security can be gravely
|
||||
* compromised. If this is not a concern, undefine SECURITY.
|
||||
*/
|
||||
#define MAPSECURITY 1
|
||||
|
||||
/*
|
||||
* This routine provides the user interface to mounting a umap layer.
|
||||
* It takes 4 mandatory parameters. The mandatory arguments are the place
|
||||
* where the next lower level is mounted, the place where the umap layer is to
|
||||
* be mounted, the name of the user mapfile, and the name of the group
|
||||
* mapfile. The routine checks the ownerships and permissions on the
|
||||
* mapfiles, then opens and reads them. Then it calls mount(), which
|
||||
* will, in turn, call the umap version of mount.
|
||||
*/
|
||||
|
||||
static struct mntopt mopts[] = {
|
||||
MOPT_STDOPTS,
|
||||
MOPT_END
|
||||
};
|
||||
|
||||
static void usage(void) __dead2;
|
||||
|
||||
int
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
static char not[] = "; not mounted";
|
||||
struct stat statbuf;
|
||||
struct umap_args args;
|
||||
FILE *fp, *gfp;
|
||||
u_long gmapdata[GMAPFILEENTRIES][2], mapdata[MAPFILEENTRIES][2];
|
||||
int ch, count, gnentries, mntflags, nentries;
|
||||
char *gmapfile, *mapfile, buf[20];
|
||||
char source[MAXPATHLEN], target[MAXPATHLEN];
|
||||
|
||||
mntflags = 0;
|
||||
mapfile = gmapfile = NULL;
|
||||
while ((ch = getopt(argc, argv, "g:o:u:")) != -1)
|
||||
switch (ch) {
|
||||
case 'g':
|
||||
gmapfile = optarg;
|
||||
break;
|
||||
case 'o':
|
||||
getmntopts(optarg, mopts, &mntflags, 0);
|
||||
break;
|
||||
case 'u':
|
||||
mapfile = optarg;
|
||||
break;
|
||||
case '?':
|
||||
default:
|
||||
usage();
|
||||
}
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
|
||||
if (argc != 2 || mapfile == NULL || gmapfile == NULL)
|
||||
usage();
|
||||
|
||||
/* resolve both target and source with realpath(3) */
|
||||
(void)checkpath(argv[0], source);
|
||||
(void)checkpath(argv[1], target);
|
||||
|
||||
/* Read in uid mapping data. */
|
||||
if ((fp = fopen(mapfile, "r")) == NULL)
|
||||
err(EX_NOINPUT, "%s%s", mapfile, not);
|
||||
|
||||
#ifdef MAPSECURITY
|
||||
/*
|
||||
* Check that group and other don't have write permissions on
|
||||
* this mapfile, and that the mapfile belongs to root.
|
||||
*/
|
||||
if (fstat(fileno(fp), &statbuf))
|
||||
err(EX_OSERR, "%s%s", mapfile, not);
|
||||
if (statbuf.st_mode & S_IWGRP || statbuf.st_mode & S_IWOTH) {
|
||||
strmode(statbuf.st_mode, buf);
|
||||
err(EX_NOPERM, "%s: improper write permissions (%s)%s",
|
||||
mapfile, buf, not);
|
||||
}
|
||||
if (statbuf.st_uid != ROOTUSER)
|
||||
errx(EX_NOPERM, "%s does not belong to root%s", mapfile, not);
|
||||
#endif /* MAPSECURITY */
|
||||
|
||||
if ((fscanf(fp, "%d\n", &nentries)) != 1)
|
||||
errx(EX_DATAERR, "%s: nentries not found%s", mapfile, not);
|
||||
if (nentries > MAPFILEENTRIES)
|
||||
errx(EX_DATAERR,
|
||||
"maximum number of entries is %d%s", MAPFILEENTRIES, not);
|
||||
#if 0
|
||||
(void)printf("reading %d entries\n", nentries);
|
||||
#endif
|
||||
for (count = 0; count < nentries; ++count) {
|
||||
if ((fscanf(fp, "%lu %lu\n",
|
||||
&(mapdata[count][0]), &(mapdata[count][1]))) != 2) {
|
||||
if (ferror(fp))
|
||||
err(EX_OSERR, "%s%s", mapfile, not);
|
||||
if (feof(fp))
|
||||
errx(EX_DATAERR, "%s: unexpected end-of-file%s",
|
||||
mapfile, not);
|
||||
errx(EX_DATAERR, "%s: illegal format (line %d)%s",
|
||||
mapfile, count + 2, not);
|
||||
}
|
||||
#if 0
|
||||
/* Fix a security hole. */
|
||||
if (mapdata[count][1] == 0)
|
||||
errx(1, "mapping id 0 not permitted (line %d)%s",
|
||||
count + 2, not);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Read in gid mapping data. */
|
||||
if ((gfp = fopen(gmapfile, "r")) == NULL)
|
||||
err(EX_NOINPUT, "%s%s", gmapfile, not);
|
||||
|
||||
#ifdef MAPSECURITY
|
||||
/*
|
||||
* Check that group and other don't have write permissions on
|
||||
* this group mapfile, and that the file belongs to root.
|
||||
*/
|
||||
if (fstat(fileno(gfp), &statbuf))
|
||||
err(EX_OSERR, "%s%s", gmapfile, not);
|
||||
if (statbuf.st_mode & S_IWGRP || statbuf.st_mode & S_IWOTH) {
|
||||
strmode(statbuf.st_mode, buf);
|
||||
err(EX_NOPERM, "%s: improper write permissions (%s)%s",
|
||||
gmapfile, buf, not);
|
||||
}
|
||||
if (statbuf.st_uid != ROOTUSER)
|
||||
errx(EX_NOPERM, "%s does not belong to root%s", gmapfile, not);
|
||||
#endif /* MAPSECURITY */
|
||||
|
||||
if ((fscanf(gfp, "%d\n", &gnentries)) != 1)
|
||||
errx(EX_DATAERR, "%s: nentries not found%s", gmapfile, not);
|
||||
if (gnentries > MAPFILEENTRIES)
|
||||
errx(EX_DATAERR,
|
||||
"maximum number of entries is %d%s", GMAPFILEENTRIES, not);
|
||||
#if 0
|
||||
(void)printf("reading %d group entries\n", gnentries);
|
||||
#endif
|
||||
|
||||
for (count = 0; count < gnentries; ++count)
|
||||
if ((fscanf(gfp, "%lu %lu\n",
|
||||
&(gmapdata[count][0]), &(gmapdata[count][1]))) != 2) {
|
||||
if (ferror(gfp))
|
||||
err(EX_OSERR, "%s%s", gmapfile, not);
|
||||
if (feof(gfp))
|
||||
errx(EX_DATAERR, "%s: unexpected end-of-file%s",
|
||||
gmapfile, not);
|
||||
errx(EX_DATAERR, "%s: illegal format (line %d)%s",
|
||||
gmapfile, count + 2, not);
|
||||
}
|
||||
|
||||
|
||||
/* Setup mount call args. */
|
||||
args.target = source;
|
||||
args.nentries = nentries;
|
||||
args.mapdata = mapdata;
|
||||
args.gnentries = gnentries;
|
||||
args.gmapdata = gmapdata;
|
||||
|
||||
if (mount("umapfs", argv[1], mntflags, &args))
|
||||
err(1, NULL);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void
|
||||
usage()
|
||||
{
|
||||
(void)fprintf(stderr,
|
||||
"usage: mount_umapfs [-o options] -u uid-mapfile -g gid-mapfile target mount-point\n");
|
||||
exit(EX_USAGE);
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
1
|
||||
1200 1200
|
||||
@ -1,3 +0,0 @@
|
||||
2
|
||||
5217 5217
|
||||
3 3
|
||||
@ -1,175 +0,0 @@
|
||||
|
||||
\appendix
|
||||
\section{The umap Layer} \label{sect:umap}
|
||||
|
||||
\subsection{Introduction}
|
||||
|
||||
Normally, the file system is expected to span a single administrative domain.
|
||||
An administrative domain, for these purposes, is a machine or set of
|
||||
machines that share common password file information, usually through
|
||||
the yellow pages mechanism. File hierarchies that span more
|
||||
than one domain leads to certain problems, since the same numerical
|
||||
UID in one domain may correspond to a different user in another domain.
|
||||
If the system administrator is very careful to ensure that both domains
|
||||
contain identical user ID information, the umap layer can be used to
|
||||
run between those domains without changes
|
||||
|
||||
The umap layer is a file system layer that sits on top of the normal
|
||||
file layer. The umap layer maps Unix-style UIDs from
|
||||
one domain into the UIDs in the other domain. By setting up the mappings
|
||||
properly, the same user with different UIDs in two domains can be seen
|
||||
as the same user, from the system point of view, or, conversely, two
|
||||
different users with the same UID in the two domains can be distinguished.
|
||||
|
||||
First, we define some terms. ``User'' refers to the human (or daemon) that
|
||||
has privileges to login, run programs, and access files. ``UID''refers to
|
||||
the numerical identifier that uniquely identifies the user within a
|
||||
single domain. ``Login name'' refers to the character string the user
|
||||
types to log into the system. ``GID'' refers to the numerical group
|
||||
identifier used by Unix systems to identify groups of users. ``Group
|
||||
name'' is the character string name attached to a particular GID in the
|
||||
local {\sf /etc/groups} file or the yellow pages groups file.
|
||||
|
||||
In order for the umap layer to work properly, all users
|
||||
in either domain must have password file entries in both domains.
|
||||
They do not, however, have to have the same numerical UID, nor even the
|
||||
same character string login name (the latter is highly recommended,
|
||||
if possible, however). Any user not having a UID in one domain will be
|
||||
treated as the special user NOBODY by the other domain, probably with
|
||||
undesirable consequences. Any user not owning any files in the shared
|
||||
sub-trees need not be given a UID in the other domain.
|
||||
|
||||
Groups work similarly. The umap layer can translate group ID's between
|
||||
domains in the same manner as UID's. Again, any group that wishes to
|
||||
participate must have a group ID in both domains,
|
||||
though it need not be the same GID in both. If a group in one domain is not
|
||||
known in the other domain, that group will be treated as being NULLGROUP.
|
||||
The umap layer has no provisions for enrolling UID's from other domains
|
||||
as group members, but, since each user from each domain must have some
|
||||
UID in every domain, the UID in the local domain can be used to enroll
|
||||
the user in the local groups.
|
||||
|
||||
NOBODY and NULLGROUP are special reserved UID's and GID's, respectively.
|
||||
NOBODY is user 32767. NULLGROUP is group 65534. If the system administrator
|
||||
wants to have an appropriate text string appear when these UID's are
|
||||
encountered by programs like {\sf ls -l}, he should add these values to
|
||||
the password and {\sf /etc/groups} file, or to the appropriate yellow pages.
|
||||
If these IDs are already in use in that domain, different values can be
|
||||
used for NOBODY and NULLGROUP, but that will require a recompilation of
|
||||
the umap layer code and, as a result, the entire kernel. These
|
||||
values are defined in the {\sf umap\_info.h} file, kept with the rest of the
|
||||
umap source code.
|
||||
|
||||
When the umap layer is in use, one of the participating domains is declared
|
||||
to be the master. All UID and GID information stored for participating files
|
||||
will be stored in vnodes using its mappings, no matter what site the copies of
|
||||
the files are stored at. The master domain therefore need not run a copy
|
||||
of the umap layer, as it already has all of the correct mappings. All
|
||||
other domains must run a umap layer on top of any other layers they use.
|
||||
|
||||
\subsection{Setting Up a umap Layer}
|
||||
|
||||
The system administrator of a system needing to use the umap layer
|
||||
must take several actions.
|
||||
First, he must create files containing the necessary UID
|
||||
and GID mappings. There is a separate file for user and group IDs. The
|
||||
format of the files is the same. The first line contains the total number
|
||||
of entries in the file. Each subsequent line contains one mapping. A
|
||||
mapping line consists of two numerical UIDs, separated by white space.
|
||||
The first is the UID of a user on the local machine. The second is the
|
||||
UID for the same user on the master machine. The maximum number of users
|
||||
that can be mapped for a single shared sub-tree is 64. The maximum number of
|
||||
groups that can be mapped for a single sub-tree is 16. These constants
|
||||
are set in the {\sf umap\_info.h} file, and can be changed, but changing them
|
||||
requires recompilation. Separate mapping files can be used for each shared
|
||||
subtree, or the same mapping files can be shared by several sub-trees.
|
||||
|
||||
Below is a sample UID mapping file. There are four entries. UID 5 is mapped
|
||||
to 5, 521 to 521, and 7000 to 7000. UID 2002 is mapped to 604. On this
|
||||
machine, the UID's for users 5, 521, and 7000 are the same as on the master,
|
||||
but UID 2002 is for a user whose UID on the master machine is 604. All
|
||||
files in the sub-tree belonging to that user have UID 604 in their inodes,
|
||||
even on this machine, but the umap layer will ensure that anyone running
|
||||
under UID 2002 will have all files in this sub-tree owned by 604 treated as if
|
||||
they were owned by 2002. An {\sf ls -l} on a file owned by 604 in this sub-tree
|
||||
will show the login name associated with UID 2002 as the owner.
|
||||
|
||||
\noindent4\newline
|
||||
5 5\newline
|
||||
521 521\newline
|
||||
2002 604\newline
|
||||
7000 7000\newline
|
||||
|
||||
The user and group mapping files should be owned by the root user, and
|
||||
should be writable only by that user. If they are not owned by root, or
|
||||
are writable by some other user, the umap mounting command will abort.
|
||||
|
||||
Normally, the sub-tree is grafted directly into the place in
|
||||
the file hierarchy where the it should appear to users. Using the umap
|
||||
layer requires that the sub-tree be grafted somewhere else, and
|
||||
the umap layer be mounted in the desired position in the file hierarchy.
|
||||
Depending on the situation, the underlying sub-tree can be wherever is
|
||||
convenient.
|
||||
|
||||
\subsection{Troubleshooting umap Layer Problems}
|
||||
|
||||
The umap layer code was not built with special convenience or
|
||||
robustness in mind, as it is expected to be superseded with a better
|
||||
user ID mapping strategy in the near future. As a result, it is not
|
||||
very forgiving of errors in being set up. Here are some possible
|
||||
problems, and what to do about them.
|
||||
|
||||
\begin{itemize}
|
||||
|
||||
|
||||
\item{Problem: A file belongs to NOBODY, or group NULLGROUP.
|
||||
|
||||
Fixes: The mapping files don't know about this file's real user or group.
|
||||
Either they are not in the mapping files, or the counts on the number of
|
||||
entries in the mapping files are too low, so entries at the end (including
|
||||
these) are being ignored. Add the entries or fix the counts, and either
|
||||
unmount and remount the sub-tree, or reboot.}
|
||||
|
||||
\item{Problem: A normal operation does not work.
|
||||
|
||||
Fixes: Possibly, some mapping has not been set properly. Check to
|
||||
see which files are used by the operation and who they appear to be
|
||||
owned by. If they are owned by NOBODY or some other suspicious user,
|
||||
there may be a problem in the mapping files. Be sure to check groups,
|
||||
too. As above, if the counts of mappings in the mapping files are lower
|
||||
than the actual numbers of pairs, pairs at the end of the file will be
|
||||
ignored. If any changes are made in the mapping files, you will need to
|
||||
either unmount and remount or reboot before they will take effect.
|
||||
|
||||
Another possible problem can arise because not all Unix utilities
|
||||
rely exclusively on numeric UID for identification. For instance,
|
||||
SCCS saves the login name in files. If a user's login name on two machines
|
||||
isn't the same, SCCS may veto an operation even though Unix file permissions,
|
||||
as checked by the umap layer, may say it's OK. There's not much to be
|
||||
done in such cases, unless the login name can be changed or one fiddles
|
||||
improperly with SCCS information. There may be other, undiscovered cases
|
||||
where similar problems arise, some of which may be even harder to handle.}
|
||||
|
||||
\item{Problem: Someone has access permissions he should not have.
|
||||
|
||||
Fixes: This is probably caused by a mistake in the mapping files. Check
|
||||
both user and group mapping files. If any changes are made in the mapping
|
||||
files, you will need to unmount and remount the sub-tree or reboot before they
|
||||
will take effect.}
|
||||
|
||||
\item{Problem: {\sf ls -l} (or a similar program) shows the wrong user for a file.
|
||||
|
||||
Fixes: Probably a mistake in the mapping files. In particular, if
|
||||
two local UIDs are mapped to a single master UID, stat calls will assign
|
||||
ownership to the first local UID occurring in the file, which may or may
|
||||
not be what was intended. (Generally speaking, mapping two local UIDs to
|
||||
a single master UID is a bad idea, but the software will not prevent it.
|
||||
Similarly, mapping a single local UID to two master UIDs is a bad idea,
|
||||
but will not be prevented. In this case, only the first mapping of the
|
||||
local UID will be done. The second, and all subsequent ones, will be
|
||||
ignored.) If any changes are made in the mapping files, you will need to
|
||||
unmount and remount the sub-tree or reboot before they will take effect.}
|
||||
|
||||
\end{itemize}
|
||||
|
||||
\end{document}
|
||||
@ -268,8 +268,6 @@ process file system
|
||||
SMB/CIFS file system
|
||||
.It Pa udf/
|
||||
UDF file system
|
||||
.It Pa umapfs/
|
||||
alternate uid/gid mappings file system
|
||||
.It Pa unionfs
|
||||
union file system
|
||||
.El
|
||||
|
||||
@ -135,7 +135,6 @@ nullfs_load="NO" # Null filesystem
|
||||
portalfs_load="NO" # Portal filesystem
|
||||
procfs_load="NO" # Process filesystem
|
||||
reiserfs_load="NO" # ReiserFS
|
||||
#umapfs_load="NO" # User-id map filesystem
|
||||
unionfs_load="NO" # Union filesystem
|
||||
xfs_load="NO" # XFS
|
||||
zfs_load="NO" # ZFS
|
||||
|
||||
@ -938,12 +938,12 @@ device harp #Pseudo-interface for NATM
|
||||
# currently be demand-loaded.) Some people still prefer to statically
|
||||
# compile other filesystems as well.
|
||||
#
|
||||
# NB: The PORTAL and UMAP filesystems are known to be buggy, and WILL
|
||||
# panic your system if you attempt to do anything with them. They are
|
||||
# included here as an incentive for some enterprising soul to sit down
|
||||
# and fix them. The UNION filesystem was known to be buggy in the past.
|
||||
# It is now being actively maintained, although there are still some
|
||||
# issues being resolved.
|
||||
# NB: The PORTAL filesystem is known to be buggy, and WILL panic your
|
||||
# system if you attempt to do anything with it. It is included here
|
||||
# as an incentive for some enterprising soul to sit down and fix it.
|
||||
# The UNION filesystem was known to be buggy in the past. It is now
|
||||
# being actively maintained, although there are still some issues being
|
||||
# resolved.
|
||||
#
|
||||
|
||||
# One of these is mandatory:
|
||||
@ -966,8 +966,6 @@ options PSEUDOFS #Pseudo-filesystem framework
|
||||
options PSEUDOFS_TRACE #Debugging support for PSEUDOFS
|
||||
options SMBFS #SMB/CIFS filesystem
|
||||
options UDF #Universal Disk Format
|
||||
# Broken (seriously (functionally) broken):
|
||||
#options UMAPFS #UID map filesystem
|
||||
options UNIONFS #Union filesystem
|
||||
# The xFS_ROOT options REQUIRE the associated ``options xFS''
|
||||
options NFS_ROOT #NFS usable as root device
|
||||
|
||||
@ -1199,9 +1199,6 @@ fs/udf/osta.c optional udf
|
||||
fs/udf/udf_iconv.c optional udf_iconv
|
||||
fs/udf/udf_vfsops.c optional udf
|
||||
fs/udf/udf_vnops.c optional udf
|
||||
fs/umapfs/umap_subr.c optional umapfs
|
||||
fs/umapfs/umap_vfsops.c optional umapfs
|
||||
fs/umapfs/umap_vnops.c optional umapfs
|
||||
fs/unionfs/union_subr.c optional unionfs
|
||||
fs/unionfs/union_vfsops.c optional unionfs
|
||||
fs/unionfs/union_vnops.c optional unionfs
|
||||
|
||||
@ -198,7 +198,6 @@ REISERFS opt_dontuse.h
|
||||
SMBFS opt_dontuse.h
|
||||
TMPFS opt_dontuse.h
|
||||
UDF opt_dontuse.h
|
||||
UMAPFS opt_dontuse.h
|
||||
UNIONFS opt_dontuse.h
|
||||
|
||||
# Pseudofs debugging
|
||||
|
||||
@ -1,86 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software donated to Berkeley by
|
||||
* the UCLA Ficus project.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 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.
|
||||
* 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
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)umap.h 8.4 (Berkeley) 8/20/94
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#define MAPFILEENTRIES 64
|
||||
#define GMAPFILEENTRIES 16
|
||||
#define NOBODY 32767
|
||||
#define NULLGROUP 65534
|
||||
|
||||
struct umap_args {
|
||||
char *target; /* Target of loopback */
|
||||
int nentries; /* # of entries in user map array */
|
||||
int gnentries; /* # of entries in group map array */
|
||||
u_long (*mapdata)[2]; /* pointer to array of user mappings */
|
||||
u_long (*gmapdata)[2]; /* pointer to array of group mappings */
|
||||
};
|
||||
|
||||
struct umap_mount {
|
||||
struct mount *umapm_vfs;
|
||||
struct vnode *umapm_rootvp; /* Reference to root umap_node */
|
||||
int info_nentries; /* number of uid mappings */
|
||||
int info_gnentries; /* number of gid mappings */
|
||||
u_long info_mapdata[MAPFILEENTRIES][2]; /* mapping data for
|
||||
user mapping in ficus */
|
||||
u_long info_gmapdata[GMAPFILEENTRIES][2]; /*mapping data for
|
||||
group mapping in ficus */
|
||||
};
|
||||
|
||||
#ifdef _KERNEL
|
||||
/*
|
||||
* A cache of vnode references
|
||||
*/
|
||||
struct umap_node {
|
||||
LIST_ENTRY(umap_node) umap_hash; /* Hash list */
|
||||
struct vnode *umap_lowervp; /* Aliased vnode - VREFed once */
|
||||
struct vnode *umap_vnode; /* Back pointer to vnode/umap_node */
|
||||
};
|
||||
|
||||
extern int umapfs_init(struct vfsconf *vfsp);
|
||||
extern int umap_node_create(struct mount *mp, struct vnode *target, struct vnode **vpp);
|
||||
extern u_long umap_reverse_findid(u_long id, u_long map[][2], int nentries);
|
||||
extern void umap_mapids(struct mount *v_mount, struct ucred *credp);
|
||||
|
||||
#define MOUNTTOUMAPMOUNT(mp) ((struct umap_mount *)((mp)->mnt_data))
|
||||
#define VTOUMAP(vp) ((struct umap_node *)(vp)->v_data)
|
||||
#define UMAPTOV(xp) ((xp)->umap_vnode)
|
||||
#ifdef DIAGNOSTIC
|
||||
extern struct vnode *umap_checkvp(struct vnode *vp, char *fil, int lno);
|
||||
#define UMAPVPTOLOWERVP(vp) umap_checkvp((vp), __FILE__, __LINE__)
|
||||
#else
|
||||
#define UMAPVPTOLOWERVP(vp) (VTOUMAP(vp)->umap_lowervp)
|
||||
#endif
|
||||
|
||||
#endif /* _KERNEL */
|
||||
@ -1,409 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993, 1995
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software donated to Berkeley by
|
||||
* Jan-Simon Pendry.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 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.
|
||||
* 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
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)umap_subr.c 8.9 (Berkeley) 5/14/95
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/vnode.h>
|
||||
|
||||
#include <fs/umapfs/umap.h>
|
||||
|
||||
#define LOG2_SIZEVNODE 7 /* log2(sizeof struct vnode) */
|
||||
#define NUMAPNODECACHE 16
|
||||
|
||||
/*
|
||||
* Null layer cache:
|
||||
* Each cache entry holds a reference to the target vnode
|
||||
* along with a pointer to the alias vnode. When an
|
||||
* entry is added the target vnode is VREF'd. When the
|
||||
* alias is removed the target vnode is vrele'd.
|
||||
*/
|
||||
|
||||
#define UMAP_NHASH(vp) \
|
||||
(&umap_node_hashtbl \
|
||||
[((uintptr_t)(void *)(vp) >> LOG2_SIZEVNODE) & umap_node_hash])
|
||||
static LIST_HEAD(umap_node_hashhead, umap_node) *umap_node_hashtbl;
|
||||
static u_long umap_node_hash;
|
||||
|
||||
static u_long umap_findid(u_long id, u_long map[][2], int nentries);
|
||||
static int umap_node_alloc(struct mount *mp, struct vnode *lowervp,
|
||||
struct vnode **vpp);
|
||||
static struct vnode *
|
||||
umap_node_find(struct mount *mp, struct vnode *targetvp);
|
||||
|
||||
/*
|
||||
* Initialise cache headers
|
||||
*/
|
||||
int
|
||||
umapfs_init(vfsp)
|
||||
struct vfsconf *vfsp;
|
||||
{
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_init\n"); /* printed during system boot */
|
||||
#endif
|
||||
umap_node_hashtbl = hashinit(NUMAPNODECACHE, M_CACHE, &umap_node_hash);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* umap_findid is called by various routines in umap_vnodeops.c to
|
||||
* find a user or group id in a map.
|
||||
*/
|
||||
static u_long
|
||||
umap_findid(id, map, nentries)
|
||||
u_long id;
|
||||
u_long map[][2];
|
||||
int nentries;
|
||||
{
|
||||
int i;
|
||||
|
||||
/* Find uid entry in map */
|
||||
i = 0;
|
||||
while ((i<nentries) && ((map[i][0]) != id))
|
||||
i++;
|
||||
|
||||
if (i < nentries)
|
||||
return (map[i][1]);
|
||||
else
|
||||
return (-1);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* umap_reverse_findid is called by umap_getattr() in umap_vnodeops.c to
|
||||
* find a user or group id in a map, in reverse.
|
||||
*/
|
||||
u_long
|
||||
umap_reverse_findid(id, map, nentries)
|
||||
u_long id;
|
||||
u_long map[][2];
|
||||
int nentries;
|
||||
{
|
||||
int i;
|
||||
|
||||
/* Find uid entry in map */
|
||||
i = 0;
|
||||
while ((i<nentries) && ((map[i][1]) != id))
|
||||
i++;
|
||||
|
||||
if (i < nentries)
|
||||
return (map[i][0]);
|
||||
else
|
||||
return (-1);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Return alias for target vnode if already exists, else 0.
|
||||
*/
|
||||
static struct vnode *
|
||||
umap_node_find(mp, targetvp)
|
||||
struct mount *mp;
|
||||
struct vnode *targetvp;
|
||||
{
|
||||
struct thread *td = curthread; /* XXX */
|
||||
struct umap_node_hashhead *hd;
|
||||
struct umap_node *a;
|
||||
struct vnode *vp;
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umap_node_find(mp = %p, target = %p)\n",
|
||||
(void *)mp, (void *)targetvp);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Find hash base, and then search the (two-way) linked
|
||||
* list looking for a umap_node structure which is referencing
|
||||
* the target vnode. If found, the increment the umap_node
|
||||
* reference count (but NOT the target vnode's VREF counter).
|
||||
*/
|
||||
hd = UMAP_NHASH(targetvp);
|
||||
loop:
|
||||
LIST_FOREACH(a, hd, umap_hash) {
|
||||
if (a->umap_lowervp == targetvp &&
|
||||
a->umap_vnode->v_mount == mp) {
|
||||
vp = UMAPTOV(a);
|
||||
/*
|
||||
* We need vget for the VXLOCK
|
||||
* stuff, but we don't want to lock
|
||||
* the lower node.
|
||||
*/
|
||||
if (vget(vp, 0, td)) {
|
||||
#ifdef DEBUG
|
||||
printf ("umap_node_find: vget failed.\n");
|
||||
#endif
|
||||
goto loop;
|
||||
}
|
||||
return (vp);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umap_node_find(%p, %p): NOT found\n",
|
||||
(void *)mp, (void *)targetvp);
|
||||
#endif
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Make a new umap_node node.
|
||||
* Vp is the alias vnode, lofsvp is the target vnode.
|
||||
* Maintain a reference to (targetvp).
|
||||
*/
|
||||
static int
|
||||
umap_node_alloc(mp, lowervp, vpp)
|
||||
struct mount *mp;
|
||||
struct vnode *lowervp;
|
||||
struct vnode **vpp;
|
||||
{
|
||||
struct umap_node_hashhead *hd;
|
||||
struct umap_node *xp;
|
||||
struct vnode *othervp, *vp;
|
||||
int error;
|
||||
|
||||
/* XXX This routine probably needs a node_alloc lock */
|
||||
|
||||
/*
|
||||
* Do the MALLOC before the getnewvnode since doing so afterward
|
||||
* might cause a bogus v_data pointer to get dereferenced
|
||||
* elsewhere if MALLOC should block.
|
||||
*/
|
||||
MALLOC(xp, struct umap_node *, sizeof(struct umap_node),
|
||||
M_TEMP, M_WAITOK);
|
||||
|
||||
error = getnewvnode("umap", mp, umap_vnodeop_p, vpp);
|
||||
if (error) {
|
||||
FREE(xp, M_TEMP);
|
||||
return (error);
|
||||
}
|
||||
vp = *vpp;
|
||||
error = insmntque(vp, mp); /* XXX: Too early for mpsafe fs */
|
||||
if (error != 0) {
|
||||
FREE(xp, M_TEMP);
|
||||
*vpp = NULLVP;
|
||||
return (error);
|
||||
}
|
||||
|
||||
vp->v_type = lowervp->v_type;
|
||||
xp->umap_vnode = vp;
|
||||
vp->v_data = xp;
|
||||
xp->umap_lowervp = lowervp;
|
||||
/*
|
||||
* Before we insert our new node onto the hash chains,
|
||||
* check to see if someone else has beaten us to it.
|
||||
* (We could have slept in MALLOC.)
|
||||
*/
|
||||
othervp = umap_node_find(mp, lowervp);
|
||||
if (othervp) {
|
||||
FREE(xp, M_TEMP);
|
||||
vp->v_type = VBAD; /* node is discarded */
|
||||
vp->v_usecount = 0; /* XXX */
|
||||
*vpp = othervp;
|
||||
return (0);
|
||||
}
|
||||
VREF(lowervp); /* Extra VREF will be vrele'd in umap_node_create */
|
||||
hd = UMAP_NHASH(lowervp);
|
||||
LIST_INSERT_HEAD(hd, xp, umap_hash);
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Try to find an existing umap_node vnode refering
|
||||
* to it, otherwise make a new umap_node vnode which
|
||||
* contains a reference to the target vnode.
|
||||
*/
|
||||
int
|
||||
umap_node_create(mp, targetvp, newvpp)
|
||||
struct mount *mp;
|
||||
struct vnode *targetvp;
|
||||
struct vnode **newvpp;
|
||||
{
|
||||
struct vnode *aliasvp;
|
||||
|
||||
aliasvp = umap_node_find(mp, targetvp);
|
||||
if (aliasvp) {
|
||||
/*
|
||||
* Take another reference to the alias vnode
|
||||
*/
|
||||
#ifdef DEBUG
|
||||
vprint("umap_node_create: exists", aliasvp);
|
||||
#endif
|
||||
/* VREF(aliasvp); */
|
||||
} else {
|
||||
int error;
|
||||
|
||||
/*
|
||||
* Get new vnode.
|
||||
*/
|
||||
#ifdef DEBUG
|
||||
printf("umap_node_create: create new alias vnode\n");
|
||||
#endif
|
||||
/*
|
||||
* Make new vnode reference the umap_node.
|
||||
*/
|
||||
error = umap_node_alloc(mp, targetvp, &aliasvp);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
/*
|
||||
* aliasvp is already VREF'd by getnewvnode()
|
||||
*/
|
||||
}
|
||||
|
||||
vrele(targetvp);
|
||||
|
||||
#ifdef DEBUG
|
||||
vprint("umap_node_create: alias", aliasvp);
|
||||
vprint("umap_node_create: target", targetvp);
|
||||
#endif
|
||||
|
||||
*newvpp = aliasvp;
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifdef DIAGNOSTIC
|
||||
int umap_checkvp_barrier = 1;
|
||||
struct vnode *
|
||||
umap_checkvp(vp, fil, lno)
|
||||
struct vnode *vp;
|
||||
char *fil;
|
||||
int lno;
|
||||
{
|
||||
struct umap_node *a = VTOUMAP(vp);
|
||||
#if 0
|
||||
/*
|
||||
* Can't do this check because vop_reclaim runs
|
||||
* with funny vop vector.
|
||||
*/
|
||||
if (vp->v_op != umap_vnodeop_p) {
|
||||
printf ("umap_checkvp: on non-umap-node\n");
|
||||
while (umap_checkvp_barrier) /*WAIT*/ ;
|
||||
panic("umap_checkvp");
|
||||
}
|
||||
#endif
|
||||
if (a->umap_lowervp == NULL) {
|
||||
/* Should never happen */
|
||||
int i; u_long *p;
|
||||
printf("vp = %p, ZERO ptr\n", (void *)vp);
|
||||
for (p = (u_long *) a, i = 0; i < 8; i++)
|
||||
printf(" %p", (void *)p[i]);
|
||||
printf("\n");
|
||||
/* wait for debugger */
|
||||
while (umap_checkvp_barrier) /*WAIT*/ ;
|
||||
panic("umap_checkvp");
|
||||
}
|
||||
if (vrefcnt(a->umap_lowervp) < 1) {
|
||||
int i; u_long *p;
|
||||
printf("vp = %p, unref'ed lowervp\n", (void *)vp);
|
||||
for (p = (u_long *) a, i = 0; i < 8; i++)
|
||||
printf(" %p", (void *)p[i]);
|
||||
printf("\n");
|
||||
/* wait for debugger */
|
||||
while (umap_checkvp_barrier) /*WAIT*/ ;
|
||||
panic ("umap with unref'ed lowervp");
|
||||
}
|
||||
#if 0
|
||||
printf("umap %x/%d -> %x/%d [%s, %d]\n",
|
||||
a->umap_vnode, a->umap_vnode->v_usecount,
|
||||
a->umap_lowervp, a->umap_lowervp->v_usecount,
|
||||
fil, lno);
|
||||
#endif
|
||||
return (a->umap_lowervp);
|
||||
}
|
||||
#endif /* DIAGNOSTIC */
|
||||
|
||||
/* umap_mapids maps all of the ids in a credential, both user and group. */
|
||||
|
||||
void
|
||||
umap_mapids(v_mount, credp)
|
||||
struct mount *v_mount;
|
||||
struct ucred *credp;
|
||||
{
|
||||
int i;
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
|
||||
if (credp == NOCRED)
|
||||
return;
|
||||
|
||||
KASSERT(!crshared(credp), ("remapping a shared cred"));
|
||||
|
||||
/* Find uid entry in map */
|
||||
|
||||
uid = (uid_t) umap_findid(credp->cr_uid,
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_mapdata,
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_nentries);
|
||||
|
||||
if (uid != -1)
|
||||
credp->cr_uid = uid;
|
||||
else
|
||||
credp->cr_uid = (uid_t) NOBODY;
|
||||
|
||||
#ifdef notdef
|
||||
/* cr_gid is the same as cr_groups[0] in 4BSD */
|
||||
|
||||
/* Find gid entry in map */
|
||||
|
||||
gid = (gid_t) umap_findid(credp->cr_gid,
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_gmapdata,
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_gnentries);
|
||||
|
||||
if (gid != -1)
|
||||
credp->cr_gid = gid;
|
||||
else
|
||||
credp->cr_gid = NULLGROUP;
|
||||
#endif
|
||||
|
||||
/* Now we must map each of the set of groups in the cr_groups
|
||||
structure. */
|
||||
|
||||
i = 0;
|
||||
while (credp->cr_groups[i] != 0) {
|
||||
gid = (gid_t) umap_findid(credp->cr_groups[i],
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_gmapdata,
|
||||
MOUNTTOUMAPMOUNT(v_mount)->info_gnentries);
|
||||
|
||||
if (gid != -1)
|
||||
credp->cr_groups[i++] = gid;
|
||||
else
|
||||
credp->cr_groups[i++] = NULLGROUP;
|
||||
}
|
||||
}
|
||||
@ -1,412 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993, 1995
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software donated to Berkeley by
|
||||
* the UCLA Ficus project.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 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.
|
||||
* 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
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)umap_vfsops.c 8.8 (Berkeley) 5/14/95
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Umap Layer
|
||||
* (See mount_umapfs(8) for a description of this layer.)
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/namei.h>
|
||||
#include <sys/vnode.h>
|
||||
|
||||
#include <fs/umapfs/umap.h>
|
||||
|
||||
static MALLOC_DEFINE(M_UMAPFSMNT, "umap_mount", "UMAP mount structure");
|
||||
|
||||
static vfs_omount_t umapfs_omount;
|
||||
static vfs_root_t umapfs_root;
|
||||
static vfs_quotactl_t umapfs_quotactl;
|
||||
static vfs_statfs_t umapfs_statfs;
|
||||
static vfs_unmount_t umapfs_unmount;
|
||||
static vfs_fhtovp_t umapfs_fhtovp;
|
||||
static vfs_checkexp_t umapfs_checkexp;
|
||||
static vfs_vget_t umapfs_vget;
|
||||
static vfs_extattrctl_t umapfs_extattrctl;
|
||||
|
||||
/*
|
||||
* Mount umap layer
|
||||
*/
|
||||
static int
|
||||
umapfs_omount(mp, path, data, ndp, td)
|
||||
struct mount *mp;
|
||||
char *path;
|
||||
caddr_t data;
|
||||
struct nameidata *ndp;
|
||||
struct thread *td;
|
||||
{
|
||||
struct umap_args args;
|
||||
struct vnode *lowerrootvp, *vp;
|
||||
struct vnode *umapm_rootvp;
|
||||
struct umap_mount *amp;
|
||||
size_t size;
|
||||
int error;
|
||||
#ifdef DEBUG
|
||||
int i;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Only for root
|
||||
*/
|
||||
error = priv_check(td, PRIV_VFS_MOUNT);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_mount(mp = %p)\n", (void *)mp);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Update is a no-op
|
||||
*/
|
||||
if (mp->mnt_flag & (MNT_UPDATE | MNT_ROOTFS)) {
|
||||
return (EOPNOTSUPP);
|
||||
/* return (VFS_MOUNT(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, path, data, ndp, td));*/
|
||||
}
|
||||
|
||||
/*
|
||||
* Get argument
|
||||
*/
|
||||
error = copyin(data, (caddr_t)&args, sizeof(struct umap_args));
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
/*
|
||||
* Find lower node
|
||||
*/
|
||||
NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF,
|
||||
UIO_USERSPACE, args.target, td);
|
||||
error = namei(ndp);
|
||||
if (error)
|
||||
return (error);
|
||||
NDFREE(ndp, NDF_ONLY_PNBUF);
|
||||
|
||||
/*
|
||||
* Sanity check on lower vnode
|
||||
*/
|
||||
lowerrootvp = ndp->ni_vp;
|
||||
#ifdef DEBUG
|
||||
printf("vp = %p, check for VDIR...\n", (void *)lowerrootvp);
|
||||
#endif
|
||||
vrele(ndp->ni_dvp);
|
||||
ndp->ni_dvp = 0;
|
||||
|
||||
if (lowerrootvp->v_type != VDIR) {
|
||||
vput(lowerrootvp);
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("mp = %p\n", (void *)mp);
|
||||
#endif
|
||||
|
||||
amp = (struct umap_mount *) malloc(sizeof(struct umap_mount),
|
||||
M_UMAPFSMNT, M_WAITOK); /* XXX */
|
||||
|
||||
/*
|
||||
* Save reference to underlying FS
|
||||
*/
|
||||
amp->umapm_vfs = lowerrootvp->v_mount;
|
||||
|
||||
/*
|
||||
* Now copy in the number of entries and maps for umap mapping.
|
||||
*/
|
||||
if (args.nentries > MAPFILEENTRIES || args.gnentries >
|
||||
GMAPFILEENTRIES) {
|
||||
vput(lowerrootvp);
|
||||
free(amp, M_UMAPFSMNT);
|
||||
/* XXX missing error = EINVAL ? */
|
||||
return (error);
|
||||
}
|
||||
|
||||
amp->info_nentries = args.nentries;
|
||||
amp->info_gnentries = args.gnentries;
|
||||
error = copyin(args.mapdata, (caddr_t)amp->info_mapdata,
|
||||
2*sizeof(u_long)*args.nentries);
|
||||
if (error) {
|
||||
free(amp, M_UMAPFSMNT);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umap_mount:nentries %d\n",args.nentries);
|
||||
for (i = 0; i < args.nentries; i++)
|
||||
printf(" %lu maps to %lu\n", amp->info_mapdata[i][0],
|
||||
amp->info_mapdata[i][1]);
|
||||
#endif
|
||||
|
||||
error = copyin(args.gmapdata, (caddr_t)amp->info_gmapdata,
|
||||
2*sizeof(u_long)*args.gnentries);
|
||||
if (error) {
|
||||
free(amp, M_UMAPFSMNT);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umap_mount:gnentries %d\n",args.gnentries);
|
||||
for (i = 0; i < args.gnentries; i++)
|
||||
printf(" group %lu maps to %lu\n",
|
||||
amp->info_gmapdata[i][0],
|
||||
amp->info_gmapdata[i][1]);
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Save reference. Each mount also holds
|
||||
* a reference on the root vnode.
|
||||
*/
|
||||
error = umap_node_create(mp, lowerrootvp, &vp);
|
||||
/*
|
||||
* Unlock the node (either the lower or the alias)
|
||||
*/
|
||||
VOP_UNLOCK(vp, 0, td);
|
||||
/*
|
||||
* Make sure the node alias worked
|
||||
*/
|
||||
if (error) {
|
||||
vrele(lowerrootvp);
|
||||
free(amp, M_UMAPFSMNT); /* XXX */
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* Keep a held reference to the root vnode.
|
||||
* It is vrele'd in umapfs_unmount.
|
||||
*/
|
||||
ASSERT_VOP_LOCKED(vp, "umapfs_mount");
|
||||
umapm_rootvp = vp;
|
||||
umapm_rootvp->v_vflag |= VV_ROOT;
|
||||
amp->umapm_rootvp = umapm_rootvp;
|
||||
if (UMAPVPTOLOWERVP(umapm_rootvp)->v_mount->mnt_flag & MNT_LOCAL) {
|
||||
MNT_ILOCK(mp);
|
||||
mp->mnt_flag |= MNT_LOCAL;
|
||||
MNT_IUNLOCK(mp);
|
||||
}
|
||||
mp->mnt_data = (qaddr_t) amp;
|
||||
vfs_getnewfsid(mp);
|
||||
|
||||
(void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
|
||||
&size);
|
||||
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
|
||||
(void)umapfs_statfs(mp, &mp->mnt_stat, td);
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_mount: lower %s, alias at %s\n",
|
||||
mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
|
||||
#endif
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Free reference to umap layer
|
||||
*/
|
||||
static int
|
||||
umapfs_unmount(mp, mntflags, td)
|
||||
struct mount *mp;
|
||||
int mntflags;
|
||||
struct thread *td;
|
||||
{
|
||||
int error;
|
||||
int flags = 0;
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_unmount(mp = %p)\n", (void *)mp);
|
||||
#endif
|
||||
|
||||
if (mntflags & MNT_FORCE)
|
||||
flags |= FORCECLOSE;
|
||||
|
||||
/*
|
||||
* Clear out buffer cache. I don't think we
|
||||
* ever get anything cached at this level at the
|
||||
* moment, but who knows...
|
||||
*/
|
||||
#ifdef notyet
|
||||
mntflushbuf(mp, 0);
|
||||
if (mntinvalbuf(mp, 1))
|
||||
return (EBUSY);
|
||||
#endif
|
||||
/* There is 1 extra root vnode reference (umapm_rootvp). */
|
||||
error = vflush(mp, 1, flags, td);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
/*
|
||||
* Finally, throw away the umap_mount structure
|
||||
*/
|
||||
free(mp->mnt_data, M_UMAPFSMNT); /* XXX */
|
||||
mp->mnt_data = 0;
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_root(mp, flags, vpp, td)
|
||||
struct mount *mp;
|
||||
int flags;
|
||||
struct vnode **vpp;
|
||||
struct thread *td;
|
||||
{
|
||||
struct thread *td = curthread; /* XXX */
|
||||
struct vnode *vp;
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_root(mp = %p, vp = %p->%p)\n",
|
||||
(void *)mp, (void *)MOUNTTOUMAPMOUNT(mp)->umapm_rootvp,
|
||||
(void *)UMAPVPTOLOWERVP(MOUNTTOUMAPMOUNT(mp)->umapm_rootvp));
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Return locked reference to root.
|
||||
*/
|
||||
vp = MOUNTTOUMAPMOUNT(mp)->umapm_rootvp;
|
||||
VREF(vp);
|
||||
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
|
||||
*vpp = vp;
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_quotactl(mp, cmd, uid, arg, td)
|
||||
struct mount *mp;
|
||||
int cmd;
|
||||
uid_t uid;
|
||||
caddr_t arg;
|
||||
struct thread *td;
|
||||
{
|
||||
|
||||
return (VFS_QUOTACTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd, uid, arg, td));
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_statfs(mp, sbp, td)
|
||||
struct mount *mp;
|
||||
struct statfs *sbp;
|
||||
struct thread *td;
|
||||
{
|
||||
int error;
|
||||
struct statfs mstat;
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("umapfs_statfs(mp = %p, vp = %p->%p)\n",
|
||||
(void *)mp, (void *)MOUNTTOUMAPMOUNT(mp)->umapm_rootvp,
|
||||
(void *)UMAPVPTOLOWERVP(MOUNTTOUMAPMOUNT(mp)->umapm_rootvp));
|
||||
#endif
|
||||
|
||||
bzero(&mstat, sizeof(mstat));
|
||||
|
||||
error = VFS_STATFS(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, &mstat, td);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
/* 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;
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_vget(mp, ino, flags, vpp)
|
||||
struct mount *mp;
|
||||
ino_t ino;
|
||||
int flags;
|
||||
struct vnode **vpp;
|
||||
{
|
||||
|
||||
return (VFS_VGET(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, ino, flags, vpp));
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_fhtovp(mp, fidp, vpp)
|
||||
struct mount *mp;
|
||||
struct fid *fidp;
|
||||
struct vnode **vpp;
|
||||
{
|
||||
|
||||
return (VFS_FHTOVP(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, fidp, vpp));
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_checkexp(mp, nam, exflagsp, credanonp)
|
||||
struct mount *mp;
|
||||
struct sockaddr *nam;
|
||||
int *exflagsp;
|
||||
struct ucred **credanonp;
|
||||
{
|
||||
|
||||
return (VFS_CHECKEXP(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, nam,
|
||||
exflagsp, credanonp));
|
||||
}
|
||||
|
||||
static int
|
||||
umapfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, td)
|
||||
struct mount *mp;
|
||||
int cmd;
|
||||
struct vnode *filename_vp;
|
||||
int namespace;
|
||||
const char *attrname;
|
||||
struct thread *td;
|
||||
{
|
||||
|
||||
return (VFS_EXTATTRCTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd,
|
||||
filename_vp, namespace, attrname, td));
|
||||
}
|
||||
|
||||
static struct vfsops umap_vfsops = {
|
||||
.vfs_checkexp = umapfs_checkexp,
|
||||
.vfs_extattrctl = umapfs_extattrctl,
|
||||
.vfs_fhtovp = umapfs_fhtovp,
|
||||
.vfs_init = umapfs_init,
|
||||
.vfs_omount = umapfs_omount,
|
||||
.vfs_quotactl = umapfs_quotactl,
|
||||
.vfs_root = umapfs_root,
|
||||
.vfs_statfs = umapfs_statfs,
|
||||
.vfs_unmount = umapfs_unmount,
|
||||
.vfs_vget = umapfs_vget,
|
||||
};
|
||||
|
||||
VFS_SET(umap_vfsops, umapfs, VFCF_LOOPBACK);
|
||||
@ -1,534 +0,0 @@
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software donated to Berkeley by
|
||||
* the UCLA Ficus project.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 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.
|
||||
* 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
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)umap_vnops.c 8.6 (Berkeley) 5/22/95
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Umap Layer
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mount.h>
|
||||
#include <sys/namei.h>
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/vnode.h>
|
||||
|
||||
#include <fs/umapfs/umap.h>
|
||||
#include <fs/nullfs/null.h>
|
||||
|
||||
static int umap_bug_bypass = 0; /* for debugging: enables bypass printf'ing */
|
||||
SYSCTL_INT(_debug, OID_AUTO, umapfs_bug_bypass, CTLFLAG_RW,
|
||||
&umap_bug_bypass, 0, "");
|
||||
|
||||
static vop_generic_t umap_bypass;
|
||||
static vop_getattr_t umap_getattr;
|
||||
static vop_inactive_t umap_inactive;
|
||||
static vop_lock1_t umap_lock;
|
||||
static vop_print_t umap_print;
|
||||
static vop_reclaim_t umap_reclaim;
|
||||
static vop_rename_t umap_rename;
|
||||
static vop_unlock_t umap_unlock;
|
||||
static vop_vptofh_t umap_vptofh;
|
||||
|
||||
/*
|
||||
* This is the 10-Apr-92 bypass routine.
|
||||
* See null_vnops.c:null_bypass for more details.
|
||||
*/
|
||||
static int
|
||||
umap_bypass(ap)
|
||||
struct vop_generic_args /* {
|
||||
struct vnodeop_desc *a_desc;
|
||||
<other random data follows, presumably>
|
||||
} */ *ap;
|
||||
{
|
||||
struct ucred **credpp = 0, *credp = 0;
|
||||
struct ucred *savecredp = 0, *savecompcredp = 0;
|
||||
struct ucred *compcredp = 0;
|
||||
struct vnode **this_vp_p;
|
||||
int error;
|
||||
struct vnode *old_vps[VDESC_MAX_VPS];
|
||||
struct vnode *vp1 = 0;
|
||||
struct vnode **vps_p[VDESC_MAX_VPS];
|
||||
struct vnode ***vppp;
|
||||
struct vnodeop_desc *descp = ap->a_desc;
|
||||
int reles, i;
|
||||
struct componentname **compnamepp = 0;
|
||||
|
||||
if (umap_bug_bypass)
|
||||
printf ("umap_bypass: %s\n", descp->vdesc_name);
|
||||
|
||||
#ifdef DIAGNOSTIC
|
||||
/*
|
||||
* We require at least one vp.
|
||||
*/
|
||||
if (descp->vdesc_vp_offsets == NULL ||
|
||||
descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET)
|
||||
panic ("umap_bypass: no vp's in map");
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Map the vnodes going in.
|
||||
* Later, we'll invoke the operation based on
|
||||
* the first mapped vnode's operation vector.
|
||||
*/
|
||||
reles = descp->vdesc_flags;
|
||||
for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
|
||||
if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
|
||||
break; /* bail out at end of list */
|
||||
vps_p[i] = this_vp_p =
|
||||
VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[i], ap);
|
||||
|
||||
if (i == 0) {
|
||||
vp1 = *vps_p[0];
|
||||
}
|
||||
|
||||
/*
|
||||
* We're not guaranteed that any but the first vnode
|
||||
* are of our type. Check for and don't map any
|
||||
* that aren't. (Must map first vp or vclean fails.)
|
||||
*/
|
||||
|
||||
if (i && (*this_vp_p)->v_op != umap_vnodeop_p) {
|
||||
old_vps[i] = NULL;
|
||||
} else {
|
||||
old_vps[i] = *this_vp_p;
|
||||
*(vps_p[i]) = UMAPVPTOLOWERVP(*this_vp_p);
|
||||
if (reles & 1)
|
||||
VREF(*this_vp_p);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Fix the credentials. (That's the purpose of this layer.)
|
||||
*/
|
||||
|
||||
if (descp->vdesc_cred_offset != VDESC_NO_OFFSET) {
|
||||
|
||||
credpp = VOPARG_OFFSETTO(struct ucred**,
|
||||
descp->vdesc_cred_offset, ap);
|
||||
|
||||
/* Save old values */
|
||||
|
||||
savecredp = (*credpp);
|
||||
if (savecredp != NOCRED)
|
||||
(*credpp) = crdup(savecredp);
|
||||
credp = *credpp;
|
||||
|
||||
if (umap_bug_bypass && credp->cr_uid != 0)
|
||||
printf("umap_bypass: user was %lu, group %lu\n",
|
||||
(u_long)credp->cr_uid, (u_long)credp->cr_gid);
|
||||
|
||||
/* Map all ids in the credential structure. */
|
||||
|
||||
umap_mapids(vp1->v_mount, credp);
|
||||
|
||||
if (umap_bug_bypass && credp->cr_uid != 0)
|
||||
printf("umap_bypass: user now %lu, group %lu\n",
|
||||
(u_long)credp->cr_uid, (u_long)credp->cr_gid);
|
||||
}
|
||||
|
||||
/* BSD often keeps a credential in the componentname structure
|
||||
* for speed. If there is one, it better get mapped, too.
|
||||
*/
|
||||
|
||||
if (descp->vdesc_componentname_offset != VDESC_NO_OFFSET) {
|
||||
|
||||
compnamepp = VOPARG_OFFSETTO(struct componentname**,
|
||||
descp->vdesc_componentname_offset, ap);
|
||||
|
||||
compcredp = (*compnamepp)->cn_cred;
|
||||
savecompcredp = compcredp;
|
||||
if (savecompcredp != NOCRED)
|
||||
(*compnamepp)->cn_cred = crdup(savecompcredp);
|
||||
compcredp = (*compnamepp)->cn_cred;
|
||||
|
||||
if (umap_bug_bypass && compcredp->cr_uid != 0)
|
||||
printf(
|
||||
"umap_bypass: component credit user was %lu, group %lu\n",
|
||||
(u_long)compcredp->cr_uid,
|
||||
(u_long)compcredp->cr_gid);
|
||||
|
||||
/* Map all ids in the credential structure. */
|
||||
|
||||
umap_mapids(vp1->v_mount, compcredp);
|
||||
|
||||
if (umap_bug_bypass && compcredp->cr_uid != 0)
|
||||
printf(
|
||||
"umap_bypass: component credit user now %lu, group %lu\n",
|
||||
(u_long)compcredp->cr_uid,
|
||||
(u_long)compcredp->cr_gid);
|
||||
}
|
||||
|
||||
/*
|
||||
* Call the operation on the lower layer
|
||||
* with the modified argument structure.
|
||||
*/
|
||||
error = VCALL(ap);
|
||||
|
||||
/*
|
||||
* Maintain the illusion of call-by-value
|
||||
* by restoring vnodes in the argument structure
|
||||
* to their original value.
|
||||
*/
|
||||
reles = descp->vdesc_flags;
|
||||
for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
|
||||
if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
|
||||
break; /* bail out at end of list */
|
||||
if (old_vps[i]) {
|
||||
*(vps_p[i]) = old_vps[i];
|
||||
if (reles & 1)
|
||||
vrele(*(vps_p[i]));
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* Map the possible out-going vpp
|
||||
* (Assumes that the lower layer always returns
|
||||
* a VREF'ed vpp unless it gets an error.)
|
||||
*/
|
||||
if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
|
||||
!(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
|
||||
!error) {
|
||||
if (descp->vdesc_flags & VDESC_VPP_WILLRELE)
|
||||
goto out;
|
||||
vppp = VOPARG_OFFSETTO(struct vnode***,
|
||||
descp->vdesc_vpp_offset, ap);
|
||||
if (*vppp)
|
||||
error = umap_node_create(old_vps[0]->v_mount, **vppp, *vppp);
|
||||
};
|
||||
|
||||
out:
|
||||
/*
|
||||
* Free duplicate cred structure and restore old one.
|
||||
*/
|
||||
if (descp->vdesc_cred_offset != VDESC_NO_OFFSET) {
|
||||
if (umap_bug_bypass && credp && credp->cr_uid != 0)
|
||||
printf("umap_bypass: returning-user was %lu\n",
|
||||
(u_long)credp->cr_uid);
|
||||
|
||||
if (savecredp != NOCRED) {
|
||||
crfree(credp);
|
||||
(*credpp) = savecredp;
|
||||
if (umap_bug_bypass && credpp && (*credpp)->cr_uid != 0)
|
||||
printf(
|
||||
"umap_bypass: returning-user now %lu\n\n",
|
||||
(u_long)(*credpp)->cr_uid);
|
||||
}
|
||||
}
|
||||
|
||||
if (descp->vdesc_componentname_offset != VDESC_NO_OFFSET) {
|
||||
if (umap_bug_bypass && compcredp && compcredp->cr_uid != 0)
|
||||
printf(
|
||||
"umap_bypass: returning-component-user was %lu\n",
|
||||
(u_long)compcredp->cr_uid);
|
||||
|
||||
if (savecompcredp != NOCRED) {
|
||||
crfree(compcredp);
|
||||
(*compnamepp)->cn_cred = savecompcredp;
|
||||
if (umap_bug_bypass && credpp && (*credpp)->cr_uid != 0)
|
||||
printf(
|
||||
"umap_bypass: returning-component-user now %lu\n",
|
||||
(u_long)compcredp->cr_uid);
|
||||
}
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* We handle getattr to change the fsid.
|
||||
*/
|
||||
static int
|
||||
umap_getattr(ap)
|
||||
struct vop_getattr_args /* {
|
||||
struct vnode *a_vp;
|
||||
struct vattr *a_vap;
|
||||
struct ucred *a_cred;
|
||||
struct thread *a_td;
|
||||
} */ *ap;
|
||||
{
|
||||
short uid, gid;
|
||||
int error, tmpid, nentries, gnentries;
|
||||
u_long (*mapdata)[2], (*gmapdata)[2];
|
||||
struct vnode **vp1p;
|
||||
struct vnodeop_desc *descp = ap->a_desc;
|
||||
|
||||
error = umap_bypass((struct vop_generic_args *)ap);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
/*
|
||||
* Umap needs to map the uid and gid returned by a stat
|
||||
* into the proper values for this site. This involves
|
||||
* finding the returned uid in the mapping information,
|
||||
* translating it into the uid on the other end,
|
||||
* and filling in the proper field in the vattr
|
||||
* structure pointed to by ap->a_vap. The group
|
||||
* is easier, since currently all groups will be
|
||||
* translate to the NULLGROUP.
|
||||
*/
|
||||
|
||||
/* Find entry in map */
|
||||
|
||||
uid = ap->a_vap->va_uid;
|
||||
gid = ap->a_vap->va_gid;
|
||||
if (umap_bug_bypass)
|
||||
printf("umap_getattr: mapped uid = %d, mapped gid = %d\n", uid,
|
||||
gid);
|
||||
|
||||
vp1p = VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[0], ap);
|
||||
nentries = MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_nentries;
|
||||
mapdata = (MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_mapdata);
|
||||
gnentries = MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_gnentries;
|
||||
gmapdata = (MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_gmapdata);
|
||||
|
||||
/* Reverse map the uid for the vnode. Since it's a reverse
|
||||
map, we can't use umap_mapids() to do it. */
|
||||
|
||||
tmpid = umap_reverse_findid(uid, mapdata, nentries);
|
||||
|
||||
if (tmpid != -1) {
|
||||
|
||||
ap->a_vap->va_uid = (uid_t) tmpid;
|
||||
if (umap_bug_bypass)
|
||||
printf("umap_getattr: original uid = %d\n", uid);
|
||||
} else
|
||||
ap->a_vap->va_uid = (uid_t) NOBODY;
|
||||
|
||||
/* Reverse map the gid for the vnode. */
|
||||
|
||||
tmpid = umap_reverse_findid(gid, gmapdata, gnentries);
|
||||
|
||||
if (tmpid != -1) {
|
||||
|
||||
ap->a_vap->va_gid = (gid_t) tmpid;
|
||||
if (umap_bug_bypass)
|
||||
printf("umap_getattr: original gid = %d\n", gid);
|
||||
} else
|
||||
ap->a_vap->va_gid = (gid_t) NULLGROUP;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* We need to process our own vnode lock and then clear the
|
||||
* interlock flag as it applies only to our vnode, not the
|
||||
* vnodes below us on the stack.
|
||||
*/
|
||||
static int
|
||||
umap_lock(ap)
|
||||
struct vop_lock1_args /* {
|
||||
struct vnode *a_vp;
|
||||
int a_flags;
|
||||
struct thread *a_td;
|
||||
} */ *ap;
|
||||
{
|
||||
|
||||
/*
|
||||
* vop_nolock no longer exists. I could have pasted the code
|
||||
* in so that it compiles, but that would be doing our users a
|
||||
* great disservice. umapfs is about 5 years behind the nullfs
|
||||
* code that it is derived from. The stub locking here guarantees
|
||||
* a deadlock the moment a VOP_INACTIVE arrives. There is no point
|
||||
* pasting the code that makes it compile either, because that just
|
||||
* makes it Even More Wrong.
|
||||
*/
|
||||
vop_nolock(ap);
|
||||
if ((ap->a_flags & LK_TYPE_MASK) == LK_DRAIN)
|
||||
return (0);
|
||||
ap->a_flags &= ~LK_INTERLOCK;
|
||||
return (null_bypass((struct vop_generic_args *)ap));
|
||||
}
|
||||
|
||||
/*
|
||||
* We need to process our own vnode unlock and then clear the
|
||||
* interlock flag as it applies only to our vnode, not the
|
||||
* vnodes below us on the stack.
|
||||
*/
|
||||
static int
|
||||
umap_unlock(ap)
|
||||
struct vop_unlock_args /* {
|
||||
struct vnode *a_vp;
|
||||
int a_flags;
|
||||
struct thread *a_td;
|
||||
} */ *ap;
|
||||
{
|
||||
vop_nounlock(ap);
|
||||
ap->a_flags &= ~LK_INTERLOCK;
|
||||
return (null_bypass((struct vop_generic_args *)ap));
|
||||
}
|
||||
|
||||
static int
|
||||
umap_inactive(ap)
|
||||
struct vop_inactive_args /* {
|
||||
struct vnode *a_vp;
|
||||
struct thread *a_td;
|
||||
} */ *ap;
|
||||
{
|
||||
struct vnode *vp = ap->a_vp;
|
||||
struct umap_node *xp = VTOUMAP(vp);
|
||||
struct vnode *lowervp = xp->umap_lowervp;
|
||||
/*
|
||||
* Do nothing (and _don't_ bypass).
|
||||
* Wait to vrele lowervp until reclaim,
|
||||
* so that until then our umap_node is in the
|
||||
* cache and reusable.
|
||||
*
|
||||
*/
|
||||
VOP_INACTIVE(lowervp, ap->a_td);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umap_reclaim(ap)
|
||||
struct vop_reclaim_args /* {
|
||||
struct vnode *a_vp;
|
||||
} */ *ap;
|
||||
{
|
||||
struct vnode *vp = ap->a_vp;
|
||||
struct umap_node *xp = VTOUMAP(vp);
|
||||
struct vnode *lowervp = xp->umap_lowervp;
|
||||
|
||||
/* After this assignment, this node will not be re-used. */
|
||||
xp->umap_lowervp = NULL;
|
||||
LIST_REMOVE(xp, umap_hash);
|
||||
FREE(vp->v_data, M_TEMP);
|
||||
vp->v_data = NULL;
|
||||
vp->v_object = NULL;
|
||||
vrele(lowervp);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umap_print(ap)
|
||||
struct vop_print_args /* {
|
||||
struct vnode *a_vp;
|
||||
} */ *ap;
|
||||
{
|
||||
struct vnode *vp = ap->a_vp;
|
||||
printf("\tvp=%p, lowervp=%p\n", vp, UMAPVPTOLOWERVP(vp));
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
umap_rename(ap)
|
||||
struct vop_rename_args /* {
|
||||
struct vnode *a_fdvp;
|
||||
struct vnode *a_fvp;
|
||||
struct componentname *a_fcnp;
|
||||
struct vnode *a_tdvp;
|
||||
struct vnode *a_tvp;
|
||||
struct componentname *a_tcnp;
|
||||
} */ *ap;
|
||||
{
|
||||
int error;
|
||||
struct componentname *compnamep;
|
||||
struct ucred *compcredp, *savecompcredp;
|
||||
struct vnode *vp;
|
||||
|
||||
/*
|
||||
* Rename is irregular, having two componentname structures.
|
||||
* We need to map the cre in the second structure,
|
||||
* and then bypass takes care of the rest.
|
||||
*/
|
||||
|
||||
vp = ap->a_fdvp;
|
||||
compnamep = ap->a_tcnp;
|
||||
compcredp = compnamep->cn_cred;
|
||||
|
||||
savecompcredp = compcredp;
|
||||
compcredp = compnamep->cn_cred = crdup(savecompcredp);
|
||||
|
||||
if (umap_bug_bypass && compcredp->cr_uid != 0)
|
||||
printf(
|
||||
"umap_rename: rename component credit user was %lu, group %lu\n",
|
||||
(u_long)compcredp->cr_uid, (u_long)compcredp->cr_gid);
|
||||
|
||||
/* Map all ids in the credential structure. */
|
||||
|
||||
umap_mapids(vp->v_mount, compcredp);
|
||||
|
||||
if (umap_bug_bypass && compcredp->cr_uid != 0)
|
||||
printf(
|
||||
"umap_rename: rename component credit user now %lu, group %lu\n",
|
||||
(u_long)compcredp->cr_uid, (u_long)compcredp->cr_gid);
|
||||
|
||||
error = umap_bypass((struct vop_generic_args *)ap);
|
||||
|
||||
/* Restore the additional mapped componentname cred structure. */
|
||||
|
||||
crfree(compcredp);
|
||||
compnamep->cn_cred = savecompcredp;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static int
|
||||
umap_vptofh(ap)
|
||||
struct vop_vptofh_args /* {
|
||||
struct vnode *a_vp;
|
||||
struct fid *a_fhp;
|
||||
} */ *ap;
|
||||
{
|
||||
struct vnode *lvp;
|
||||
|
||||
lvp = UMAPVPTOLOWERVP(ap->a_vp);
|
||||
return (VOP_VPTOFH(lvp, ap->a_fhp));
|
||||
}
|
||||
|
||||
/*
|
||||
* Global vfs data structures
|
||||
*/
|
||||
/*
|
||||
* XXX - strategy, bwrite are hand coded currently. They should
|
||||
* go away with a merged buffer/block cache.
|
||||
*
|
||||
*/
|
||||
static struct vop_vector umap_vnodeops = {
|
||||
.vop_default = umap_bypass,
|
||||
|
||||
.vop_getattr = umap_getattr,
|
||||
.vop_inactive = umap_inactive,
|
||||
.vop_lock1 = umap_lock,
|
||||
.vop_print = umap_print,
|
||||
.vop_reclaim = umap_reclaim,
|
||||
.vop_rename = umap_rename,
|
||||
.vop_unlock = umap_unlock,
|
||||
.vop_vptofh = umap_vptofh,
|
||||
};
|
||||
@ -37,7 +37,6 @@ COMM= ${SYS}/dev/advansys/*.[ch] \
|
||||
${SYS}/fs/procfs/*.[ch] \
|
||||
${SYS}/fs/smbfs/*.[ch] \
|
||||
${SYS}/fs/udf/*.[ch] \
|
||||
${SYS}/fs/umapfs/*.[ch] \
|
||||
${SYS}/fs/unionfs/*.[ch] \
|
||||
${SYS}/kern/*.[ch] \
|
||||
${SYS}/net/*.[ch] \
|
||||
@ -96,7 +95,6 @@ COMMDIR2= ${SYS}/dev/advansys \
|
||||
${SYS}/fs/portalfs \
|
||||
${SYS}/fs/procfs \
|
||||
${SYS}/fs/specfs \
|
||||
${SYS}/fs/umapfs \
|
||||
${SYS}/fs/unionfs \
|
||||
${SYS}/fs/cd9660 \
|
||||
${SYS}/ufs/ffs \
|
||||
|
||||
@ -38,7 +38,7 @@ DGEN= conf \
|
||||
dev dev/scsi \
|
||||
fs fs/deadfs fs/fdescfs fs/fifofs \
|
||||
fs/lofs fs/nullfs fs/portalfs fs/procfs \
|
||||
fs/specfs fs/umapfs fs/unionfs \
|
||||
fs/specfs fs/unionfs \
|
||||
hp hp/dev hp/hpux \
|
||||
kern libkern \
|
||||
net netinet nfs scripts sys \
|
||||
|
||||
@ -1,9 +0,0 @@
|
||||
# $FreeBSD$
|
||||
|
||||
.PATH: ${.CURDIR}/../../fs/umapfs
|
||||
|
||||
KMOD= umapfs
|
||||
SRCS= vnode_if.h \
|
||||
umap_subr.c umap_vfsops.c umap_vnops.c
|
||||
|
||||
.include <bsd.kmod.mk>
|
||||
@ -73,7 +73,6 @@ sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nfs
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/newfs
|
||||
sbin/nextboot
|
||||
|
||||
@ -75,7 +75,6 @@ sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nfs
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/natd
|
||||
sbin/nfsiod
|
||||
|
||||
@ -73,7 +73,6 @@ sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nfs
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/natd
|
||||
sbin/newfs
|
||||
|
||||
@ -68,7 +68,6 @@ sbin/mknod
|
||||
sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/newfs
|
||||
sbin/nextboot
|
||||
|
||||
@ -71,7 +71,6 @@ sbin/mknod
|
||||
sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/newfs
|
||||
sbin/nextboot
|
||||
|
||||
@ -72,7 +72,6 @@ sbin/mknod
|
||||
sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/natd
|
||||
sbin/newfs
|
||||
|
||||
@ -72,7 +72,6 @@ sbin/mknod
|
||||
sbin/mdmfs
|
||||
sbin/mount
|
||||
sbin/mount_nullfs
|
||||
sbin/mount_umapfs
|
||||
sbin/mount_unionfs
|
||||
sbin/natd
|
||||
sbin/newfs
|
||||
|
||||
Loading…
Reference in New Issue
Block a user