Attachment #204560 for bug #237860

Lines 2-8 Link Here

(-)usr.sbin/mountd/Makefile (-1 / +1 lines)
2	# $FreeBSD: head/usr.sbin/mountd/Makefile 314659 2017-03-04 11:38:03Z ngie $	2	# $FreeBSD: head/usr.sbin/mountd/Makefile 314659 2017-03-04 11:38:03Z ngie $
3		3
4	PROG= mountd	4	PROG= mountd
5	SRCS= mountd.c getmntopts.c	5	SRCS= mountd.c getmntopts.c mountd_dt.d
6	MAN= exports.5 netgroup.5 mountd.8	6	MAN= exports.5 netgroup.5 mountd.8
7		7
8	MOUNT= ${SRCTOP}/sbin/mount	8	MOUNT= ${SRCTOP}/sbin/mount




.\"     @(#)mountd.8	8.4 (Berkeley) 4/28/95
.\" $FreeBSD: head/usr.sbin/mountd/mountd.8 314436 2017-02-28 23:42:47Z imp $
.\"
.Dd May 22, 2019
.Dt MOUNTD 8
.Os
.Sh NAME

mount requests
.Sh SYNOPSIS
.Nm
.Op Fl 2deIlnrS
.Op Fl h Ar bindip
.Op Fl p Ar port
.Op Ar exportsfile ...

and if IPv6 is enabled,
.Li ::1
to the list.
.It Fl I
Make a reload of the exports file(s) be done via a comparison between the
current and new exports entries, only doing system calls to update the kernel
exports for cases that have changed.
This can reduce the number of system calls being done significantly for
a large number of exported file systems, when only a small number of changes
to the exports have been made.
For a server with 10,000 exported file systems, this can reduce the duration
during which the nfsd threads are suspended during the reload from seconds
to milliseconds.
.It Fl l
Cause all succeeded
.Nm





#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/fnv_hash.h>
#include <sys/linker.h>
#include <sys/module.h>
#include <sys/mount.h>

#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/sdt.h>

#include <rpc/rpc.h>
#include <rpc/rpc_com.h>

#include <unistd.h>
#include "pathnames.h"
#include "mntopts.h"
#include "mountd_dt.h"

#ifdef DEBUG
#include <stdarg.h>

struct exportlist {
	struct dirlist	*ex_dirl;
	struct dirlist	*ex_defdir;
	struct grouplist *ex_grphead;
	int		ex_flag;
	fsid_t		ex_fs;
	char		*ex_fsdir;
	char		*ex_indexfile;
	struct xucred	ex_defanon;
	int		ex_defexflags;
	int		ex_numsecflavors;
	int		ex_secflavors[MAXSECFLAVORS];
	int		ex_defnumsecflavors;

};
/* ex_flag bits */
#define	EX_LINKED	0x1
#define	EX_DONE		0x2
#define	EX_DEFSET	0x4
#define	EX_PUBLICFH	0x8

SLIST_HEAD(exportlisthead, exportlist);

struct netmsk {
	struct sockaddr_storage nt_net;

	int gr_type;
	union grouptypes gr_ptr;
	struct grouplist *gr_next;
	struct xucred gr_anon;
	int gr_exflags;
	int gr_flag;
	int gr_numsecflavors;
	int gr_secflavors[MAXSECFLAVORS];
};

#define	GT_DEFAULT	0x3
#define GT_IGNORE	0x5

/* Group flags */
#define	GR_FND		0x1

struct hostlist {
	int		 ht_flag;	/* Uses DP_xx bits */
	struct grouplist *ht_grp;

/* Global defs */
static char	*add_expdir(struct dirlist **, char *, int);
static void	add_dlist(struct dirlist **, struct dirlist *,
		    struct grouplist *, int, struct exportlist *,
		    struct xucred *, int);
static void	add_mlist(char *, char *);
static int	check_dirpath(char *);
static int	check_options(struct dirlist *);

static void	clearout_service(void);
static void	del_mlist(char *hostp, char *dirp);
static struct dirlist	*dirp_search(struct dirlist *, char *);
static int	do_export_mount(struct exportlist *, struct statfs *);
static int	do_mount(struct exportlist *, struct grouplist *, int,
		    struct xucred *, char *, int, struct statfs *, int, int *);
static int	do_opt(char **, char **, struct exportlist *,
		    struct grouplist *, int *, int *, struct xucred *);
static struct exportlist	*ex_search(fsid_t *, struct exportlisthead *);
static struct exportlist	*get_exp(void);
static void	free_dir(struct dirlist *);
static void	free_exp(struct exportlist *);
static void	free_grp(struct grouplist *);
static void	free_host(struct hostlist *);
static void	free_v4rootexp(void);
static void	get_exportlist_one(int);
static void	get_exportlist(int);
static void	insert_exports(struct exportlist *, struct exportlisthead *);
static void	free_exports(struct exportlisthead *);
static void	read_exportfile(int);
static int	compare_nmount_exportlist(struct iovec *, int, char *);
static int	compare_export(struct exportlist *, struct exportlist *);
static int	compare_cred(struct xucred *, struct xucred *);
static int	compare_secflavor(int *, int *, int);
static void	delete_export(struct iovec *, int, struct statfs *, char *);
static int	get_host(char *, struct grouplist *, struct grouplist *);
static struct hostlist *get_ht(void);
static int	get_line(void);

static void	getexp_err(struct exportlist *, struct grouplist *, const char *);
static struct grouplist	*get_grp(void);
static void	hang_dirp(struct dirlist *, struct grouplist *,
		    struct exportlist *, int, struct xucred *, int);
static void	huphandler(int sig);
static int	makemask(struct sockaddr_storage *ssp, int bitlen);
static void	mntsrv(struct svc_req *, SVCXPRT *);

static int	xdr_mlist(XDR *, caddr_t);
static void	terminate(int);

#define	EXPHASH(f)	(fnv_32_buf((f), sizeof(fsid_t), 0) % exphashsize)
static struct exportlisthead *exphead = NULL;
static struct exportlisthead *oldexphead = NULL;
static int exphashsize = 0;
static SLIST_HEAD(, mountlist) mlhead = SLIST_HEAD_INITIALIZER(&mlhead);
static char *exnames_default[2] = { _PATH_EXPORTS, NULL };
static char **exnames;
static char **hosts = NULL;


static int v4root_phase = 0;
static char v4root_dirpath[PATH_MAX + 1];
static struct exportlist *v4root_ep = NULL;
static int has_publicfh = 0;
static int has_set_publicfh = 0;

static struct pidfh *pfh = NULL;
/* Bits for opt_flags above */

