d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- Remove UMAP filesystem. It was disconnected from build three years ago,

Browse Source 
and it is seriously broken.

Discussed on:   freebsd-arch@
Approved by:	re (mux)
This commit is contained in:
rafan 2007-06-25 05:06:57 +00:00
parent c929d3d5a3
commit ff392b04b7
32 changed files with 16 additions and 2060 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ObsoleteFiles.inc
View File

@ -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

2
etc/mtree/BSD.include.dist
View File

@ -146,8 +146,6 @@
..
udf
..
umapfs
..
unionfs
..
..

3
include/Makefile
View File

@ -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 \

2
rescue/rescue/Makefile
View File

@ -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

1
sbin/Makefile
View File

@ -59,7 +59,6 @@ SUBDIR= adjkerntz \
mount_ntfs \
mount_nullfs \
mount_udf \
mount_umapfs \
mount_unionfs \
natd \
newfs \

2
sbin/mount/mount.8
View File

@ -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

3
sbin/mount/mount.c
View File

@ -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
};

14
sbin/mount_umapfs/Makefile
View File

@ -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>

146
sbin/mount_umapfs/mount_umapfs.8
View File

@ -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.

235
sbin/mount_umapfs/mount_umapfs.c
View File

@ -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);
}

2
sbin/mount_umapfs/sample.group.mapfile
View File

@ -1,2 +0,0 @@
1
1200 1200

3
sbin/mount_umapfs/sample.user.mapfile
View File

@ -1,3 +0,0 @@
2
5217 5217
3 3

175
sbin/mount_umapfs/umap_manual
View File

@ -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}

2
share/man/man7/hier.7
View File

@ -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

1
sys/boot/forth/loader.conf
View File

@ -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

14
sys/conf/NOTES
View File

@ -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

3
sys/conf/files
View File

@ -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

1
sys/conf/options
View File

@ -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

86
sys/fs/umapfs/umap.h
View File

@ -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 */

409
sys/fs/umapfs/umap_subr.c
View File

@ -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;
}
}

412
sys/fs/umapfs/umap_vfsops.c
View File

@ -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);

534
sys/fs/umapfs/umap_vnops.c
View File

@ -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,
};

2
sys/kern/Make.tags.inc
View File

@ -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 \

2
sys/kern/Makefile
View File

@ -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 \

9
sys/modules/umapfs/Makefile
View File

@ -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>

1
tools/tools/tinybsd/conf/bridge/tinybsd.basefiles
View File

@ -73,7 +73,6 @@ sbin/mdmfs
sbin/mount
sbin/mount_nfs
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/newfs
sbin/nextboot

1
tools/tools/tinybsd/conf/default/tinybsd.basefiles
View File

@ -75,7 +75,6 @@ sbin/mdmfs
sbin/mount
sbin/mount_nfs
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/natd
sbin/nfsiod

1
tools/tools/tinybsd/conf/firewall/tinybsd.basefiles
View File

@ -73,7 +73,6 @@ sbin/mdmfs
sbin/mount
sbin/mount_nfs
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/natd
sbin/newfs

1
tools/tools/tinybsd/conf/minimal/tinybsd.basefiles
View File

@ -68,7 +68,6 @@ sbin/mknod
sbin/mdmfs
sbin/mount
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/newfs
sbin/nextboot

1
tools/tools/tinybsd/conf/vpn/tinybsd.basefiles
View File

@ -71,7 +71,6 @@ sbin/mknod
sbin/mdmfs
sbin/mount
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/newfs
sbin/nextboot

1
tools/tools/tinybsd/conf/wireless/tinybsd.basefiles
View File

@ -72,7 +72,6 @@ sbin/mknod
sbin/mdmfs
sbin/mount
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/natd
sbin/newfs

1
tools/tools/tinybsd/conf/wrap/tinybsd.basefiles
View File

@ -72,7 +72,6 @@ sbin/mknod
sbin/mdmfs
sbin/mount
sbin/mount_nullfs
sbin/mount_umapfs
sbin/mount_unionfs
sbin/natd
sbin/newfs