	in_port_t svcport;
	int c, k, s;
	int maxrec = RPC_MAXDATASIZE;
	int attempt_cnt, passno, port_len, port_pos, ret;
	char **port_list;

	passno = 0;
	/* Check that another mountd isn't already running. */
	pfh = pidfile_open(_PATH_MOUNTDPID, 0600, &otherpid);
	if (pfh == NULL) {

	else
		close(s);

	while ((c = getopt(argc, argv, "2deh:Ilnp:rS")) != -1)
		switch (c) {
		case '2':
			force_v2 = 1;

		case 'S':
			suspend_nfsd = 1;
			break;
		case 'I':
			passno = 1;
			break;
		default:
			usage();
		}


	argc -= optind;
	argv += optind;
	grphead = (struct grouplist *)NULL;
	if (argc > 0)
		exnames = argv;
	else

	openlog("mountd", LOG_PID, LOG_DAEMON);
	if (debug)
		warnx("getting export list");
	get_exportlist(0);
	if (debug)
		warnx("getting mount list");
	get_mountlist();

	/* Expand svc_run() here so that we can call get_exportlist(). */
	for (;;) {
		if (got_sighup) {
			get_exportlist(passno);
			got_sighup = 0;
		}
		readfds = svc_fdset;

		if (bad)
			ep = NULL;
		else
			ep = ex_search(&fsb.f_fsid, exphead);
		hostset = defset = 0;
		if (ep && (chk_host(ep->ex_defdir, saddr, &defset, &hostset,
		    &numsecflavors, &secflavorsp) ||

	int false = 0;
	int putdef;
	sigset_t sighup_mask;
	int i;

	sigemptyset(&sighup_mask);
	sigaddset(&sighup_mask, SIGHUP);
	sigprocmask(SIG_BLOCK, &sighup_mask, NULL);

	for (i = 0; i < exphashsize; i++)
		SLIST_FOREACH(ep, &exphead[i], entries) {
			putdef = 0;
			if (put_exlist(ep->ex_dirl, xdrsp, ep->ex_defdir,
				       &putdef, brief))
				goto errout;
			if (ep->ex_defdir && putdef == 0 &&
				put_exlist(ep->ex_defdir, xdrsp, NULL,
				&putdef, brief))
				goto errout;
		}
	sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL);
	if (!xdr_bool(xdrsp, &false))
		return (0);

 * Get the export list from one, currently open file
 */
static void
get_exportlist_one(int passno)
{
	struct exportlist *ep;
	struct grouplist *grp, *tgrp, *savgrp;
	struct dirlist *dirhead;
	struct statfs fsb;
	struct xucred anon;

					 * See if this directory is already
					 * in the list.
					 */
					ep = ex_search(&fsb.f_fsid, exphead);
					if (ep == (struct exportlist *)NULL) {
					    ep = get_exp();
					    ep->ex_fs = fsb.f_fsid;

		 * Loop through hosts, pushing the exports into the kernel.
		 * After loop, tgrp points to the start of the list and
		 * grp points to the last entry in the list.
		 * Do not do the do_mount() for passno == 1, since the
		 * second pass will do it, as required.
		 */
		grp = tgrp;
		do {
			grp->gr_exflags = exflags;
			grp->gr_anon = anon;
			if (passno == 0 && do_mount(ep, grp, exflags, &anon,
			    dirp, dirplen, &fsb, ep->ex_numsecflavors,
			    ep->ex_secflavors)) {
				getexp_err(ep, tgrp, NULL);
				goto nextline;
			}

		 */
		if (v4root_phase > 0 && v4root_phase <= 2) {
			/*
			 * These structures are used for the "-I" reload,
			 * so save them for that case.  Otherwise, just
			 * free them up now.
			 */
			if (passno == 1 && ep != NULL) {
				savgrp = tgrp;
				while (tgrp != NULL) {
					/*
					 * Save the security flavors and exflags
					 * for this host set in the groups.
					 */
					tgrp->gr_numsecflavors =
					    ep->ex_numsecflavors;
					if (ep->ex_numsecflavors > 0)
						memcpy(tgrp->gr_secflavors,
						    ep->ex_secflavors,
						    sizeof(ep->ex_secflavors));
					tgrp = tgrp->gr_next;
				}
				if (v4root_ep == NULL) {
					v4root_ep = ep;
					ep = NULL;	/* Don't free below. */
				}
				grp->gr_next = v4root_ep->ex_grphead;
				v4root_ep->ex_grphead = savgrp;
			}
			if (ep != NULL)
				free_exp(ep);
			while (tgrp != NULL) {

		 * Success. Update the data structures.
		 */
		if (has_host) {
			hang_dirp(dirhead, tgrp, ep, opt_flags, &anon, exflags);
			grp->gr_next = ep->ex_grphead;
			ep->ex_grphead = tgrp;
		} else {
			hang_dirp(dirhead, (struct grouplist *)NULL, ep,
				opt_flags, &anon, exflags);
			free_grp(grp);
		}
		dirhead = (struct dirlist *)NULL;
		if ((ep->ex_flag & EX_LINKED) == 0) {
			insert_exports(ep, exphead);

			ep->ex_flag |= EX_LINKED;
		}

 * Get the export list from all specified files
 */
static void
get_exportlist(int passno)
{
	struct exportlist *ep, *ep2;
	struct grouplist *grp, *tgrp;
	struct export_args export;
	struct iovec *iov;
	struct statfs *mntbufp;
	struct xvfsconf vfc;
	char errmsg[255];
	int num, i;
	int iovlen;
	int done;
	struct nfsex_args eargs;

	MOUNTD_PASSNO("passno", passno);
		(void)nfssvc(NFSSVC_SUSPENDNFSD, NULL);
	v4root_dirpath[0] = '\0';
	free_v4rootexp();
	if (passno == 1) {
		/*
		 * Save the current lists as old ones, so that the new lists
		 * can be compared with the old ones in the 2nd pass.
		 */
		for (i = 0; i < exphashsize; i++) {
			SLIST_FIRST(&oldexphead[i]) = SLIST_FIRST(&exphead[i]);
			SLIST_INIT(&exphead[i]);
		}

		/* Note that the public fh has not yet been set. */
		has_set_publicfh = 0;

		/* Read the export file(s) and process them */
		read_exportfile(passno);
	} else {
		/*
		 * Just make the old lists empty.
		 * exphashsize == 0 for the first call, before oldexphead
		 * has been initialized-->loop won't be executed.
		 */
		for (i = 0; i < exphashsize; i++)
			SLIST_INIT(&oldexphead[i]);
	}

	bzero(&export, sizeof(export));
	export.ex_flags = MNT_DELEXPORT;
	iov = NULL;
	iovlen = 0;
	bzero(errmsg, sizeof(errmsg));

	if (suspend_nfsd != 0)
		(void)nfssvc(NFSSVC_SUSPENDNFSD, NULL);
	/*
	 * Delete the old V4 root dir.
	 */
	SLIST_FOREACH_SAFE(ep, &exphead, entries, ep2) {
		SLIST_REMOVE(&exphead, ep, exportlist, entries);
		free_exp(ep);
	}

	grp = grphead;
	while (grp) {
		tgrp = grp;
		grp = grp->gr_next;
		free_grp(tgrp);
	}
	grphead = (struct grouplist *)NULL;

	/*
	 * and the old V4 root dir.
	 */
	bzero(&eargs, sizeof (eargs));
	eargs.export.ex_flags = MNT_DELEXPORT;

	    errno != ENOENT)
		syslog(LOG_ERR, "Can't delete exports for V4:");

	build_iovec(&iov, &iovlen, "fstype", NULL, 0);
	build_iovec(&iov, &iovlen, "fspath", NULL, 0);
	build_iovec(&iov, &iovlen, "from", NULL, 0);
	build_iovec(&iov, &iovlen, "update", NULL, 0);
	build_iovec(&iov, &iovlen, "export", &export,
	    sizeof(export));
	build_iovec(&iov, &iovlen, "errmsg", errmsg,
	    sizeof(errmsg));

	/*
	 * For passno == 1, compare the old and new lists updating the kernel
	 * exports for any cases that have changed.
	 * This call is doing the second pass through the lists.
	 * If it fails, fall back on the bulk reload.
	 */
	if (passno == 1 && compare_nmount_exportlist(iov, iovlen, errmsg) ==
	    0) {
		MOUNTD_COMPAREOK("compareok");
		/* Free up the old lists. */
		free_exports(oldexphead);
	} else {
		MOUNTD_PASSNO_0("doing passno=0");
		/*
		 * Clear flag that notes if a public fh has been exported.
		 * It is set by do_mount() if MNT_EXPUBLIC is set for the entry.
		 */
		has_publicfh = 0;

		/* exphead == NULL if not yet allocated (first call). */
		if (exphead != NULL) {
			/*
			 * First, get rid of the old lists.
			 */
			free_exports(exphead);
			free_exports(oldexphead);
		}

		/*
		 * And delete exports that are in the kernel for all local
		 * filesystems.
		 * XXX: Should know how to handle all local exportable
		 * filesystems.
		 */
		num = getmntinfo(&mntbufp, MNT_NOWAIT);

		/* Allocate hash tables, for first call. */
		if (exphead == NULL) {
			/* Target an average linked list length of 10. */
			exphashsize = num / 10;
			if (exphashsize < 1)
				exphashsize = 1;
			else if (exphashsize > 100000)
				exphashsize = 100000;
			exphead = malloc(exphashsize * sizeof(*exphead));
			oldexphead = malloc(exphashsize * sizeof(*oldexphead));
			if (exphead == NULL || oldexphead == NULL)
				errx(1, "Can't malloc hash tables");

			for (i = 0; i < exphashsize; i++) {
				SLIST_INIT(&exphead[i]);
				SLIST_INIT(&oldexphead[i]);
			}
		 */
		if (nmount(iov, iovlen, fsp->f_flags) < 0 &&
		    errno != ENOENT && errno != ENOTSUP && errno != EXDEV) {
			syslog(LOG_ERR,
			    "can't delete exports for %s: %m %s",
			    fsp->f_mntonname, errmsg);
		}
	
		for (i = 0; i < num; i++)
			delete_export(iov, iovlen, &mntbufp[i], errmsg);


		/* Read the export file(s) and process them */
		read_exportfile(0);
	}

	if (iov != NULL) {

	}

	/*
	 * If there was no public fh, clear any previous one set.
	 */
	if (has_publicfh == 0)
		(void) nfssvc(NFSSVC_NOPUBLICFH, NULL);

	/* Resume the nfsd. If they weren't suspended, this is harmless. */
	(void)nfssvc(NFSSVC_RESUMENFSD, NULL);
	MOUNTD_EO_GET_EXPORTLIST("eo get exportlist");
}

/*
 * Insert an export entry in the appropriate list.
 */
static void
insert_exports(struct exportlist *ep, struct exportlisthead *exhp)
{
	uint32_t i;

	i = EXPHASH(&ep->ex_fs);
	MOUNTD_FS_HASH("fs hash", ep->ex_fsdir, i);
	SLIST_INSERT_HEAD(&exhp[i], ep, entries);
}

/*
 * Free up the exports lists passed in as arguments.
 */
static void
free_exports(struct exportlisthead *exhp)
{
	struct exportlist *ep, *ep2;
	int i;

	for (i = 0; i < exphashsize; i++) {
		SLIST_FOREACH_SAFE(ep, &exhp[i], entries, ep2) {
			SLIST_REMOVE(&exhp[i], ep, exportlist, entries);
			free_exp(ep);
		}
		SLIST_INIT(&exhp[i]);
	}
}

/*
 * Read the exports file(s) and call get_exportlist_one() for each line.
 */
static void
read_exportfile(int passno)
{
	int done, i;

	/*
	 * Read in the exports file and build the list, calling
	 * nmount() as we go along to push the export rules into the kernel.
	 */

			syslog(LOG_WARNING, "can't open %s", exnames[i]);
			continue;
		}
		get_exportlist_one(passno);
		fclose(exp_file);
		done++;
	}

		syslog(LOG_ERR, "can't open any exports file");
		exit(2);
	}
}

/*
 * Compare the export lists against the old ones and do nmount() operations
 * for any cases that have changed.  This avoids doing nmount() for entries
 * that have not changed.
 * Return 0 upon success, 1 otherwise.
 */
static int
compare_nmount_exportlist(struct iovec *iov, int iovlen, char *errmsg)
{
	struct exportlist *ep, *oep;
	struct grouplist *grp;
	struct statfs fs, ofs;
	int i, ret;

	/*
	 * Loop through the current list and look for an entry in the old
	 * list.
	 * If found, check to see if it the same.
	 *        If it is not the same, delete and re-export.
	 *        Then mark it done on the old list.
	 * else (not found)
	 *        export it.
	 * Any entries left in the old list after processing must have their
	 * exports deleted.
	 */
	for (i = 0; i < exphashsize; i++)
		SLIST_FOREACH(ep, &exphead[i], entries) {
			MOUNTD_FOREACH_EP("foreach ep", ep->ex_fsdir);
			oep = ex_search(&ep->ex_fs, oldexphead);
			if (oep != NULL) {
				/*
				 * Check the mount paths are the same.
				 * If not, return 1 so that the reload of the
				 * exports will be done in bulk, the
				 * passno == 0 way.
				 */
				MOUNTD_FOUND_OLD_EXP("found old exp");
				if (strcmp(ep->ex_fsdir, oep->ex_fsdir) != 0)
					return (1);
				MOUNTD_SAME_FSDIR("same fsdir");
				/*
				 * Test to see if the entry is the same.
				 * If not the same delete exports and
				 * re-export.
				 */
				if (compare_export(ep, oep) != 0) {
					/*
					 * Clear has_publicfh if if was set
					 * in the old exports, but only if it
					 * has not been set during processing of
					 * the exports for this pass, as
					 * indicated by has_set_publicfh.
					 */
					if (has_set_publicfh == 0 &&
					    (oep->ex_flag & EX_PUBLICFH) != 0)
						has_publicfh = 0;

					/* Delete and re-export. */
					if (statfs(ep->ex_fsdir, &fs) < 0)
						return (1);
					delete_export(iov, iovlen, &fs, errmsg);
					ret = do_export_mount(ep, &fs);
					if (ret != 0)
						return (ret);
				}
				oep->ex_flag |= EX_DONE;
				MOUNTD_EXDONE("exdone");
			} else {
				MOUNTD_NOT_FOUND_SO_EXPORT(
				    "not found so export");
				/* Not found, so do export. */
				if (statfs(ep->ex_fsdir, &fs) < 0)
					return (1);
				ret = do_export_mount(ep, &fs);
				if (ret != 0)
					return (ret);
			}
		}

	/* Delete exports not done. */
	for (i = 0; i < exphashsize; i++)
		SLIST_FOREACH(oep, &oldexphead[i], entries) {
			if ((oep->ex_flag & EX_DONE) == 0) {
				MOUNTD_NOT_DONE_DELETE("not done delete",
					oep->ex_fsdir);
				if (statfs(oep->ex_fsdir, &ofs) >= 0 &&
				    oep->ex_fs.val[0] == ofs.f_fsid.val[0] &&
				    oep->ex_fs.val[1] == ofs.f_fsid.val[1]) {
					MOUNTD_DO_DELETE("do_delete");
					/*
					 * Clear has_publicfh if if was set
					 * in the old exports, but only if it
					 * has not been set during processing of
					 * the exports for this pass, as
					 * indicated by has_set_publicfh.
					 */
					if (has_set_publicfh == 0 &&
					    (oep->ex_flag & EX_PUBLICFH) != 0)
						has_publicfh = 0;

					delete_export(iov, iovlen, &ofs,
					    errmsg);
				}
			}
		}

	/* Do the V4 root exports, as required. */
	grp = NULL;
	if (v4root_ep != NULL)
		grp = v4root_ep->ex_grphead;
	v4root_phase = 2;
	while (v4root_ep != NULL && grp != NULL) {
		MOUNTD_V4ROOT_EXPATH("v4root expath", v4root_dirpath);
		ret = do_mount(v4root_ep, grp, grp->gr_exflags, &grp->gr_anon,
		    v4root_dirpath, strlen(v4root_dirpath), &fs,
		    grp->gr_numsecflavors, grp->gr_secflavors);
		if (ret != 0) {
			v4root_phase = 0;
			return (ret);
		}
		grp = grp->gr_next;
	}
	v4root_phase = 0;
	free_v4rootexp();
	return (0);
}

/*
 * Compare old and current exportlist entries for the fsid and return 0
 * if they are the same, 1 otherwise.
 */
static int
compare_export(struct exportlist *ep, struct exportlist *oep)
{
	struct grouplist *grp, *ogrp;

	if (strcmp(ep->ex_fsdir, oep->ex_fsdir) != 0)
		return (1);
	if ((ep->ex_flag & EX_DEFSET) != (oep->ex_flag & EX_DEFSET))
		return (1);
	if ((ep->ex_defdir != NULL && oep->ex_defdir == NULL) ||
	    (ep->ex_defdir == NULL && oep->ex_defdir != NULL))
		return (1);
	if (ep->ex_defdir != NULL && (ep->ex_defdir->dp_flag & DP_DEFSET) !=
	    (oep->ex_defdir->dp_flag & DP_DEFSET))
		return (1);
	if ((ep->ex_flag & EX_DEFSET) != 0 && (ep->ex_defnumsecflavors !=
	    oep->ex_defnumsecflavors || ep->ex_defexflags !=
	    oep->ex_defexflags || compare_cred(&ep->ex_defanon,
	    &oep->ex_defanon) != 0 || compare_secflavor(ep->ex_defsecflavors,
	    oep->ex_defsecflavors, ep->ex_defnumsecflavors) != 0))
		return (1);

	/* Now, check all the groups. */
	for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp = ogrp->gr_next)
		ogrp->gr_flag = 0;
	for (grp = ep->ex_grphead; grp != NULL; grp = grp->gr_next) {
		for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp =
		    ogrp->gr_next)
			if ((ogrp->gr_flag & GR_FND) == 0 &&
			    grp->gr_numsecflavors == ogrp->gr_numsecflavors &&
			    grp->gr_exflags == ogrp->gr_exflags &&
			    compare_cred(&grp->gr_anon, &ogrp->gr_anon) == 0 &&
			    compare_secflavor(grp->gr_secflavors,
			    ogrp->gr_secflavors, grp->gr_numsecflavors) == 0)
				break;
		if (ogrp != NULL)
			ogrp->gr_flag |= GR_FND;
		else
			return (1);
	}
	for (ogrp = oep->ex_grphead; ogrp != NULL; ogrp = ogrp->gr_next)
		if ((ogrp->gr_flag & GR_FND) == 0)
			return (1);
	return (0);
}

/*
 * Compare to struct xucred's.  Return 0 if the same and 1 otherwise.
 */
static int
compare_cred(struct xucred *cr0, struct xucred *cr1)
{
	int fnd, grp_fnd[XU_NGROUPS], i, j;

	if (cr0->cr_uid != cr1->cr_uid || cr0->cr_ngroups != cr1->cr_ngroups)
		return (1);

	/* Handle common cases. */
	if (cr0->cr_ngroups == 0)
		return (0);
	if (cr0->cr_ngroups == 1) {
		if (cr0->cr_groups[0] == cr1->cr_groups[0])
			return (0);
		return (1);
	}
	if (memcmp(cr0->cr_groups, cr1->cr_groups, sizeof(*cr0->cr_groups) *
	    cr0->cr_ngroups) == 0)
		return (0);

	for (i = 0; i < cr0->cr_ngroups; i++)
		grp_fnd[i] = 0;
	/*
	 * Search through the old and new groups lists, noting matches.
	 * Since there is no ordering and duplicates can exist in the lists,
	 * the algorithm is inefficient.  However cr_ngroups is small and
	 * the common cases are handled above.
	 */
	for (i = 0; i < cr0->cr_ngroups; i++) {
		fnd = 0;
		for (j = 0; j < cr0->cr_ngroups; j++) {
			if (cr0->cr_groups[i] == cr1->cr_groups[j]) {
				grp_fnd[j] = 1;
				fnd = 1;
			}
		}
		if (fnd == 0)
			return (1);
	}
	for (i = 0; i < cr0->cr_ngroups; i++)
		if (grp_fnd[i] == 0)
			return (1);
	return (0);
}

/*
 * Compare two lists of security flavors.  Return 0 if the same and 1 otherwise.
 * This is almost identical to compare_cred(), but I didn't factor out
 * the algorithm, since compare_cred() may need to change if/when more than
 * XU_NGROUPS groups are supported.
 */
static int
compare_secflavor(int *sec1, int *sec2, int nsec)
{
	int fnd, sec_fnd[MAXSECFLAVORS], i, j;

	/* Handle common cases first. */
	if (nsec == 0)
		return (0);
	if (nsec == 1) {
		if (sec1[0] == sec2[0])
			return (0);
		return (1);
	}
	if (memcmp(sec1, sec2, sizeof(*sec1) * nsec) == 0)
		return (0);

	for (i = 0; i < nsec; i++)
		sec_fnd[i] = 0;
	/*
	 * Search the new group list starting at the same position in the
	 * Search through the old and new secflavors lists, noting matches.
	 * Since there is no ordering and duplicates can exist in the lists,
	 * the algorithm is inefficient.  However nsec is small and
	 * the common cases are handled above.
	 */
	for (i = 0; i < nsec; i++) {
		fnd = 0;
		for (j = 0; j < nsec; j++) {
			if (sec1[i] == sec2[j]) {
				sec_fnd[j] = 1;
				fnd = 1;
			}
		}
		if (fnd == 0)
			return (1);
	}
	for (i = 0; i < nsec; i++)
		if (sec_fnd[i] == 0)
			return (1);
	return (0);
}

/*
 * Delete an exports entry.
 */
static void
delete_export(struct iovec *iov, int iovlen, struct statfs *fsp, char *errmsg)
{
	struct xvfsconf vfc;

	if (getvfsbyname(fsp->f_fstypename, &vfc) != 0) {
		syslog(LOG_ERR, "getvfsbyname() failed for %s",
		    fsp->f_fstypename);
		return;
	}
	
	/*
	 * We do not need to delete "export" flag from
	 * filesystems that do not have it set.
	 */
	if (!(fsp->f_flags & MNT_EXPORTED))
		return;
	/*
	 * Do not delete export for network filesystem by
	 * passing "export" arg to nmount().
	 * It only makes sense to do this for local filesystems.
	 */
	if (vfc.vfc_flags & VFCF_NETWORK)
		return;
	
	iov[1].iov_base = fsp->f_fstypename;
	iov[1].iov_len = strlen(fsp->f_fstypename) + 1;
	iov[3].iov_base = fsp->f_mntonname;
	iov[3].iov_len = strlen(fsp->f_mntonname) + 1;
	iov[5].iov_base = fsp->f_mntfromname;
	iov[5].iov_len = strlen(fsp->f_mntfromname) + 1;
	errmsg[0] = '\0';
	
	/*
	 * EXDEV is returned when path exists but is not a
	 * mount point.  May happens if raced with unmount.
	 */
	if (nmount(iov, iovlen, fsp->f_flags) < 0 && errno != ENOENT &&
	    errno != ENOTSUP && errno != EXDEV) {
		syslog(LOG_ERR,
		    "can't delete exports for %s: %m %s",
		    fsp->f_mntonname, errmsg);
	}
}

/*

 * Search the export list for a matching fs.
 */
static struct exportlist *
ex_search(fsid_t *fsid, struct exportlisthead *exhp)
{
	struct exportlist *ep;
	uint32_t i;

	i = EXPHASH(fsid);
	SLIST_FOREACH(ep, &exhp[i], entries) {
		if (ep->ex_fs.val[0] == fsid->val[0] &&
		    ep->ex_fs.val[1] == fsid->val[1])
			return (ep);

 */
static void
hang_dirp(struct dirlist *dp, struct grouplist *grp, struct exportlist *ep,
	int flags, struct xucred *anoncrp, int exflags)
{
	struct hostlist *hp;
	struct dirlist *dp2;

		else
			ep->ex_defdir = dp;
		if (grp == (struct grouplist *)NULL) {
			ep->ex_flag |= EX_DEFSET;
			ep->ex_defdir->dp_flag |= DP_DEFSET;
			/* Save the default security flavors list. */
			ep->ex_defnumsecflavors = ep->ex_numsecflavors;
			if (ep->ex_numsecflavors > 0)
				memcpy(ep->ex_defsecflavors, ep->ex_secflavors,
				    sizeof(ep->ex_secflavors));
			ep->ex_defanon = *anoncrp;
			ep->ex_defexflags = exflags;
		} else while (grp) {
			hp = get_ht();
			hp->ht_grp = grp;

		 */
		while (dp) {
			dp2 = dp->dp_left;
			add_dlist(&ep->ex_dirl, dp, grp, flags, ep, anoncrp,
			    exflags);
			dp = dp2;
		}
	}

 */
static void
add_dlist(struct dirlist **dpp, struct dirlist *newdp, struct grouplist *grp,
	int flags, struct exportlist *ep, struct xucred *anoncrp, int exflags)
{
	struct dirlist *dp;
	struct hostlist *hp;

	if (dp) {
		cmp = strcmp(dp->dp_dirp, newdp->dp_dirp);
		if (cmp > 0) {
			add_dlist(&dp->dp_left, newdp, grp, flags, ep, anoncrp,
			    exflags);
			return;
		} else if (cmp < 0) {
			add_dlist(&dp->dp_right, newdp, grp, flags, ep, anoncrp,
			    exflags);
			return;
		} else
			free((caddr_t)newdp);

			grp = grp->gr_next;
		} while (grp);
	} else {
		ep->ex_flag |= EX_DEFSET;
		dp->dp_flag |= DP_DEFSET;
		/* Save the default security flavors list. */
		ep->ex_defnumsecflavors = ep->ex_numsecflavors;
		if (ep->ex_numsecflavors > 0)
			memcpy(ep->ex_defsecflavors, ep->ex_secflavors,
			    sizeof(ep->ex_secflavors));
		ep->ex_defanon = *anoncrp;
		ep->ex_defexflags = exflags;
	}
}


static void
free_exp(struct exportlist *ep)
{
	struct grouplist *grp, *tgrp;

	if (ep->ex_defdir) {
		free_host(ep->ex_defdir->dp_hosts);

	if (ep->ex_indexfile)
		free(ep->ex_indexfile);
	free_dir(ep->ex_dirl);
	grp = ep->ex_grphead;
	while (grp) {
		tgrp = grp;
		grp = grp->gr_next;
		free_grp(tgrp);
	}
	free((caddr_t)ep);
}

/*
 * Free up the v4root exports.
 */
static void
free_v4rootexp(void)
{

	if (v4root_ep != NULL) {
		free_exp(v4root_ep);
		v4root_ep = NULL;
	}
}

/*
 * Free hosts.
 */
static void

}

/*
 * Call do_mount() from the struct exportlist, for each case needed.
 */
static int
do_export_mount(struct exportlist *ep, struct statfs *fsp)
{
	struct grouplist *grp, defgrp;
	int ret;
	size_t dirlen;

	MOUNTD_DO_MOUNT_EXPORT("do mount export", ep->ex_fsdir);
	dirlen = strlen(ep->ex_fsdir);
	if ((ep->ex_flag & EX_DEFSET) != 0) {
		defgrp.gr_type = GT_DEFAULT;
		defgrp.gr_next = NULL;
		/* We have an entry for all other hosts/nets. */
		MOUNTD_EX_DEFEXFLAGS("ex defexflags", ep->ex_defexflags);
		ret = do_mount(ep, &defgrp, ep->ex_defexflags, &ep->ex_defanon,
		    ep->ex_fsdir, dirlen, fsp, ep->ex_defnumsecflavors,
		    ep->ex_defsecflavors);
		if (ret != 0)
			return (ret);
	}

	/* Do a mount for each group. */
	grp = ep->ex_grphead;
	while (grp != NULL) {
		MOUNTD_DO_MOUNT_GR_TYPE("do mount gr type", grp->gr_type,
		    grp->gr_exflags);
		ret = do_mount(ep, grp, grp->gr_exflags, &grp->gr_anon,
		    ep->ex_fsdir, dirlen, fsp, grp->gr_numsecflavors,
		    grp->gr_secflavors);
		if (ret != 0)
			return (ret);
		grp = grp->gr_next;
	}
	return (0);
}

/*
 * Do the nmount() syscall with the update flag to push the export info into
 * the kernel.
 */
static int
do_mount(struct exportlist *ep, struct grouplist *grp, int exflags,
    struct xucred *anoncrp, char *dirp, int dirplen, struct statfs *fsb,
    int numsecflavors, int *secflavors)
{
	struct statfs fsb1;
	struct addrinfo *ai;

	bzero(errmsg, sizeof(errmsg));
	eap->ex_flags = exflags;
	eap->ex_anon = *anoncrp;
	MOUNTD_DO_MOUNT_EXFLAGS("do mount exflags", exflags);
	eap->ex_indexfile = ep->ex_indexfile;
	if (grp->gr_type == GT_HOST)
		ai = grp->gr_ptr.gt_addrinfo;
	else
		ai = NULL;
	eap->ex_numsecflavors = numsecflavors;
	MOUNTD_DO_MOUNT_NUMSEC("do mount numsec", numsecflavors);
	for (i = 0; i < eap->ex_numsecflavors; i++)
		eap->ex_secflavors[i] = secflavors[i];
	if (eap->ex_numsecflavors == 0) {
		eap->ex_numsecflavors = 1;
		eap->ex_secflavors[0] = AUTH_SYS;

			else if (nfssvc(NFSSVC_PUBLICFH, (caddr_t)&fh) < 0)
				syslog(LOG_ERR,
				    "Can't set public fh for %s", public_name);
			else {
				has_publicfh = 1;
				has_set_publicfh = 1;
				ep->ex_flag |= EX_PUBLICFH;
			}
		}
skip:
		if (ai != NULL)

nextfield(char **cp, char **endcp)
{
	char *p;
	char quot = 0;

	p = *cp;
	while (*p == ' ' || *p == '\t')
		p++;
	*cp = p;
	while (*p != '\0') {
		if (quot) {
			if (*p == quot)
				quot = 0;
		} else {
			if (*p == '\\' && *(p + 1) != '\0')
				p++;
			else if (*p == '\'' || *p == '"')
				quot = *p;
			else if (*p == ' ' || *p == '\t')
				break;
		}
		p++;
	};
	*endcp = p;
}

/*

	/*
	 * Get the user's password table entry.
	 */
	names = namelist;
	name = strsep_quote(&names, ":");
	/* Bug?  name could be NULL here */
	if (isdigit(*name) || *name == '-')
		pw = getpwuid(atoi(name));

	}
	cr->cr_ngroups = 0;
	while (names != NULL && *names != '\0' && cr->cr_ngroups < XU_NGROUPS) {
		name = strsep_quote(&names, ":");
		if (isdigit(*name) || *name == '-') {
			cr->cr_groups[cr->cr_ngroups++] = atoi(name);
		} else {




/* $FreeBSD$ */

provider mountd {
	probe passno(char *, int);
	probe compareok(char *);
	probe passno_0(char *);
	probe eo_get_exportlist(char *);
	probe fs_hash(char *, char *, uint32_t);
	probe foreach_ep(char *, char *);
	probe found_old_exp(char *);
	probe same_fsdir(char *);
	probe exdone(char *);
	probe not_found_so_export(char *);
	probe not_done_delete(char *, char *);
	probe do_delete(char *);
	probe v4root_expath(char *, char *);
	probe do_mount_export(char *, char *);
	probe ex_defexflags(char *, int);
	probe do_mount_gr_type(char *, int, int);
	probe do_mount_exflags(char *, int);
	probe do_mount_numsec(char *, int);
};

Return to bug 237860

Lines 28-34 Link Here

(-)usr.sbin/mountd/mountd.8 (-2 / +12 lines)
28	.\" @(#)mountd.8 8.4 (Berkeley) 4/28/95	28	.\" @(#)mountd.8 8.4 (Berkeley) 4/28/95
29	.\" $FreeBSD: head/usr.sbin/mountd/mountd.8 314436 2017-02-28 23:42:47Z imp $	29	.\" $FreeBSD: head/usr.sbin/mountd/mountd.8 314436 2017-02-28 23:42:47Z imp $
30	.\"	30	.\"
31	.Dd October 24, 2016	31	.Dd May 22, 2019
32	.Dt MOUNTD 8	32	.Dt MOUNTD 8
33	.Os	33	.Os
34	.Sh NAME	34	.Sh NAME
Lines 38-44 Link Here
38	mount requests	38	mount requests
39	.Sh SYNOPSIS	39	.Sh SYNOPSIS
40	.Nm	40	.Nm
41	.Op Fl 2delnrS	41	.Op Fl 2deIlnrS
42	.Op Fl h Ar bindip	42	.Op Fl h Ar bindip
43	.Op Fl p Ar port	43	.Op Fl p Ar port
44	.Op Ar exportsfile ...	44	.Op Ar exportsfile ...
Lines 87-92 will automatically add Link Here
87	and if IPv6 is enabled,	87	and if IPv6 is enabled,
88	.Li ::1	88	.Li ::1
89	to the list.	89	to the list.
		90	.It Fl I
		91	Make a reload of the exports file(s) be done via a comparison between the
		92	current and new exports entries, only doing system calls to update the kernel
		93	exports for cases that have changed.
		94	This can reduce the number of system calls being done significantly for
		95	a large number of exported file systems, when only a small number of changes
		96	to the exports have been made.
		97	For a server with 10,000 exported file systems, this can reduce the duration
		98	during which the nfsd threads are suspended during the reload from seconds
		99	to milliseconds.
90	.It Fl l	100	.It Fl l
91	Cause all succeeded	101	Cause all succeeded
92	.Nm	102	.Nm

Line 0 Link Here

(-)usr.sbin/mountd/mountd_dt.d (+22 lines)
	1	/* $FreeBSD$ */
	2
	3	provider mountd {
	4	probe passno(char *, int);
	5	probe compareok(char *);
	6	probe passno_0(char *);
	7	probe eo_get_exportlist(char *);
	8	probe fs_hash(char , char , uint32_t);
	9	probe foreach_ep(char , char );
	10	probe found_old_exp(char *);
	11	probe same_fsdir(char *);
	12	probe exdone(char *);
	13	probe not_found_so_export(char *);
	14	probe not_done_delete(char , char );
	15	probe do_delete(char *);
	16	probe v4root_expath(char , char );
	17	probe do_mount_export(char , char );
	18	probe ex_defexflags(char *, int);
	19	probe do_mount_gr_type(char *, int, int);
	20	probe do_mount_exflags(char *, int);
	21	probe do_mount_numsec(char *, int);
	22	};