Attachment #181420 for bug #218320

Added Link Here

(-)b/TODO.ino64 (+4 lines)
1	Commit checklist: see /preapply.sh
2
3	After commit checklist:
4	1. Regen and commit sys/kern and sys/compat/freebsd32 sysents.




#!/bin/sh

set -e
PATH=$HOME/bin:$PATH

PRISTINE_BASE=/scratch/tmp/kib/obj/scratch/tmp/kib/ino64_master/
CHANGED_BASE=/scratch/tmp/kib/obj/scratch/tmp/kib/ino64/
objs=$(find $CHANGED_BASE \! -regex '.*test.*' \! -regex '.*private.*' \
    -type f -name '*.so.*.full' | sed 's@^'${CHANGED_BASE}'@@' )

exclude_list="libhx509.so.11 libgssapi_ntlm.so.10"
subs_list="libarchive.so.6@libarchive.so.7 libmilter.so.5@libmilter.so.6 libzfs.so.2@libzfs.so.3"

mkdir -p tmp
rm -rf compat_reports tmp/*
troubles=
for obj in $objs; do
#	    -public-headers ${PRISTINE_BASE}/tmp/usr/include
    if echo $obj | grep world32 ; then
	suffix=-32
    else
	suffix=""
    fi
    libname1=$(basename ${obj} | sed 's/\.full//')
    libname=${libname1}${suffix}
    for x in $exclude_list; do
	if [ ${x}${suffix} \= $libname ] ; then
		continue 2
	fi
    done
    changed_obj=${CHANGED_BASE}/${obj}
    pristine_obj=$(echo ${changed_obj} | sed s/ino64/ino64_master/g)
    for x in ${subs_list} ; do
	name1=$(echo ${x} | sed 's/@.*$//')
	name2=$(echo ${x} | sed 's/^.*@//')
	if [ ${name2} \= ${libname1} ]
	   $pristine_obj=$(echo ${pristine_obj} | sed s/${name2}/${name1}/)
    fi
    abi-dumper.pl ${pristine_obj} \
      -lver pristine -o tmp/${libname}-pristine.dump
    abi-dumper.pl ${changed_obj} \
      -lver ino64 -o tmp/${libname}-ino64.dump
    if abi-compliance-checker.pl -l ${libname} \
      -old tmp/${libname}-pristine.dump \
      -new tmp/${libname}-ino64.dump ; then : ; else
	troubles="${troubles} ${libname}"
    fi
done

echo "Troublesome libraries: " ${troubles}

Lines 37-42 SRCS+= libzfs_changelist.c \ Link Here

(-)b/cddl/lib/libzfs/Makefile (+1 lines)
37	zprop_common.c \	37	zprop_common.c \
38		38
39	WARNS?= 0	39	WARNS?= 0
		40	SHLIB_MAJOR= 3
40	CSTD= c99	41	CSTD= c99
41	CFLAGS+= -DZFS_NO_ACL	42	CFLAGS+= -DZFS_NO_ACL
42	CFLAGS+= -I${SRCTOP}/sbin/mount	43	CFLAGS+= -I${SRCTOP}/sbin/mount

Lines 223-229 static void kernel_stat_to_stat(struct kernel_stat in, struct stat out) { Link Here

(-)b/contrib/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc (-3 / +7 lines)
223		223
224	uptr internal_stat(const char path, void buf) {	224	uptr internal_stat(const char path, void buf) {
225	#if SANITIZER_FREEBSD	225	#if SANITIZER_FREEBSD
226	return internal_syscall(SYSCALL(stat), path, buf);	226	return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path,
		227	(uptr)buf, 0);
227	#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS	228	#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
228	return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,	229	return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
229	(uptr)buf, 0);	230	(uptr)buf, 0);
Lines 247-253 uptr internal_stat(const char path, void buf) { Link Here
247		248
248	uptr internal_lstat(const char path, void buf) {	249	uptr internal_lstat(const char path, void buf) {
249	#if SANITIZER_FREEBSD	250	#if SANITIZER_FREEBSD
250	return internal_syscall(SYSCALL(lstat), path, buf);	251	return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path,
		252	(uptr)buf, AT_SYMLINK_NOFOLLOW);
251	#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS	253	#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
252	return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,	254	return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
253	(uptr)buf, AT_SYMLINK_NOFOLLOW);	255	(uptr)buf, AT_SYMLINK_NOFOLLOW);
Lines 590-596 uptr internal_getppid() { Link Here
590	}	592	}
591		593
592	uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {	594	uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
593	#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS	595	#if SANITIZER_FREEBSD
		596	return internal_syscall(SYSCALL(getdirentries), fd, (uptr)dirp, count, NULL);
		597	#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
594	return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);	598	return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);
595	#else	599	#else
596	return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count);	600	return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count);

Lines 489-495 namespace __sanitizer { Link Here

(-)b/contrib/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h (-1 / +2 lines)
489	};	489	};
490	#elif SANITIZER_FREEBSD	490	#elif SANITIZER_FREEBSD
491	struct __sanitizer_dirent {	491	struct __sanitizer_dirent {
492	unsigned int d_fileno;	492	unsigned long long d_fileno;
		493	unsigned long long d_off;
493	unsigned short d_reclen;	494	unsigned short d_reclen;
494	// more fields that we don't care about	495	// more fields that we don't care about
495	};	496	};




int
audit_set_terminal_id(au_tid_t *tid)
{
	dev_t port;
	int ret;

	if (tid == NULL)
		return (kAUBadParamErr);
	if ((ret = audit_set_terminal_port(&port)) != kAUNoErr)
		return (ret);
	tid->port = port;
	return (audit_set_terminal_host(&tid->machine));
}





#include <sys/_types.h>
#include <sys/dirent.h>

#ifndef _SIZE_T_DECLARED
typedef	__size_t	size_t;
#define	_SIZE_T_DECLARED
#endif

#ifndef _SSIZE_T_DECLARED
typedef	__ssize_t	ssize_t;
#define	_SSIZE_T_DECLARED
#endif

#ifndef _OFF_T_DECLARED
typedef	__off_t		off_t;
#define	_OFF_T_DECLARED
#endif

#if __XSI_VISIBLE

#ifndef _INO_T_DECLARED

#if __BSD_VISIBLE
DIR	*__opendir2(const char *, int);
int	 fdclosedir(DIR *);
ssize_t	 getdents(int, char *, size_t);
ssize_t	 getdirentries(int, char *, size_t, off_t *);
#endif
DIR	*opendir(const char *);
DIR	*fdopendir(int);

Lines 11-17 CFLAGS+= -DHAVE_BZLIB_H=1 -DHAVE_LIBLZMA=1 -DHAVE_LZMA_H=1 Link Here

(-)b/lib/libarchive/Makefile (-1 / +1 lines)
11		11
12	# FreeBSD SHLIB_MAJOR value is managed as part of the FreeBSD system.	12	# FreeBSD SHLIB_MAJOR value is managed as part of the FreeBSD system.
13	# It has no real relation to the libarchive version number.	13	# It has no real relation to the libarchive version number.
14	SHLIB_MAJOR= 6	14	SHLIB_MAJOR= 7
15		15
16	CFLAGS+= -DPLATFORM_CONFIG_H=\"${.CURDIR}/config_freebsd.h\"	16	CFLAGS+= -DPLATFORM_CONFIG_H=\"${.CURDIR}/config_freebsd.h\"
17	CFLAGS+= -I${.OBJDIR}	17	CFLAGS+= -I${.OBJDIR}

Lines 148-154 SRCS+= __getosreldate.c \ Link Here

(-)b/lib/libc/gen/Makefile.inc (-1 / +9 lines)
148	waitid.c \	148	waitid.c \
149	wordexp.c	149	wordexp.c
150	.if ${MK_SYMVER} == yes	150	.if ${MK_SYMVER} == yes
151	SRCS+= fts-compat.c \	151	SRCS+= devname-compat11.c \
		152	fts-compat.c \
		153	fts-compat11.c \
		154	ftw-compat11.c \
		155	getmntinfo-compat11.c \
		156	glob-compat11.c \
		157	nftw-compat11.c \
		158	readdir-compat11.c \
		159	scandir-compat11.c \
152	unvis-compat.c	160	unvis-compat.c
153	.endif	161	.endif
154		162




	ctermid;
	ctermid_r;
	daemon;
	devname;
	devname_r;
	getdiskbyname;
	dladdr;
	dlclose;

	setfsent;
	endfsent;
	ftok;
	ftw;
	glob;
	globfree;
	getbootfile;
	getbsize;
	cgetset;

	getloadavg;
	getlogin;
	getlogin_r;
	getmntinfo;
	setnetgrent;
	getnetgrent;
	endnetgrent;

	lrand48;
	modf;
	mrand48;
	nftw;
	nice;
	nlist;
	nrand48;

	pclose;
	psignal;
	raise;
	readdir;
	readdir_r;
	readpassphrase;
	getpass;
	rewinddir;
	scandir;
	alphasort;
	seed48;
	seekdir;
	user_from_uid;

	fdevname_r;
	fdopendir;
	feature_present;
	fts_children;
	fts_close;
	fts_get_clientptr;
	fts_get_stream;
	fts_open;
	fts_read;
	fts_set;
	fts_set_clientptr;
	posix_spawn;
	posix_spawn_file_actions_addclose;
	posix_spawn_file_actions_adddup2;

	pthread_mutex_consistent;
	pthread_mutexattr_getrobust;
	pthread_mutexattr_setrobust;
	scandir_b;
	stravis;
};

FBSD_1.5 {
	alphasort;
	basename;
	devname;
	devname_r;
	dirname;
	fts_children;
	fts_close;
	fts_get_clientptr;
	fts_get_stream;
	fts_open;
	fts_read;
	fts_set;
	fts_set_clientptr;
	ftw;
	getmntinfo;
	glob;
	globfree;
	nftw;
	readdir;
	readdir_r;
	scandir;
	scandir_b;
	sem_clockwait_np;
};





/*-
 * Copyright (c) 2011 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include "gen-compat.h"

char *
freebsd11_devname(uint32_t dev, mode_t type)
{

	return (devname(dev, type));
}

char *
freebsd11_devname_r(uint32_t dev, mode_t type, char *buf, int len)
{

	return (devname_r(dev, type, buf, len));
}

__sym_compat(devname, freebsd11_devname, FBSD_1.0);
__sym_compat(devname_r, freebsd11_devname_r, FBSD_1.0);





#include "namespace.h"
#include <sys/param.h>
#define	_WANT_FREEBSD11_STATFS
#include <sys/mount.h>
#define	_WANT_FREEBSD11_STAT
#include <sys/stat.h>

#define	_WANT_FREEBSD11_DIRENT
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "gen-compat.h"
#include "fts-compat.h"
#include "un-namespace.h"


 */
struct _fts_private {
	FTS		ftsp_fts;
	struct freebsd11_statfs	ftsp_statfs;
	uint32_t	ftsp_dev;
	int		ftsp_linksreliable;
};


static FTSENT *
fts_build(FTS *sp, int type)
{
	struct freebsd11_dirent *dp;
	FTSENT *p, *head;
	int nitems;
	FTSENT *cur, *tail;


	/* Read the directory, attaching each entry to the `link' pointer. */
	doadjust = 0;
	for (head = tail = NULL, nitems = 0;
	    dirp && (dp = freebsd11_readdir(dirp));) {
		dnamlen = dp->d_namlen;
		if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
			continue;

fts_stat(FTS *sp, FTSENT *p, int follow)
{
	FTSENT *t;
	uint32_t dev;
	uint32_t ino;
	struct freebsd11_stat *sbp, sb;
	int saved_errno;

	/* If user needs stat info, stat buffer already allocated. */

	 * fail, set the errno from the stat call.
	 */
	if (ISSET(FTS_LOGICAL) || follow) {
		if (freebsd11_stat(p->fts_accpath, sbp)) {
			saved_errno = errno;
			if (!freebsd11_lstat(p->fts_accpath, sbp)) {
				errno = 0;
				return (FTS_SLNONE);
			}
			p->fts_errno = saved_errno;
			goto err;
		}
	} else if (freebsd11_lstat(p->fts_accpath, sbp)) {
		p->fts_errno = errno;
err:		memset(sbp, 0, sizeof(struct stat));
		return (FTS_NS);


	struct ftsent_withstat {
		FTSENT	ent;
		struct	freebsd11_stat statbuf;
	};

	/*

fts_safe_changedir(FTS *sp, FTSENT *p, int fd, char *path)
{
	int ret, oerrno, newfd;
	struct freebsd11_stat sb;

	newfd = fd;
	if (ISSET(FTS_NOCHDIR))
		return (0);
	if (fd < 0 && (newfd = _open(path, O_RDONLY | O_CLOEXEC, 0)) < 0)
		return (-1);
	if (freebsd11_fstat(newfd, &sb)) {
		ret = -1;
		goto bail;
	}

	 * avoidance.
	 */
	if (priv->ftsp_dev != ent->fts_dev) {
		if (freebsd11_statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
			priv->ftsp_dev = ent->fts_dev;
			priv->ftsp_linksreliable = 0;
			for (cpp = ufslike_filesystems; *cpp; cpp++) {




	struct _ftsent *fts_cur;	/* current node */
	struct _ftsent *fts_child;	/* linked list of children */
	struct _ftsent **fts_array;	/* sort array */
	uint32_t fts_dev;		/* starting device # */
	char *fts_path;			/* path for this descent */
	int fts_rfd;			/* fd for root */
	int fts_pathlen;		/* sizeof(path) */

	u_short fts_pathlen;		/* strlen(fts_path) */
	u_short fts_namelen;		/* strlen(fts_name) */

	uint32_t fts_ino;		/* inode */
	uint32_t fts_dev;		/* device */
	uint16_t fts_nlink;		/* link count */

#define	FTS_ROOTPARENTLEVEL	-1
#define	FTS_ROOTLEVEL		 0

#define	FTS_SKIP	 4		/* discard node */
	u_short fts_instr;		/* fts_set() instructions */

	struct freebsd11_stat *fts_statp; /* stat(2) information */
	char *fts_name;			/* file name */
	FTS *fts_fts;			/* back pointer to main FTS */
} FTSENT;




/*-
 * Copyright (c) 1990, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. 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.
 *
 * from: $OpenBSD: fts.c,v 1.22 1999/10/03 19:22:22 millert Exp $
 */

#if 0
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)fts.c	8.6 (Berkeley) 8/14/94";
#endif /* LIBC_SCCS and not lint */
#endif

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#define	_WANT_FREEBSD11_STATFS
#include <sys/mount.h>
#define	_WANT_FREEBSD11_STAT
#include <sys/stat.h>

#define	_WANT_FREEBSD11_DIRENT
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <fts.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "gen-compat.h"
#include "fts-compat11.h"
#include "un-namespace.h"

#include "gen-private.h"

static FTSENT11	*fts_alloc(FTS11 *, char *, size_t);
static FTSENT11	*fts_build(FTS11 *, int);
static void	 fts_lfree(FTSENT11 *);
static void	 fts_load(FTS11 *, FTSENT11 *);
static size_t	 fts_maxarglen(char * const *);
static void	 fts_padjust(FTS11 *, FTSENT11 *);
static int	 fts_palloc(FTS11 *, size_t);
static FTSENT11	*fts_sort(FTS11 *, FTSENT11 *, size_t);
static int	 fts_stat(FTS11 *, FTSENT11 *, int, int);
static int	 fts_safe_changedir(FTS11 *, FTSENT11 *, int, char *);
static int	 fts_ufslinks(FTS11 *, const FTSENT11 *);

#define	ISDOT(a)	(a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))

#define	CLR(opt)	(sp->fts_options &= ~(opt))
#define	ISSET(opt)	(sp->fts_options & (opt))
#define	SET(opt)	(sp->fts_options |= (opt))

#define	FCHDIR(sp, fd)	(!ISSET(FTS_NOCHDIR) && fchdir(fd))

/* fts_build flags */
#define	BCHILD		1		/* fts_children */
#define	BNAMES		2		/* fts_children, names only */
#define	BREAD		3		/* fts_read */

/*
 * Internal representation of an FTS, including extra implementation
 * details.  The FTS returned from fts_open points to this structure's
 * ftsp_fts member (and can be cast to an _fts_private as required)
 */
struct _fts_private11 {
	FTS11		ftsp_fts;
	struct freebsd11_statfs	ftsp_statfs;
	uint32_t	ftsp_dev;
	int		ftsp_linksreliable;
};

/*
 * The "FTS_NOSTAT" option can avoid a lot of calls to stat(2) if it
 * knows that a directory could not possibly have subdirectories.  This
 * is decided by looking at the link count: a subdirectory would
 * increment its parent's link count by virtue of its own ".." entry.
 * This assumption only holds for UFS-like filesystems that implement
 * links and directories this way, so we must punt for others.
 */

static const char *ufslike_filesystems[] = {
	"ufs",
	"zfs",
	"nfs",
	"ext2fs",
	0
};

FTS11 *
freebsd11_fts_open(char * const *argv, int options,
    int (*compar)(const FTSENT11 * const *, const FTSENT11 * const *))
{
	struct _fts_private11 *priv;
	FTS11 *sp;
	FTSENT11 *p, *root;
	FTSENT11 *parent, *tmp;
	size_t len, nitems;

	/* Options check. */
	if (options & ~FTS_OPTIONMASK) {
		errno = EINVAL;
		return (NULL);
	}

	/* fts_open() requires at least one path */
	if (*argv == NULL) {
		errno = EINVAL;
		return (NULL);
	}

	/* Allocate/initialize the stream. */
	if ((priv = calloc(1, sizeof(*priv))) == NULL)
		return (NULL);
	sp = &priv->ftsp_fts;
	sp->fts_compar = compar;
	sp->fts_options = options;

	/* Shush, GCC. */
	tmp = NULL;

	/* Logical walks turn on NOCHDIR; symbolic links are too hard. */
	if (ISSET(FTS_LOGICAL))
		SET(FTS_NOCHDIR);

	/*
	 * Start out with 1K of path space, and enough, in any case,
	 * to hold the user's paths.
	 */
	if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN)))
		goto mem1;

	/* Allocate/initialize root's parent. */
	if ((parent = fts_alloc(sp, "", 0)) == NULL)
		goto mem2;
	parent->fts_level = FTS_ROOTPARENTLEVEL;

	/* Allocate/initialize root(s). */
	for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
		len = strlen(*argv);

		p = fts_alloc(sp, *argv, len);
		p->fts_level = FTS_ROOTLEVEL;
		p->fts_parent = parent;
		p->fts_accpath = p->fts_name;
		p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW), -1);

		/* Command-line "." and ".." are real directories. */
		if (p->fts_info == FTS_DOT)
			p->fts_info = FTS_D;

		/*
		 * If comparison routine supplied, traverse in sorted
		 * order; otherwise traverse in the order specified.
		 */
		if (compar) {
			p->fts_link = root;
			root = p;
		} else {
			p->fts_link = NULL;
			if (root == NULL)
				tmp = root = p;
			else {
				tmp->fts_link = p;
				tmp = p;
			}
		}
	}
	if (compar && nitems > 1)
		root = fts_sort(sp, root, nitems);

	/*
	 * Allocate a dummy pointer and make fts_read think that we've just
	 * finished the node before the root(s); set p->fts_info to FTS_INIT
	 * so that everything about the "current" node is ignored.
	 */
	if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
		goto mem3;
	sp->fts_cur->fts_link = root;
	sp->fts_cur->fts_info = FTS_INIT;

	/*
	 * If using chdir(2), grab a file descriptor pointing to dot to ensure
	 * that we can get back here; this could be avoided for some paths,
	 * but almost certainly not worth the effort.  Slashes, symbolic links,
	 * and ".." are all fairly nasty problems.  Note, if we can't get the
	 * descriptor we run anyway, just more slowly.
	 */
	if (!ISSET(FTS_NOCHDIR) &&
	    (sp->fts_rfd = _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0)
		SET(FTS_NOCHDIR);

	return (sp);

mem3:	fts_lfree(root);
	free(parent);
mem2:	free(sp->fts_path);
mem1:	free(sp);
	return (NULL);
}

static void
fts_load(FTS11 *sp, FTSENT11 *p)
{
	size_t len;
	char *cp;

	/*
	 * Load the stream structure for the next traversal.  Since we don't
	 * actually enter the directory until after the preorder visit, set
	 * the fts_accpath field specially so the chdir gets done to the right
	 * place and the user can access the first node.  From fts_open it's
	 * known that the path will fit.
	 */
	len = p->fts_pathlen = p->fts_namelen;
	memmove(sp->fts_path, p->fts_name, len + 1);
	if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
		len = strlen(++cp);
		memmove(p->fts_name, cp, len + 1);
		p->fts_namelen = len;
	}
	p->fts_accpath = p->fts_path = sp->fts_path;
	sp->fts_dev = p->fts_dev;
}

int
freebsd11_fts_close(FTS11 *sp)
{
	FTSENT11 *freep, *p;
	int saved_errno;

	/*
	 * This still works if we haven't read anything -- the dummy structure
	 * points to the root list, so we step through to the end of the root
	 * list which has a valid parent pointer.
	 */
	if (sp->fts_cur) {
		for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
			freep = p;
			p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
			free(freep);
		}
		free(p);
	}

	/* Free up child linked list, sort array, path buffer. */
	if (sp->fts_child)
		fts_lfree(sp->fts_child);
	if (sp->fts_array)
		free(sp->fts_array);
	free(sp->fts_path);

	/* Return to original directory, save errno if necessary. */
	if (!ISSET(FTS_NOCHDIR)) {
		saved_errno = fchdir(sp->fts_rfd) ? errno : 0;
		(void)_close(sp->fts_rfd);

		/* Set errno and return. */
		if (saved_errno != 0) {
			/* Free up the stream pointer. */
			free(sp);
			errno = saved_errno;
			return (-1);
		}
	}

	/* Free up the stream pointer. */
	free(sp);
	return (0);
}

/*
 * Special case of "/" at the end of the path so that slashes aren't
 * appended which would cause paths to be written as "....//foo".
 */
#define	NAPPEND(p)							\
	(p->fts_path[p->fts_pathlen - 1] == '/'				\
	    ? p->fts_pathlen - 1 : p->fts_pathlen)

FTSENT11 *
freebsd11_fts_read(FTS11 *sp)
{
	FTSENT11 *p, *tmp;
	int instr;
	char *t;
	int saved_errno;

	/* If finished or unrecoverable error, return NULL. */
	if (sp->fts_cur == NULL || ISSET(FTS_STOP))
		return (NULL);

	/* Set current node pointer. */
	p = sp->fts_cur;

	/* Save and zero out user instructions. */
	instr = p->fts_instr;
	p->fts_instr = FTS_NOINSTR;

	/* Any type of file may be re-visited; re-stat and re-turn. */
	if (instr == FTS_AGAIN) {
		p->fts_info = fts_stat(sp, p, 0, -1);
		return (p);
	}

	/*
	 * Following a symlink -- SLNONE test allows application to see
	 * SLNONE and recover.  If indirecting through a symlink, have
	 * keep a pointer to current location.  If unable to get that
	 * pointer, follow fails.
	 */
	if (instr == FTS_FOLLOW &&
	    (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
		p->fts_info = fts_stat(sp, p, 1, -1);
		if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
			if ((p->fts_symfd = _open(".", O_RDONLY | O_CLOEXEC,
			    0)) < 0) {
				p->fts_errno = errno;
				p->fts_info = FTS_ERR;
			} else
				p->fts_flags |= FTS_SYMFOLLOW;
		}
		return (p);
	}

	/* Directory in pre-order. */
	if (p->fts_info == FTS_D) {
		/* If skipped or crossed mount point, do post-order visit. */
		if (instr == FTS_SKIP ||
		    (ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
			if (p->fts_flags & FTS_SYMFOLLOW)
				(void)_close(p->fts_symfd);
			if (sp->fts_child) {
				fts_lfree(sp->fts_child);
				sp->fts_child = NULL;
			}
			p->fts_info = FTS_DP;
			return (p);
		}

		/* Rebuild if only read the names and now traversing. */
		if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
			CLR(FTS_NAMEONLY);
			fts_lfree(sp->fts_child);
			sp->fts_child = NULL;
		}

		/*
		 * Cd to the subdirectory.
		 *
		 * If have already read and now fail to chdir, whack the list
		 * to make the names come out right, and set the parent errno
		 * so the application will eventually get an error condition.
		 * Set the FTS_DONTCHDIR flag so that when we logically change
		 * directories back to the parent we don't do a chdir.
		 *
		 * If haven't read do so.  If the read fails, fts_build sets
		 * FTS_STOP or the fts_info field of the node.
		 */
		if (sp->fts_child != NULL) {
			if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
				p->fts_errno = errno;
				p->fts_flags |= FTS_DONTCHDIR;
				for (p = sp->fts_child; p != NULL;
				    p = p->fts_link)
					p->fts_accpath =
					    p->fts_parent->fts_accpath;
			}
		} else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
			if (ISSET(FTS_STOP))
				return (NULL);
			return (p);
		}
		p = sp->fts_child;
		sp->fts_child = NULL;
		goto name;
	}

	/* Move to the next node on this level. */
next:	tmp = p;
	if ((p = p->fts_link) != NULL) {
		/*
		 * If reached the top, return to the original directory (or
		 * the root of the tree), and load the paths for the next root.
		 */
		if (p->fts_level == FTS_ROOTLEVEL) {
			if (FCHDIR(sp, sp->fts_rfd)) {
				SET(FTS_STOP);
				return (NULL);
			}
			free(tmp);
			fts_load(sp, p);
			return (sp->fts_cur = p);
		}

		/*
		 * User may have called fts_set on the node.  If skipped,
		 * ignore.  If followed, get a file descriptor so we can
		 * get back if necessary.
		 */
		if (p->fts_instr == FTS_SKIP) {
			free(tmp);
			goto next;
		}
		if (p->fts_instr == FTS_FOLLOW) {
			p->fts_info = fts_stat(sp, p, 1, -1);
			if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
				if ((p->fts_symfd =
				    _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0) {
					p->fts_errno = errno;
					p->fts_info = FTS_ERR;
				} else
					p->fts_flags |= FTS_SYMFOLLOW;
			}
			p->fts_instr = FTS_NOINSTR;
		}

		free(tmp);

name:		t = sp->fts_path + NAPPEND(p->fts_parent);
		*t++ = '/';
		memmove(t, p->fts_name, p->fts_namelen + 1);
		return (sp->fts_cur = p);
	}

	/* Move up to the parent node. */
	p = tmp->fts_parent;

	if (p->fts_level == FTS_ROOTPARENTLEVEL) {
		/*
		 * Done; free everything up and set errno to 0 so the user
		 * can distinguish between error and EOF.
		 */
		free(tmp);
		free(p);
		errno = 0;
		return (sp->fts_cur = NULL);
	}

	/* NUL terminate the pathname. */
	sp->fts_path[p->fts_pathlen] = '\0';

	/*
	 * Return to the parent directory.  If at a root node or came through
	 * a symlink, go back through the file descriptor.  Otherwise, cd up
	 * one directory.
	 */
	if (p->fts_level == FTS_ROOTLEVEL) {
		if (FCHDIR(sp, sp->fts_rfd)) {
			SET(FTS_STOP);
			return (NULL);
		}
	} else if (p->fts_flags & FTS_SYMFOLLOW) {
		if (FCHDIR(sp, p->fts_symfd)) {
			saved_errno = errno;
			(void)_close(p->fts_symfd);
			errno = saved_errno;
			SET(FTS_STOP);
			return (NULL);
		}
		(void)_close(p->fts_symfd);
	} else if (!(p->fts_flags & FTS_DONTCHDIR) &&
	    fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
		SET(FTS_STOP);
		return (NULL);
	}
	free(tmp);
	p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
	return (sp->fts_cur = p);
}

/*
 * Fts_set takes the stream as an argument although it's not used in this
 * implementation; it would be necessary if anyone wanted to add global
 * semantics to fts using fts_set.  An error return is allowed for similar
 * reasons.
 */
/* ARGSUSED */
int
freebsd11_fts_set(FTS11 *sp, FTSENT11 *p, int instr)
{
	if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
	    instr != FTS_NOINSTR && instr != FTS_SKIP) {
		errno = EINVAL;
		return (1);
	}
	p->fts_instr = instr;
	return (0);
}

FTSENT11 *
freebsd11_fts_children(FTS11 *sp, int instr)
{
	FTSENT11 *p;
	int fd, rc, serrno;

	if (instr != 0 && instr != FTS_NAMEONLY) {
		errno = EINVAL;
		return (NULL);
	}

	/* Set current node pointer. */
	p = sp->fts_cur;

	/*
	 * Errno set to 0 so user can distinguish empty directory from
	 * an error.
	 */
	errno = 0;

	/* Fatal errors stop here. */
	if (ISSET(FTS_STOP))
		return (NULL);

	/* Return logical hierarchy of user's arguments. */
	if (p->fts_info == FTS_INIT)
		return (p->fts_link);

	/*
	 * If not a directory being visited in pre-order, stop here.  Could
	 * allow FTS_DNR, assuming the user has fixed the problem, but the
	 * same effect is available with FTS_AGAIN.
	 */
	if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
		return (NULL);

	/* Free up any previous child list. */
	if (sp->fts_child != NULL)
		fts_lfree(sp->fts_child);

	if (instr == FTS_NAMEONLY) {
		SET(FTS_NAMEONLY);
		instr = BNAMES;
	} else
		instr = BCHILD;

	/*
	 * If using chdir on a relative path and called BEFORE fts_read does
	 * its chdir to the root of a traversal, we can lose -- we need to
	 * chdir into the subdirectory, and we don't know where the current
	 * directory is, so we can't get back so that the upcoming chdir by
	 * fts_read will work.
	 */
	if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
	    ISSET(FTS_NOCHDIR))
		return (sp->fts_child = fts_build(sp, instr));

	if ((fd = _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0)
		return (NULL);
	sp->fts_child = fts_build(sp, instr);
	serrno = (sp->fts_child == NULL) ? errno : 0;
	rc = fchdir(fd);
	if (rc < 0 && serrno == 0)
		serrno = errno;
	(void)_close(fd);
	errno = serrno;
	if (rc < 0)
		return (NULL);
	return (sp->fts_child);
}

#ifndef freebsd11_fts_get_clientptr
#error "freebsd11_fts_get_clientptr not defined"
#endif

void *
(freebsd11_fts_get_clientptr)(FTS11 *sp)
{

	return (freebsd11_fts_get_clientptr(sp));
}

#ifndef freebsd11_fts_get_stream
#error "freebsd11_fts_get_stream not defined"
#endif

FTS11 *
(freebsd11_fts_get_stream)(FTSENT11 *p)
{
	return (freebsd11_fts_get_stream(p));
}

void
freebsd11_fts_set_clientptr(FTS11 *sp, void *clientptr)
{

	sp->fts_clientptr = clientptr;
}

/*
 * This is the tricky part -- do not casually change *anything* in here.  The
 * idea is to build the linked list of entries that are used by fts_children
 * and fts_read.  There are lots of special cases.
 *
 * The real slowdown in walking the tree is the stat calls.  If FTS_NOSTAT is
 * set and it's a physical walk (so that symbolic links can't be directories),
 * we can do things quickly.  First, if it's a 4.4BSD file system, the type
 * of the file is in the directory entry.  Otherwise, we assume that the number
 * of subdirectories in a node is equal to the number of links to the parent.
 * The former skips all stat calls.  The latter skips stat calls in any leaf
 * directories and for any files after the subdirectories in the directory have
 * been found, cutting the stat calls by about 2/3.
 */
static FTSENT11 *
fts_build(FTS11 *sp, int type)
{
	struct freebsd11_dirent *dp;
	FTSENT11 *p, *head;
	FTSENT11 *cur, *tail;
	DIR *dirp;
	void *oldaddr;
	char *cp;
	int cderrno, descend, oflag, saved_errno, nostat, doadjust;
	long level;
	long nlinks;	/* has to be signed because -1 is a magic value */
	size_t dnamlen, len, maxlen, nitems;

	/* Set current node pointer. */
	cur = sp->fts_cur;

	/*
	 * Open the directory for reading.  If this fails, we're done.
	 * If being called from fts_read, set the fts_info field.
	 */
#ifdef FTS_WHITEOUT
	if (ISSET(FTS_WHITEOUT))
		oflag = DTF_NODUP | DTF_REWIND;
	else
		oflag = DTF_HIDEW | DTF_NODUP | DTF_REWIND;
#else
#define __opendir2(path, flag) opendir(path)
#endif
	if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
		if (type == BREAD) {
			cur->fts_info = FTS_DNR;
			cur->fts_errno = errno;
		}
		return (NULL);
	}

	/*
	 * Nlinks is the number of possible entries of type directory in the
	 * directory if we're cheating on stat calls, 0 if we're not doing
	 * any stat calls at all, -1 if we're doing stats on everything.
	 */
	if (type == BNAMES) {
		nlinks = 0;
		/* Be quiet about nostat, GCC. */
		nostat = 0;
	} else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
		if (fts_ufslinks(sp, cur))
			nlinks = cur->fts_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2);
		else
			nlinks = -1;
		nostat = 1;
	} else {
		nlinks = -1;
		nostat = 0;
	}

#ifdef notdef
	(void)printf("nlinks == %d (cur: %d)\n", nlinks, cur->fts_nlink);
	(void)printf("NOSTAT %d PHYSICAL %d SEEDOT %d\n",
	    ISSET(FTS_NOSTAT), ISSET(FTS_PHYSICAL), ISSET(FTS_SEEDOT));
#endif
	/*
	 * If we're going to need to stat anything or we want to descend
	 * and stay in the directory, chdir.  If this fails we keep going,
	 * but set a flag so we don't chdir after the post-order visit.
	 * We won't be able to stat anything, but we can still return the
	 * names themselves.  Note, that since fts_read won't be able to
	 * chdir into the directory, it will have to return different path
	 * names than before, i.e. "a/b" instead of "b".  Since the node
	 * has already been visited in pre-order, have to wait until the
	 * post-order visit to return the error.  There is a special case
	 * here, if there was nothing to stat then it's not an error to
	 * not be able to stat.  This is all fairly nasty.  If a program
	 * needed sorted entries or stat information, they had better be
	 * checking FTS_NS on the returned nodes.
	 */
	cderrno = 0;
	if (nlinks || type == BREAD) {
		if (fts_safe_changedir(sp, cur, _dirfd(dirp), NULL)) {
			if (nlinks && type == BREAD)
				cur->fts_errno = errno;
			cur->fts_flags |= FTS_DONTCHDIR;
			descend = 0;
			cderrno = errno;
		} else
			descend = 1;
	} else
		descend = 0;

	/*
	 * Figure out the max file name length that can be stored in the
	 * current path -- the inner loop allocates more path as necessary.
	 * We really wouldn't have to do the maxlen calculations here, we
	 * could do them in fts_read before returning the path, but it's a
	 * lot easier here since the length is part of the dirent structure.
	 *
	 * If not changing directories set a pointer so that can just append
	 * each new name into the path.
	 */
	len = NAPPEND(cur);
	if (ISSET(FTS_NOCHDIR)) {
		cp = sp->fts_path + len;
		*cp++ = '/';
	} else {
		/* GCC, you're too verbose. */
		cp = NULL;
	}
	len++;
	maxlen = sp->fts_pathlen - len;

	level = cur->fts_level + 1;

	/* Read the directory, attaching each entry to the `link' pointer. */
	doadjust = 0;
	for (head = tail = NULL, nitems = 0;
	    dirp && (dp = freebsd11_readdir(dirp));) {
		dnamlen = dp->d_namlen;
		if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
			continue;

		if ((p = fts_alloc(sp, dp->d_name, dnamlen)) == NULL)
			goto mem1;
		if (dnamlen >= maxlen) {	/* include space for NUL */
			oldaddr = sp->fts_path;
			if (fts_palloc(sp, dnamlen + len + 1)) {
				/*
				 * No more memory for path or structures.  Save
				 * errno, free up the current structure and the
				 * structures already allocated.
				 */
mem1:				saved_errno = errno;
				if (p)
					free(p);
				fts_lfree(head);
				(void)closedir(dirp);
				cur->fts_info = FTS_ERR;
				SET(FTS_STOP);
				errno = saved_errno;
				return (NULL);
			}
			/* Did realloc() change the pointer? */
			if (oldaddr != sp->fts_path) {
				doadjust = 1;
				if (ISSET(FTS_NOCHDIR))
					cp = sp->fts_path + len;
			}
			maxlen = sp->fts_pathlen - len;
		}

		p->fts_level = level;
		p->fts_parent = sp->fts_cur;
		p->fts_pathlen = len + dnamlen;

#ifdef FTS_WHITEOUT
		if (dp->d_type == DT_WHT)
			p->fts_flags |= FTS_ISW;
#endif

		if (cderrno) {
			if (nlinks) {
				p->fts_info = FTS_NS;
				p->fts_errno = cderrno;
			} else
				p->fts_info = FTS_NSOK;
			p->fts_accpath = cur->fts_accpath;
		} else if (nlinks == 0
#ifdef DT_DIR
		    || (nostat &&
		    dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
#endif
		    ) {
			p->fts_accpath =
			    ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
			p->fts_info = FTS_NSOK;
		} else {
			/* Build a file name for fts_stat to stat. */
			if (ISSET(FTS_NOCHDIR)) {
				p->fts_accpath = p->fts_path;
				memmove(cp, p->fts_name, p->fts_namelen + 1);
				p->fts_info = fts_stat(sp, p, 0, _dirfd(dirp));
			} else {
				p->fts_accpath = p->fts_name;
				p->fts_info = fts_stat(sp, p, 0, -1);
			}

			/* Decrement link count if applicable. */
			if (nlinks > 0 && (p->fts_info == FTS_D ||
			    p->fts_info == FTS_DC || p->fts_info == FTS_DOT))
				--nlinks;
		}

		/* We walk in directory order so "ls -f" doesn't get upset. */
		p->fts_link = NULL;
		if (head == NULL)
			head = tail = p;
		else {
			tail->fts_link = p;
			tail = p;
		}
		++nitems;
	}
	if (dirp)
		(void)closedir(dirp);

	/*
	 * If realloc() changed the address of the path, adjust the
	 * addresses for the rest of the tree and the dir list.
	 */
	if (doadjust)
		fts_padjust(sp, head);

	/*
	 * If not changing directories, reset the path back to original
	 * state.
	 */
	if (ISSET(FTS_NOCHDIR))
		sp->fts_path[cur->fts_pathlen] = '\0';

	/*
	 * If descended after called from fts_children or after called from
	 * fts_read and nothing found, get back.  At the root level we use
	 * the saved fd; if one of fts_open()'s arguments is a relative path
	 * to an empty directory, we wind up here with no other way back.  If
	 * can't get back, we're done.
	 */
	if (descend && (type == BCHILD || !nitems) &&
	    (cur->fts_level == FTS_ROOTLEVEL ?
	    FCHDIR(sp, sp->fts_rfd) :
	    fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
		fts_lfree(head);
		cur->fts_info = FTS_ERR;
		SET(FTS_STOP);
		return (NULL);
	}

	/* If didn't find anything, return NULL. */
	if (!nitems) {
		if (type == BREAD)
			cur->fts_info = FTS_DP;
		return (NULL);
	}

	/* Sort the entries. */
	if (sp->fts_compar && nitems > 1)
		head = fts_sort(sp, head, nitems);
	return (head);
}

static int
fts_stat(FTS11 *sp, FTSENT11 *p, int follow, int dfd)
{
	FTSENT11 *t;
	uint32_t dev;
	uint32_t ino;
	struct freebsd11_stat *sbp, sb;
	int saved_errno;
	const char *path;

	if (dfd == -1)
		path = p->fts_accpath, dfd = AT_FDCWD;
	else
		path = p->fts_name;

	/* If user needs stat info, stat buffer already allocated. */
	sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;

#ifdef FTS_WHITEOUT
	/* Check for whiteout. */
	if (p->fts_flags & FTS_ISW) {
		if (sbp != &sb) {
			memset(sbp, '\0', sizeof(*sbp));
			sbp->st_mode = S_IFWHT;
		}
		return (FTS_W);
	}
#endif

	/*
	 * If doing a logical walk, or application requested FTS_FOLLOW, do
	 * a stat(2).  If that fails, check for a non-existent symlink.  If
	 * fail, set the errno from the stat call.
	 */
	if (ISSET(FTS_LOGICAL) || follow) {
		if (freebsd11_fstatat(dfd, path, sbp, 0)) {
			saved_errno = errno;
			if (freebsd11_fstatat(dfd, path, sbp,
			    AT_SYMLINK_NOFOLLOW)) {
				p->fts_errno = saved_errno;
				goto err;
			}
			errno = 0;
			if (S_ISLNK(sbp->st_mode))
				return (FTS_SLNONE);
		}
	} else if (freebsd11_fstatat(dfd, path, sbp, AT_SYMLINK_NOFOLLOW)) {
		p->fts_errno = errno;
err:		memset(sbp, 0, sizeof(*sbp));
		return (FTS_NS);
	}

	if (S_ISDIR(sbp->st_mode)) {
		/*
		 * Set the device/inode.  Used to find cycles and check for
		 * crossing mount points.  Also remember the link count, used
		 * in fts_build to limit the number of stat calls.  It is
		 * understood that these fields are only referenced if fts_info
		 * is set to FTS_D.
		 */
		dev = p->fts_dev = sbp->st_dev;
		ino = p->fts_ino = sbp->st_ino;
		p->fts_nlink = sbp->st_nlink;

		if (ISDOT(p->fts_name))
			return (FTS_DOT);

		/*
		 * Cycle detection is done by brute force when the directory
		 * is first encountered.  If the tree gets deep enough or the
		 * number of symbolic links to directories is high enough,
		 * something faster might be worthwhile.
		 */
		for (t = p->fts_parent;
		    t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
			if (ino == t->fts_ino && dev == t->fts_dev) {
				p->fts_cycle = t;
				return (FTS_DC);
			}
		return (FTS_D);
	}
	if (S_ISLNK(sbp->st_mode))
		return (FTS_SL);
	if (S_ISREG(sbp->st_mode))
		return (FTS_F);
	return (FTS_DEFAULT);
}

/*
 * The comparison function takes pointers to pointers to FTSENT structures.
 * Qsort wants a comparison function that takes pointers to void.
 * (Both with appropriate levels of const-poisoning, of course!)
 * Use a trampoline function to deal with the difference.
 */
static int
fts_compar(const void *a, const void *b)
{
	FTS11 *parent;

	parent = (*(const FTSENT11 * const *)a)->fts_fts;
	return (*parent->fts_compar)(a, b);
}

static FTSENT11 *
fts_sort(FTS11 *sp, FTSENT11 *head, size_t nitems)
{
	FTSENT11 **ap, *p;

	/*
	 * Construct an array of pointers to the structures and call qsort(3).
	 * Reassemble the array in the order returned by qsort.  If unable to
	 * sort for memory reasons, return the directory entries in their
	 * current order.  Allocate enough space for the current needs plus
	 * 40 so don't realloc one entry at a time.
	 */
	if (nitems > sp->fts_nitems) {
		sp->fts_nitems = nitems + 40;
		if ((sp->fts_array = reallocf(sp->fts_array,
		    sp->fts_nitems * sizeof(FTSENT11 *))) == NULL) {
			sp->fts_nitems = 0;
			return (head);
		}
	}
	for (ap = sp->fts_array, p = head; p; p = p->fts_link)
		*ap++ = p;
	qsort(sp->fts_array, nitems, sizeof(FTSENT11 *), fts_compar);
	for (head = *(ap = sp->fts_array); --nitems; ++ap)
		ap[0]->fts_link = ap[1];
	ap[0]->fts_link = NULL;
	return (head);
}

static FTSENT11 *
fts_alloc(FTS11 *sp, char *name, size_t namelen)
{
	FTSENT11 *p;
	size_t len;

	struct ftsent11_withstat {
		FTSENT11	ent;
		struct	freebsd11_stat statbuf;
	};

	/*
	 * The file name is a variable length array and no stat structure is
	 * necessary if the user has set the nostat bit.  Allocate the FTSENT
	 * structure, the file name and the stat structure in one chunk, but
	 * be careful that the stat structure is reasonably aligned.
	 */
	if (ISSET(FTS_NOSTAT))
		len = sizeof(FTSENT11) + namelen + 1;
	else
		len = sizeof(struct ftsent11_withstat) + namelen + 1;

	if ((p = malloc(len)) == NULL)
		return (NULL);

	if (ISSET(FTS_NOSTAT)) {
		p->fts_name = (char *)(p + 1);
		p->fts_statp = NULL;
	} else {
		p->fts_name = (char *)((struct ftsent11_withstat *)p + 1);
		p->fts_statp = &((struct ftsent11_withstat *)p)->statbuf;
	}

	/* Copy the name and guarantee NUL termination. */
	memcpy(p->fts_name, name, namelen);
	p->fts_name[namelen] = '\0';
	p->fts_namelen = namelen;
	p->fts_path = sp->fts_path;
	p->fts_errno = 0;
	p->fts_flags = 0;
	p->fts_instr = FTS_NOINSTR;
	p->fts_number = 0;
	p->fts_pointer = NULL;
	p->fts_fts = sp;
	return (p);
}

static void
fts_lfree(FTSENT11 *head)
{
	FTSENT11 *p;

	/* Free a linked list of structures. */
	while ((p = head)) {
		head = head->fts_link;
		free(p);
	}
}

/*
 * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
 * Most systems will allow creation of paths much longer than MAXPATHLEN, even
 * though the kernel won't resolve them.  Add the size (not just what's needed)
 * plus 256 bytes so don't realloc the path 2 bytes at a time.
 */
static int
fts_palloc(FTS11 *sp, size_t more)
{

	sp->fts_pathlen += more + 256;
	sp->fts_path = reallocf(sp->fts_path, sp->fts_pathlen);
	return (sp->fts_path == NULL);
}

/*
 * When the path is realloc'd, have to fix all of the pointers in structures
 * already returned.
 */
static void
fts_padjust(FTS11 *sp, FTSENT11 *head)
{
	FTSENT11 *p;
	char *addr = sp->fts_path;

#define	ADJUST(p) do {							\
	if ((p)->fts_accpath != (p)->fts_name) {			\
		(p)->fts_accpath =					\
		    (char *)addr + ((p)->fts_accpath - (p)->fts_path);	\
	}								\
	(p)->fts_path = addr;						\
} while (0)
	/* Adjust the current set of children. */
	for (p = sp->fts_child; p; p = p->fts_link)
		ADJUST(p);

	/* Adjust the rest of the tree, including the current level. */
	for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
		ADJUST(p);
		p = p->fts_link ? p->fts_link : p->fts_parent;
	}
}

static size_t
fts_maxarglen(char * const *argv)
{
	size_t len, max;

	for (max = 0; *argv; ++argv)
		if ((len = strlen(*argv)) > max)
			max = len;
	return (max + 1);
}

/*
 * Change to dir specified by fd or p->fts_accpath without getting
 * tricked by someone changing the world out from underneath us.
 * Assumes p->fts_dev and p->fts_ino are filled in.
 */
static int
fts_safe_changedir(FTS11 *sp, FTSENT11 *p, int fd, char *path)
{
	int ret, oerrno, newfd;
	struct freebsd11_stat sb;

	newfd = fd;
	if (ISSET(FTS_NOCHDIR))
		return (0);
	if (fd < 0 && (newfd = _open(path, O_RDONLY | O_DIRECTORY |
	    O_CLOEXEC, 0)) < 0)
		return (-1);
	if (freebsd11_fstat(newfd, &sb)) {
		ret = -1;
		goto bail;
	}
	if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) {
		errno = ENOENT;		/* disinformation */
		ret = -1;
		goto bail;
	}
	ret = fchdir(newfd);
bail:
	oerrno = errno;
	if (fd < 0)
		(void)_close(newfd);
	errno = oerrno;
	return (ret);
}

/*
 * Check if the filesystem for "ent" has UFS-style links.
 */
static int
fts_ufslinks(FTS11 *sp, const FTSENT11 *ent)
{
	struct _fts_private11 *priv;
	const char **cpp;

	priv = (struct _fts_private11 *)sp;
	/*
	 * If this node's device is different from the previous, grab
	 * the filesystem information, and decide on the reliability
	 * of the link information from this filesystem for stat(2)
	 * avoidance.
	 */
	if (priv->ftsp_dev != ent->fts_dev) {
		if (freebsd11_statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
			priv->ftsp_dev = ent->fts_dev;
			priv->ftsp_linksreliable = 0;
			for (cpp = ufslike_filesystems; *cpp; cpp++) {
				if (strcmp(priv->ftsp_statfs.f_fstypename,
				    *cpp) == 0) {
					priv->ftsp_linksreliable = 1;
					break;
				}
			}
		} else {
			priv->ftsp_linksreliable = 0;
		}
	}
	return (priv->ftsp_linksreliable);
}

__sym_compat(fts_open, freebsd11_fts_open, FBSD_1.1);
__sym_compat(fts_close, freebsd11_fts_close, FBSD_1.1);
__sym_compat(fts_read, freebsd11_fts_read, FBSD_1.1);
__sym_compat(fts_set, freebsd11_fts_set, FBSD_1.1);
__sym_compat(fts_children, freebsd11_fts_children, FBSD_1.1);
__sym_compat(fts_get_clientptr, freebsd11_fts_get_clientptr, FBSD_1.1);
__sym_compat(fts_get_stream, freebsd11_fts_get_stream, FBSD_1.1);
__sym_compat(fts_set_clientptr, freebsd11_fts_set_clientptr, FBSD_1.1);




/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. 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.
 *
 *	@(#)fts.h	8.3 (Berkeley) 8/14/94
 * $FreeBSD$
 */

#ifndef	_FTS_COPMAT11_H_
#define	_FTS_COPMAT11_H_

typedef struct {
	struct _ftsent11 *fts_cur;	/* current node */
	struct _ftsent11 *fts_child;	/* linked list of children */
	struct _ftsent11 **fts_array;	/* sort array */
	uint32_t fts_dev;		/* starting device # */
	char *fts_path;			/* path for this descent */
	int fts_rfd;			/* fd for root */
	__size_t fts_pathlen;		/* sizeof(path) */
	__size_t fts_nitems;		/* elements in the sort array */
	int (*fts_compar)		/* compare function */
	    (const struct _ftsent11 * const *,
	    const struct _ftsent11 * const *);
	int fts_options;		/* fts_open options, global flags */
	void *fts_clientptr;		/* thunk for sort function */
} FTS11;

typedef struct _ftsent11 {
	struct _ftsent11 *fts_cycle;	/* cycle node */
	struct _ftsent11 *fts_parent;	/* parent directory */
	struct _ftsent11 *fts_link;	/* next file in directory */
	long long fts_number;		/* local numeric value */
	void *fts_pointer;		/* local address value */
	char *fts_accpath;		/* access path */
	char *fts_path;			/* root path */
	int fts_errno;			/* errno for this node */
	int fts_symfd;			/* fd for symlink */
	__size_t fts_pathlen;		/* strlen(fts_path) */
	__size_t fts_namelen;		/* strlen(fts_name) */

	uint32_t fts_ino;		/* inode */
	uint32_t fts_dev;		/* device */
	uint16_t fts_nlink;		/* link count */

	long fts_level;			/* depth (-1 to N) */

	int fts_info;			/* user status for FTSENT structure */

	unsigned fts_flags;		/* private flags for FTSENT structure */

	int fts_instr;			/* fts_set() instructions */

	struct freebsd11_stat *fts_statp; /* stat(2) information */
	char *fts_name;			/* file name */
	FTS11 *fts_fts;			/* back pointer to main FTS */
} FTSENT11;

FTSENT11	*freebsd11_fts_children(FTS11 *, int);
int		 freebsd11_fts_close(FTS11 *);
void		*freebsd11_fts_get_clientptr(FTS11 *);
#define	freebsd11_fts_get_clientptr(fts)	((fts)->fts_clientptr)
FTS11		*freebsd11_fts_get_stream(FTSENT11 *);
#define	freebsd11_fts_get_stream(ftsent)	((ftsent)->fts_fts)
FTS11		*freebsd11_fts_open(char * const *, int,
		    int (*)(const FTSENT11 * const *,
		    const FTSENT11 * const *));
FTSENT11	*freebsd11_fts_read(FTS11 *);
int		 freebsd11_fts_set(FTS11 *, FTSENT11 *, int);
void		 freebsd11_fts_set_clientptr(FTS11 *, void *);

#endif /* !_FTS_COMPAT11_H_ */




/*	$OpenBSD: ftw.c,v 1.5 2005/08/08 08:05:34 espie Exp $	*/

/*
 * Copyright (c) 2003, 2004 Todd C. Miller <Todd.Miller@courtesan.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Sponsored in part by the Defense Advanced Research Projects
 * Agency (DARPA) and Air Force Research Laboratory, Air Force
 * Materiel Command, USAF, under agreement number F39502-99-1-0512.
 *
 * from: $FreeBSD$
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fts.h>
#include <ftw.h>

#include "fts-compat11.h"

int
freebsd11_ftw(const char *path,
    int (*fn)(const char *, const struct freebsd11_stat *, int), int nfds)
{
	char * const paths[2] = { (char *)path, NULL };
	FTSENT11 *cur;
	FTS11 *ftsp;
	int error = 0, fnflag, sverrno;

	/* XXX - nfds is currently unused */
	if (nfds < 1) {
		errno = EINVAL;
		return (-1);
	}

	ftsp = freebsd11_fts_open(paths,
	    FTS_LOGICAL | FTS_COMFOLLOW | FTS_NOCHDIR, NULL);
	if (ftsp == NULL)
		return (-1);
	while ((cur = freebsd11_fts_read(ftsp)) != NULL) {
		switch (cur->fts_info) {
		case FTS_D:
			fnflag = FTW_D;
			break;
		case FTS_DNR:
			fnflag = FTW_DNR;
			break;
		case FTS_DP:
			/* we only visit in preorder */
			continue;
		case FTS_F:
		case FTS_DEFAULT:
			fnflag = FTW_F;
			break;
		case FTS_NS:
		case FTS_NSOK:
		case FTS_SLNONE:
			fnflag = FTW_NS;
			break;
		case FTS_SL:
			fnflag = FTW_SL;
			break;
		case FTS_DC:
			errno = ELOOP;
			/* FALLTHROUGH */
		default:
			error = -1;
			goto done;
		}
		error = fn(cur->fts_path, cur->fts_statp, fnflag);
		if (error != 0)
			break;
	}
done:
	sverrno = errno;
	if (freebsd11_fts_close(ftsp) != 0 && error == 0)
		error = -1;
	else
		errno = sverrno;
	return (error);
}

__sym_compat(ftw, freebsd11_ftw, FBSD_1.0);




/*-
 * Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 * $FreeBSD$
 */

#ifndef	_GEN_COMPAT_H_
#define	_GEN_COMPAT_H_

#include <dirent.h>

#define FREEBSD11_DIRSIZ(dp)						\
	(sizeof(struct freebsd11_dirent) - sizeof((dp)->d_name) +	\
	    (((dp)->d_namlen + 1 + 3) &~ 3))

struct freebsd11_dirent;
struct freebsd11_stat;
struct freebsd11_statfs;

struct freebsd11_dirent *freebsd11_readdir(DIR *);
int	freebsd11_readdir_r(DIR *, struct freebsd11_dirent *,
	    struct freebsd11_dirent **);
int	freebsd11_stat(const char *, struct freebsd11_stat *);
int	freebsd11_lstat(const char *, struct freebsd11_stat *);
int	freebsd11_fstat(int, struct freebsd11_stat *);
int	freebsd11_fstatat(int, const char *, struct freebsd11_stat *, int);

int	freebsd11_statfs(const char *, struct freebsd11_statfs *);
int	freebsd11_getfsstat(struct freebsd11_statfs *, long, int);
int	freebsd11_getmntinfo(struct freebsd11_statfs **, int);

char	*freebsd11_devname(__uint32_t dev, __mode_t type);
char	*freebsd11_devname_r(__uint32_t dev, __mode_t type, char *buf, int len);

#endif /* _GEN_COMPAT_H_ */

Lines 47-53 struct _dirdesc { Link Here

(-)b/lib/libc/gen/gen-private.h (-1 / +1 lines)
47	long dd_size; /* amount of data returned by getdirentries */	47	long dd_size; /* amount of data returned by getdirentries */
48	char dd_buf; / data buffer */	48	char dd_buf; / data buffer */
49	int dd_len; /* size of data buffer */	49	int dd_len; /* size of data buffer */
50	long dd_seek; /* magic cookie returned by getdirentries */	50	off_t dd_seek; /* magic cookie returned by getdirentries */
51	int dd_flags; /* flags for readdir */	51	int dd_flags; /* flags for readdir */
52	struct pthread_mutex dd_lock; / lock */	52	struct pthread_mutex dd_lock; / lock */
53	struct _telldir dd_td; / telldir position recording */	53	struct _telldir dd_td; / telldir position recording */




/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. 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.
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)getmntinfo.c	8.1 (Berkeley) 6/4/93";
#endif /* LIBC_SCCS and not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/ucred.h>
#define	_WANT_FREEBSD11_STATFS
#include <sys/mount.h>
#include <stdlib.h>
#include "gen-compat.h"

/*
 * Return information about mounted filesystems.
 */
int
freebsd11_getmntinfo(struct freebsd11_statfs **mntbufp, int flags)
{
	static struct freebsd11_statfs *mntbuf;
	static int mntsize;
	static long bufsize;

	if (mntsize <= 0 &&
	    (mntsize = freebsd11_getfsstat(0, 0, MNT_NOWAIT)) < 0)
		return (0);
	if (bufsize > 0 &&
	    (mntsize = freebsd11_getfsstat(mntbuf, bufsize, flags)) < 0)
		return (0);
	while (bufsize <= mntsize * sizeof(struct freebsd11_statfs)) {
		if (mntbuf)
			free(mntbuf);
		bufsize = (mntsize + 1) * sizeof(struct freebsd11_statfs);
		if ((mntbuf = (struct freebsd11_statfs *)malloc(bufsize)) == 0)
			return (0);
		if ((mntsize = freebsd11_getfsstat(mntbuf, bufsize, flags)) < 0)
			return (0);
	}
	*mntbufp = mntbuf;
	return (mntsize);
}

__sym_compat(getmntinfo, freebsd11_getmntinfo, FBSD_1.0);




/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Guido van Rossum.
 *
 * Copyright (c) 2011 The FreeBSD Foundation
 * All rights reserved.
 * Portions of this software were developed by David Chisnall
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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.
 * 3. 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.
 *
 * from: $FreeBSD$
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)glob.c	8.3 (Berkeley) 10/13/93";
#endif /* LIBC_SCCS and not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#define	_WANT_FREEBSD11_STAT
#include <sys/stat.h>

#include <ctype.h>
#define	_WANT_FREEBSD11_DIRENT
#include <dirent.h>
#include <errno.h>
#include <glob.h>
#include <limits.h>
#include <pwd.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wchar.h>

#include "collate.h"
#include "gen-compat.h"
#include "glob-compat11.h"

/*
 * glob(3) expansion limits. Stop the expansion if any of these limits
 * is reached. This caps the runtime in the face of DoS attacks. See
 * also CVE-2010-2632
 */
#define	GLOB_LIMIT_BRACE	128	/* number of brace calls */
#define	GLOB_LIMIT_PATH		65536	/* number of path elements */
#define	GLOB_LIMIT_READDIR	16384	/* number of readdirs */
#define	GLOB_LIMIT_STAT		1024	/* number of stat system calls */
#define	GLOB_LIMIT_STRING	ARG_MAX	/* maximum total size for paths */

struct glob_limit {
	size_t	l_brace_cnt;
	size_t	l_path_lim;
	size_t	l_readdir_cnt;	
	size_t	l_stat_cnt;	
	size_t	l_string_cnt;
};

#define	DOT		L'.'
#define	EOS		L'\0'
#define	LBRACKET	L'['
#define	NOT		L'!'
#define	QUESTION	L'?'
#define	QUOTE		L'\\'
#define	RANGE		L'-'
#define	RBRACKET	L']'
#define	SEP		L'/'
#define	STAR		L'*'
#define	TILDE		L'~'
#define	LBRACE		L'{'
#define	RBRACE		L'}'
#define	COMMA		L','

#define	M_QUOTE		0x8000000000ULL
#define	M_PROTECT	0x4000000000ULL
#define	M_MASK		0xffffffffffULL
#define	M_CHAR		0x00ffffffffULL

typedef uint_fast64_t Char;

#define	CHAR(c)		((Char)((c)&M_CHAR))
#define	META(c)		((Char)((c)|M_QUOTE))
#define	UNPROT(c)	((c) & ~M_PROTECT)
#define	M_ALL		META(L'*')
#define	M_END		META(L']')
#define	M_NOT		META(L'!')
#define	M_ONE		META(L'?')
#define	M_RNG		META(L'-')
#define	M_SET		META(L'[')
#define	ismeta(c)	(((c)&M_QUOTE) != 0)
#ifdef DEBUG
#define	isprot(c)	(((c)&M_PROTECT) != 0)
#endif

static int	 compare(const void *, const void *);
static int	 g_Ctoc(const Char *, char *, size_t);
static int	 g_lstat(Char *, struct freebsd11_stat *, glob11_t *);
static DIR	*g_opendir(Char *, glob11_t *);
static const Char *g_strchr(const Char *, wchar_t);
#ifdef notdef
static Char	*g_strcat(Char *, const Char *);
#endif
static int	 g_stat(Char *, struct freebsd11_stat *, glob11_t *);
static int	 glob0(const Char *, glob11_t *, struct glob_limit *,
    const char *);
static int	 glob1(Char *, glob11_t *, struct glob_limit *);
static int	 glob2(Char *, Char *, Char *, Char *, glob11_t *,
    struct glob_limit *);
static int	 glob3(Char *, Char *, Char *, Char *, Char *, glob11_t *,
    struct glob_limit *);
static int	 globextend(const Char *, glob11_t *, struct glob_limit *,
    const char *);
static const Char *
		 globtilde(const Char *, Char *, size_t, glob11_t *);
static int	 globexp0(const Char *, glob11_t *, struct glob_limit *,
    const char *);
static int	 globexp1(const Char *, glob11_t *, struct glob_limit *);
static int	 globexp2(const Char *, const Char *, glob11_t *,
    struct glob_limit *);
static int	 globfinal(glob11_t *, struct glob_limit *, size_t,
    const char *);
static int	 match(Char *, Char *, Char *);
static int	 err_nomatch(glob11_t *, struct glob_limit *, const char *);
static int	 err_aborted(glob11_t *, int, char *);
#ifdef DEBUG
static void	 qprintf(const char *, Char *);
#endif

int
freebsd11_glob(const char * __restrict pattern, int flags,
	 int (*errfunc)(const char *, int), glob11_t * __restrict pglob)
{
	struct glob_limit limit = { 0, 0, 0, 0, 0 };
	const char *patnext;
	Char *bufnext, *bufend, patbuf[MAXPATHLEN], prot;
	mbstate_t mbs;
	wchar_t wc;
	size_t clen;
	int too_long;

	patnext = pattern;
	if (!(flags & GLOB_APPEND)) {
		pglob->gl_pathc = 0;
		pglob->gl_pathv = NULL;
		if (!(flags & GLOB_DOOFFS))
			pglob->gl_offs = 0;
	}
	if (flags & GLOB_LIMIT) {
		limit.l_path_lim = pglob->gl_matchc;
		if (limit.l_path_lim == 0)
			limit.l_path_lim = GLOB_LIMIT_PATH;
	}
	pglob->gl_flags = flags & ~GLOB_MAGCHAR;
	pglob->gl_errfunc = errfunc;
	pglob->gl_matchc = 0;

	bufnext = patbuf;
	bufend = bufnext + MAXPATHLEN - 1;
	too_long = 1;
	if (flags & GLOB_NOESCAPE) {
		memset(&mbs, 0, sizeof(mbs));
		while (bufnext <= bufend) {
			clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
			if (clen == (size_t)-1 || clen == (size_t)-2)
				return (err_nomatch(pglob, &limit, pattern));
			else if (clen == 0) {
				too_long = 0;
				break;
			}
			*bufnext++ = wc;
			patnext += clen;
		}
	} else {
		/* Protect the quoted characters. */
		memset(&mbs, 0, sizeof(mbs));
		while (bufnext <= bufend) {
			if (*patnext == '\\') {
				if (*++patnext == '\0') {
					*bufnext++ = QUOTE;
					continue;
				}
				prot = M_PROTECT;
			} else
				prot = 0;
			clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
			if (clen == (size_t)-1 || clen == (size_t)-2)
				return (err_nomatch(pglob, &limit, pattern));
			else if (clen == 0) {
				too_long = 0;
				break;
			}
			*bufnext++ = wc | prot;
			patnext += clen;
		}
	}
	if (too_long)
		return (err_nomatch(pglob, &limit, pattern));
	*bufnext = EOS;

	if (flags & GLOB_BRACE)
	    return (globexp0(patbuf, pglob, &limit, pattern));
	else
	    return (glob0(patbuf, pglob, &limit, pattern));
}

static int
globexp0(const Char *pattern, glob11_t *pglob, struct glob_limit *limit,
    const char *origpat) {
	int rv;
	size_t oldpathc;

	/* Protect a single {}, for find(1), like csh */
	if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS) {
		if ((pglob->gl_flags & GLOB_LIMIT) &&
		    limit->l_brace_cnt++ >= GLOB_LIMIT_BRACE) {
			errno = E2BIG;
			return (GLOB_NOSPACE);
		}
		return (glob0(pattern, pglob, limit, origpat));
	}

	oldpathc = pglob->gl_pathc;

	if ((rv = globexp1(pattern, pglob, limit)) != 0)
		return rv;

	return (globfinal(pglob, limit, oldpathc, origpat));
}

/*
 * Expand recursively a glob {} pattern. When there is no more expansion
 * invoke the standard globbing routine to glob the rest of the magic
 * characters
 */
static int
globexp1(const Char *pattern, glob11_t *pglob, struct glob_limit *limit)
{
	const Char* ptr;

	if ((ptr = g_strchr(pattern, LBRACE)) != NULL) {
		if ((pglob->gl_flags & GLOB_LIMIT) &&
		    limit->l_brace_cnt++ >= GLOB_LIMIT_BRACE) {
			errno = E2BIG;
			return (GLOB_NOSPACE);
		}
		return (globexp2(ptr, pattern, pglob, limit));
	}

	return (glob0(pattern, pglob, limit, NULL));
}


/*
 * Recursive brace globbing helper. Tries to expand a single brace.
 * If it succeeds then it invokes globexp1 with the new pattern.
 * If it fails then it tries to glob the rest of the pattern and returns.
 */
static int
globexp2(const Char *ptr, const Char *pattern, glob11_t *pglob,
    struct glob_limit *limit)
{
	int     i, rv;
	Char   *lm, *ls;
	const Char *pe, *pm, *pm1, *pl;
	Char    patbuf[MAXPATHLEN];

	/* copy part up to the brace */
	for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
		continue;
	*lm = EOS;
	ls = lm;

	/* Find the balanced brace */
	for (i = 0, pe = ++ptr; *pe != EOS; pe++)
		if (*pe == LBRACKET) {
			/* Ignore everything between [] */
			for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
				continue;
			if (*pe == EOS) {
				/*
				 * We could not find a matching RBRACKET.
				 * Ignore and just look for RBRACE
				 */
				pe = pm;
			}
		}
		else if (*pe == LBRACE)
			i++;
		else if (*pe == RBRACE) {
			if (i == 0)
				break;
			i--;
		}

	/* Non matching braces; just glob the pattern */
	if (i != 0 || *pe == EOS)
		return (glob0(pattern, pglob, limit, NULL));

	for (i = 0, pl = pm = ptr; pm <= pe; pm++)
		switch (*pm) {
		case LBRACKET:
			/* Ignore everything between [] */
			for (pm1 = pm++; *pm != RBRACKET && *pm != EOS; pm++)
				continue;
			if (*pm == EOS) {
				/*
				 * We could not find a matching RBRACKET.
				 * Ignore and just look for RBRACE
				 */
				pm = pm1;
			}
			break;

		case LBRACE:
			i++;
			break;

		case RBRACE:
			if (i) {
			    i--;
			    break;
			}
			/* FALLTHROUGH */
		case COMMA:
			if (i && *pm == COMMA)
				break;
			else {
				/* Append the current string */
				for (lm = ls; (pl < pm); *lm++ = *pl++)
					continue;
				/*
				 * Append the rest of the pattern after the
				 * closing brace
				 */
				for (pl = pe + 1; (*lm++ = *pl++) != EOS;)
					continue;

				/* Expand the current pattern */
#ifdef DEBUG
				qprintf("globexp2:", patbuf);
#endif
				rv = globexp1(patbuf, pglob, limit);
				if (rv)
					return (rv);

				/* move after the comma, to the next string */
				pl = pm + 1;
			}
			break;

		default:
			break;
		}
	return (0);
}



/*
 * expand tilde from the passwd file.
 */
static const Char *
globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob11_t *pglob)
{
	struct passwd *pwd;
	char *h, *sc;
	const Char *p;
	Char *b, *eb;
	wchar_t wc;
	wchar_t wbuf[MAXPATHLEN];
	wchar_t *wbufend, *dc;
	size_t clen;
	mbstate_t mbs;
	int too_long;

	if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
		return (pattern);

	/* 
	 * Copy up to the end of the string or / 
	 */
	eb = &patbuf[patbuf_len - 1];
	for (p = pattern + 1, b = patbuf;
	    b < eb && *p != EOS && UNPROT(*p) != SEP; *b++ = *p++)
		continue;

	if (*p != EOS && UNPROT(*p) != SEP)
		return (NULL);

	*b = EOS;
	h = NULL;

	if (patbuf[0] == EOS) {
		/*
		 * handle a plain ~ or ~/ by expanding $HOME first (iff
		 * we're not running setuid or setgid) and then trying
		 * the password file
		 */
		if (issetugid() != 0 ||
		    (h = getenv("HOME")) == NULL) {
			if (((h = getlogin()) != NULL &&
			     (pwd = getpwnam(h)) != NULL) ||
			    (pwd = getpwuid(getuid())) != NULL)
				h = pwd->pw_dir;
			else
				return (pattern);
		}
	}
	else {
		/*
		 * Expand a ~user
		 */
		if (g_Ctoc(patbuf, (char *)wbuf, sizeof(wbuf)))
			return (NULL);
		if ((pwd = getpwnam((char *)wbuf)) == NULL)
			return (pattern);
		else
			h = pwd->pw_dir;
	}

	/* Copy the home directory */
	dc = wbuf;
	sc = h;
	wbufend = wbuf + MAXPATHLEN - 1;
	too_long = 1;
	memset(&mbs, 0, sizeof(mbs));
	while (dc <= wbufend) {
		clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs);
		if (clen == (size_t)-1 || clen == (size_t)-2) {
			/* XXX See initial comment #2. */
			wc = (unsigned char)*sc;
			clen = 1;
			memset(&mbs, 0, sizeof(mbs));
		}
		if ((*dc++ = wc) == EOS) {
			too_long = 0;
			break;
		}
		sc += clen;
	}
	if (too_long)
		return (NULL);

	dc = wbuf;
	for (b = patbuf; b < eb && *dc != EOS; *b++ = *dc++ | M_PROTECT)
		continue;
	if (*dc != EOS)
		return (NULL);

	/* Append the rest of the pattern */
	if (*p != EOS) {
		too_long = 1;
		while (b <= eb) {
			if ((*b++ = *p++) == EOS) {
				too_long = 0;
				break;
			}
		}
		if (too_long)
			return (NULL);
	} else
		*b = EOS;

	return (patbuf);
}


/*
 * The main glob() routine: compiles the pattern (optionally processing
 * quotes), calls glob1() to do the real pattern matching, and finally
 * sorts the list (unless unsorted operation is requested).  Returns 0
 * if things went well, nonzero if errors occurred.
 */
static int
glob0(const Char *pattern, glob11_t *pglob, struct glob_limit *limit,
    const char *origpat) {
	const Char *qpatnext;
	int err;
	size_t oldpathc;
	Char *bufnext, c, patbuf[MAXPATHLEN];

	qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);
	if (qpatnext == NULL) {
		errno = E2BIG;
		return (GLOB_NOSPACE);
	}
	oldpathc = pglob->gl_pathc;
	bufnext = patbuf;

	/* We don't need to check for buffer overflow any more. */
	while ((c = *qpatnext++) != EOS) {
		switch (c) {
		case LBRACKET:
			c = *qpatnext;
			if (c == NOT)
				++qpatnext;
			if (*qpatnext == EOS ||
			    g_strchr(qpatnext+1, RBRACKET) == NULL) {
				*bufnext++ = LBRACKET;
				if (c == NOT)
					--qpatnext;
				break;
			}
			*bufnext++ = M_SET;
			if (c == NOT)
				*bufnext++ = M_NOT;
			c = *qpatnext++;
			do {
				*bufnext++ = CHAR(c);
				if (*qpatnext == RANGE &&
				    (c = qpatnext[1]) != RBRACKET) {
					*bufnext++ = M_RNG;
					*bufnext++ = CHAR(c);
					qpatnext += 2;
				}
			} while ((c = *qpatnext++) != RBRACKET);
			pglob->gl_flags |= GLOB_MAGCHAR;
			*bufnext++ = M_END;
			break;
		case QUESTION:
			pglob->gl_flags |= GLOB_MAGCHAR;
			*bufnext++ = M_ONE;
			break;
		case STAR:
			pglob->gl_flags |= GLOB_MAGCHAR;
			/* collapse adjacent stars to one,
			 * to avoid exponential behavior
			 */
			if (bufnext == patbuf || bufnext[-1] != M_ALL)
			    *bufnext++ = M_ALL;
			break;
		default:
			*bufnext++ = CHAR(c);
			break;
		}
	}
	*bufnext = EOS;
#ifdef DEBUG
	qprintf("glob0:", patbuf);
#endif

	if ((err = glob1(patbuf, pglob, limit)) != 0)
		return(err);

	if (origpat != NULL)
		return (globfinal(pglob, limit, oldpathc, origpat));

	return (0);
}

static int
globfinal(glob11_t *pglob, struct glob_limit *limit, size_t oldpathc,
    const char *origpat) {
	if (pglob->gl_pathc == oldpathc)
		return (err_nomatch(pglob, limit, origpat));

	if (!(pglob->gl_flags & GLOB_NOSORT))
		qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
		    pglob->gl_pathc - oldpathc, sizeof(char *), compare);

	return (0);
}

static int
compare(const void *p, const void *q)
{
	return (strcoll(*(char **)p, *(char **)q));
}

static int
glob1(Char *pattern, glob11_t *pglob, struct glob_limit *limit)
{
	Char pathbuf[MAXPATHLEN];

	/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
	if (*pattern == EOS)
		return (0);
	return (glob2(pathbuf, pathbuf, pathbuf + MAXPATHLEN - 1,
	    pattern, pglob, limit));
}

/*
 * The functions glob2 and glob3 are mutually recursive; there is one level
 * of recursion for each segment in the pattern that contains one or more
 * meta characters.
 */
static int
glob2(Char *pathbuf, Char *pathend, Char *pathend_last, Char *pattern,
      glob11_t *pglob, struct glob_limit *limit)
{
	struct freebsd11_stat sb;
	Char *p, *q;
	int anymeta;

	/*
	 * Loop over pattern segments until end of pattern or until
	 * segment with meta character found.
	 */
	for (anymeta = 0;;) {
		if (*pattern == EOS) {		/* End of pattern? */
			*pathend = EOS;
			if (g_lstat(pathbuf, &sb, pglob))
				return (0);

			if ((pglob->gl_flags & GLOB_LIMIT) &&
			    limit->l_stat_cnt++ >= GLOB_LIMIT_STAT) {
				errno = E2BIG;
				return (GLOB_NOSPACE);
			}
			if ((pglob->gl_flags & GLOB_MARK) &&
			    UNPROT(pathend[-1]) != SEP &&
			    (S_ISDIR(sb.st_mode) ||
			    (S_ISLNK(sb.st_mode) &&
			    g_stat(pathbuf, &sb, pglob) == 0 &&
			    S_ISDIR(sb.st_mode)))) {
				if (pathend + 1 > pathend_last) {
					errno = E2BIG;
					return (GLOB_NOSPACE);
				}
				*pathend++ = SEP;
				*pathend = EOS;
			}
			++pglob->gl_matchc;
			return (globextend(pathbuf, pglob, limit, NULL));
		}

		/* Find end of next segment, copy tentatively to pathend. */
		q = pathend;
		p = pattern;
		while (*p != EOS && UNPROT(*p) != SEP) {
			if (ismeta(*p))
				anymeta = 1;
			if (q + 1 > pathend_last) {
				errno = E2BIG;
				return (GLOB_NOSPACE);
			}
			*q++ = *p++;
		}

		if (!anymeta) {		/* No expansion, do next segment. */
			pathend = q;
			pattern = p;
			while (UNPROT(*pattern) == SEP) {
				if (pathend + 1 > pathend_last) {
					errno = E2BIG;
					return (GLOB_NOSPACE);
				}
				*pathend++ = *pattern++;
			}
		} else			/* Need expansion, recurse. */
			return (glob3(pathbuf, pathend, pathend_last, pattern,
			    p, pglob, limit));
	}
	/* NOTREACHED */
}

static int
glob3(Char *pathbuf, Char *pathend, Char *pathend_last,
      Char *pattern, Char *restpattern,
      glob11_t *pglob, struct glob_limit *limit)
{
	struct freebsd11_dirent *dp;
	DIR *dirp;
	int err, too_long, saverrno, saverrno2;
	char buf[MAXPATHLEN + MB_LEN_MAX - 1];

	struct freebsd11_dirent *(*readdirfunc)(DIR *);

	if (pathend > pathend_last) {
		errno = E2BIG;
		return (GLOB_NOSPACE);
	}
	*pathend = EOS;
	if (pglob->gl_errfunc != NULL &&
	    g_Ctoc(pathbuf, buf, sizeof(buf))) {
		errno = E2BIG;
		return (GLOB_NOSPACE);
	}

	saverrno = errno;
	errno = 0;
	if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
		if (errno == ENOENT || errno == ENOTDIR)
			return (0);
		err = err_aborted(pglob, errno, buf);
		if (errno == 0)
			errno = saverrno;
		return (err);
	}

	err = 0;

	/* pglob->gl_readdir takes a void *, fix this manually */
	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
		readdirfunc =
		    (struct freebsd11_dirent *(*)(DIR *))pglob->gl_readdir;
	else
		readdirfunc = freebsd11_readdir;

	errno = 0;
	/* Search directory for matching names. */
	while ((dp = (*readdirfunc)(dirp)) != NULL) {
		char *sc;
		Char *dc;
		wchar_t wc;
		size_t clen;
		mbstate_t mbs;

		if ((pglob->gl_flags & GLOB_LIMIT) &&
		    limit->l_readdir_cnt++ >= GLOB_LIMIT_READDIR) {
			errno = E2BIG;
			err = GLOB_NOSPACE;
			break;
		}

		/* Initial DOT must be matched literally. */
		if (dp->d_name[0] == '.' && UNPROT(*pattern) != DOT) {
			errno = 0;
			continue;
		}
		memset(&mbs, 0, sizeof(mbs));
		dc = pathend;
		sc = dp->d_name;
		too_long = 1;
		while (dc <= pathend_last) {
			clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs);
			if (clen == (size_t)-1 || clen == (size_t)-2) {
				/* XXX See initial comment #2. */
				wc = (unsigned char)*sc;
				clen = 1;
				memset(&mbs, 0, sizeof(mbs));
			}
			if ((*dc++ = wc) == EOS) {
				too_long = 0;
				break;
			}
			sc += clen;
		}
		if (too_long && (err = err_aborted(pglob, ENAMETOOLONG,
		    buf))) {
			errno = ENAMETOOLONG;
			break;
		}
		if (too_long || !match(pathend, pattern, restpattern)) {
			*pathend = EOS;
			errno = 0;
			continue;
		}
		if (errno == 0)
			errno = saverrno;
		err = glob2(pathbuf, --dc, pathend_last, restpattern,
		    pglob, limit);
		if (err)
			break;
		errno = 0;
	}

	saverrno2 = errno;
	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
		(*pglob->gl_closedir)(dirp);
	else
		closedir(dirp);
	errno = saverrno2;

	if (err)
		return (err);

	if (dp == NULL && errno != 0 &&
	    (err = err_aborted(pglob, errno, buf)))
		return (err);

	if (errno == 0)
		errno = saverrno;
	return (0);
}


/*
 * Extend the gl_pathv member of a glob11_t structure to accommodate a new item,
 * add the new item, and update gl_pathc.
 *
 * This assumes the BSD realloc, which only copies the block when its size
 * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
 * behavior.
 *
 * Return 0 if new item added, error code if memory couldn't be allocated.
 *
 * Invariant of the glob11_t structure:
 *	Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
 *	gl_pathv points to (gl_offs + gl_pathc + 1) items.
 */
static int
globextend(const Char *path, glob11_t *pglob, struct glob_limit *limit,
    const char *origpat)
{
	char **pathv;
	size_t i, newn, len;
	char *copy;
	const Char *p;

	if ((pglob->gl_flags & GLOB_LIMIT) &&
	    pglob->gl_matchc > limit->l_path_lim) {
		errno = E2BIG;
		return (GLOB_NOSPACE);
	}

	newn = 2 + pglob->gl_pathc + pglob->gl_offs;
	/* reallocarray(NULL, newn, size) is equivalent to malloc(newn*size). */
	pathv = reallocarray(pglob->gl_pathv, newn, sizeof(*pathv));
	if (pathv == NULL)
		return (GLOB_NOSPACE);

	if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
		/* first time around -- clear initial gl_offs items */
		pathv += pglob->gl_offs;
		for (i = pglob->gl_offs + 1; --i > 0; )
			*--pathv = NULL;
	}
	pglob->gl_pathv = pathv;

	if (origpat != NULL)
		copy = strdup(origpat);
	else {
		for (p = path; *p++ != EOS;)
			continue;
		len = MB_CUR_MAX * (size_t)(p - path); /* XXX overallocation */
		if ((copy = malloc(len)) != NULL) {
			if (g_Ctoc(path, copy, len)) {
				free(copy);
				errno = E2BIG;
				return (GLOB_NOSPACE);
			}
		}
	}
	if (copy != NULL) {
		limit->l_string_cnt += strlen(copy) + 1;
		if ((pglob->gl_flags & GLOB_LIMIT) &&
		    limit->l_string_cnt >= GLOB_LIMIT_STRING) {
			free(copy);
			errno = E2BIG;
			return (GLOB_NOSPACE);
		}
		pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
	}
	pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
	return (copy == NULL ? GLOB_NOSPACE : 0);
}

/*
 * pattern matching function for filenames.  Each occurrence of the *
 * pattern causes a recursion level.
 */
static int
match(Char *name, Char *pat, Char *patend)
{
	int ok, negate_range;
	Char c, k;
	struct xlocale_collate *table =
		(struct xlocale_collate*)__get_locale()->components[XLC_COLLATE];

	while (pat < patend) {
		c = *pat++;
		switch (c & M_MASK) {
		case M_ALL:
			if (pat == patend)
				return (1);
			do
			    if (match(name, pat, patend))
				    return (1);
			while (*name++ != EOS);
			return (0);
		case M_ONE:
			if (*name++ == EOS)
				return (0);
			break;
		case M_SET:
			ok = 0;
			if ((k = *name++) == EOS)
				return (0);
			if ((negate_range = ((*pat & M_MASK) == M_NOT)) != 0)
				++pat;
			while (((c = *pat++) & M_MASK) != M_END)
				if ((*pat & M_MASK) == M_RNG) {
					if (table->__collate_load_error ?
					    CHAR(c) <= CHAR(k) &&
					    CHAR(k) <= CHAR(pat[1]) :
					    __wcollate_range_cmp(CHAR(c),
					    CHAR(k)) <= 0 &&
					    __wcollate_range_cmp(CHAR(k),
					    CHAR(pat[1])) <= 0)
						ok = 1;
					pat += 2;
				} else if (c == k)
					ok = 1;
			if (ok == negate_range)
				return (0);
			break;
		default:
			if (*name++ != c)
				return (0);
			break;
		}
	}
	return (*name == EOS);
}

/* Free allocated data belonging to a glob11_t structure. */
void
freebsd11_globfree(glob11_t *pglob)
{
	size_t i;
	char **pp;

	if (pglob->gl_pathv != NULL) {
		pp = pglob->gl_pathv + pglob->gl_offs;
		for (i = pglob->gl_pathc; i--; ++pp)
			if (*pp)
				free(*pp);
		free(pglob->gl_pathv);
		pglob->gl_pathv = NULL;
	}
}

static DIR *
g_opendir(Char *str, glob11_t *pglob)
{
	char buf[MAXPATHLEN + MB_LEN_MAX - 1];

	if (*str == EOS)
		strcpy(buf, ".");
	else {
		if (g_Ctoc(str, buf, sizeof(buf))) {
			errno = ENAMETOOLONG;
			return (NULL);
		}
	}

	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
		return ((*pglob->gl_opendir)(buf));

	return (opendir(buf));
}

static int
g_lstat(Char *fn, struct freebsd11_stat *sb, glob11_t *pglob)
{
	char buf[MAXPATHLEN + MB_LEN_MAX - 1];

	if (g_Ctoc(fn, buf, sizeof(buf))) {
		errno = ENAMETOOLONG;
		return (-1);
	}
	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
		return((*pglob->gl_lstat)(buf, sb));
	return (freebsd11_lstat(buf, sb));
}

static int
g_stat(Char *fn, struct freebsd11_stat *sb, glob11_t *pglob)
{
	char buf[MAXPATHLEN + MB_LEN_MAX - 1];

	if (g_Ctoc(fn, buf, sizeof(buf))) {
		errno = ENAMETOOLONG;
		return (-1);
	}
	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
		return ((*pglob->gl_stat)(buf, sb));
	return (freebsd11_stat(buf, sb));
}

static const Char *
g_strchr(const Char *str, wchar_t ch)
{

	do {
		if (*str == ch)
			return (str);
	} while (*str++);
	return (NULL);
}

static int
g_Ctoc(const Char *str, char *buf, size_t len)
{
	mbstate_t mbs;
	size_t clen;

	memset(&mbs, 0, sizeof(mbs));
	while (len >= MB_CUR_MAX) {
		clen = wcrtomb(buf, CHAR(*str), &mbs);
		if (clen == (size_t)-1) {
			/* XXX See initial comment #2. */
			*buf = (char)CHAR(*str);
			clen = 1;
			memset(&mbs, 0, sizeof(mbs));
		}
		if (CHAR(*str) == EOS)
			return (0);
		str++;
		buf += clen;
		len -= clen;
	}
	return (1);
}

static int
err_nomatch(glob11_t *pglob, struct glob_limit *limit, const char *origpat) {
	/*
	 * If there was no match we are going to append the origpat
	 * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
	 * and the origpat did not contain any magic characters
	 * GLOB_NOMAGIC is there just for compatibility with csh.
	 */
	if ((pglob->gl_flags & GLOB_NOCHECK) ||
	    ((pglob->gl_flags & GLOB_NOMAGIC) &&
	    !(pglob->gl_flags & GLOB_MAGCHAR)))
		return (globextend(NULL, pglob, limit, origpat));
	return (GLOB_NOMATCH);
}

static int
err_aborted(glob11_t *pglob, int err, char *buf) {
	if ((pglob->gl_errfunc != NULL && pglob->gl_errfunc(buf, err)) ||
	    (pglob->gl_flags & GLOB_ERR))
		return (GLOB_ABORTED);
	return (0);
}

#ifdef DEBUG
static void
qprintf(const char *str, Char *s)
{
	Char *p;

	(void)printf("%s\n", str);
	if (s != NULL) {
		for (p = s; *p != EOS; p++)
			(void)printf("%c", (char)CHAR(*p));
		(void)printf("\n");
		for (p = s; *p != EOS; p++)
			(void)printf("%c", (isprot(*p) ? '\\' : ' '));
		(void)printf("\n");
		for (p = s; *p != EOS; p++)
			(void)printf("%c", (ismeta(*p) ? '_' : ' '));
		(void)printf("\n");
	}
}
#endif

__sym_compat(glob, freebsd11_glob, FBSD_1.0);
__sym_compat(globfree, freebsd11_globfree, FBSD_1.0);




/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Guido van Rossum.
 *
 * 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.
 * 3. 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.
 *
 *	@(#)glob.h	8.1 (Berkeley) 6/2/93
 * from: $FreeBSD$
 * $FreeBSD$
 */

#ifndef _GLOB_COMPAT11_H_
#define	_GLOB_COMPAT11_H_

#include <sys/cdefs.h>
#include <sys/types.h>
#include <glob.h>

struct freebsd11_stat;
typedef struct {
	size_t gl_pathc;	/* Count of total paths so far. */
	size_t gl_matchc;	/* Count of paths matching pattern. */
	size_t gl_offs;		/* Reserved at beginning of gl_pathv. */
	int gl_flags;		/* Copy of flags parameter to glob. */
	char **gl_pathv;	/* List of paths matching pattern. */
				/* Copy of errfunc parameter to glob. */
	int (*gl_errfunc)(const char *, int);

	/*
	 * Alternate filesystem access methods for glob; replacement
	 * versions of closedir(3), readdir(3), opendir(3), stat(2)
	 * and lstat(2).
	 */
	void (*gl_closedir)(void *);
	struct freebsd11_dirent *(*gl_readdir)(void *);
	void *(*gl_opendir)(const char *);
	int (*gl_lstat)(const char *, struct freebsd11_stat *);
	int (*gl_stat)(const char *, struct freebsd11_stat *);
} glob11_t;

__BEGIN_DECLS
int	freebsd11_glob(const char * __restrict, int,
	int (*)(const char *, int), glob11_t * __restrict);
void	freebsd11_globfree(glob11_t *);
__END_DECLS

#endif /* !_GLOB_COMPAT11_H_ */




/*
 * Copyright (c) 2003, 2004 Todd C. Miller <Todd.Miller@courtesan.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Sponsored in part by the Defense Advanced Research Projects
 * Agency (DARPA) and Air Force Research Laboratory, Air Force
 * Materiel Command, USAF, under agreement number F39502-99-1-0512.
 *
 * from: $OpenBSD: nftw.c,v 1.7 2006/03/31 19:41:44 millert Exp $
 * from: $FreeBSD$
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fts.h>
#include <ftw.h>

#include "fts-compat11.h"

int
freebsd11_nftw(const char *path,
    int (*fn)(const char *, const struct freebsd11_stat *, int, struct FTW *),
    int nfds, int ftwflags)
{
	char * const paths[2] = { (char *)path, NULL };
	struct FTW ftw;
	FTSENT11 *cur;
	FTS11 *ftsp;
	int error = 0, ftsflags, fnflag, postorder, sverrno;

	/* XXX - nfds is currently unused */
	if (nfds < 1) {
		errno = EINVAL;
		return (-1);
	}

	ftsflags = FTS_COMFOLLOW;
	if (!(ftwflags & FTW_CHDIR))
		ftsflags |= FTS_NOCHDIR;
	if (ftwflags & FTW_MOUNT)
		ftsflags |= FTS_XDEV;
	if (ftwflags & FTW_PHYS)
		ftsflags |= FTS_PHYSICAL;
	else
		ftsflags |= FTS_LOGICAL;
	postorder = (ftwflags & FTW_DEPTH) != 0;
	ftsp = freebsd11_fts_open(paths, ftsflags, NULL);
	if (ftsp == NULL)
		return (-1);
	while ((cur = freebsd11_fts_read(ftsp)) != NULL) {
		switch (cur->fts_info) {
		case FTS_D:
			if (postorder)
				continue;
			fnflag = FTW_D;
			break;
		case FTS_DC:
			continue;
		case FTS_DNR:
			fnflag = FTW_DNR;
			break;
		case FTS_DP:
			if (!postorder)
				continue;
			fnflag = FTW_DP;
			break;
		case FTS_F:
		case FTS_DEFAULT:
			fnflag = FTW_F;
			break;
		case FTS_NS:
		case FTS_NSOK:
			fnflag = FTW_NS;
			break;
		case FTS_SL:
			fnflag = FTW_SL;
			break;
		case FTS_SLNONE:
			fnflag = FTW_SLN;
			break;
		default:
			error = -1;
			goto done;
		}
		ftw.base = cur->fts_pathlen - cur->fts_namelen;
		ftw.level = cur->fts_level;
		error = fn(cur->fts_path, cur->fts_statp, fnflag, &ftw);
		if (error != 0)
			break;
	}
done:
	sverrno = errno;
	if (freebsd11_fts_close(ftsp) != 0 && error == 0)
		error = -1;
	else
		errno = sverrno;
	return (error);
}

__sym_compat(nftw, freebsd11_nftw, FBSD_1.0);




/*
 * Copyright (c) 1983, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. 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.
 *
 * from:
 * $FreeBSD$
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)readdir.c	8.3 (Berkeley) 9/29/94";
#endif /* LIBC_SCCS and not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#define	_WANT_FREEBSD11_DIRENT
#include <dirent.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "un-namespace.h"

#include "libc_private.h"
#include "gen-private.h"
#include "telldir.h"

#include "gen-compat.h"

static int
freebsd11_cvtdirent(struct freebsd11_dirent *dstdp, struct dirent *srcdp)
{

	if (srcdp->d_namlen > sizeof(dstdp->d_name) - 1)
		return (ENAMETOOLONG);
	dstdp->d_type = srcdp->d_type;
	dstdp->d_namlen = srcdp->d_namlen;
	dstdp->d_fileno = srcdp->d_fileno;		/* truncate */
	dstdp->d_reclen = FREEBSD11_DIRSIZ(dstdp);
	bcopy(srcdp->d_name, dstdp->d_name, dstdp->d_namlen);
	bzero(dstdp->d_name + dstdp->d_namlen,
	    dstdp->d_reclen - offsetof(struct freebsd11_dirent, d_name) -
	    dstdp->d_namlen);
	return (0);
}

struct freebsd11_dirent *
freebsd11_readdir(DIR *dirp)
{
	static struct freebsd11_dirent *compatbuf;
	struct freebsd11_dirent *dstdp;
	struct dirent *dp;

	if (__isthreaded)
		_pthread_mutex_lock(&dirp->dd_lock);
again:
	dp = _readdir_unlocked(dirp, 1);
	if (dp != NULL) {
		if (compatbuf == NULL)
			compatbuf = malloc(sizeof(struct freebsd11_dirent));
		if (freebsd11_cvtdirent(compatbuf, dp) != 0)
			goto again;
		dstdp = compatbuf;
	} else
		dstdp = NULL;
	if (__isthreaded)
		_pthread_mutex_unlock(&dirp->dd_lock);

	return (dstdp);
}

int
freebsd11_readdir_r(DIR *dirp, struct freebsd11_dirent *entry,
    struct freebsd11_dirent **result)
{
	struct dirent xentry;
	struct dirent *xresult;
	int error;

again:
	error = readdir_r(dirp, &xentry, &xresult);

	if (error != 0)
		return (error);
	if (xresult != NULL) {
		if (freebsd11_cvtdirent(entry, &xentry) != 0)
			goto again;
		*result = entry;
	} else
		*result = NULL;
	return (0);
}

__sym_compat(readdir, freebsd11_readdir, FBSD_1.0);
__sym_compat(readdir_r, freebsd11_readdir_r, FBSD_1.0);




/*
 * Copyright (c) 1983, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. 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.
 *
 * from:
 * $FreeBSD$
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)scandir.c	8.3 (Berkeley) 1/2/94";
#endif /* LIBC_SCCS and not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

/*
 * Scan the directory dirname calling select to make a list of selected
 * directory entries then sort using qsort and compare routine dcomp.
 * Returns the number of entries and a pointer to a list of pointers to
 * struct dirent (through namelist). Returns -1 if there were any errors.
 */

#include "namespace.h"
#define	_WANT_FREEBSD11_DIRENT
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include "un-namespace.h"

#include "gen-compat.h"

#ifdef	I_AM_SCANDIR_B
#include "block_abi.h"
#define	SELECT(x)	CALL_BLOCK(select, x)
#ifndef __BLOCKS__
void
qsort_b(void *, size_t, size_t, void*);
#endif
#else
#define	SELECT(x)	select(x)
#endif

static int freebsd11_alphasort_thunk(void *thunk, const void *p1,
    const void *p2);

int
#ifdef I_AM_SCANDIR_B
freebsd11_scandir_b(const char *dirname, struct freebsd11_dirent ***namelist,
    DECLARE_BLOCK(int, select, const struct freebsd11_dirent *),
    DECLARE_BLOCK(int, dcomp, const struct freebsd11_dirent **,
    const struct freebsd11_dirent **))
#else
freebsd11_scandir(const char *dirname, struct freebsd11_dirent ***namelist,
    int (*select)(const struct freebsd11_dirent *),
    int (*dcomp)(const struct freebsd11_dirent **,
	const struct freebsd11_dirent **))
#endif
{
	struct freebsd11_dirent *d, *p, **names = NULL;
	size_t numitems;
	long arraysz;
	DIR *dirp;

	if ((dirp = opendir(dirname)) == NULL)
		return(-1);

	numitems = 0;
	arraysz = 32;	/* initial estimate of the array size */
	names = (struct freebsd11_dirent **)malloc(
	    arraysz * sizeof(struct freebsd11_dirent *));
	if (names == NULL)
		goto fail;

	while ((d = freebsd11_readdir(dirp)) != NULL) {
		if (select != NULL && !SELECT(d))
			continue;	/* just selected names */
		/*
		 * Make a minimum size copy of the data
		 */
		p = (struct freebsd11_dirent *)malloc(FREEBSD11_DIRSIZ(d));
		if (p == NULL)
			goto fail;
		p->d_fileno = d->d_fileno;
		p->d_type = d->d_type;
		p->d_reclen = d->d_reclen;
		p->d_namlen = d->d_namlen;
		bcopy(d->d_name, p->d_name, p->d_namlen + 1);
		/*
		 * Check to make sure the array has space left and
		 * realloc the maximum size.
		 */
		if (numitems >= arraysz) {
			struct freebsd11_dirent **names2;

			names2 = reallocarray(names, arraysz,
			    2 * sizeof(struct freebsd11_dirent *));
			if (names2 == NULL) {
				free(p);
				goto fail;
			}
			names = names2;
			arraysz *= 2;
		}
		names[numitems++] = p;
	}
	closedir(dirp);
	if (numitems && dcomp != NULL)
#ifdef I_AM_SCANDIR_B
		qsort_b(names, numitems, sizeof(struct freebsd11_dirent *),
		    (void*)dcomp);
#else
		qsort_r(names, numitems, sizeof(struct freebsd11_dirent *),
		    &dcomp, freebsd11_alphasort_thunk);
#endif
	*namelist = names;
	return (numitems);

fail:
	while (numitems > 0)
		free(names[--numitems]);
	free(names);
	closedir(dirp);
	return (-1);
}

/*
 * Alphabetic order comparison routine for those who want it.
 * POSIX 2008 requires that alphasort() uses strcoll().
 */
int
freebsd11_alphasort(const struct freebsd11_dirent **d1,
    const struct freebsd11_dirent **d2)
{

	return (strcoll((*d1)->d_name, (*d2)->d_name));
}

static int
freebsd11_alphasort_thunk(void *thunk, const void *p1, const void *p2)
{
	int (*dc)(const struct freebsd11_dirent **, const struct
	    freebsd11_dirent **);

	dc = *(int (**)(const struct freebsd11_dirent **,
	    const struct freebsd11_dirent **))thunk;
	return (dc((const struct freebsd11_dirent **)p1,
	    (const struct freebsd11_dirent **)p2));
}

__sym_compat(alphasort, freebsd11_alphasort, FBSD_1.0);
__sym_compat(scandir, freebsd11_scandir, FBSD_1.0);
__sym_compat(scandir_b, freebsd11_scandir_b, FBSD_1.4);





static int alphasort_thunk(void *thunk, const void *p1, const void *p2);

/*
 * The DIRSIZ macro is the minimum record length which will hold the directory
 * entry.  This requires the amount of space in struct dirent without the
 * d_name field, plus enough space for the name and a terminating nul byte
 * (dp->d_namlen + 1), rounded up to a 4 byte boundary.
 */
#undef DIRSIZ
#define DIRSIZ(dp)							\
	((sizeof(struct dirent) - sizeof(dp)->d_name) +			\
	    (((dp)->d_namlen + 1 + 3) &~ 3))

int
#ifdef I_AM_SCANDIR_B
scandir_b(const char *dirname, struct dirent ***namelist,

		/*
		 * Make a minimum size copy of the data
		 */
		p = (struct dirent *)malloc(_GENERIC_DIRSIZ(d));
		if (p == NULL)
			goto fail;
		p->d_fileno = d->d_fileno;

Lines 47-53 Link Here

(-)b/lib/libc/gen/telldir.h (-1 / +1 lines)
47	struct ddloc {	47	struct ddloc {
48	LIST_ENTRY(ddloc) loc_lqe; /* entry in list */	48	LIST_ENTRY(ddloc) loc_lqe; /* entry in list */
49	long loc_index; /* key associated with structure */	49	long loc_index; /* key associated with structure */
50	long loc_seek; /* magic cookie returned by getdirentries */	50	off_t loc_seek; /* magic cookie returned by getdirentries */
51	long loc_loc; /* offset of entry in buffer */	51	long loc_loc; /* offset of entry in buffer */
52	};	52	};
53		53




__sym_compat(shmctl, freebsd7_shmctl, FBSD_1.0);
#endif

__sym_compat(nfstat, freebsd11_nfstat, FBSD_1.0);
__sym_compat(nlstat, freebsd11_nlstat, FBSD_1.0);
__sym_compat(nstat, freebsd11_nstat, FBSD_1.0);

__sym_compat(fhstat, freebsd11_fhstat, FBSD_1.0);
__sym_compat(fstat, freebsd11_fstat, FBSD_1.0);
__sym_compat(fstatat, freebsd11_fstatat, FBSD_1.1);
__sym_compat(lstat, freebsd11_lstat, FBSD_1.0);
__sym_compat(stat, freebsd11_stat, FBSD_1.0);

__sym_compat(getdents, freebsd11_getdents, FBSD_1.0);
__sym_compat(getdirentries, freebsd11_getdirentries, FBSD_1.0);

__sym_compat(getfsstat, freebsd11_getfsstat, FBSD_1.0);
__sym_compat(fhstatfs, freebsd11_fhstatfs, FBSD_1.0);
__sym_compat(fstatfs, freebsd11_fstatfs, FBSD_1.0);
__sym_compat(statfs, freebsd11_statfs, FBSD_1.0);

__sym_compat(mknod, freebsd11_mknod, FBSD_1.0);
__sym_compat(mknodat, freebsd11_mknodat, FBSD_1.1);

#undef __sym_compat

#define	__weak_reference(sym,alias)	\




struct rusage;
struct sigaction;
struct sockaddr;
struct stat;
struct timespec;
struct timeval;
struct timezone;

		    const struct timespec *, struct timespec *);
int		__sys_close(int);
int		__sys_connect(int, const struct sockaddr *, __socklen_t);
__ssize_t	__sys_getdirentries(int, char *, __size_t, __off_t *);
int		__sys_fcntl(int, int, ...);
int		__sys_fdatasync(int);
int		__sys_fstatat(int, const char *, struct stat *, int);
int		__sys_fsync(int);
__pid_t		__sys_fork(void);
int		__sys_ftruncate(int, __off_t);

Lines 35-40 SRCS+= \ Link Here

(-)b/lib/libc/sys/Makefile.inc (+2 lines)
35	__error.c \	35	__error.c \
36	interposing_table.c	36	interposing_table.c
37		37
		38	SRCS+= getdents.c lstat.c mknod.c stat.c
		39
38	SRCS+= futimens.c utimensat.c	40	SRCS+= futimens.c utimensat.c
39	NOASM+= futimens.o utimensat.o	41	NOASM+= futimens.o utimensat.o
40	PSEUDO+= _futimens.o _utimensat.o	42	PSEUDO+= _futimens.o _utimensat.o




	fchown;
	fcntl;
	fhopen;
	fhstat;
	fhstatfs;
	flock;
	fork;
	fpathconf;
	fstat;
	fstatfs;
	fsync;
	futimes;
	getaudit;
	getaudit_addr;
	getauid;
	getcontext;
	getdents;
	getdirentries;
	getdtablesize;
	getegid;
	geteuid;
	getfh;
	getfsstat;
	getgid;
	getgroups;
	getitimer;

	link;
	lio_listio;
	listen;
	lstat;
	lutimes;
	mac_syscall;
	madvise;

	minherit;
	mkdir;
	mkfifo;
	mknod;
	mlock;
	mlockall;
	modfind;

	netbsd_lchown;
	netbsd_msync;
	nfssvc;
	nfstat;
	nlstat;
	nmount;
	nstat;
	ntp_adjtime;
	ntp_gettime;
	open;

	sigwaitinfo;
	socket;
	socketpair;
	stat;
	statfs;
	swapoff;
	swapon;
	symlink;

	fchmodat;
	fchownat;
	fexecve;
	fstatat;
	futimesat;
	jail_get;
	jail_set;

	lpathconf;
	mkdirat;
	mkfifoat;
	mknodat;
	msgctl;
	readlinkat;
	renameat;

FBSD_1.5 {
	clock_nanosleep;
	fdatasync;
	fhstat;
	fhstatfs;
	fstat;
	fstatat;
	fstatfs;
	getdents;
	getdirentries;
	getfsstat;
	lstat;
	mknod;
	mknodat;
	stat;
	statfs;
};

FBSDprivate_1.0 {

	__sys_getauid;
	_getcontext;
	__sys_getcontext;
	_getdents;
	__sys_getdents;
	_getdirentries;
	__sys_getdirentries;
	_getdtablesize;

	__sys_lio_listio;
	_listen;
	__sys_listen;
	_lstat;
	__sys_lstat;
	_lutimes;
	__sys_lutimes;
	_mac_syscall;

	__sys_netbsd_msync;
	_nfssvc;
	__sys_nfssvc;
	_nfstat;
	__sys_nfstat;
	_nlstat;
	__sys_nlstat;
	_nmount;
	__sys_nmount;
	_nstat;
	__sys_nstat;
	_ntp_adjtime;
	__sys_ntp_adjtime;
	_ntp_gettime;

	__sys_socket;
	_socketpair;
	__sys_socketpair;
	_stat;
	__sys_stat;
	_statfs;
	__sys_statfs;
	_swapcontext;




/*-
 * Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#include <sys/syscall.h>
#include <dirent.h>
#include "libc_private.h"

ssize_t
getdents(int fd, char *buf, size_t nbytes)
{

	return (__sys_getdirentries(fd, buf, nbytes, NULL));
}

Lines 40-49 Link Here

(-)b/lib/libc/sys/getdirentries.2 (-4 / +4 lines)
40	.Sh SYNOPSIS	40	.Sh SYNOPSIS
41	.In sys/types.h	41	.In sys/types.h
42	.In dirent.h	42	.In dirent.h
43	.Ft int	43	.Ft ssize_t
44	.Fn getdirentries "int fd" "char buf" "int nbytes" "long basep"	44	.Fn getdirentries "int fd" "char buf" "size_t nbytes" "off_t basep"
45	.Ft int	45	.Ft ssize_t
46	.Fn getdents "int fd" "char *buf" "int nbytes"	46	.Fn getdents "int fd" "char *buf" "size_t nbytes"
47	.Sh DESCRIPTION	47	.Sh DESCRIPTION
48	The	48	The
49	.Fn getdirentries	49	.Fn getdirentries




/*-
 * Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <unistd.h>
#include "libc_private.h"

int
lstat(const char *path, struct stat *sb)
{

	return (__sys_fstatat(AT_FDCWD, path, sb, AT_SYMLINK_NOFOLLOW));
}




/*-
 * Copyright (c) 2011 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <unistd.h>
#include "libc_private.h"

int __sys_mknodat(int, const char *, mode_t, dev_t);

int
mknod(const char *path, mode_t mode, dev_t dev)
{

	return (__sys_mknodat(AT_FDCWD, path, mode, dev));
}




/*-
 * Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "namespace.h"
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <unistd.h>
#include "libc_private.h"

int
stat(const char *path, struct stat *sb)
{

	return (__sys_fstatat(AT_FDCWD, path, sb, 0));
}

Lines 28-34 Link Here

(-)b/lib/libc/sys/statfs.2 (-3 / +3 lines)
28	.\" @(#)statfs.2 8.5 (Berkeley) 5/24/95	28	.\" @(#)statfs.2 8.5 (Berkeley) 5/24/95
29	.\" $FreeBSD$	29	.\" $FreeBSD$
30	.\"	30	.\"
31	.Dd November 1, 2006	31	.Dd February 13, 2017
32	.Dt STATFS 2	32	.Dt STATFS 2
33	.Os	33	.Os
34	.Sh NAME	34	.Sh NAME
Lines 66-73 typedef struct fsid { int32_t val[2]; } fsid_t; /* file system id type */ Link Here
66	*/	66	*/
67		67
68	#define MFSNAMELEN 16 /* length of type name including null */	68	#define MFSNAMELEN 16 /* length of type name including null */
69	#define MNAMELEN 88 /* size of on/from name bufs */	69	#define MNAMELEN 1024 /* size of on/from name bufs */
70	#define STATFS_VERSION 0x20030518 /* current version number */	70	#define STATFS_VERSION 0x20140518 /* current version number */
71		71
72	struct statfs {	72	struct statfs {
73	uint32_t f_version; /* structure version number */	73	uint32_t f_version; /* structure version number */

Lines 452-457 nopgrp: Link Here

(-)b/lib/libkvm/kvm_proc.c (+1 lines)
452	} else {	452	} else {
453	kp->ki_stat = SZOMB;	453	kp->ki_stat = SZOMB;
454	}	454	}
		455	kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
455	bcopy(&kinfo_proc, bp, sizeof(kinfo_proc));	456	bcopy(&kinfo_proc, bp, sizeof(kinfo_proc));
456	++bp;	457	++bp;
457	++cnt;	458	++cnt;

Lines 29-34 SRCS+= main.c engine.c listener.c handler.c comm.c monitor.c smfi.c \ Link Here

(-)b/lib/libmilter/Makefile (+1 lines)
29	CLEANFILES+=sm_os.h	29	CLEANFILES+=sm_os.h
30		30
31	WARNS?= 0	31	WARNS?= 0
		32	SHLIB_MAJOR= 6
32		33
33	sm_os.h: ${SENDMAIL_DIR}/include/sm/os/sm_os_freebsd.h .NOMETA	34	sm_os.h: ${SENDMAIL_DIR}/include/sm/os/sm_os_freebsd.h .NOMETA
34	ln -sf ${.ALLSRC} ${.TARGET}	35	ln -sf ${.ALLSRC} ${.TARGET}

Lines 13-18 SRCS= cd9660.c \ Link Here

(-)b/lib/libprocstat/Makefile (+4 lines)
13	smbfs.c \	13	smbfs.c \
14	udf.c	14	udf.c
15		15
		16	.if ${MK_SYMVER} == yes
		17	SRCS+= libprocstat_compat.c
		18	.endif
		19
16	VERSION_DEF= ${LIBCSRCDIR}/Versions.def	20	VERSION_DEF= ${LIBCSRCDIR}/Versions.def
17	SYMBOL_MAPS= ${.CURDIR}/Symbol.map	21	SYMBOL_MAPS= ${.CURDIR}/Symbol.map
18		22




	procstat_freefiles;
	procstat_freeprocs;
	procstat_get_pipe_info;
	procstat_get_pts_info;
	procstat_get_socket_info;
	procstat_get_vnode_info;
	procstat_getfiles;
	procstat_getprocs;
	procstat_open_kvm;

	procstat_freegroups;
	procstat_freekstack;
	procstat_freevmmap;
	procstat_get_sem_info;
	procstat_get_shm_info;
	procstat_getargv;
	procstat_getauxv;
	procstat_getenvv;

FBSD_1.5 {
	procstat_freeptlwpinfo;
	procstat_getptlwpinfo;
	procstat_get_pts_info;
	procstat_get_sem_info;
	procstat_get_shm_info;
	procstat_get_vnode_info;
};




	struct statfs stbuf;
	struct kinfo_file *kif;
	struct kinfo_vmentry *kve;
	char *name, *path;
	uint64_t fileid;
	uint64_t size;
	uint64_t fsid;
	uint64_t rdev;
	uint16_t mode;
	uint32_t rdev;
	int vntype;
	int status;


	sock->dom_family = kif->kf_sock_domain;
	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
	bcopy(&kif->kf_un.kf_sock.kf_sa_local, &sock->sa_local,
	    kif->kf_un.kf_sock.kf_sa_local.ss_len);
	bcopy(&kif->kf_un.kf_sock.kf_sa_peer, &sock->sa_peer,
	    kif->kf_un.kf_sock.kf_sa_peer.ss_len);

	/*
	 * Protocol specific data.




struct vnstat {
	uint64_t	vn_fileid;
	uint64_t	vn_size;
	uint64_t	vn_dev;
	uint64_t	vn_fsid;
	char		*vn_mntdir;
	uint32_t	vn_dev;
	uint32_t	vn_fsid;
	int		vn_type;
	uint16_t	vn_mode;
	char		vn_devname[SPECNAMELEN + 1];
};
struct ptsstat {
	uint64_t	dev;
	char		devname[SPECNAMELEN + 1];
};
struct pipestat {




/*-
 * Copyright (c) 2014 Gleb Kurtsou <gleb@FreeBSD.org>
 * All rights reserved.
 *
 * 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.
 *
 * 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.
 *
 * $FreeBSD$
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/user.h>
#include <sys/socket.h>
#include <string.h>

#include "libprocstat.h"

struct freebsd11_ptsstat {
	uint32_t	dev;
	char		devname[SPECNAMELEN + 1];
};

struct freebsd11_vnstat {
	uint64_t	vn_fileid;
	uint64_t	vn_size;
	char		*vn_mntdir;
	uint32_t	vn_dev;
	uint32_t	vn_fsid;
	int		vn_type;
	uint16_t	vn_mode;
	char		vn_devname[SPECNAMELEN + 1];
};
struct freebsd11_semstat {
	uint32_t	value;
	uint16_t	mode;
};
struct freebsd11_shmstat {
	uint64_t	size;
	uint16_t	mode;
};

int	freebsd11_procstat_get_pts_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_ptsstat *pts, char *errbuf);
int	freebsd11_procstat_get_sem_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_semstat *sem, char *errbuf);
int	freebsd11_procstat_get_shm_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_shmstat *shm, char *errbuf);
int	freebsd11_procstat_get_vnode_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_vnstat *vn, char *errbuf);

int
freebsd11_procstat_get_pts_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_ptsstat *pts_compat, char *errbuf)
{
	struct ptsstat pts;
	int r;

	r = procstat_get_pts_info(procstat, fst, &pts, errbuf);
	if (r != 0)
		return (r);
	pts_compat->dev = pts.dev;
	memcpy(pts_compat->devname, pts.devname,
	    sizeof(pts_compat->devname));
	return (0);
}

int
freebsd11_procstat_get_sem_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_semstat *sem_compat, char *errbuf)
{
	struct semstat sem;
	int r;

	r = procstat_get_sem_info(procstat, fst, &sem, errbuf);
	if (r != 0)
		return (r);
	sem_compat->value = sem.value;
	sem_compat->mode = sem.mode;
	return (0);
}

int
freebsd11_procstat_get_shm_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_shmstat *shm_compat, char *errbuf)
{
	struct shmstat shm;
	int r;

	r = procstat_get_shm_info(procstat, fst, &shm, errbuf);
	if (r != 0)
		return (r);
	shm_compat->size = shm.size;
	shm_compat->mode = shm.mode;
	return (0);
}

int
freebsd11_procstat_get_vnode_info(struct procstat *procstat,
    struct filestat *fst, struct freebsd11_vnstat *vn_compat, char *errbuf)
{
	struct vnstat vn;
	int r;

	r = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
	if (r != 0)
		return (r);
	vn_compat->vn_fileid = vn.vn_fileid;
	vn_compat->vn_size = vn.vn_size;
	vn_compat->vn_mntdir = vn.vn_mntdir;
	vn_compat->vn_dev = vn.vn_dev;
	vn_compat->vn_fsid = vn.vn_fsid;
	vn_compat->vn_type = vn.vn_type;
	vn_compat->vn_mode = vn.vn_mode;
	memcpy(vn_compat->vn_devname, vn.vn_devname,
	    sizeof(vn_compat->vn_devname));
	return (0);
}

__sym_compat(procstat_get_pts_info, freebsd11_procstat_get_pts_info, FBSD_1.2);
__sym_compat(procstat_get_vnode_info, freebsd11_procstat_get_vnode_info,
    FBSD_1.2);
__sym_compat(procstat_get_sem_info, freebsd11_procstat_get_sem_info, FBSD_1.3);
__sym_compat(procstat_get_shm_info, freebsd11_procstat_get_shm_info, FBSD_1.3);

Lines 45-52 struct uufsd { Link Here

(-)b/lib/libufs/libufs.h (-2 / +2 lines)
45	ufs2_daddr_t d_sblock; /* superblock location */	45	ufs2_daddr_t d_sblock; /* superblock location */
46	struct csum d_sbcsum; / Superblock summary info */	46	struct csum d_sbcsum; / Superblock summary info */
47	caddr_t d_inoblock; /* inode block */	47	caddr_t d_inoblock; /* inode block */
48	ino_t d_inomin; /* low inode */	48	uint32_t d_inomin; /* low inode (not ino_t for ABI compat) */
49	ino_t d_inomax; /* high inode */	49	uint32_t d_inomax; /* high inode (not ino_t for ABI compat) */
50	union {	50	union {
51	struct fs d_fs; /* filesystem information */	51	struct fs d_fs; /* filesystem information */
52	char d_sb[MAXBSIZE];	52	char d_sb[MAXBSIZE];




Index: devel/llvm39/Makefile
===================================================================
--- devel/llvm39/Makefile	(revision 437547)
+++ devel/llvm39/Makefile	(working copy)
@@ -326,6 +326,7 @@
 
 post-patch-COMPILER_RT-on:
 	cd ${WRKSRC_compiler_rt} && patch < ${PATCHDIR}/compiler-rt-patch-svn-294806
+	cd ${WRKSRC_compiler_rt} && patch < ${PATCHDIR}/compiler-rt-patch-ino64
 
 post-build-COMPILER_RT-on:
 	${MKDIR} ${WRKDIR}/compiler-rt-build
Index: devel/llvm39/files/compiler-rt-patch-ino64
===================================================================
--- devel/llvm39/files/compiler-rt-patch-ino64	(nonexistent)
+++ devel/llvm39/files/compiler-rt-patch-ino64	(working copy)
@@ -0,0 +1,49 @@
+diff --git lib/sanitizer_common/sanitizer_linux.cc lib/sanitizer_common/sanitizer_linux.cc
+index 7328a5c0ac1..4b59a39ee27 100644
+--- lib/sanitizer_common/sanitizer_linux.cc
++++ lib/sanitizer_common/sanitizer_linux.cc
+@@ -223,7 +223,8 @@ static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) {
+ 
+ uptr internal_stat(const char *path, void *buf) {
+ #if SANITIZER_FREEBSD
+-  return internal_syscall(SYSCALL(stat), path, buf);

#!/bin/sh
if [ x"$INO64GIT" = x ]; then
    echo "set INO64GIT env var to point to the git mirror of ino64"
    exit 1
fi
xxx=$(svn st 2>&1)
if [ x"$xxx" \!= x ]; then
    echo "working directory is not clean, check with svn status"
    exit 1
fi
set -e
svn cp include/fts.h lib/libc/gen/fts-compat11.h
rm lib/libc/gen/fts-compat11.h
svn cp include/glob.h lib/libc/gen/glob-compat11.h
rm lib/libc/gen/glob-compat11.h
svn cp lib/libc/gen/fts.c lib/libc/gen/fts-compat11.c
rm lib/libc/gen/fts-compat11.c
svn cp lib/libc/gen/ftw.c lib/libc/gen/ftw-compat11.c
rm lib/libc/gen/ftw-compat11.c
svn cp lib/libc/gen/nftw.c lib/libc/gen/nftw-compat11.c
rm lib/libc/gen/nftw-compat11.c
svn cp lib/libc/gen/glob.c lib/libc/gen/glob-compat11.c
rm lib/libc/gen/glob-compat11.c
svn cp lib/libc/gen/getmntinfo.c lib/libc/gen/getmntinfo-compat11.c
rm lib/libc/gen/getmntinfo-compat11.c
svn cp lib/libc/gen/readdir.c lib/libc/gen/readdir-compat11.c
rm lib/libc/gen/readdir-compat11.c
svn cp lib/libc/gen/scandir.c lib/libc/gen/scandir-compat11.c
rm lib/libc/gen/scandir-compat11.c
(cd $INO64GIT && git diff origin/master ino64) | gpatch -p1
add_files="lib/libc/sys/getdents.c lib/libc/sys/lstat.c"
add_files="$add_files lib/libc/sys/mknod.c lib/libc/sys/stat.c"
add_files="$add_files lib/libc/gen/gen-compat.h lib/libc/gen/devname-compat11.c"
add_files="$add_files lib/libprocstat/libprocstat_compat.c"
svn add $add_files
svn propset svn:keywords 'FreeBSD=%H' $add_files
rm -f TODO.ino64 preapply.sh abi.sh ports.patch
xxx=$(svn st | awk '$1 ~ /^\?$/ {print $2}')
if [ x"$xxx" \!= x ]; then
    echo "unmanaged files were found after patching, check"
    exit 1
fi
echo "Looks good"




			err(8, "%s", *argv);
		if (chkuse(number, 1))
			continue;
		/*
		 * Print a warning if converting the block number to a dev_t
		 * will truncate it.  badsect was not very useful in versions
		 * of BSD before 4.4 because dev_t was 16 bits and another
		 * bit was lost by bogus sign extensions.
		 */
		diskbn = dbtofsb(fs, number);
		if (mknod(*argv, IFMT|0600, (dev_t)diskbn) < 0) {
			printf("sector %ld cannot be represented as a dev_t\n",
			    (long)number);
			errs++;
		}
		else if (mknod(*argv, IFMT|0600, (dev_t)diskbn) < 0) {
			warn("%s", *argv);
			errs++;
		}




	struct suj_ino *stmp;
	union dinode *ip;
	nlink_t nlink;
	nlink_t reqlink;
	int recmode;
	int reqlink;
	int isdot;
	int mode;
	ino_t ino;

	struct suj_rec *srec;
	struct jrefrec *rrec;
	nlink_t dotlinks;
	nlink_t newlinks;
	nlink_t removes;
	nlink_t nlink;
	ino_t ino;
	int isdot;
	int isat;




.\"     @(#)acct.5	8.1 (Berkeley) 6/5/93
.\" $FreeBSD$
.\"
.Dd February 13, 2017
.Dt ACCT 5
.Os
.Sh NAME

#define AC_COMM_LEN 16

/*
 * Accounting structure version 3 (current).
 * The first byte is always zero.
 * Time units are microseconds.
 */

struct acctv3 {
	uint8_t  ac_zero;		/* zero identifies new version */
	uint8_t  ac_version;		/* record version number */
	uint16_t ac_len;		/* record length */


	uint16_t ac_len2;		/* record length */
	union {
		uint32_t  ac_align;	/* force v1 compatible alignment */

#define	AFORK	0x01			/* forked but not exec'ed */
/* ASU is no longer supported */




.\"     @(#)dir.5	8.3 (Berkeley) 4/19/94
.\" $FreeBSD$
.\"
.Dd February 13, 2017
.Dt DIR 5
.Os
.Sh NAME

 * contained in the entry.  These are followed by the name padded to a 4
 * byte boundary with null bytes.  All names are guaranteed null terminated.
 * The maximum length of a name in a directory is MAXNAMLEN.
 * Explicit pad is added between the last member of the header and
 * d_name, to avoid having the ABI padding in the end of dirent on
 * LP64 arches.  There is code depending on d_name being last.  Also,
 * keeping this pad for ILP32 architectures simplifies compat32 layer.
 */

struct dirent {
	ino_t      d_fileno;		/* file number of entry */
	off_t      d_off;		/* directory offset of entry */
	__uint16_t d_reclen;		/* length of this record */
	__uint8_t  d_type;		/* file type, see below */
	__uint8_t  d_namlen;		/* length of string in d_name */
	__uint32_t d_pad0;
#if __BSD_VISIBLE
#else
#define	MAXNAMLEN	255
	char	d_name[MAXNAMLEN + 1];	/* name must be no longer than this */
#else
	char	d_name[255 + 1];	/* name must be no longer than this */
#endif
};



/*
 * The _GENERIC_DIRSIZ macro gives the minimum record length which will hold
 * the directory entry.  This returns the amount of space in struct direct
 * without the d_name field, plus enough space for the name with a terminating
 * null byte (dp->d_namlen+1), rounded up to a 8 byte boundary.
 *
 * XXX although this macro is in the implementation namespace, it requires
 * a manifest constant that is not.
 */
#define	_GENERIC_DIRLEN(namlen)					\
	((__offsetof(struct dirent, d_name) + (namlen) + 1 + 7) & ~7)
#define	_GENERIC_DIRSIZ(dp)	_GENERIC_DIRLEN((dp)->d_namlen)
#endif /* __BSD_VISIBLE */

#ifdef _KERNEL
#define	GENERIC_DIRSIZ(dp)	_GENERIC_DIRSIZ(dp)




typedef	u_int64_t	au_asflgs_t __attribute__ ((aligned (8)));

struct au_tid {
	u_int32_t	port;		/* XXX dev_t compatibility */
	u_int32_t	machine;
};
typedef	struct au_tid	au_tid_t;

struct au_tid_addr {
	u_int32_t	at_port;	/* XXX dev_t compatibility */
	u_int32_t	at_type;
	u_int32_t	at_addr[4];
};

Lines 40-47 typedef ino_t ino64_t; Link Here

(-)b/sys/cddl/compat/opensolaris/sys/dirent.h (-3 / +1 lines)
40		40
41	#define d_ino d_fileno	41	#define d_ino d_fileno
42		42
43	#define DIRENT64_RECLEN(len) ((sizeof(struct dirent) - \	43	#define DIRENT64_RECLEN(len) _GENERIC_DIRLEN(len)
44	sizeof(((struct dirent *)NULL)->d_name) + \
45	(len) + 1 + 3) & ~3)
46		44
47	#endif /* !_OPENSOLARIS_SYS_DIRENT_H_ */	45	#endif /* !_OPENSOLARIS_SYS_DIRENT_H_ */

Lines 94-99 freebsd32_fexecve Link Here

(-)b/sys/compat/freebsd32/capabilities.conf (+5 lines)
94	flock	94	flock
95	fork	95	fork
96	fpathconf	96	fpathconf
		97	freebsd11_freebsd32_fstat
		98	freebsd11_freebsd32_fstatat
		99	freebsd11_freebsd32_getdirentries
		100	freebsd11_freebsd32_fstatfs
		101	freebsd11_freebsd32_mknodat
97	freebsd6_freebsd32_ftruncate	102	freebsd6_freebsd32_ftruncate
98	freebsd6_freebsd32_lseek	103	freebsd6_freebsd32_lseek
99	freebsd6_freebsd32_mmap	104	freebsd6_freebsd32_mmap




	struct timeval32 it_value;
};

#define FREEBSD4_MFSNAMELEN	16
#define FREEBSD4_MNAMELEN	(88 - 2 * sizeof(int32_t))

/* 4.x version */
struct statfs32 {

	int32_t	f_flags;
	int32_t	f_syncwrites;
	int32_t	f_asyncwrites;
	char	f_fstypename[FREEBSD4_MFSNAMELEN];
	char	f_mntonname[FREEBSD4_MNAMELEN];
	int32_t	f_syncreads;
	int32_t	f_asyncreads;

};

struct stat32 {
	dev_t st_dev;
	ino_t st_ino;
	nlink_t st_nlink;
	mode_t	st_mode;
	u_int16_t st_padding0;
	uid_t	st_uid;
	gid_t	st_gid;
	u_int32_t st_padding1;
	dev_t st_rdev;
	struct timespec32 st_atim;
	struct timespec32 st_mtim;
	struct timespec32 st_ctim;
	struct timespec32 st_birthtim;
	off_t	st_size;
	int64_t	st_blocks;
	u_int32_t st_blksize;
	u_int32_t st_flags;
	u_int64_t st_gen;
	u_int64_t st_spare[10];
};
struct freebsd11_stat32 {
	u_int32_t st_dev;
	u_int32_t st_ino;
	mode_t	st_mode;
	u_int16_t st_nlink;
	uid_t	st_uid;
	gid_t	st_gid;
	u_int32_t st_rdev;
	struct timespec32 st_atim;
	struct timespec32 st_mtim;
	struct timespec32 st_ctim;


struct ostat32 {
	__uint16_t st_dev;
	__uint32_t st_ino;
	mode_t	st_mode;
	__uint16_t st_nlink;
	__uint16_t st_uid;
	__uint16_t st_gid;
	__uint16_t st_rdev;

	pid_t	ki_tsid;
	short	ki_jobc;
	short	ki_spare_short1;
	uint32_t ki_tdev_freebsd11;
	sigset_t ki_siglist;
	sigset_t ki_sigmask;
	sigset_t ki_sigignore;

	char	ki_moretdname[MAXCOMLEN-TDNAMLEN+1];
	char	ki_sparestrings[46];
	int	ki_spareints[KI_NSPARE_INT];
	uint64_t ki_tdev;
	int	ki_oncpu;
	int	ki_lastcpu;
	int	ki_tracer;




CTASSERT(sizeof(struct iovec32) == 8);
CTASSERT(sizeof(struct msghdr32) == 28);
#ifndef __mips__
CTASSERT(sizeof(struct stat32) == 192);
CTASSERT(sizeof(struct freebsd11_stat32) == 96);
#endif
CTASSERT(sizeof(struct sigaction32) == 24);


	return (error);
}

#if defined(COMPAT_FREEBSD11)
int
freebsd11_freebsd32_mknod(struct thread *td,
    struct freebsd11_freebsd32_mknod_args *uap)
{

	return (kern_mknodat(td, AT_FDCWD, uap->path, UIO_USERSPACE, uap->mode,
	    uap->dev));
}

int
freebsd11_freebsd32_mknodat(struct thread *td,
    struct freebsd11_freebsd32_mknodat_args *uap)
{

	return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode,
	    uap->dev));
}
#endif /* COMPAT_FREEBSD11 */

int
freebsd32_mprotect(struct thread *td, struct freebsd32_mprotect_args *uap)
{

}
#endif

#if defined(COMPAT_FREEBSD11)
int
freebsd11_freebsd32_getdirentries(struct thread *td,
    struct freebsd11_freebsd32_getdirentries_args *uap)
{
	long base;
	int32_t base32;
	int error;

	error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
	    &base, NULL);
	if (error)
		return (error);
	if (uap->basep != NULL) {
		base32 = base;
		error = copyout(&base32, uap->basep, sizeof(int32_t));
	}
	return (error);
}

int
freebsd11_freebsd32_getdents(struct thread *td,
    struct freebsd11_freebsd32_getdents_args *uap)
{
	struct freebsd11_freebsd32_getdirentries_args ap;

	ap.fd = uap->fd;
	ap.buf = uap->buf;
	ap.count = uap->count;
	ap.basep = NULL;
	return (freebsd11_freebsd32_getdirentries(td, &ap));
}
#endif /* COMPAT_FREEBSD11 */

int
freebsd32_getdirentries(struct thread *td,
    struct freebsd32_getdirentries_args *uap)

	CP(*in, *out, st_flags);
	CP(*in, *out, st_gen);
	TS_CP(*in, *out, st_birthtim);
	out->st_padding0 = 0;
	out->st_padding1 = 0;
	bzero(out->st_spare, sizeof(out->st_spare));
}

#ifdef COMPAT_43

}
#endif

int
freebsd32_stat(struct thread *td, struct freebsd32_stat_args *uap)
{
	struct stat sb;
	struct stat32 sb32;
	int error;

	error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
	    &sb, NULL);
	if (error)
		return (error);
	copy_stat(&sb, &sb32);
	error = copyout(&sb32, uap->ub, sizeof (sb32));
	return (error);
}

#ifdef COMPAT_43
int
ofreebsd32_stat(struct thread *td, struct ofreebsd32_stat_args *uap)

	return (error);
}

#ifdef COMPAT_43
int
ofreebsd32_lstat(struct thread *td, struct ofreebsd32_lstat_args *uap)
{
	struct stat sb;
	struct ostat32 sb32;
	int error;

	error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
	    UIO_USERSPACE, &sb, NULL);
	if (error)
		return (error);
	copy_ostat(&sb, &sb32);
	error = copyout(&sb32, uap->ub, sizeof (sb32));
	return (error);
}
#endif

int
freebsd32_fhstat(struct thread *td, struct freebsd32_fhstat_args *uap)
{
	struct stat sb;
	struct stat32 sb32;
	struct fhandle fh;
	int error;

	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
        if (error != 0)
                return (error);
	error = kern_fhstat(td, fh, &sb);
	if (error != 0)
		return (error);
	copy_stat(&sb, &sb32);
	error = copyout(&sb32, uap->sb, sizeof (sb32));
	return (error);
}

#if defined(COMPAT_FREEBSD11)
static void
freebsd11_cvtstat32(struct stat *in, struct freebsd11_stat32 *out)
{

	CP(*in, *out, st_ino);
	CP(*in, *out, st_nlink);
	CP(*in, *out, st_dev);
	CP(*in, *out, st_mode);
	CP(*in, *out, st_uid);
	CP(*in, *out, st_gid);
	CP(*in, *out, st_rdev);
	TS_CP(*in, *out, st_atim);
	TS_CP(*in, *out, st_mtim);
	TS_CP(*in, *out, st_ctim);
	CP(*in, *out, st_size);
	CP(*in, *out, st_blocks);
	CP(*in, *out, st_blksize);
	CP(*in, *out, st_flags);
	CP(*in, *out, st_gen);
	TS_CP(*in, *out, st_birthtim);
	out->st_lspare = 0;
	bzero((char *)&out->st_birthtim + sizeof(out->st_birthtim),
	    sizeof(*out) - offsetof(struct freebsd11_stat32,
	    st_birthtim) - sizeof(out->st_birthtim));
}

int
freebsd11_freebsd32_stat(struct thread *td,
    struct freebsd11_freebsd32_stat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat32 sb32;
	int error;

	error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
	    &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtstat32(&sb, &sb32);
	error = copyout(&sb32, uap->ub, sizeof (sb32));
	return (error);
}

#ifdef COMPAT_43
int
freebsd11_freebsd32_fstat(struct thread *td,
    struct freebsd11_freebsd32_fstat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat32 sb32;
	int error;

	error = kern_fstat(td, uap->fd, &sb);
	if (error != 0)
		return (error);
	freebsd11_cvtstat32(&sb, &sb32);
	error = copyout(&sb32, uap->ub, sizeof (sb32));
	return (error);
}

int
freebsd11_freebsd32_fstatat(struct thread *td,
    struct freebsd11_freebsd32_fstatat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat32 sb32;
	int error;

	error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
	    &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtstat32(&sb, &sb32);
	error = copyout(&sb32, uap->buf, sizeof (sb32));
	return (error);
}

int
freebsd11_freebsd32_lstat(struct thread *td,
    struct freebsd11_freebsd32_lstat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat32 sb32;
	int error;

	error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
	    UIO_USERSPACE, &sb, NULL);
	if (error)
		return (error);
	freebsd11_cvtstat32(&sb, &sb32);
	error = copyout(&sb32, uap->ub, sizeof (sb32));
	return (error);
}

int
freebsd11_freebsd32_fhstat(struct thread *td,
    struct freebsd11_freebsd32_fhstat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat32 sb32;
	struct fhandle fh;
	int error;

	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
        if (error != 0)
                return (error);
	error = kern_fhstat(td, fh, &sb);
	if (error != 0)
		return (error);
	freebsd11_cvtstat32(&sb, &sb32);
	error = copyout(&sb32, uap->sb, sizeof (sb32));
	return (error);
}
#endif

int




;		case where the event exists, but we don't want auditing, the
;		event should be #defined to AUE_NULL in audit_kevents.h.
;	type	one of STD, OBSOL, UNIMPL, COMPAT, COMPAT4, COMPAT6,
;		COMPAT7, COMPAT11, NODEF, NOARGS, NOPROTO, NOSTD
;		The COMPAT* options may be combined with one or more NO*
;		options separated by '|' with no spaces (e.g. COMPAT|NOARGS)
;	name	psuedo-prototype of syscall routine

;	COMPAT6	included on COMPAT6 #ifdef (FreeBSD 6 compat)
;	COMPAT7	included on COMPAT7 #ifdef (FreeBSD 7 compat)
;	COMPAT10 included on COMPAT10 #ifdef (FreeBSD 10 compat)
;	COMPAT11 included on COMPAT11 #ifdef (FreeBSD 11 compat)
;	OBSOL	obsolete, not included in system, only specifies name
;	UNIMPL	not implemented, placeholder only
;	NOSTD	implemented but as a lkm that can be statically

11	AUE_NULL	OBSOL	execv
12	AUE_CHDIR	NOPROTO	{ int chdir(char *path); }
13	AUE_FCHDIR	NOPROTO	{ int fchdir(int fd); }
14	AUE_MKNOD	COMPAT11 { int freebsd32_mknod(char *path, \
					int mode, int dev); }
15	AUE_CHMOD	NOPROTO	{ int chmod(char *path, int mode); }
16	AUE_CHOWN	NOPROTO	{ int chown(char *path, int uid, int gid); }
17	AUE_NULL	NOPROTO	{ int obreak(char *nsize); } break \

185	AUE_NULL	UNIMPL	lfs_markv
186	AUE_NULL	UNIMPL	lfs_segclean
187	AUE_NULL	UNIMPL	lfs_segwait
188	AUE_STAT	COMPAT11 { int freebsd32_stat(char *path, \
				    struct freebsd11_stat32 *ub); }
189	AUE_FSTAT	COMPAT11 { int freebsd32_fstat(int fd, \
				    struct freebsd11_stat32 *ub); }
190	AUE_LSTAT	COMPAT11 { int freebsd32_lstat(char *path, \
				    struct freebsd11_stat32 *ub); }
191	AUE_PATHCONF	NOPROTO	{ int pathconf(char *path, int name); }
192	AUE_FPATHCONF	NOPROTO	{ int fpathconf(int fd, int name); }
193	AUE_NULL	UNIMPL	nosys

195	AUE_SETRLIMIT	NOPROTO	{ int setrlimit(u_int which, \
				    struct rlimit *rlp); } setrlimit \
				    __setrlimit_args int
196	AUE_GETDIRENTRIES COMPAT11 { int freebsd32_getdirentries(int fd, \
				    char *buf, u_int count, int32_t *basep); }
197	AUE_MMAP	COMPAT6	{ caddr_t freebsd32_mmap(caddr_t addr, \
				    size_t len, int prot, int flags, int fd, \

269	AUE_NULL	UNIMPL	nosys
270	AUE_NULL	UNIMPL	nosys
271	AUE_NULL	UNIMPL	nosys
272	AUE_O_GETDENTS	COMPAT11 { int freebsd32_getdents(int fd, char *buf, \
				    int count); }
273	AUE_NULL	UNIMPL	nosys
274	AUE_LCHMOD	NOPROTO	{ int lchmod(char *path, mode_t mode); }
275	AUE_LCHOWN	NOPROTO	{ int lchown(char *path, uid_t uid, \

				    struct timeval32 *tptr); }
277	AUE_MSYNC	NOPROTO	{ int msync(void *addr, size_t len, \
				    int flags); } netbsd_msync msync_args int
278	AUE_STAT  COMPAT11|NOPROTO { int nstat(char *path, struct nstat *ub); }
279	AUE_FSTAT COMPAT11|NOPROTO { int nfstat(int fd, struct nstat *sb); }
280	AUE_LSTAT COMPAT11|NOPROTO { int nlstat(char *path, struct nstat *ub); }
281	AUE_NULL	UNIMPL	nosys
282	AUE_NULL	UNIMPL	nosys
283	AUE_NULL	UNIMPL	nosys

				    struct statfs32 *buf); }
298	AUE_FHOPEN	NOPROTO	{ int fhopen(const struct fhandle *u_fhp, \
			 	    int flags); }
299	AUE_FHSTAT	COMPAT11 { int freebsd32_fhstat( \
				    const struct fhandle *u_fhp, \
				    struct freebsd11_stat32 *sb); }
; syscall numbers for FreeBSD
300	AUE_NULL	NOPROTO	{ int modnext(int modid); }
301	AUE_NULL	STD	{ int freebsd32_modstat(int modid, \

				    size_t nbytes, struct sf_hdtr32 *hdtr, \
				    off_t *sbytes, int flags); }
394	AUE_NULL	UNIMPL	mac_syscall
395	AUE_GETFSSTAT	COMPAT11|NOPROTO	{ int getfsstat( \
				    struct freebsd11_statfs *buf, \
				    long bufsize, int mode); }
396	AUE_STATFS	COMPAT11|NOPROTO	{ int statfs(char *path, \
				    struct statfs *buf); }
397	AUE_FSTATFS	NOPROTO	{ int fstatfs(int fd, struct statfs *buf); }
398	AUE_FHSTATFS	NOPROTO	{ int fhstatfs(const struct fhandle *u_fhp, \
				    struct statfs *buf); }
397	AUE_FSTATFS	COMPAT11|NOPROTO	{ int fstatfs(int fd, \
				    struct freebsd11_statfs *buf); }
398	AUE_FHSTATFS	COMPAT11|NOPROTO	{ int fhstatfs( \
				    const struct fhandle *u_fhp, \
				    struct freebsd11_statfs *buf); }
399	AUE_NULL	UNIMPL	nosys
400	AUE_SEMCLOSE	NOSTD|NOPROTO	{ int ksem_close(semid_t id); }
401	AUE_SEMPOST	NOSTD|NOPROTO	{ int ksem_post(semid_t id); }

				    gid_t gid, int flag); }
492	AUE_FEXECVE	STD	{ int freebsd32_fexecve(int fd, \
				    uint32_t *argv, uint32_t *envv); }
493	AUE_FSTATAT	COMPAT11 { int freebsd32_fstatat(int fd, \
				    char *path, struct freebsd11_stat32 *buf, \
				    int flag); }
494	AUE_FUTIMESAT	STD	{ int freebsd32_futimesat(int fd, char *path, \
				    struct timeval *times); }
495	AUE_LINKAT	NOPROTO	{ int linkat(int fd1, char *path1, int fd2, \

				    mode_t mode); }
497	AUE_MKFIFOAT	NOPROTO	{ int mkfifoat(int fd, char *path, \
				    mode_t mode); }
498	AUE_MKNODAT	COMPAT11 { int freebsd32_mknodat(int fd, char *path, \
				    mode_t mode, uint32_t dev); }
499	AUE_OPENAT_RWTC	NOPROTO	{ int openat(int fd, char *path, int flag, \
				    mode_t mode); }
500	AUE_READLINKAT	NOPROTO	{ int readlinkat(int fd, char *path, char *buf, \

				    id_t id, \
				    const struct vm_domain_policy *policy); }
550	AUE_FSYNC	NOPROTO	{ int fdatasync(int fd); }
551	AUE_FSTAT	STD	{ int freebsd32_fstat(int fd, \
				    struct stat32 *ub); }
552	AUE_FSTATAT	STD	{ int freebsd32_fstatat(int fd, \
				    char *path, struct stat32 *buf, \
				    int flag); }
553	AUE_FHSTAT	STD	{ int freebsd32_fhstat( \
				    const struct fhandle *u_fhp, \
				    struct stat32 *sb); }
554	AUE_GETDIRENTRIES STD	{ ssize_t freebsd32_getdirentries( \
				    int fd, char *buf, size_t count, \
				    int32_t *basep); }
555	AUE_STATFS	NOPROTO	{ int statfs(char *path, \
				    struct statfs32 *buf); }
556	AUE_FSTATFS	NOPROTO	{ int fstatfs(int fd, struct statfs32 *buf); }
557	AUE_GETFSSTAT	NOPROTO	{ int getfsstat(struct statfs32 *buf, \
				    long bufsize, int mode); }
558	AUE_FHSTATFS	NOPROTO	{ int fhstatfs(const struct fhandle *u_fhp, \
				    struct statfs32 *buf); }
559	AUE_MKNODAT	NOPROTO	{ int mknodat(int fd, char *path, mode_t mode, \
				    dev_t dev); }




linux_mount(struct thread *td, struct linux_mount_args *args)
{
	char fstypename[MFSNAMELEN];
	char *mntonname, *mntfromname;
	int error, fsflags;
	int fsflags;

	mntonname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
	mntfromname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
	error = copyinstr(args->filesystemtype, fstypename, MFSNAMELEN - 1,
	    NULL);
	if (error != 0)
		goto out;
	error = copyinstr(args->specialfile, mntfromname, MNAMELEN - 1, NULL);
	if (error != 0)
		goto out;
	error = copyinstr(args->dir, mntonname, MNAMELEN - 1, NULL);
	if (error != 0)
		goto out;

#ifdef DEBUG
	if (ldebug(mount))

	    "fspath", mntonname,
	    "from", mntfromname,
	    NULL);
out:
	free(mntonname, M_TEMP);
	free(mntfromname, M_TEMP);
	return (error);
}


Lines 60-65 SX_SYSINIT(snp_register_lock, &snp_register_lock, Link Here

(-)b/sys/dev/snp/snp.c (+8 lines)
60	#define SNP_UNLOCK() sx_xunlock(&snp_register_lock)	60	#define SNP_UNLOCK() sx_xunlock(&snp_register_lock)
61	#endif	61	#endif
62		62
		63	#define SNPGTYY_32DEV _IOR('T', 89, uint32_t)
		64
63	/*	65	/*
64	* There is no need to have a big input buffer. In most typical setups,	66	* There is no need to have a big input buffer. In most typical setups,
65	* we won't inject much data into the TTY, because users can't type	67	* we won't inject much data into the TTY, because users can't type
Lines 275-280 snp_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, Link Here
275	else	277	else
276	(dev_t )data = tty_udev(ss->snp_tty);	278	(dev_t )data = tty_udev(ss->snp_tty);
277	return (0);	279	return (0);
		280	case SNPGTYY_32DEV:
		281	if (ss->snp_tty == NULL)
		282	(uint32_t )data = -1;
		283	else
		284	(uint32_t )data = tty_udev(ss->snp_tty); /* trunc */
		285	return (0);
278	case FIONREAD:	286	case FIONREAD:
279	tp = ss->snp_tty;	287	tp = ss->snp_tty;
280	if (tp != NULL) {	288	if (tp != NULL) {

Lines 28-33 Link Here

(-)b/sys/fs/devfs/devfs_devs.c (-1 / +13 lines)
28	* $FreeBSD$	28	* $FreeBSD$
29	*/	29	*/
30		30
		31	#include "opt_compat.h"
		32
31	#include <sys/param.h>	33	#include <sys/param.h>
32	#include <sys/systm.h>	34	#include <sys/systm.h>
33	#include <sys/conf.h>	35	#include <sys/conf.h>
Lines 80-89 sysctl_devname(SYSCTL_HANDLER_ARGS) Link Here
80	{	82	{
81	int error;	83	int error;
82	dev_t ud;	84	dev_t ud;
		85	#ifdef COMPAT_FREEBSD11
		86	uint32_t ud_compat;
		87	#endif
83	struct cdev_priv *cdp;	88	struct cdev_priv *cdp;
84	struct cdev *dev;	89	struct cdev *dev;
85		90
86	error = SYSCTL_IN(req, &ud, sizeof (ud));	91	#ifdef COMPAT_FREEBSD11
		92	if (req->newlen == sizeof(ud_compat)) {
		93	error = SYSCTL_IN(req, &ud_compat, sizeof(ud_compat));
		94	if (error == 0)
		95	ud = ud_compat == (uint32_t)NODEV ? NODEV : ud_compat;
		96	} else
		97	#endif
		98	error = SYSCTL_IN(req, &ud, sizeof (ud));
87	if (error)	99	if (error)
88	return (error);	100	return (error);
89	if (ud == NODEV)	101	if (ud == NODEV)

Lines 1315-1320 devfs_readdir(struct vop_readdir_args *ap) Link Here

(-)b/sys/fs/devfs/devfs_vnops.c (+1 lines)
1315	else	1315	else
1316	de = dd;	1316	de = dd;
1317	dp = dd->de_dirent;	1317	dp = dd->de_dirent;
		1318	MPASS(dp->d_reclen == GENERIC_DIRSIZ(dp));
1318	if (dp->d_reclen > uio->uio_resid)	1319	if (dp->d_reclen > uio->uio_resid)
1319	break;	1320	break;
1320	dp->d_fileno = de->de_inode;	1321	dp->d_fileno = de->de_inode;

Lines 485-491 fdesc_setattr(struct vop_setattr_args *ap) Link Here

(-)b/sys/fs/fdescfs/fdesc_vnops.c (-1 / +1 lines)
485	return (error);	485	return (error);
486	}	486	}
487		487
488	#define UIO_MX 16	488	#define UIO_MX _GENERIC_DIRLEN(10) /* number of symbols in INT_MAX printout */
489		489
490	static int	490	static int
491	fdesc_readdir(struct vop_readdir_args *ap)	491	fdesc_readdir(struct vop_readdir_args *ap)

Lines 537-543 struct nandfs_bdesc { Link Here

(-)b/sys/fs/nandfs/nandfs_fs.h (-1 / +1 lines)
537		537
538	#ifndef _KERNEL	538	#ifndef _KERNEL
539	#ifndef MNAMELEN	539	#ifndef MNAMELEN
540	#define MNAMELEN 88	540	#define MNAMELEN 1024
541	#endif	541	#endif
542	#endif	542	#endif
543		543




#define	NFSMINOR(d)		minor(d)

/*
 * Define this to be the macro that returns the minimum size required
 * for a directory entry.
 */
#define	DIRENT_SIZE(dp)		GENERIC_DIRSIZ(dp)

/*
 * The vnode tag for nfsv4root.
 */
#define	VT_NFSV4ROOT		"nfsv4root"




int nfstest_openallsetattr = 0;
#endif	/* !APPLEKEXT */

#define	DIRHDSIZ	offsetof(struct dirent, d_name)

/*
 * nfscl_getsameserver() can return one of three values:

			if (error)
			    return (error);
			nd->nd_mrep = NULL;
			dp = (struct dirent *)uio_iov_base(uiop);
			dp->d_off = 0;
			dp->d_type = DT_DIR;
			dp->d_fileno = dotfileid;
			dp->d_namlen = 1;
			*((uint64_t *)dp->d_name) = 0;	/* Zero pad it. */
			dp->d_name[0] = '.';
			dp->d_reclen = _GENERIC_DIRSIZ(dp) + NFSX_HYPER;
			dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
			/*
			 * Just make these offset cookie 0.
			 */
			tl = (u_int32_t *)&dp->d_name[8];
			*tl++ = 0;
			*tl = 0;
			blksiz += dp->d_reclen;

			uiop->uio_offset += dp->d_reclen;
			uio_iov_base_add(uiop, dp->d_reclen);
			uio_iov_len_add(uiop, -(dp->d_reclen));
			dp = (struct dirent *)uio_iov_base(uiop);
			dp->d_off = 0;
			dp->d_type = DT_DIR;
			dp->d_fileno = dotdotfileid;
			dp->d_namlen = 2;
			*((uint64_t *)dp->d_name) = 0;
			dp->d_name[0] = '.';
			dp->d_name[1] = '.';
			dp->d_reclen = _GENERIC_DIRSIZ(dp) + NFSX_HYPER;
			dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
			/*
			 * Just make these offset cookie 0.
			 */
			tl = (u_int32_t *)&dp->d_name[8];
			*tl++ = 0;
			*tl = 0;
			blksiz += dp->d_reclen;

				error = EBADRPC;
				goto nfsmout;
			}
			tlen = roundup2(len, 8);
			if (tlen == len)
				tlen += 8;  /* To ensure null termination. */
			left = DIRBLKSIZ - blksiz;
			if (_GENERIC_DIRLEN(len) + NFSX_HYPER > left) {
				dp->d_reclen += left;
				uio_iov_base_add(uiop, left);
				uio_iov_len_add(uiop, -(left));

				uiop->uio_offset += left;
				blksiz = 0;
			}
			if (_GENERIC_DIRLEN(len) + NFSX_HYPER >
			    uio_uio_resid(uiop))
				bigenough = 0;
			if (bigenough) {
				dp = (struct dirent *)uio_iov_base(uiop);
				dp->d_off = 0;
				dp->d_namlen = len;
				dp->d_reclen = _GENERIC_DIRLEN(len) +
				    NFSX_HYPER;
				dp->d_type = DT_UNKNOWN;
				blksiz += dp->d_reclen;
				if (blksiz == DIRBLKSIZ)

				error = nfsm_mbufuio(nd, uiop, len);
				if (error)
					goto nfsmout;
				cp = uio_iov_base(uiop);
				tlen -= len;
				*cp = '\0';	/* null terminate */
				cp += tlen;	/* points to cookie storage */

	/*
	 * Add extra empty records to any remaining DIRBLKSIZ chunks.
	 */
	while (uio_uio_resid(uiop) > 0 && uio_uio_resid(uiop) != tresid) {
		dp = (struct dirent *)uio_iov_base(uiop);
		dp->d_type = DT_UNKNOWN;
		dp->d_fileno = 0;
		dp->d_namlen = 0;

			    return (error);
			nd->nd_mrep = NULL;
			dp = (struct dirent *)uio_iov_base(uiop);
			dp->d_off = 0;
			dp->d_type = DT_DIR;
			dp->d_fileno = dotfileid;
			dp->d_namlen = 1;
			*((uint64_t *)dp->d_name) = 0;	/* Zero pad it. */
			dp->d_name[0] = '.';
			dp->d_reclen = _GENERIC_DIRSIZ(dp) + NFSX_HYPER;
			dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
			/*
			 * Just make these offset cookie 0.
			 */
			tl = (u_int32_t *)&dp->d_name[8];
			*tl++ = 0;
			*tl = 0;
			blksiz += dp->d_reclen;

			uio_iov_base_add(uiop, dp->d_reclen);
			uio_iov_len_add(uiop, -(dp->d_reclen));
			dp = (struct dirent *)uio_iov_base(uiop);
			dp->d_off = 0;
			dp->d_type = DT_DIR;
			dp->d_fileno = dotdotfileid;
			dp->d_namlen = 2;
			*((uint64_t *)dp->d_name) = 0;
			dp->d_name[0] = '.';
			dp->d_name[1] = '.';
			dp->d_reclen = _GENERIC_DIRSIZ(dp) + NFSX_HYPER;
			dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
			/*
			 * Just make these offset cookie 0.
			 */
			tl = (u_int32_t *)&dp->d_name[8];
			*tl++ = 0;
			*tl = 0;
			blksiz += dp->d_reclen;

				error = EBADRPC;
				goto nfsmout;
			}
			tlen = roundup2(len, 8);
			if (tlen == len)
				tlen += 8;  /* To ensure null termination. */
			left = DIRBLKSIZ - blksiz;
			if (_GENERIC_DIRLEN(len) + NFSX_HYPER > left) {
				dp->d_reclen += left;
				uio_iov_base_add(uiop, left);
				uio_iov_len_add(uiop, -(left));

				uiop->uio_offset += left;
				blksiz = 0;
			}
			if (_GENERIC_DIRLEN(len) + NFSX_HYPER >
			    uio_uio_resid(uiop))
				bigenough = 0;
			if (bigenough) {
				dp = (struct dirent *)uio_iov_base(uiop);
				dp->d_off = 0;
				dp->d_namlen = len;
				dp->d_reclen = _GENERIC_DIRLEN(len) +
				    NFSX_HYPER;
				dp->d_type = DT_UNKNOWN;
				blksiz += dp->d_reclen;
				if (blksiz == DIRBLKSIZ)

Lines 205-212 static int nfs_renameit(struct vnode sdvp, struct vnode svp, Link Here

(-)b/sys/fs/nfsclient/nfs_clvnops.c (-2 lines)
205	/*	205	/*
206	* Global variables	206	* Global variables
207	*/	207	*/
208	#define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
209
210	SYSCTL_DECL(_vfs_nfs);	208	SYSCTL_DECL(_vfs_nfs);
211		209
212	static int nfsaccess_cache_timeout = NFS_MAXATTRTIMO;	210	static int nfsaccess_cache_timeout = NFS_MAXATTRTIMO;

Lines 2018-2034 again: Link Here

(-)b/sys/fs/nfsserver/nfs_nfsdport.c (-11 / +28 lines)
2018	}	2018	}
2019		2019
2020	/*	2020	/*
2021	* For now ZFS requires VOP_LOOKUP as a workaround. Until ino_t is changed	2021	* Check to see if entries in this directory can be safely acquired
2022	* to 64 bit type a ZFS filesystem with over 1 billion files in it	2022	* via VFS_VGET() or if a switch to VOP_LOOKUP() is required.
2023	* will suffer from 64bit -> 32bit truncation.	2023	* ZFS snapshot directories need VOP_LOOKUP(), so that any
		2024	* automount of the snapshot directory that is required will
		2025	* be done.
		2026	* This needs to be done here for NFSv4, since NFSv4 never does
		2027	* a VFS_VGET() for "." or "..".
2024	*/	2028	*/
2025	if (is_zfs == 1)	2029	if (is_zfs == 1) {
2026	usevget = 0;	2030	r = VFS_VGET(mp, at.na_fileid, LK_SHARED, &nvp);
2027		2031	if (r == EOPNOTSUPP) {
2028	cn.cn_nameiop = LOOKUP;	2032	usevget = 0;
2029	cn.cn_lkflags = LK_SHARED \| LK_RETRY;	2033	cn.cn_nameiop = LOOKUP;
2030	cn.cn_cred = nd->nd_cred;	2034	cn.cn_lkflags = LK_SHARED \| LK_RETRY;
2031	cn.cn_thread = p;	2035	cn.cn_cred = nd->nd_cred;
		2036	cn.cn_thread = p;
		2037	} else if (r == 0)
		2038	vput(nvp);
		2039	}
2032		2040
2033	/*	2041	/*
2034	* Save this position, in case there is an error before one entry	2042	* Save this position, in case there is an error before one entry
Lines 2097-2103 again: Link Here
2097	else	2105	else
2098	r = EOPNOTSUPP;	2106	r = EOPNOTSUPP;
2099	if (r == EOPNOTSUPP) {	2107	if (r == EOPNOTSUPP) {
2100	usevget = 0;	2108	if (usevget) {
		2109	usevget = 0;
		2110	cn.cn_nameiop = LOOKUP;
		2111	cn.cn_lkflags =
		2112	LK_SHARED \|
		2113	LK_RETRY;
		2114	cn.cn_cred =
		2115	nd->nd_cred;
		2116	cn.cn_thread = p;
		2117	}
2101	cn.cn_nameptr = dp->d_name;	2118	cn.cn_nameptr = dp->d_name;
2102	cn.cn_namelen = nlen;	2119	cn.cn_namelen = nlen;
2103	cn.cn_flags = ISLASTCN \|	2120	cn.cn_flags = ISLASTCN \|

Lines 197-202 fpathconf Link Here

(-)b/sys/kern/capabilities.conf (+5 lines)
197	## Allow various file descriptor-based I/O operations, subject to capability	197	## Allow various file descriptor-based I/O operations, subject to capability
198	## rights.	198	## rights.
199	##	199	##
		200	freebsd11_fstat
		201	freebsd11_fstatat
		202	freebsd11_getdirentries
		203	freebsd11_fstatfs
		204	freebsd11_mknodat
200	freebsd6_ftruncate	205	freebsd6_ftruncate
201	freebsd6_lseek	206	freebsd6_lseek
202	freebsd6_mmap	207	freebsd6_mmap

Lines 96-101 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/kern/kern_acct.c (-2 / +7 lines)
96		96
97	#include <security/mac/mac_framework.h>	97	#include <security/mac/mac_framework.h>
98		98
		99	_Static_assert(sizeof(struct acctv3) - offsetof(struct acctv3, ac_trailer) ==
		100	sizeof(struct acctv2) - offsetof(struct acctv2, ac_trailer), "trailer");
		101	_Static_assert(sizeof(struct acctv3) - offsetof(struct acctv3, ac_len2) ==
		102	sizeof(struct acctv2) - offsetof(struct acctv2, ac_len2), "len2");
		103
99	/*	104	/*
100	* The routines implemented in this file are described in:	105	* The routines implemented in this file are described in:
101	* Leffler, et al.: The Design and Implementation of the 4.3BSD	106	* Leffler, et al.: The Design and Implementation of the 4.3BSD
Lines 339-345 acct_disable(struct thread *td, int logging) Link Here
339	int	344	int
340	acct_process(struct thread *td)	345	acct_process(struct thread *td)
341	{	346	{
342	struct acctv2 acct;	347	struct acctv3 acct;
343	struct timeval ut, st, tmp;	348	struct timeval ut, st, tmp;
344	struct plimit *oldlim;	349	struct plimit *oldlim;
345	struct proc *p;	350	struct proc *p;
Lines 421-427 acct_process(struct thread *td) Link Here
421	/* Setup ancillary structure fields. */	426	/* Setup ancillary structure fields. */
422	acct.ac_flagx \|= ANVER;	427	acct.ac_flagx \|= ANVER;
423	acct.ac_zero = 0;	428	acct.ac_zero = 0;
424	acct.ac_version = 2;	429	acct.ac_version = 3;
425	acct.ac_len = acct.ac_len2 = sizeof(acct);	430	acct.ac_len = acct.ac_len2 = sizeof(acct);
426		431
427	/*	432	/*




}
#endif /* COMPAT_43 */

#if defined(COMPAT_FREEBSD11)
int
freebsd11_fstat(struct thread *td, struct freebsd11_fstat_args *uap)
{
	struct stat sb;
	struct freebsd11_stat osb;
	int error;

	error = kern_fstat(td, uap->fd, &sb);
	if (error != 0)
		return (error);
	freebsd11_cvtstat(&sb, &osb);
	error = copyout(&osb, uap->sb, sizeof(osb));
	return (error);
}
#endif	/* COMPAT_FREEBSD11 */

/*
 * Return status information about a file descriptor.
 */

	return (error);
}

#if defined(COMPAT_FREEBSD11)
/*
 * Return status information about a file descriptor.
 */
#ifndef _SYS_SYSPROTO_H_
struct freebsd11_nfstat_args {
	int	fd;
	struct	nstat *sb;
};
#endif
/* ARGSUSED */
int
freebsd11_nfstat(struct thread *td, struct freebsd11_nfstat_args *uap)
{
	struct nstat nub;
	struct stat ub;


	error = kern_fstat(td, uap->fd, &ub);
	if (error == 0) {
		freebsd11_cvtnstat(&ub, &nub);
		error = copyout(&nub, uap->sb, sizeof(nub));
	}
	return (error);
}
#endif /* COMPAT_FREEBSD11 */

/*
 * Return pathconf information about a file descriptor.

	    KF_FLAG_APPEND | KF_FLAG_ASYNC | KF_FLAG_FSYNC | KF_FLAG_NONBLOCK |
	    KF_FLAG_DIRECT | KF_FLAG_HASLOCK);
	okif->kf_offset = kif->kf_offset;
	if (kif->kf_type == KF_TYPE_VNODE)
		okif->kf_vnode_type = kif->kf_un.kf_file.kf_file_type;
	else
		okif->kf_vnode_type = KF_VTYPE_VNON;
	strlcpy(okif->kf_path, kif->kf_path, sizeof(okif->kf_path));
	if (kif->kf_type == KF_TYPE_SOCKET) {
		okif->kf_sock_domain = kif->kf_un.kf_sock.kf_sock_domain0;
		okif->kf_sock_type = kif->kf_un.kf_sock.kf_sock_type0;
		okif->kf_sock_protocol = kif->kf_un.kf_sock.kf_sock_protocol0;
		okif->kf_sa_local = kif->kf_un.kf_sock.kf_sa_local;
		okif->kf_sa_peer = kif->kf_un.kf_sock.kf_sa_peer;
	} else {
		okif->kf_sa_local.ss_family = AF_UNSPEC;
		okif->kf_sa_peer.ss_family = AF_UNSPEC;
	}
}

static int

Lines 986-996 fill_kinfo_proc_only(struct proc p, struct kinfo_proc kp) Link Here

(-)b/sys/kern/kern_proc.c (-1 / +10 lines)
986	}	986	}
987	if ((p->p_flag & P_CONTROLT) && tp != NULL) {	987	if ((p->p_flag & P_CONTROLT) && tp != NULL) {
988	kp->ki_tdev = tty_udev(tp);	988	kp->ki_tdev = tty_udev(tp);
		989	kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
989	kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;	990	kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
990	if (tp->t_session)	991	if (tp->t_session)
991	kp->ki_tsid = tp->t_session->s_sid;	992	kp->ki_tsid = tp->t_session->s_sid;
992	} else	993	} else {
993	kp->ki_tdev = NODEV;	994	kp->ki_tdev = NODEV;
		995	kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
		996	}
994	if (p->p_comm[0] != '\0')	997	if (p->p_comm[0] != '\0')
995	strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));	998	strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
996	if (p->p_sysent && p->p_sysent->sv_name != NULL &&	999	if (p->p_sysent && p->p_sysent->sv_name != NULL &&
Lines 1232-1237 freebsd32_kinfo_proc_out(const struct kinfo_proc ki, struct kinfo_proc32 ki32) Link Here
1232	CP(ki, ki32, ki_tsid);	1235	CP(ki, ki32, ki_tsid);
1233	CP(ki, ki32, ki_jobc);	1236	CP(ki, ki32, ki_jobc);
1234	CP(ki, ki32, ki_tdev);	1237	CP(ki, ki32, ki_tdev);
		1238	CP(ki, ki32, ki_tdev_freebsd11);
1235	CP(ki, ki32, ki_siglist);	1239	CP(ki, ki32, ki_siglist);
1236	CP(ki, ki32, ki_sigmask);	1240	CP(ki, ki32, ki_sigmask);
1237	CP(ki, ki32, ki_sigignore);	1241	CP(ki, ki32, ki_sigignore);
Lines 2204-2209 sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS) Link Here
2204	vn_lock(vp, LK_SHARED \| LK_RETRY);	2208	vn_lock(vp, LK_SHARED \| LK_RETRY);
2205	if (VOP_GETATTR(vp, &va, cred) == 0) {	2209	if (VOP_GETATTR(vp, &va, cred) == 0) {
2206	kve->kve_fileid = va.va_fileid;	2210	kve->kve_fileid = va.va_fileid;
		2211	/* truncate */
2207	kve->kve_fsid = va.va_fsid;	2212	kve->kve_fsid = va.va_fsid;
2208	}	2213	}
2209	vput(vp);	2214	vput(vp);
Lines 2443-2452 kern_proc_vmmap_out(struct proc p, struct sbuf sb, ssize_t maxlen, int flags) Link Here
2443	if (VOP_GETATTR(vp, &va, cred) == 0) {	2448	if (VOP_GETATTR(vp, &va, cred) == 0) {
2444	kve->kve_vn_fileid = va.va_fileid;	2449	kve->kve_vn_fileid = va.va_fileid;
2445	kve->kve_vn_fsid = va.va_fsid;	2450	kve->kve_vn_fsid = va.va_fsid;
		2451	kve->kve_vn_fsid_freebsd11 =
		2452	kve->kve_vn_fsid; /* truncate */
2446	kve->kve_vn_mode =	2453	kve->kve_vn_mode =
2447	MAKEIMODE(va.va_type, va.va_mode);	2454	MAKEIMODE(va.va_type, va.va_mode);
2448	kve->kve_vn_size = va.va_size;	2455	kve->kve_vn_size = va.va_size;
2449	kve->kve_vn_rdev = va.va_rdev;	2456	kve->kve_vn_rdev = va.va_rdev;
		2457	kve->kve_vn_rdev_freebsd11 =
		2458	kve->kve_vn_rdev; /* truncate */
2450	kve->kve_status = KF_ATTR_VALID;	2459	kve->kve_status = KF_ATTR_VALID;
2451	}	2460	}
2452	vput(vp);	2461	vput(vp);

Lines 10-15 compat4=COMPAT_FREEBSD4 Link Here

(-)b/sys/kern/makesyscalls.sh (-4 / +33 lines)
10	compat6=COMPAT_FREEBSD6	10	compat6=COMPAT_FREEBSD6
11	compat7=COMPAT_FREEBSD7	11	compat7=COMPAT_FREEBSD7
12	compat10=COMPAT_FREEBSD10	12	compat10=COMPAT_FREEBSD10
		13	compat11=COMPAT_FREEBSD11
13		14
14	# output files:	15	# output files:
15	sysnames="syscalls.c"	16	sysnames="syscalls.c"
Lines 36-41 syscompat7="sysent.compat7.$$" Link Here
36	syscompat7dcl="sysent.compat7dcl.$$"	37	syscompat7dcl="sysent.compat7dcl.$$"
37	syscompat10="sysent.compat10.$$"	38	syscompat10="sysent.compat10.$$"
38	syscompat10dcl="sysent.compat10dcl.$$"	39	syscompat10dcl="sysent.compat10dcl.$$"
		40	syscompat11="sysent.compat11.$$"
		41	syscompat11dcl="sysent.compat11dcl.$$"
39	sysent="sysent.switch.$$"	42	sysent="sysent.switch.$$"
40	sysinc="sysinc.switch.$$"	43	sysinc="sysinc.switch.$$"
41	sysarg="sysarg.switch.$$"	44	sysarg="sysarg.switch.$$"
Lines 50-58 else Link Here
50	capenabled=""	53	capenabled=""
51	fi	54	fi
52		55
53	trap "rm $sysaue $sysdcl $syscompat $syscompatdcl $syscompat4 $syscompat4dcl $syscompat6 $syscompat6dcl $syscompat7 $syscompat7dcl $syscompat10 $syscompat10dcl $sysent $sysinc $sysarg $sysprotoend $systracetmp $systraceret" 0	56	trap "rm $sysaue $sysdcl $syscompat $syscompatdcl $syscompat4 $syscompat4dcl $syscompat6 $syscompat6dcl $syscompat7 $syscompat7dcl $syscompat10 $syscompat10dcl $syscompat11 $syscompat11dcl $sysent $sysinc $sysarg $sysprotoend $systracetmp $systraceret" 0
54		57
55	touch $sysaue $sysdcl $syscompat $syscompatdcl $syscompat4 $syscompat4dcl $syscompat6 $syscompat6dcl $syscompat7 $syscompat7dcl $syscompat10 $syscompat10dcl $sysent $sysinc $sysarg $sysprotoend $systracetmp $systraceret	58	touch $sysaue $sysdcl $syscompat $syscompatdcl $syscompat4 $syscompat4dcl $syscompat6 $syscompat6dcl $syscompat7 $syscompat7dcl $syscompat10 $syscompat10dcl $syscompat11 $syscompat11dcl $sysent $sysinc $sysarg $sysprotoend $systracetmp $systraceret
56		59
57	case $# in	60	case $# in
58	0) echo "usage: $0 input-file <config-file>" 1>&2	61	0) echo "usage: $0 input-file <config-file>" 1>&2
Lines 92-97 sed -e ' Link Here
92	syscompat7dcl = \"$syscompat7dcl\"	95	syscompat7dcl = \"$syscompat7dcl\"
93	syscompat10 = \"$syscompat10\"	96	syscompat10 = \"$syscompat10\"
94	syscompat10dcl = \"$syscompat10dcl\"	97	syscompat10dcl = \"$syscompat10dcl\"
		98	syscompat11 = \"$syscompat11\"
		99	syscompat11dcl = \"$syscompat11dcl\"
95	sysent = \"$sysent\"	100	sysent = \"$sysent\"
96	syssw = \"$syssw\"	101	syssw = \"$syssw\"
97	sysinc = \"$sysinc\"	102	sysinc = \"$sysinc\"
Lines 107-112 sed -e ' Link Here
107	compat6 = \"$compat6\"	112	compat6 = \"$compat6\"
108	compat7 = \"$compat7\"	113	compat7 = \"$compat7\"
109	compat10 = \"$compat10\"	114	compat10 = \"$compat10\"
		115	compat11 = \"$compat11\"
110	syscallprefix = \"$syscallprefix\"	116	syscallprefix = \"$syscallprefix\"
111	switchname = \"$switchname\"	117	switchname = \"$switchname\"
112	namesname = \"$namesname\"	118	namesname = \"$namesname\"
Lines 155-160 sed -e ' Link Here
155	printf "\n#ifdef %s\n\n", compat6 > syscompat6	161	printf "\n#ifdef %s\n\n", compat6 > syscompat6
156	printf "\n#ifdef %s\n\n", compat7 > syscompat7	162	printf "\n#ifdef %s\n\n", compat7 > syscompat7
157	printf "\n#ifdef %s\n\n", compat10 > syscompat10	163	printf "\n#ifdef %s\n\n", compat10 > syscompat10
		164	printf "\n#ifdef %s\n\n", compat11 > syscompat11
158		165
159	printf "/\n System call names.\n *\n" > sysnames	166	printf "/\n System call names.\n *\n" > sysnames
160	printf " * DO NOT EDIT-- this file is automatically generated.\n" > sysnames	167	printf " * DO NOT EDIT-- this file is automatically generated.\n" > sysnames
Lines 205-210 sed -e ' Link Here
205	print > syscompat6	212	print > syscompat6
206	print > syscompat7	213	print > syscompat7
207	print > syscompat10	214	print > syscompat10
		215	print > syscompat11
208	print > sysnames	216	print > sysnames
209	print > systrace	217	print > systrace
210	print > systracetmp	218	print > systracetmp
Lines 221-226 sed -e ' Link Here
221	print > syscompat6	229	print > syscompat6
222	print > syscompat7	230	print > syscompat7
223	print > syscompat10	231	print > syscompat10
		232	print > syscompat11
224	print > sysnames	233	print > sysnames
225	print > systrace	234	print > systrace
226	print > systracetmp	235	print > systracetmp
Lines 237-242 sed -e ' Link Here
237	print > syscompat6	246	print > syscompat6
238	print > syscompat7	247	print > syscompat7
239	print > syscompat10	248	print > syscompat10
		249	print > syscompat11
240	print > sysnames	250	print > sysnames
241	print > systrace	251	print > systrace
242	print > systracetmp	252	print > systracetmp
Lines 345-350 sed -e ' Link Here
345	argalias = "freebsd7_" argalias	355	argalias = "freebsd7_" argalias
346	if (flag("COMPAT10"))	356	if (flag("COMPAT10"))
347	argalias = "freebsd10_" argalias	357	argalias = "freebsd10_" argalias
		358	if (flag("COMPAT11"))
		359	argalias = "freebsd11_" argalias
348	}	360	}
349	f++	361	f++
350		362
Lines 497-503 sed -e ' Link Here
497	next	509	next
498	}	510	}
499	type("COMPAT") \|\| type("COMPAT4") \|\| type("COMPAT6") \|\| \	511	type("COMPAT") \|\| type("COMPAT4") \|\| type("COMPAT6") \|\| \
500	type("COMPAT7") \|\| type("COMPAT10") {	512	type("COMPAT7") \|\| type("COMPAT10") \|\| type("COMPAT11") {
501	if (flag("COMPAT")) {	513	if (flag("COMPAT")) {
502	ncompat++	514	ncompat++
503	out = syscompat	515	out = syscompat
Lines 533-538 sed -e ' Link Here
533	wrap = "compat10"	545	wrap = "compat10"
534	prefix = "freebsd10_"	546	prefix = "freebsd10_"
535	descr = "freebsd10"	547	descr = "freebsd10"
		548	} else if (flag("COMPAT11")) {
		549	ncompat11++
		550	out = syscompat11
		551	outdcl = syscompat11dcl
		552	wrap = "compat11"
		553	prefix = "freebsd11_"
		554	descr = "freebsd11"
536	}	555	}
537	parseline()	556	parseline()
538	if (argc != 0 && !flag("NOARGS") && !flag("NOPROTO") && \	557	if (argc != 0 && !flag("NOARGS") && !flag("NOPROTO") && \
Lines 608-614 sed -e ' Link Here
608	END {	627	END {
609	printf "\n#define AS(name) (sizeof(struct name) / sizeof(register_t))\n" > sysinc	628	printf "\n#define AS(name) (sizeof(struct name) / sizeof(register_t))\n" > sysinc
610		629
611	if (ncompat != 0 \|\| ncompat4 != 0 \|\| ncompat6 != 0 \|\| ncompat7 != 0 \|\| ncompat10 != 0)	630	if (ncompat != 0 \|\| ncompat4 != 0 \|\| ncompat6 != 0 \|\| ncompat7 != 0 \|\| ncompat10 != 0 \|\| ncompat11 != 0)
612	printf "#include \"opt_compat.h\"\n\n" > syssw	631	printf "#include \"opt_compat.h\"\n\n" > syssw
613		632
614	if (ncompat != 0) {	633	if (ncompat != 0) {
Lines 649-659 sed -e ' Link Here
649	printf "#define compat10(n, name) 0, (sy_call_t *)nosys\n" > sysinc	668	printf "#define compat10(n, name) 0, (sy_call_t *)nosys\n" > sysinc
650	printf "#endif\n" > sysinc	669	printf "#endif\n" > sysinc
651	}	670	}
		671	if (ncompat11 != 0) {
		672	printf "\n#ifdef %s\n", compat11 > sysinc
		673	printf "#define compat11(n, name) n, (sy_call_t *)__CONCAT(freebsd11_,name)\n" > sysinc
		674	printf "#else\n" > sysinc
		675	printf "#define compat11(n, name) 0, (sy_call_t *)nosys\n" > sysinc
		676	printf "#endif\n" > sysinc
		677	}
		678
652	printf("\n#endif /* %s */\n\n", compat) > syscompatdcl	679	printf("\n#endif /* %s */\n\n", compat) > syscompatdcl
653	printf("\n#endif /* %s */\n\n", compat4) > syscompat4dcl	680	printf("\n#endif /* %s */\n\n", compat4) > syscompat4dcl
654	printf("\n#endif /* %s */\n\n", compat6) > syscompat6dcl	681	printf("\n#endif /* %s */\n\n", compat6) > syscompat6dcl
655	printf("\n#endif /* %s */\n\n", compat7) > syscompat7dcl	682	printf("\n#endif /* %s */\n\n", compat7) > syscompat7dcl
656	printf("\n#endif /* %s */\n\n", compat10) > syscompat10dcl	683	printf("\n#endif /* %s */\n\n", compat10) > syscompat10dcl
		684	printf("\n#endif /* %s */\n\n", compat11) > syscompat11dcl
657		685
658	printf("\n#undef PAD_\n") > sysprotoend	686	printf("\n#undef PAD_\n") > sysprotoend
659	printf("#undef PADL_\n") > sysprotoend	687	printf("#undef PADL_\n") > sysprotoend
Lines 677-682 cat $sysarg $sysdcl \ Link Here
677	$syscompat6 $syscompat6dcl \	705	$syscompat6 $syscompat6dcl \
678	$syscompat7 $syscompat7dcl \	706	$syscompat7 $syscompat7dcl \
679	$syscompat10 $syscompat10dcl \	707	$syscompat10 $syscompat10dcl \
		708	$syscompat11 $syscompat11dcl \
680	$sysaue $sysprotoend > $sysproto	709	$sysaue $sysprotoend > $sysproto
681	cat $systracetmp >> $systrace	710	cat $systracetmp >> $systrace
682	cat $systraceret >> $systrace	711	cat $systraceret >> $systrace





	kif->kf_type = KF_TYPE_SOCKET;
	so = fp->f_data;
	kif->kf_un.kf_sock.kf_sock_domain0 =
	    so->so_proto->pr_domain->dom_family;
	kif->kf_un.kf_sock.kf_sock_type0 = so->so_type;
	kif->kf_un.kf_sock.kf_sock_protocol0 = so->so_proto->pr_protocol;
	kif->kf_un.kf_sock.kf_sock_pcb = (uintptr_t)so->so_pcb;
	switch (kif->kf_un.kf_sock.kf_sock_domain0) {
	case AF_INET:
	case AF_INET6:
		if (kif->kf_un.kf_sock.kf_sock_protocol0 == IPPROTO_TCP) {
			if (so->so_pcb != NULL) {
				inpcb = (struct inpcb *)(so->so_pcb);
				kif->kf_un.kf_sock.kf_sock_inpcb =

		break;
	}
	error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa);
	if (error == 0 &&
	    sa->sa_len <= sizeof(kif->kf_un.kf_sock.kf_sa_local)) {
		bcopy(sa, &kif->kf_un.kf_sock.kf_sa_local, sa->sa_len);
		free(sa, M_SONAME);
	}
	error = so->so_proto->pr_usrreqs->pru_peeraddr(so, &sa);
	if (error == 0 &&
	    sa->sa_len <= sizeof(kif->kf_un.kf_sock.kf_sa_peer)) {
		bcopy(sa, &kif->kf_un.kf_sock.kf_sa_peer, sa->sa_len);
		free(sa, M_SONAME);
	}
	strncpy(kif->kf_path, so->so_proto->pr_domain->dom_name,




;		case where the event exists, but we don't want auditing, the
;		event should be #defined to AUE_NULL in audit_kevents.h.
;	type	one of STD, OBSOL, UNIMPL, COMPAT, COMPAT4, COMPAT6,
;		COMPAT7, COMPAT11, NODEF, NOARGS, NOPROTO, NOSTD
;		The COMPAT* options may be combined with one or more NO*
;		options separated by '|' with no spaces (e.g. COMPAT|NOARGS)
;	name	psuedo-prototype of syscall routine

;	COMPAT6	included on COMPAT_FREEBSD6 #ifdef (FreeBSD 6 compat)
;	COMPAT7	included on COMPAT_FREEBSD7 #ifdef (FreeBSD 7 compat)
;	COMPAT10 included on COMPAT_FREEBSD10 #ifdef (FreeBSD 10 compat)
;	COMPAT11 included on COMPAT11 #ifdef (FreeBSD 11 compat)
;	OBSOL	obsolete, not included in system, only specifies name
;	UNIMPL	not implemented, placeholder only
;	NOSTD	implemented but as a lkm that can be statically

11	AUE_NULL	OBSOL	execv
12	AUE_CHDIR	STD	{ int chdir(char *path); }
13	AUE_FCHDIR	STD	{ int fchdir(int fd); }
14	AUE_MKNOD	COMPAT11 { int mknod(char *path, int mode, int dev); }
15	AUE_CHMOD	STD	{ int chmod(char *path, int mode); }
16	AUE_CHOWN	STD	{ int chown(char *path, int uid, int gid); }
17	AUE_NULL	STD	{ int obreak(char *nsize); } break \

185	AUE_NULL	UNIMPL	lfs_markv
186	AUE_NULL	UNIMPL	lfs_segclean
187	AUE_NULL	UNIMPL	lfs_segwait
188	AUE_STAT	COMPAT11 { int stat(char *path, \
				    struct freebsd11_stat *ub); }
189	AUE_FSTAT	COMPAT11 { int fstat(int fd, \
				    struct freebsd11_stat *sb); }
190	AUE_LSTAT	COMPAT11 { int lstat(char *path, \
				    struct freebsd11_stat *ub); }
191	AUE_PATHCONF	STD	{ int pathconf(char *path, int name); }
192	AUE_FPATHCONF	STD	{ int fpathconf(int fd, int name); }
193	AUE_NULL	UNIMPL	nosys

195	AUE_SETRLIMIT	STD	{ int setrlimit(u_int which, \
				    struct rlimit *rlp); } setrlimit \
				    __setrlimit_args int
196	AUE_GETDIRENTRIES	COMPAT11 { int getdirentries(int fd, char *buf, \
				    u_int count, long *basep); }
197	AUE_MMAP	COMPAT6	{ caddr_t mmap(caddr_t addr, \
				    size_t len, int prot, int flags, int fd, \

269	AUE_NULL	UNIMPL	nosys
270	AUE_NULL	UNIMPL	nosys
271	AUE_NULL	UNIMPL	nosys
272	AUE_O_GETDENTS	COMPAT11 { int getdents(int fd, char *buf, \
				    size_t count); }
273	AUE_NULL	UNIMPL	nosys
274	AUE_LCHMOD	STD	{ int lchmod(char *path, mode_t mode); }

				    struct timeval *tptr); }
277	AUE_MSYNC	NOPROTO	{ int msync(void *addr, size_t len, \
				    int flags); } netbsd_msync msync_args int
278	AUE_STAT	COMPAT11 { int nstat(char *path, struct nstat *ub); }
279	AUE_FSTAT	COMPAT11 { int nfstat(int fd, struct nstat *sb); }
280	AUE_LSTAT	COMPAT11 { int nlstat(char *path, struct nstat *ub); }
281	AUE_NULL	UNIMPL	nosys
282	AUE_NULL	UNIMPL	nosys
283	AUE_NULL	UNIMPL	nosys

				    struct ostatfs *buf); }
298	AUE_FHOPEN	STD	{ int fhopen(const struct fhandle *u_fhp, \
				    int flags); }
299	AUE_FHSTAT	COMPAT11 { int fhstat(const struct fhandle *u_fhp, \
				    struct freebsd11_stat *sb); }
; syscall numbers for FreeBSD
300	AUE_NULL	STD	{ int modnext(int modid); }
301	AUE_NULL	STD	{ int modstat(int modid, \

				    off_t *sbytes, int flags); }
394	AUE_NULL	STD	{ int mac_syscall(const char *policy, \
				    int call, void *arg); }
395	AUE_GETFSSTAT	COMPAT11 { int getfsstat(struct freebsd11_statfs *buf, \
				    long bufsize, int mode); }
396	AUE_STATFS	COMPAT11 { int statfs(char *path, \
				    struct freebsd11_statfs *buf); }
397	AUE_FSTATFS	COMPAT11 { int fstatfs(int fd, \
				    struct freebsd11_statfs *buf); }
398	AUE_FHSTATFS	COMPAT11 { int fhstatfs(const struct fhandle *u_fhp, \
				    struct freebsd11_statfs *buf); }
399	AUE_NULL	UNIMPL	nosys
400	AUE_SEMCLOSE	NOSTD	{ int ksem_close(semid_t id); }
401	AUE_SEMPOST	NOSTD	{ int ksem_post(semid_t id); }

				    gid_t gid, int flag); }
492	AUE_FEXECVE	STD	{ int fexecve(int fd, char **argv, \
				    char **envv); }
493	AUE_FSTATAT	COMPAT11 { int fstatat(int fd, char *path, \
				    struct freebsd11_stat *buf, int flag); }
494	AUE_FUTIMESAT	STD	{ int futimesat(int fd, char *path, \
				    struct timeval *times); }
495	AUE_LINKAT	STD	{ int linkat(int fd1, char *path1, int fd2, \
				    char *path2, int flag); }
496	AUE_MKDIRAT	STD	{ int mkdirat(int fd, char *path, mode_t mode); }
497	AUE_MKFIFOAT	STD	{ int mkfifoat(int fd, char *path, mode_t mode); }
498	AUE_MKNODAT	COMPAT11 { int mknodat(int fd, char *path, mode_t mode, \
				    uint32_t dev); }
; XXX: see the comment for open
499	AUE_OPENAT_RWTC	STD	{ int openat(int fd, char *path, int flag, \
				    mode_t mode); }

				    id_t id, const struct \
				    vm_domain_policy_entry *policy); }
550	AUE_FSYNC	STD	{ int fdatasync(int fd); }
551	AUE_FSTAT	STD	{ int fstat(int fd, struct stat *sb); }
552	AUE_FSTATAT	STD	{ int fstatat(int fd, char *path, \
				    struct stat *buf, int flag); }
553	AUE_FHSTAT	STD	{ int fhstat(const struct fhandle *u_fhp, \
				    struct stat *sb); }
554	AUE_GETDIRENTRIES STD	{ ssize_t getdirentries(int fd, char *buf, \
				    size_t count, off_t *basep); }
555	AUE_STATFS	STD	{ int statfs(char *path, struct statfs *buf); }
556	AUE_FSTATFS	STD	{ int fstatfs(int fd, struct statfs *buf); }
557	AUE_GETFSSTAT	STD	{ int getfsstat(struct statfs *buf, \
				    long bufsize, int mode); }
558	AUE_FHSTATFS	STD	{ int fhstatfs(const struct fhandle *u_fhp, \
				    struct statfs *buf); }
559	AUE_MKNODAT	STD	{ int mknodat(int fd, char *path, mode_t mode, \
				    dev_t dev); }

; Please copy any additions and changes to the following compatability tables:
; sys/compat/freebsd32/syscalls.master

Lines 1205-1211 tty_to_xtty(struct tty tp, struct xtty xt) Link Here

(-)b/sys/kern/tty.c (-1 / +1 lines)
1205	xt->xt_pgid = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;	1205	xt->xt_pgid = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
1206	xt->xt_sid = tp->t_session ? tp->t_session->s_sid : 0;	1206	xt->xt_sid = tp->t_session ? tp->t_session->s_sid : 0;
1207	xt->xt_flags = tp->t_flags;	1207	xt->xt_flags = tp->t_flags;
1208	xt->xt_dev = tp->t_dev ? dev2udev(tp->t_dev) : NODEV;	1208	xt->xt_dev = tp->t_dev ? dev2udev(tp->t_dev) : (uint32_t)NODEV;
1209	}	1209	}
1210		1210
1211	static int	1211	static int

Lines 592-597 ptsdev_fill_kinfo(struct file fp, struct kinfo_file kif, struct filedesc *fdp) Link Here

(-)b/sys/kern/tty_pts.c (+2 lines)
592	kif->kf_type = KF_TYPE_PTS;	592	kif->kf_type = KF_TYPE_PTS;
593	tp = fp->f_data;	593	tp = fp->f_data;
594	kif->kf_un.kf_pts.kf_pts_dev = tty_udev(tp);	594	kif->kf_un.kf_pts.kf_pts_dev = tty_udev(tp);
		595	kif->kf_un.kf_pts.kf_pts_dev_freebsd11 =
		596	kif->kf_un.kf_pts.kf_pts_dev; /* truncate */
595	strlcpy(kif->kf_path, tty_devname(tp), sizeof(kif->kf_path));	597	strlcpy(kif->kf_path, tty_devname(tp), sizeof(kif->kf_path));
596	return (0);	598	return (0);
597	}	599	}




/*
 * Get old format filesystem statistics.
 */
static void freebsd4_cvtstatfs(struct statfs *, struct ostatfs *);

#ifndef _SYS_SYSPROTO_H_
struct freebsd4_statfs_args {

	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_statfs(td, uap->path, UIO_USERSPACE, sfp);
	if (error == 0) {
		freebsd4_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);

	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_fstatfs(td, uap->fd, sfp);
	if (error == 0) {
		freebsd4_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);

	size = count * sizeof(struct statfs);
	error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE,
	    uap->mode);
	if (error == 0)
		td->td_retval[0] = count;
	if (size != 0) {
		sp = buf;
		while (count != 0 && error == 0) {
			freebsd4_cvtstatfs(sp, &osb);
			error = copyout(&osb, uap->buf, sizeof(osb));
			sp++;
			uap->buf++;

	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_fhstatfs(td, fh, sfp);
	if (error == 0) {
		freebsd4_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);

 * Convert a new format statfs structure to an old format statfs structure.
 */
static void
freebsd4_cvtstatfs(nsp, osp)
	struct statfs *nsp;
	struct ostatfs *osp;
{

}
#endif /* COMPAT_FREEBSD4 */

#if defined(COMPAT_FREEBSD11)
/*
 * Get old format filesystem statistics.
 */
static void freebsd11_cvtstatfs(struct statfs *, struct freebsd11_statfs *);

int
freebsd11_statfs(struct thread *td, struct freebsd11_statfs_args *uap)
{
	struct freebsd11_statfs osb;
	struct statfs *sfp;
	int error;

	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_statfs(td, uap->path, UIO_USERSPACE, sfp);
	if (error == 0) {
		freebsd11_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);
	return (error);
}

/*
 * Get filesystem statistics.
 */
int
freebsd11_fstatfs(struct thread *td, struct freebsd11_fstatfs_args *uap)
{
	struct freebsd11_statfs osb;
	struct statfs *sfp;
	int error;

	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_fstatfs(td, uap->fd, sfp);
	if (error == 0) {
		freebsd11_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);
	return (error);
}

/*
 * Get statistics on all filesystems.
 */
int
freebsd11_getfsstat(struct thread *td, struct freebsd11_getfsstat_args *uap)
{
	struct freebsd11_statfs osb;
	struct statfs *buf, *sp;
	size_t count, size;
	int error;

	count = uap->bufsize / sizeof(struct ostatfs);
	size = count * sizeof(struct statfs);
	error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE,
	    uap->mode);
	if (error == 0)
		td->td_retval[0] = count;
	if (size > 0) {
		sp = buf;
		while (count > 0 && error == 0) {
			freebsd11_cvtstatfs(sp, &osb);
			error = copyout(&osb, uap->buf, sizeof(osb));
			sp++;
			uap->buf++;
			count--;
		}
		free(buf, M_STATFS);
	}
	return (error);
}

/*
 * Implement fstatfs() for (NFS) file handles.
 */
int
freebsd11_fhstatfs(struct thread *td, struct freebsd11_fhstatfs_args *uap)
{
	struct freebsd11_statfs osb;
	struct statfs *sfp;
	fhandle_t fh;
	int error;

	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
	if (error)
		return (error);
	sfp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
	error = kern_fhstatfs(td, fh, sfp);
	if (error == 0) {
		freebsd11_cvtstatfs(sfp, &osb);
		error = copyout(&osb, uap->buf, sizeof(osb));
	}
	free(sfp, M_STATFS);
	return (error);
}

/*
 * Convert a new format statfs structure to an old format statfs structure.
 */
static void
freebsd11_cvtstatfs(nsp, osp)
	struct statfs *nsp;
	struct freebsd11_statfs *osp;
{
	bzero(osp, sizeof(*osp));
	osp->f_version = FREEBSD11_STATFS_VERSION;
	osp->f_type = nsp->f_type;
	osp->f_flags = nsp->f_flags;
	osp->f_bsize = nsp->f_bsize;
	osp->f_iosize = nsp->f_iosize;
	osp->f_blocks = nsp->f_blocks;
	osp->f_bfree = nsp->f_bfree;
	osp->f_bavail = nsp->f_bavail;
	osp->f_files = nsp->f_files;
	osp->f_ffree = nsp->f_ffree;
	osp->f_syncwrites = nsp->f_syncwrites;
	osp->f_asyncwrites = nsp->f_asyncwrites;
	osp->f_syncreads = nsp->f_syncreads;
	osp->f_asyncreads = nsp->f_asyncreads;
	osp->f_namemax = nsp->f_namemax;
	osp->f_owner = nsp->f_owner;
	osp->f_fsid = nsp->f_fsid;
	strlcpy(osp->f_fstypename, nsp->f_fstypename,
	    MIN(MFSNAMELEN, sizeof(osp->f_fstypename)));
	strlcpy(osp->f_mntonname, nsp->f_mntonname,
	    MIN(MNAMELEN, sizeof(osp->f_mntonname)));
	strlcpy(osp->f_mntfromname, nsp->f_mntfromname,
	    MIN(MNAMELEN, sizeof(osp->f_mntfromname)));
}
#endif /* COMPAT_FREEBSD11 */

/*
 * Change current working directory to a given file descriptor.
 */

 * Create a special file.
 */
#ifndef _SYS_SYSPROTO_H_
struct mknodat_args {
	int	fd;
	char	*path;
	mode_t	mode;
	dev_t	dev;
};
#endif
int
sys_mknodat(struct thread *td, struct mknodat_args *uap)
{

	return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode,
	    uap->dev));
}

#if defined(COMPAT_FREEBSD11)
int
freebsd11_mknod(struct thread *td,
    struct freebsd11_mknod_args *uap)
{

	return (kern_mknodat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
	    uap->mode, uap->dev));
}

#ifndef _SYS_SYSPROTO_H_
struct mknodat_args {
	int	fd;
	char	*path;
	mode_t	mode;
	dev_t	dev;
};
#endif
int
freebsd11_mknodat(struct thread *td,
    struct freebsd11_mknodat_args *uap)
{

	return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode,
	    uap->dev));
}
#endif /* COMPAT_FREEBSD11 */

int
kern_mknodat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
    int mode, dev_t dev)
{
	struct vnode *vp;
	struct mount *mp;

}
#endif /* COMPAT_43 */

#if defined(COMPAT_FREEBSD11)
void
freebsd11_cvtstat(struct stat *st, struct freebsd11_stat *ost)
{

	ost->st_dev = st->st_dev;
	ost->st_ino = st->st_ino;		/* truncate */
	ost->st_mode = st->st_mode;
	ost->st_nlink = st->st_nlink;		/* truncate */
	ost->st_uid = st->st_uid;
	ost->st_gid = st->st_gid;
	ost->st_rdev = st->st_rdev;
	ost->st_atim = st->st_atim;
	ost->st_mtim = st->st_mtim;
	ost->st_ctim = st->st_ctim;
	ost->st_size = st->st_size;
	ost->st_blocks = st->st_blocks;
	ost->st_blksize = st->st_blksize;
	ost->st_flags = st->st_flags;
	ost->st_gen = st->st_gen;
	ost->st_lspare = 0;
	ost->st_birthtim = st->st_birthtim;
	bzero((char *)&ost->st_birthtim + sizeof(ost->st_birthtim),
	    sizeof(*ost) - offsetof(struct freebsd11_stat,
	    st_birthtim) - sizeof(ost->st_birthtim));
}

int
freebsd11_stat(struct thread *td, struct freebsd11_stat_args* uap)
	struct thread *td;
	register struct stat_args /* {
		char *path;
		struct stat *ub;
	} */ *uap;
{
	struct stat sb;
	struct freebsd11_stat osb;
	int error;

	error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
	    &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtstat(&sb, &osb);
	error = copyout(&osb, uap->ub, sizeof(osb));
	return (error);
}

int
freebsd11_lstat(struct thread *td, struct freebsd11_lstat_args* uap)
{
	struct stat sb;
	struct freebsd11_stat osb;
	int error;

	error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
	    UIO_USERSPACE, &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtstat(&sb, &osb);
	error = copyout(&osb, uap->ub, sizeof(osb));
	return (error);
}

int
freebsd11_fhstat(struct thread *td, struct freebsd11_fhstat_args* uap)
{
	struct fhandle fh;
	struct stat sb;
	struct freebsd11_stat osb;
	int error;

	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
	if (error != 0)
		return (error);
	error = kern_fhstat(td, fh, &sb);
	if (error != 0)
		return (error);
	freebsd11_cvtstat(&sb, &osb);
	error = copyout(&osb, uap->sb, sizeof(osb));
	return (error);
}

int
freebsd11_fstatat(struct thread *td, struct freebsd11_fstatat_args* uap)
{
	struct stat sb;
	struct freebsd11_stat osb;
	int error;

	error = kern_statat(td, uap->flag, uap->fd, uap->path,
	    UIO_USERSPACE, &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtstat(&sb, &osb);
	error = copyout(&osb, uap->buf, sizeof(osb));
	return (error);
}
#endif	/* COMPAT_FREEBSD11 */

/*
 * Get file status
 */
#ifndef _SYS_SYSPROTO_H_
struct fstatat_args {
	int	fd;

	return (0);
}

#if defined(COMPAT_FREEBSD11)
 * Get file status; this version does not follow links.
 */
#ifndef _SYS_SYSPROTO_H_
struct lstat_args {
	char	*path;
	struct stat *ub;
};
#endif
int
sys_lstat(td, uap)
	struct thread *td;
	register struct lstat_args /* {
		char *path;
		struct stat *ub;
	} */ *uap;
{
	struct stat sb;
	int error;

	error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
	    UIO_USERSPACE, &sb, NULL);
	if (error == 0)
		error = copyout(&sb, uap->ub, sizeof (sb));
	return (error);
}

/*
 * Implementation of the NetBSD [l]stat() functions.
 */
void
freebsd11_cvtnstat(struct stat *sb, struct nstat *nsb)
	struct stat *sb;
	struct nstat *nsb;
{

	bzero(nsb, sizeof(*nsb));
	nsb->st_dev = sb->st_dev;
	nsb->st_ino = sb->st_ino;
	nsb->st_mode = sb->st_mode;

}

#ifndef _SYS_SYSPROTO_H_
struct freebsd11_nstat_args {
	char	*path;
	struct nstat *ub;
};
#endif
int
freebsd11_nstat(td, uap)
	struct thread *td;
	register struct freebsd11_nstat_args /* {
		char *path;
		struct nstat *ub;
	} */ *uap;

	    &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtnstat(&sb, &nsb);
	return (copyout(&nsb, uap->ub, sizeof (nsb)));
}


 * NetBSD lstat.  Get file status; this version does not follow links.
 */
#ifndef _SYS_SYSPROTO_H_
struct freebsd11_nlstat_args {
	char	*path;
	struct stat *ub;
};
#endif
int
freebsd11_nlstat(td, uap)
	struct thread *td;
	register struct freebsd11_nlstat_args /* {
		char *path;
		struct nstat *ub;
	} */ *uap;

	    UIO_USERSPACE, &sb, NULL);
	if (error != 0)
		return (error);
	freebsd11_cvtnstat(&sb, &nsb);
	return (copyout(&nsb, uap->ub, sizeof (nsb)));
}
#endif /* COMPAT_FREEBSD11 */

/*
 * Get configurable pathname variables.

	return (error);
}

#if defined(COMPAT_43) || defined(COMPAT_FREEBSD11)
int
freebsd11_kern_getdirentries(struct thread *td, int fd, char *ubuf, u_int count,
    long *basep, void (*func)(struct freebsd11_dirent *))
{
	struct freebsd11_dirent dstdp;
	struct dirent *dp, *edp;
	char *dirbuf;
	off_t base;
	ssize_t resid, ucount;
	int error;

	/* XXX arbitrary sanity limit on `count'. */
	count = min(count, 64 * 1024);

	dirbuf = malloc(count, M_TEMP, M_WAITOK);

	error = kern_getdirentries(td, fd, dirbuf, count, &base, &resid,
	    UIO_SYSSPACE);
	if (error != 0)
		goto done;
	if (basep != NULL)
		*basep = base;

	ucount = 0;
	for (dp = (struct dirent *)dirbuf,
	    edp = (struct dirent *)&dirbuf[count - resid];
	    ucount < count && dp < edp; ) {
		if (dp->d_reclen == 0)
			break;
		MPASS(dp->d_reclen >= _GENERIC_DIRLEN(0));
		if (dp->d_namlen > sizeof(dstdp.d_name) - 1)
			continue;
		dstdp.d_type = dp->d_type;
		dstdp.d_namlen = dp->d_namlen;
		dstdp.d_fileno = dp->d_fileno;		/* truncate */
		dstdp.d_reclen = sizeof(dstdp) - sizeof(dstdp.d_name) +
		    ((dp->d_namlen + 1 + 3) &~ 3);
		bcopy(dp->d_name, dstdp.d_name, dstdp.d_namlen);
		bzero(dstdp.d_name + dstdp.d_namlen,
		    dstdp.d_reclen - offsetof(struct freebsd11_dirent, d_name) -
		    dstdp.d_namlen);
		MPASS(dstdp.d_reclen <= dp->d_reclen);
		MPASS(ucount + dstdp.d_reclen <= count);
		if (func != NULL)
			func(&dstdp);
		error = copyout(&dstdp, ubuf + ucount, dstdp.d_reclen);
		if (error != 0)
			break;
		dp = (struct dirent *)((char *)dp + dp->d_reclen);
		ucount += dstdp.d_reclen;
	}

done:
	free(dirbuf, M_TEMP);
	if (error == 0)
		td->td_retval[0] = ucount;
	return (error);
}
#endif /* COMPAT */

#ifdef COMPAT_43
static void
ogetdirentries_cvt(struct freebsd11_dirent *dp)
{
#if (BYTE_ORDER == LITTLE_ENDIAN)
	/*
	 * The expected low byte of dp->d_namlen is our dp->d_type.
	 * The high MBZ byte of dp->d_namlen is our dp->d_namlen.
	 */
	dp->d_type = dp->d_namlen;
	dp->d_namlen = 0;
#else
	/*
	 * The dp->d_type is the high byte of the expected dp->d_namlen,
	 * so must be zero'ed.
	 */
	dp->d_type = 0;
#endif
}

/*
 * Read a block of directory entries in a filesystem independent format.
 */

kern_ogetdirentries(struct thread *td, struct ogetdirentries_args *uap,
    long *ploff)
{
	long base;
	int error;
	struct uio auio, kuio;
	struct iovec aiov, kiov;
	struct dirent *dp, *edp;
	cap_rights_t rights;
	caddr_t dirbuf;
	int error, eofflag, readcnt;
	long loff;
	off_t foffset;

	/* XXX arbitrary sanity limit on `count'. */
	if (uap->count > 64 * 1024)
		return (EINVAL);

	error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
	    &base, ogetdirentries_cvt);

	if (error == 0 && uap->basep != NULL)
		error = copyout(&base, uap->basep, sizeof(long));

	vp = fp->f_vnode;
	foffset = foffset_lock(fp, 0);
unionread:
	if (vp->v_type != VDIR) {
		foffset_unlock(fp, foffset, 0);
		fdrop(fp, td);
		return (EINVAL);
	}
	aiov.iov_base = uap->buf;
	aiov.iov_len = uap->count;
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	auio.uio_rw = UIO_READ;
	auio.uio_segflg = UIO_USERSPACE;
	auio.uio_td = td;
	auio.uio_resid = uap->count;
	vn_lock(vp, LK_SHARED | LK_RETRY);
	loff = auio.uio_offset = foffset;
#ifdef MAC
	error = mac_vnode_check_readdir(td->td_ucred, vp);
	if (error != 0) {
		VOP_UNLOCK(vp, 0);
		foffset_unlock(fp, foffset, FOF_NOUPDATE);
		fdrop(fp, td);
		return (error);
	}
#endif
#	if (BYTE_ORDER != LITTLE_ENDIAN)
		if (vp->v_mount->mnt_maxsymlinklen <= 0) {
			error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
			    NULL, NULL);
			foffset = auio.uio_offset;
		} else
#	endif
	{
		kuio = auio;
		kuio.uio_iov = &kiov;
		kuio.uio_segflg = UIO_SYSSPACE;
		kiov.iov_len = uap->count;
		dirbuf = malloc(uap->count, M_TEMP, M_WAITOK);
		kiov.iov_base = dirbuf;
		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
			    NULL, NULL);
		foffset = kuio.uio_offset;
		if (error == 0) {
			readcnt = uap->count - kuio.uio_resid;
			edp = (struct dirent *)&dirbuf[readcnt];
			for (dp = (struct dirent *)dirbuf; dp < edp; ) {
#				if (BYTE_ORDER == LITTLE_ENDIAN)
					/*
					 * The expected low byte of
					 * dp->d_namlen is our dp->d_type.
					 * The high MBZ byte of dp->d_namlen
					 * is our dp->d_namlen.
					 */
					dp->d_type = dp->d_namlen;
					dp->d_namlen = 0;
#				else
					/*
					 * The dp->d_type is the high byte
					 * of the expected dp->d_namlen,
					 * so must be zero'ed.
					 */
					dp->d_type = 0;
#				endif
				if (dp->d_reclen > 0) {
					dp = (struct dirent *)
					    ((char *)dp + dp->d_reclen);
				} else {
					error = EIO;
					break;
				}
			}
			if (dp >= edp)
				error = uiomove(dirbuf, readcnt, &auio);
		}
		free(dirbuf, M_TEMP);
	}
	if (error != 0) {
		VOP_UNLOCK(vp, 0);
		foffset_unlock(fp, foffset, 0);
		fdrop(fp, td);
		return (error);
	}
	if (uap->count == auio.uio_resid &&
	    (vp->v_vflag & VV_ROOT) &&
	    (vp->v_mount->mnt_flag & MNT_UNION)) {
		struct vnode *tvp = vp;
		vp = vp->v_mount->mnt_vnodecovered;
		VREF(vp);
		fp->f_vnode = vp;
		fp->f_data = vp;
		foffset = 0;
		vput(tvp);
		goto unionread;
	}
	VOP_UNLOCK(vp, 0);
	foffset_unlock(fp, foffset, 0);
	fdrop(fp, td);
	td->td_retval[0] = uap->count - auio.uio_resid;
	if (error == 0)
		*ploff = loff;
	return (error);
}
#endif /* COMPAT_43 */

#if defined(COMPAT_FREEBSD11)
 * Read a block of directory entries in a filesystem independent format.
 */
#ifndef _SYS_SYSPROTO_H_
struct freebsd11_getdirentries_args {
	int	fd;
	char	*buf;
	u_int	count;

};
#endif
int
freebsd11_getdirentries(struct thread *td,
    struct freebsd11_getdirentries_args *uap)
	register struct getdirentries_args /* {
		int fd;
		char *buf;
		u_int count;
		long *basep;
	} */ *uap;
{
	long base;
	int error;

	error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
	    &base, NULL);

	if (error == 0 && uap->basep != NULL)
		error = copyout(&base, uap->basep, sizeof(long));
	return (error);
}

int
freebsd11_getdents(struct thread *td, struct freebsd11_getdents_args *uap)
{
	struct freebsd11_getdirentries_args ap;

	ap.fd = uap->fd;
	ap.buf = uap->buf;
	ap.count = uap->count;
	ap.basep = NULL;
	return (freebsd11_getdirentries(td, &ap));
}
#endif /* COMPAT_FREEBSD11 */

/*
 * Read a block of directory entries in a filesystem independent format.
 */
int
sys_getdirentries(struct thread *td, struct getdirentries_args *uap)
{
	off_t base;
	int error;

	error = kern_getdirentries(td, uap->fd, uap->buf, uap->count, &base,
	    NULL, UIO_USERSPACE);
	if (error != 0)
		return (error);
	if (uap->basep != NULL)
		error = copyout(&base, uap->basep, sizeof(off_t));
	return (error);
}

int
kern_getdirentries(struct thread *td, int fd, char *buf, size_t count,
    off_t *basep, ssize_t *residp, enum uio_seg bufseg)
{
	struct vnode *vp;
	struct file *fp;
	struct uio auio;
	struct iovec aiov;
	cap_rights_t rights;
	off_t loff;
	int error, eofflag;
	off_t foffset;


	return (error);
}

#ifndef _SYS_SYSPROTO_H_
struct getdents_args {
	int fd;
	char *buf;
	size_t count;
};
#endif
int
sys_getdents(td, uap)
	struct thread *td;
	register struct getdents_args /* {
		int fd;
		char *buf;
		u_int count;
	} */ *uap;
{
	struct getdirentries_args ap;

	ap.fd = uap->fd;
	ap.buf = uap->buf;
	ap.count = uap->count;
	ap.basep = NULL;
	return (sys_getdirentries(td, &ap));
}

/*
 * Set the mode mask for creation of filesystem nodes.
 */

Lines 2354-2360 vn_fill_kinfo_vnode(struct vnode vp, struct kinfo_file kif) Link Here

(-)b/sys/kern/vfs_vnops.c (-1 / +5 lines)
2354	char fullpath, freepath;	2354	char fullpath, freepath;
2355	int error;	2355	int error;
2356		2356
2357	kif->kf_vnode_type = vntype_to_kinfo(vp->v_type);	2357	kif->kf_un.kf_file.kf_file_type = vntype_to_kinfo(vp->v_type);
2358	freepath = NULL;	2358	freepath = NULL;
2359	fullpath = "-";	2359	fullpath = "-";
2360	error = vn_fullpath(curthread, vp, &fullpath, &freepath);	2360	error = vn_fullpath(curthread, vp, &fullpath, &freepath);
Lines 2383-2392 vn_fill_kinfo_vnode(struct vnode vp, struct kinfo_file kif) Link Here
2383	else	2383	else
2384	kif->kf_un.kf_file.kf_file_fsid =	2384	kif->kf_un.kf_file.kf_file_fsid =
2385	vp->v_mount->mnt_stat.f_fsid.val[0];	2385	vp->v_mount->mnt_stat.f_fsid.val[0];
		2386	kif->kf_un.kf_file.kf_file_fsid_freebsd11 =
		2387	kif->kf_un.kf_file.kf_file_fsid; /* truncate */
2386	kif->kf_un.kf_file.kf_file_fileid = va.va_fileid;	2388	kif->kf_un.kf_file.kf_file_fileid = va.va_fileid;
2387	kif->kf_un.kf_file.kf_file_mode = MAKEIMODE(va.va_type, va.va_mode);	2389	kif->kf_un.kf_file.kf_file_mode = MAKEIMODE(va.va_type, va.va_mode);
2388	kif->kf_un.kf_file.kf_file_size = va.va_size;	2390	kif->kf_un.kf_file.kf_file_size = va.va_size;
2389	kif->kf_un.kf_file.kf_file_rdev = va.va_rdev;	2391	kif->kf_un.kf_file.kf_file_rdev = va.va_rdev;
		2392	kif->kf_un.kf_file.kf_file_rdev_freebsd11 =
		2393	kif->kf_un.kf_file.kf_file_rdev; /* truncate */
2390	return (0);	2394	return (0);
2391	}	2395	}
2392		2396




	union nfsfh fh;
	struct sockaddr *sa;
	struct sockaddr_storage ss;
	char *servername;
	struct timeval timo;
	int retries;
	rpcvers_t vers;


	ASSERT_VOP_LOCKED(vp, "nlm_advlock_1");

	servername = malloc(MNAMELEN, M_TEMP, M_WAITOK); /* XXXKIB vp locked */
	nmp = VFSTONFS(vp->v_mount);
	/*
	 * Push any pending writes to the server and flush our cache

	AUTH_DESTROY(auth);

	nlm_host_release(host);
	free(servername, M_TEMP);
	return (error);
}





	mode_t	vn_mode;
	uid_t	vn_uid;
	gid_t	vn_gid;
	u_int32_t vn_dev;		/* XXX dev_t compatibility */
	long	vn_fsid;		/* XXX uint64_t compatibility */
	long	vn_fileid;		/* XXX ino_t compatibility */
	long	vn_gen;
};


	int			ar_arg_atfd2;
	int			ar_arg_fflags;
	mode_t			ar_arg_mode;
	int			ar_arg_dev;	/* XXX dev_t compatibility */
	long			ar_arg_value;
	void			*ar_arg_addr;
	int			ar_arg_len;




typedef	__uint64_t	__fsfilcnt_t;
typedef	__uint32_t	__gid_t;
typedef	__int64_t	__id_t;		/* can hold a gid_t, pid_t, or uid_t */
typedef	__uint64_t	__ino_t;	/* inode number */
typedef	long		__key_t;	/* IPC key (for Sys V IPC) */
typedef	__int32_t	__lwpid_t;	/* Thread ID (a.k.a. LWP) */
typedef	__uint16_t	__mode_t;	/* permissions */
typedef	int		__accmode_t;	/* access permissions */
typedef	int		__nl_item;
typedef	__uint64_t	__nlink_t;	/* link count */
typedef	__int64_t	__off_t;	/* file offset */
typedef	__int64_t	__off64_t;	/* file offset (alias) */
typedef	__int32_t	__pid_t;	/* process [group] */

	long double __max_align2 __aligned(_Alignof(long double));
} __max_align_t;

typedef	__uint64_t	__dev_t;	/* device number */

typedef	__uint32_t	__fixpt_t;	/* fixed point number */





#define AC_COMM_LEN 16

/*
 * Accounting structure version 3 (current).
 * The first byte is always zero.
 * Time units are microseconds.
 */

struct acctv3 {
	uint8_t   ac_zero;		/* zero identifies new version */
	uint8_t   ac_version;		/* record version number */
	uint16_t  ac_len;		/* record length */

	float	  ac_mem;		/* average memory usage */
	float	  ac_io;		/* count of IO blocks */
	__dev_t   ac_tty;		/* controlling tty */
	uint32_t  ac_pad0;
	uint16_t  ac_len2;		/* record length */
	union {
		uint32_t  ac_align;	/* force v1 compatible alignment */

#define	AFORK	0x01			/* forked but not exec'ed */
/* ASU is no longer supported */

#define ac_flagx ac_trailer.ac_flag
};

struct acctv2 {
	uint8_t   ac_zero;		/* zero identifies new version */
	uint8_t   ac_version;		/* record version number */
	uint16_t  ac_len;		/* record length */

	char	  ac_comm[AC_COMM_LEN];	/* command name */
	float	  ac_utime;		/* user time */
	float	  ac_stime;		/* system time */
	float	  ac_etime;		/* elapsed time */
	time_t	  ac_btime;		/* starting time */
	uid_t	  ac_uid;		/* user id */
	gid_t	  ac_gid;		/* group id */
	float	  ac_mem;		/* average memory usage */
	float	  ac_io;		/* count of IO blocks */
	uint32_t  ac_tty;		/* controlling tty */

	uint16_t  ac_len2;		/* record length */
	union {
		uint32_t   ac_align;	/* force v1 compatible alignment */
		uint8_t   ac_flag;	/* accounting flags */
	} ac_trailer;
};

/*
 * Legacy accounting structure (rev. 1.5-1.18).

	gid_t	  ac_gid;		/* group id */
	uint16_t  ac_mem;		/* average memory usage */
	comp_t	  ac_io;		/* count of IO blocks */
	uint32_t  ac_tty;		/* controlling tty */
	uint8_t   ac_flag;		/* accounting flags */
};





#include <sys/cdefs.h>
#include <sys/_types.h>

#ifndef _INO_T_DECLARED
typedef	__ino_t		ino_t;
#define	_INO_T_DECLARED
#endif

#ifndef _OFF_T_DECLARED
typedef	__off_t		off_t;
#define	_OFF_T_DECLARED
#endif

/*
 * The dirent structure defines the format of directory entries returned by
 * the getdirentries(2) system call.
 *
 * A directory entry has a struct dirent at the front of it, containing its
 * inode number, the length of the entry, and the length of the name
 * contained in the entry.  These are followed by the name padded to a 8
 * byte boundary with null bytes.  All names are guaranteed null terminated.
 * The maximum length of a name in a directory is MAXNAMLEN.
 *
 * Explicit padding between the last member of the header (d_namelen) and
 * d_name avoids ABI padding at the end of dirent on LP64 architectures.
 * There is code depending on d_name being last.  Also, retaining this
 * padding on ILP32 architectures simplifies the compat32 layer.
 */

struct dirent {
	ino_t      d_fileno;		/* file number of entry */
	off_t      d_off;		/* directory offset of entry */
	__uint16_t d_reclen;		/* length of this record */
	__uint8_t  d_type;		/* file type, see below */
	__uint8_t  d_namlen;		/* length of string in d_name */
	__uint32_t d_pad0;
#if __BSD_VISIBLE
#define	MAXNAMLEN	255
	char	d_name[MAXNAMLEN + 1];	/* name must be no longer than this */

#endif
};

#if defined(_WANT_FREEBSD11_DIRENT) || defined(_KERNEL)
struct freebsd11_dirent {
	__uint32_t d_fileno;		/* file number of entry */
	__uint16_t d_reclen;		/* length of this record */
	__uint8_t  d_type;		/* file type, see below */
	__uint8_t  d_namlen;		/* length of string in d_name */
	char	d_name[255 + 1];	/* name must be no longer than this */
};
#endif /* _WANT_FREEBSD11_DIRENT || _KERNEL */

#if __BSD_VISIBLE

/*
 * File types
 */

 * The _GENERIC_DIRSIZ macro gives the minimum record length which will hold
 * the directory entry.  This returns the amount of space in struct direct
 * without the d_name field, plus enough space for the name with a terminating
 * null byte (dp->d_namlen+1), rounded up to a 8 byte boundary.
 *
 * XXX although this macro is in the implementation namespace, it requires
 * a manifest constant that is not.
 */
#define	_GENERIC_DIRLEN(namlen)					\
	((__offsetof(struct dirent, d_name) + (namlen) + 1 + 7) & ~7)
#define	_GENERIC_DIRSIZ(dp)	_GENERIC_DIRLEN((dp)->d_namlen)
#endif /* __BSD_VISIBLE */

#ifdef _KERNEL




 * filesystem statistics
 */
#define	MFSNAMELEN	16		/* length of type name including null */
#define	MNAMELEN	1024		/* size of on/from name bufs */
#define	STATFS_VERSION	0x20140518	/* current version number */
struct statfs {
	uint32_t f_version;		/* structure version number */
	uint32_t f_type;		/* type of filesystem */

	char	  f_mntonname[MNAMELEN];    /* directory on which mounted */
};

#if defined(_WANT_FREEBSD11_STATFS) || defined(_KERNEL)
#define	FREEBSD11_STATFS_VERSION	0x20030518 /* current version number */
struct freebsd11_statfs {
	uint32_t f_version;		/* structure version number */
	uint32_t f_type;		/* type of filesystem */
	uint64_t f_flags;		/* copy of mount exported flags */
	uint64_t f_bsize;		/* filesystem fragment size */
	uint64_t f_iosize;		/* optimal transfer block size */
	uint64_t f_blocks;		/* total data blocks in filesystem */
	uint64_t f_bfree;		/* free blocks in filesystem */
	int64_t	 f_bavail;		/* free blocks avail to non-superuser */
	uint64_t f_files;		/* total file nodes in filesystem */
	int64_t	 f_ffree;		/* free nodes avail to non-superuser */
	uint64_t f_syncwrites;		/* count of sync writes since mount */
	uint64_t f_asyncwrites;		/* count of async writes since mount */
	uint64_t f_syncreads;		/* count of sync reads since mount */
	uint64_t f_asyncreads;		/* count of async reads since mount */
	uint64_t f_spare[10];		/* unused spare */
	uint32_t f_namemax;		/* maximum filename length */
	uid_t	  f_owner;		/* user that mounted the filesystem */
	fsid_t	  f_fsid;		/* filesystem id */
	char	  f_charspare[80];	/* spare string space */
	char	  f_fstypename[16];	/* filesystem type name */
	char	  f_mntfromname[88];	/* mounted filesystem */
	char	  f_mntonname[88];	/* directory on which mounted */
};
#endif /* _WANT_FREEBSD11_STATFS || _KERNEL */

#ifdef _KERNEL
#define	OMFSNAMELEN	16	/* length of fs type name, including null */
#define	OMNAMELEN	(88 - 2 * sizeof(long))	/* size of on/from name bufs */




#ifdef _KERNEL
struct ostat {
	__uint16_t st_dev;		/* inode's device */
	__uint32_t st_ino;		/* inode's number */
	mode_t	  st_mode;		/* inode protection mode */
	__uint16_t st_nlink;		/* number of hard links */
	__uint16_t st_uid;		/* user ID of the file's owner */
	__uint16_t st_gid;		/* group ID of the file's group */
	__uint16_t st_rdev;		/* device type */

};
#endif

#if defined(_WANT_FREEBSD11_STAT) || defined(_KERNEL)
struct freebsd11_stat {
	__uint32_t st_dev;		/* inode's device */
	__uint32_t st_ino;		/* inode's number */
	mode_t	  st_mode;		/* inode protection mode */
	__uint16_t st_nlink;		/* number of hard links */
	uid_t	  st_uid;		/* user ID of the file's owner */
	gid_t	  st_gid;		/* group ID of the file's group */
	__uint32_t st_rdev;		/* device type */
	struct	timespec st_atim;	/* time of last access */
	struct	timespec st_mtim;	/* time of last data modification */
	struct	timespec st_ctim;	/* time of last file status change */

	unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec));
	unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec));
};
#endif /* _WANT_FREEBSD11_STAT || _KERNEL */

struct stat {
	dev_t     st_dev;		/* inode's device */
	ino_t	  st_ino;		/* inode's number */
	nlink_t	  st_nlink;		/* number of hard links */
	mode_t	  st_mode;		/* inode protection mode */
	__int16_t st_padding0;
	uid_t	  st_uid;		/* user ID of the file's owner */
	gid_t	  st_gid;		/* group ID of the file's group */
	__int32_t st_padding1;
	dev_t     st_rdev;		/* device type */
	struct	timespec st_atim;	/* time of last access */
	struct	timespec st_mtim;	/* time of last data modification */
	struct	timespec st_ctim;	/* time of last file status change */
	struct	timespec st_birthtim;	/* time of file creation */
	off_t	  st_size;		/* file size, in bytes */
	blkcnt_t st_blocks;		/* blocks allocated for file */
	blksize_t st_blksize;		/* optimal blocksize for I/O */
	fflags_t  st_flags;		/* user defined flags for file */
	__uint64_t st_gen;		/* file generation number */
	__uint64_t st_spare[10];
};

#ifdef _KERNEL
struct nstat {
	__uint32_t st_dev;		/* inode's device */
	__uint32_t st_ino;		/* inode's number */
	__uint32_t st_mode;		/* inode protection mode */
	__uint32_t st_nlink;		/* number of hard links */
	uid_t	  st_uid;		/* user ID of the file's owner */
	gid_t	  st_gid;		/* group ID of the file's group */
	__uint32_t st_rdev;		/* device type */
	struct	timespec st_atim;	/* time of last access */
	struct	timespec st_mtim;	/* time of last data modification */
	struct	timespec st_ctim;	/* time of last file status change */

	__uint32_t st_gen;		/* file generation number */
	struct timespec st_birthtim;	/* time of file creation */
	/*
	 * See comment in the definition of struct freebsd11_stat
	 * above about the following padding.
	 */
	unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec));
	unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec));

Lines 117-124 int kern_futimes(struct thread td, int fd, struct timeval tptr, Link Here

(-)b/sys/sys/syscallsubr.h (-3 / +8 lines)
117	enum uio_seg tptrseg);	117	enum uio_seg tptrseg);
118	int kern_futimens(struct thread td, int fd, struct timespec tptr,	118	int kern_futimens(struct thread td, int fd, struct timespec tptr,
119	enum uio_seg tptrseg);	119	enum uio_seg tptrseg);
120	int kern_getdirentries(struct thread td, int fd, char buf, u_int count,	120	int kern_getdirentries(struct thread td, int fd, char buf, size_t count,
121	long basep, ssize_t residp, enum uio_seg bufseg);	121	off_t basep, ssize_t residp, enum uio_seg bufseg);
122	int kern_getfsstat(struct thread td, struct statfs *buf, size_t bufsize,	122	int kern_getfsstat(struct thread td, struct statfs *buf, size_t bufsize,
123	size_t *countp, enum uio_seg bufseg, int mode);	123	size_t *countp, enum uio_seg bufseg, int mode);
124	int kern_getitimer(struct thread , u_int, struct itimerval );	124	int kern_getitimer(struct thread , u_int, struct itimerval );
Lines 158-164 int kern_mkdirat(struct thread td, int fd, char path, Link Here
158	int kern_mkfifoat(struct thread td, int fd, char path,	158	int kern_mkfifoat(struct thread td, int fd, char path,
159	enum uio_seg pathseg, int mode);	159	enum uio_seg pathseg, int mode);
160	int kern_mknodat(struct thread td, int fd, char path,	160	int kern_mknodat(struct thread td, int fd, char path,
161	enum uio_seg pathseg, int mode, int dev);	161	enum uio_seg pathseg, int mode, dev_t dev);
162	int kern_mlock(struct proc proc, struct ucred cred, uintptr_t addr,	162	int kern_mlock(struct proc proc, struct ucred cred, uintptr_t addr,
163	size_t len);	163	size_t len);
164	int kern_mmap(struct thread *td, uintptr_t addr, size_t size, int prot,	164	int kern_mmap(struct thread *td, uintptr_t addr, size_t size, int prot,
Lines 290-293 int kern_socketpair(struct thread *td, int domain, int type, int protocol, Link Here
290	#define KSA_OSIGSET 0x0001 /* uses osigact_t */	290	#define KSA_OSIGSET 0x0001 /* uses osigact_t */
291	#define KSA_FREEBSD4 0x0002 /* uses ucontext4 */	291	#define KSA_FREEBSD4 0x0002 /* uses ucontext4 */
292		292
		293	struct freebsd11_dirent;
		294
		295	int freebsd11_kern_getdirentries(struct thread td, int fd, char ubuf, u_int
		296	count, long basep, void (func)(struct freebsd11_dirent *));
		297
293	#endif /* !_SYS_SYSCALLSUBR_H_ */	298	#endif /* !_SYS_SYSCALLSUBR_H_ */

Lines 148-154 struct xtty { Link Here

(-)b/sys/sys/tty.h (-1 / +1 lines)
148	pid_t xt_pgid; /* Foreground process group. */	148	pid_t xt_pgid; /* Foreground process group. */
149	pid_t xt_sid; /* Session. */	149	pid_t xt_sid; /* Session. */
150	unsigned int xt_flags; /* Terminal option flags. */	150	unsigned int xt_flags; /* Terminal option flags. */
151	dev_t xt_dev; /* Userland device. */	151	uint32_t xt_dev; /* Userland device. XXXKIB truncated */
152	};	152	};
153		153
154	#ifdef _KERNEL	154	#ifdef _KERNEL




 * it in two places: function fill_kinfo_proc in sys/kern/kern_proc.c and
 * function kvm_proclist in lib/libkvm/kvm_proc.c .
 */
#define	KI_NSPARE_INT	2
#define	KI_NSPARE_LONG	12
#define	KI_NSPARE_PTR	6


	pid_t	ki_tsid;		/* Terminal session ID */
	short	ki_jobc;		/* job control counter */
	short	ki_spare_short1;	/* unused (just here for alignment) */
	uint32_t ki_tdev_freebsd11;	/* controlling tty dev */
	sigset_t ki_siglist;		/* Signals arrived but not delivered */
	sigset_t ki_sigmask;		/* Current signal mask */
	sigset_t ki_sigignore;		/* Signals being ignored */

	 */
	char	ki_sparestrings[46];	/* spare string space */
	int	ki_spareints[KI_NSPARE_INT];	/* spare room for growth */
	uint64_t ki_tdev;		/* controlling tty dev */
	int	ki_oncpu;		/* Which cpu we are on */
	int	ki_lastcpu;		/* Last cpu we were on */
	int	ki_tracer;		/* Pid of tracing process */

	int		kf_flags;		/* Flags. */
	int		kf_pad0;		/* Round to 64 bit alignment. */
	int64_t		kf_offset;		/* Seek location. */
	int		kf_vnode_type;		/* Vnode type. */
	int		kf_sock_domain;		/* Socket domain. */
	int		kf_sock_type;		/* Socket type. */
	int		kf_sock_protocol;	/* Socket protocol. */
	struct sockaddr_storage kf_sa_local;	/* Socket address. */
	struct sockaddr_storage	kf_sa_peer;	/* Peer address. */
	union {
		struct {
			uint32_t	kf_spareint;
			/* Socket domain. */
			int		kf_sock_domain0;
			/* Socket type. */
			int		kf_sock_type0;
			/* Socket protocol. */
			int		kf_sock_protocol0;
			/* Socket address. */
			struct sockaddr_storage kf_sa_local;
			/* Peer address. */
			struct sockaddr_storage	kf_sa_peer;
			/* Address of so_pcb. */
			uint64_t	kf_sock_pcb;
			/* Address of inp_ppcb. */

			uint32_t	kf_sock_pad0;
		} kf_sock;
		struct {
			/* Vnode type. */
			int		kf_file_type;
			/* Space for future use */
			int		kf_spareint[3];
			uint64_t	kf_spareint64[30];
			/* Vnode filesystem id. */
			uint64_t	kf_file_fsid;
			/* File device. */
			uint64_t	kf_file_rdev;
			/* Global file id. */
			uint64_t	kf_file_fileid;
			/* File size. */
			uint64_t	kf_file_size;
			/* Vnode filesystem id, FreeBSD 11 compat. */
			uint32_t	kf_file_fsid_freebsd11;
			/* File device, FreeBSD 11 compat. */
			uint32_t	kf_file_rdev_freebsd11;
			/* File mode. */
			uint16_t	kf_file_mode;
			/* Round to 64 bit alignment. */

			uint32_t	kf_file_pad1;
		} kf_file;
		struct {
			uint32_t	kf_spareint[4];
			uint64_t	kf_spareint64[32];
			uint32_t	kf_sem_value;
			uint16_t	kf_sem_mode;
		} kf_sem;
		struct {
			uint32_t	kf_spareint[4];
			uint64_t	kf_spareint64[32];
			uint64_t	kf_pipe_addr;
			uint64_t	kf_pipe_peer;
			uint32_t	kf_pipe_buffer_cnt;

			uint32_t	kf_pipe_pad0[3];
		} kf_pipe;
		struct {
			uint32_t	kf_spareint[4];
			uint64_t	kf_spareint64[32];
			uint32_t	kf_pts_dev_freebsd11;
			uint32_t	kf_pts_pad0;
			uint64_t	kf_pts_dev;
			/* Round to 64 bit alignment. */
			uint32_t	kf_pts_pad1[4];
		} kf_pts;
		struct {
			uint32_t	kf_spareint[4];
			uint64_t	kf_spareint64[32];
			pid_t		kf_pid;
		} kf_proc;
	} kf_un;

	/* Truncated before copyout in sysctl */
	char		kf_path[PATH_MAX];	/* Path to file, if any. */
};
#ifndef _KERNEL
#define	kf_vnode_type	kf_un.kf_file.kf_file_type
#define	kf_sock_domain	kf_un.kf_sock.kf_sock_domain0
#define	kf_sock_type	kf_un.kf_sock.kf_sock_type0
#define	kf_sock_protocol	kf_un.kf_sock.kf_sock_protocol0
#endif

/*
 * The KERN_PROC_VMMAP sysctl allows a process to dump the VM layout of

	void	*_kve_pspare[8];		/* Space for more stuff. */
	off_t	 kve_offset;			/* Mapping offset in object */
	uint64_t kve_fileid;			/* inode number if vnode */
	uint32_t kve_fsid;			/* dev_t of vnode location */
	int	 _kve_ispare[3];		/* Space for more stuff. */
};


	uint64_t kve_end;			/* Finishing address. */
	uint64_t kve_offset;			/* Mapping offset in object */
	uint64_t kve_vn_fileid;			/* inode number if vnode */
	uint32_t kve_vn_fsid_freebsd11;		/* dev_t of vnode location */
	int	 kve_flags;			/* Flags on map entry. */
	int	 kve_resident;			/* Number of resident pages. */
	int	 kve_private_resident;		/* Number of private pages. */

	int	 kve_shadow_count;		/* VM obj shadow count. */
	int	 kve_vn_type;			/* Vnode type. */
	uint64_t kve_vn_size;			/* File size. */
	uint32_t kve_vn_rdev_freebsd11;		/* Device id if device. */
	uint16_t kve_vn_mode;			/* File mode. */
	uint16_t kve_status;			/* Status flags. */
	uint64_t kve_vn_fsid;			/* dev_t of vnode location */
	uint64_t kve_vn_rdev;			/* Device id if device. */
	int	 _kve_ispare[8];		/* Space for more stuff. */
	/* Truncated before copyout in sysctl */
	char	 kve_path[PATH_MAX];		/* Path to VM obj, if any. */
};

	int	kvo_type;			/* Object type: KVME_TYPE_*. */
	uint64_t kvo_size;			/* Object size in pages. */
	uint64_t kvo_vn_fileid;			/* inode number if vnode. */
	uint32_t kvo_vn_fsid_freebsd11;		/* dev_t of vnode location. */
	int	kvo_ref_count;			/* Reference count. */
	int	kvo_shadow_count;		/* Shadow count. */
	int	kvo_memattr;			/* Memory attribute. */
	uint64_t kvo_resident;			/* Number of resident pages. */
	uint64_t kvo_active;			/* Number of active pages. */
	uint64_t kvo_inactive;			/* Number of inactive pages. */
	uint64_t kvo_vn_fsid;
	uint64_t _kvo_qspare[7];
	uint32_t _kvo_ispare[8];
	char	kvo_path[PATH_MAX];		/* Pathname, if any. */
};




struct vattr {
	enum vtype	va_type;	/* vnode type (for create) */
	u_short		va_mode;	/* files access mode and type */
	u_short		va_padding0;
	uid_t		va_uid;		/* owner user id */
	gid_t		va_gid;		/* owner group id */
	nlink_t		va_nlink;	/* number of references to file */
	dev_t		va_fsid;	/* filesystem id */
	ino_t		va_fileid;	/* file id */
	u_quad_t	va_size;	/* file size in bytes */
	long		va_blocksize;	/* blocksize preferred for i/o */
	struct timespec	va_atime;	/* time of last access */

struct mount;
struct nameidata;
struct ostat;
struct freebsd11_stat;
struct thread;
struct proc;
struct stat;

void	cache_purgevfs(struct mount *mp, bool force);
int	change_dir(struct vnode *vp, struct thread *td);
void	cvtstat(struct stat *st, struct ostat *ost);
void	freebsd11_cvtnstat(struct stat *sb, struct nstat *nsb);
void	freebsd11_cvtstat(struct stat *st, struct freebsd11_stat *ost);
int	getnewvnode(const char *tag, struct mount *mp, struct vop_vector *vops,
	    struct vnode **vpp);
void	getnewvnode_reserve(u_int count);




#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "opt_compat.h"
#include "opt_swap.h"
#include "opt_vm.h"


	return (error);
}

#if defined(COMPAT_FREEBSD11)
#define XSWDEV_VERSION_11	1
struct xswdev11 {
	u_int	xsw_version;
	uint32_t xsw_dev;
	int	xsw_flags;
	int	xsw_nblks;
	int     xsw_used;
};
#endif

static int
sysctl_vm_swap_info(SYSCTL_HANDLER_ARGS)
{
	struct xswdev xs;
#if defined(COMPAT_FREEBSD11)
	struct xswdev11 xs11;
#endif
	int error;

	if (arg2 != 1)			/* name length */

	error = swap_dev_info(*(int *)arg1, &xs, NULL, 0);
	if (error != 0)
		return (error);
#if defined(COMPAT_FREEBSD11)
	if (req->oldlen == sizeof(xs11)) {
		xs11.xsw_version = XSWDEV_VERSION_11;
		xs11.xsw_dev = xs.xsw_dev; /* truncation */
		xs11.xsw_flags = xs.xsw_flags;
		xs11.xsw_nblks = xs.xsw_nblks;
		xs11.xsw_used = xs.xsw_used;
		error = SYSCTL_OUT(req, &xs11, sizeof(xs11));
	} else
#endif
		error = SYSCTL_OUT(req, &xs, sizeof(xs));
	return (error);
}


Lines 2342-2347 sysctl_vm_object_list(SYSCTL_HANDLER_ARGS) Link Here

(-)b/sys/vm/vm_object.c (+3 lines)
2342		2342
2343	kvo.kvo_vn_fileid = 0;	2343	kvo.kvo_vn_fileid = 0;
2344	kvo.kvo_vn_fsid = 0;	2344	kvo.kvo_vn_fsid = 0;
		2345	kvo.kvo_vn_fsid_freebsd11 = 0;
2345	freepath = NULL;	2346	freepath = NULL;
2346	fullpath = "";	2347	fullpath = "";
2347	vp = NULL;	2348	vp = NULL;
Lines 2383-2388 sysctl_vm_object_list(SYSCTL_HANDLER_ARGS) Link Here
2383	if (VOP_GETATTR(vp, &va, curthread->td_ucred) == 0) {	2384	if (VOP_GETATTR(vp, &va, curthread->td_ucred) == 0) {
2384	kvo.kvo_vn_fileid = va.va_fileid;	2385	kvo.kvo_vn_fileid = va.va_fileid;
2385	kvo.kvo_vn_fsid = va.va_fsid;	2386	kvo.kvo_vn_fsid = va.va_fsid;
		2387	kvo.kvo_vn_fsid_freebsd11 = va.va_fsid;
		2388	/* truncate */
2386	}	2389	}
2387	vput(vp);	2390	vput(vp);
2388	}	2391	}

Lines 89-95 Link Here

(-)b/sys/vm/vm_param.h (-1 / +1 lines)
89	/*	89	/*
90	* Structure for swap device statistics	90	* Structure for swap device statistics
91	*/	91	*/
92	#define XSWDEV_VERSION 1	92	#define XSWDEV_VERSION 2
93	struct xswdev {	93	struct xswdev {
94	u_int xsw_version;	94	u_int xsw_version;
95	dev_t xsw_dev;	95	dev_t xsw_dev;




This note explains how to perform useful testing of the ino64 branch,
beyond usual checks.

1. Overview.
The ino64 branch extends the basic system types ino_t, dev_t from
32bit to 64bit, and nlink_t from 16bit to 64bit.  The struct dirent is
modified, besides expected layout change due to ino_t, also get d_off
members.  Since we are taking the ABI breakage, struct statfs
f_mntfromname[] and f_mntonname[] arrays length MNAMELEN is increased
from 88 to 1024, which should allow longer mount path names.

The work is done to mitigate the ABI breakage, by providing
compatibility utilizing symbol version, ingenious use of the existing
padding in structures, and by employing other tricks.  Unfortunately,
not everything can be fixed, especially oustide the base system.  For
instance, third-party APIs which pass struct stat around are broken in
backward and forward-incompatible way.

2. Motivation.

The main risk of the ino64 change is the uncontrolled ABI breakage.
Due to expansion of the basic types dev_t, ino_t and struct dirent,
the impact is not limited to one part of the system, but affects:
- kernel/userspace interface (syscalls ABI, mostly stat(2), kinfo
  and more)
- libc interface (mostly related to the readdir(3), FTS(3))
- collateral damage in other libraries that happens to use changed types
  in the interfaces.  See, for instance, libprocstat, for which compat
  was provided using symbol versioning, and libutil, which shlib version
  was bumped.

3. Quirks.

We handled kinfo sysctl MIBs, but other MIBs which report structures
depended on the changed type, are not handled in general.  It was
considered that the breakage is either in the management interfaces,
where we usually allow ABI slip, or is not important.

Struct xvnode changed layout, no compat shims are provided.

For struct xtty, dev_t tty device member was reduced to uint32_t.  It
was decided that keeping ABI compat in this case is more useful than
reporting 64bit dev_t, for the sake of pstat.

4. Testing procedure.

4.1 New kernel, old world.
Build and install pristine HEAD world, apply patch and only build and
install updated kernel. The system must work same as with the pristine
kernel.

4.2 New kernel, new world, old third-party applications.
Build and install patched kernel and world.  Applications compiled on the
pristine HEAD (e.g. installed by pkg from the regular portmgr builds) must
work without a regression.

4.3 32bit compat.
Same as 4.1 and 4.2, but for 32bit (i386) binaries on the amd64 host.
Note that big-endian host, like powerpc, might expose additional
bugs in the 32bit compat with the patch, but the testing is too cumbersome
to arrange.

4.4 Targeted tests.
Useful programs to check items 4.1, 4.2 and 4.3 are versions of the
following programs, taken from the pristine system:

  stat(8). Use it on regular file, file in /dev, socket, pipe and so
  on. For both native and 32bit compat, stat(8) must print reasonable
  information.

  procstat(1). Use it with the -f option to examine processes files.
  kinfo(9) data must be returned in the format acceptable for older
  apps.

  Use pristine find(1) binary with many arbitrary options on a system with
  installed patched world, in particular, libc. Find examines FTS(3),
  and compat shims in libc are non-trivial.

4.5 NFS server and client test.
Check that the NFS server in the patched kernel operates correctly and without
performance regressions.  Same for client.
NFS should be checked for all four combination of patched/unpatched
kernel server/client, because the filehandle format includes inode number.

4.6 Other filesystems
Generally, filesystems should see no change in the system behaviour,
since patch goal is to provide space to grow in the ABI.  In
particular, local filesystem layout must stay same.  Of course, it is
possible that some reliance on the exact sizes of the changed types
was left unnoticed during the patch review, in which case e.g. on-disk
format would be broken.  We do not expect this to slip in, but it is
possible and should be watched for.

4.7 Test accounting
The process accounting, as documented in acct(5), changed format of
the records due to dev_t increase.  Verify that the programs like
sa(8) and accton(8) correctly work with both old and new accounting
records.

Lines 932-938 ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) Link Here

(-)b/usr.bin/kdump/kdump.c (-1 lines)
932	ip++;	932	ip++;
933	narg--;	933	narg--;
934	break;	934	break;
935	case SYS_mknod:
936	case SYS_mknodat:	935	case SYS_mknodat:
937	print_number(ip, narg, c);	936	print_number(ip, narg, c);
938	putchar(',');	937	putchar(',');




time_t	 expand(u_int);
char	*flagbits(int);
const	 char *getdev(dev_t);
int	 readrec_forward(FILE *f, struct acctv3 *av3);
int	 readrec_backward(FILE *f, struct acctv3 *av3);
int	 requested(char *[], struct acctv3 *);
static	 void usage(void);

#define AC_UTIME 1 /* user */

int
main(int argc, char *argv[])
{
	struct acctv3 ab;
	char *p;
	FILE *fp;
	int (*readrec)(FILE *f, struct acctv3 *av3);
	time_t t;
	int ch, rv;
	const char *acctfile, *format;

}

int
requested(char *argv[], struct acctv3 *acp)
{
	const char *p;





#include <stdio.h>
#include <string.h>

int	 readrec_forward(FILE *f, struct acctv3 *av2);
int	 readrec_backward(FILE *f, struct acctv3 *av2);

/*
 * Reverse offsetof: return the offset of field f

 * Return EOF on error or end-of-file.
 */
static int
readrec_v1(FILE *f, struct acctv3 *av3)
{
	struct acctv1 av1;
	int rv;

	if ((rv = fread_record(&av1, sizeof(av1), f)) == EOF)
		return (EOF);
	av3->ac_zero = 0;
	av3->ac_version = 3;
	av3->ac_len = av3->ac_len2 = sizeof(*av3);
	memcpy(av3->ac_comm, av1.ac_comm, AC_COMM_LEN);
	av3->ac_utime = decode_comp(av1.ac_utime) * 1000000;
	av3->ac_stime = decode_comp(av1.ac_stime) * 1000000;
	av3->ac_etime = decode_comp(av1.ac_etime) * 1000000;
	av3->ac_btime = av1.ac_btime;
	av3->ac_uid = av1.ac_uid;
	av3->ac_gid = av1.ac_gid;
	av3->ac_mem = av1.ac_mem;
	av3->ac_io = decode_comp(av1.ac_io);
	av3->ac_tty = av1.ac_tty;
	av3->ac_flagx = av1.ac_flag | ANVER;
	return (0);
}


 * Return EOF on error or end-of-file.
 */
static int
readrec_v2(FILE *f, struct acctv3 *av3)
{
	struct acctv2 av2;
	int rv;

	if ((rv = fread_record(&av2, sizeof(av2), f)) == EOF)
		return (EOF);
	av3->ac_zero = 0;
	av3->ac_version = 3;
	av3->ac_len = av3->ac_len2 = sizeof(*av3);
	memcpy(av3->ac_comm, av2.ac_comm, AC_COMM_LEN);
	av3->ac_utime = av2.ac_utime;
	av3->ac_stime = av2.ac_stime;
	av3->ac_etime = av2.ac_etime;
	av3->ac_btime = av2.ac_btime;
	av3->ac_uid = av2.ac_uid;
	av3->ac_gid = av2.ac_gid;
	av3->ac_mem = av2.ac_mem;
	av3->ac_io = av2.ac_io;
	av3->ac_tty = av2.ac_tty;
	av3->ac_flagx = av2.ac_flagx;
	return (0);
}

/*
 * Read an v2 accounting record stored at the current
 * position of stream f.
 * Return EOF on error or end-of-file.
 */
static int
readrec_v3(FILE *f, struct acctv3 *av3)
{

	return (fread_record(av3, sizeof(*av3), f));
}

/*

 * Return EOF on error or end-of-file.
 */
static int
readrec_vx(FILE *f, struct acctv3 *av3)
{
	uint8_t magic, version;


		return (EOF);
	switch (version) {
	case 2:
		return (readrec_v2(f, av3));
	case 3:
		return (readrec_v3(f, av3));

	/* Add handling for more versions here. */


 * or EOF on error.
 */
int
readrec_forward(FILE *f, struct acctv3 *av3)
{
	int magic, rv;


		return (EOF);
	if (magic != 0)
		/* Old record format. */
		rv = readrec_v1(f, av3);
	else
		/* New record formats. */
		rv = readrec_vx(f, av3);
	return (rv == EOF ? EOF : 1);
}


 * or EOF on error.
 */
int
readrec_backward(FILE *f, struct acctv3 *av3)
{
	off_t pos;
	int c;

		return (EOF);
	if (pos == 0)
		return (0);
	if (fseek(f, -roffsetof(struct acctv3, ac_trailer),
	    SEEK_CUR) == EOF ||
	    (c = getc(f)) == EOF)
		return (EOF);
	if (c & ANVER) {
		/*
		 * New record formats.  For v2 and v3 offset from the
		 * end for ac_len2 should be same.
		 */
		if (fseeko(f, pos - roffsetof(struct acctv2, ac_len2),
		    SEEK_SET) == EOF ||
		    fread_record(&len, sizeof(len), f) == EOF ||
		    fseeko(f, pos - len, SEEK_SET) == EOF ||
		    readrec_vx(f, av3) == EOF ||
		    fseeko(f, pos - len, SEEK_SET) == EOF)
			return (EOF);
		else

	} else {
		/* Old record format. */
		if (fseeko(f, pos - sizeof(struct acctv1), SEEK_SET) == EOF ||
		    readrec_v1(f, av3) == EOF ||
		    fseeko(f, pos - sizeof(struct acctv1), SEEK_SET) == EOF)
			return (EOF);
		else

Lines 255-261 ttymode_kvm(void) Link Here

(-)b/usr.sbin/pstat/pstat.c (-1 / +1 lines)
255	/* xt.xt_pgid = ... */	255	/* xt.xt_pgid = ... */
256	/* xt.xt_sid = ... */	256	/* xt.xt_sid = ... */
257	xt.xt_flags = tty.t_flags;	257	xt.xt_flags = tty.t_flags;
258	xt.xt_dev = NODEV;	258	xt.xt_dev = (uint32_t)NODEV;
259	ttyprt(&xt);	259	ttyprt(&xt);
260	tp = TAILQ_NEXT(&tty, t_list);	260	tp = TAILQ_NEXT(&tty, t_list);
261	}	261	}

Lines 79-85 int pacct_update(void); Link Here

(-)b/usr.sbin/sa/extern.h (-1 / +1 lines)
79	void pacct_print(void);	79	void pacct_print(void);
80		80
81	/* external functions in readrec.c */	81	/* external functions in readrec.c */
82	int readrec_forward(FILE f, struct acctv2 av2);	82	int readrec_forward(FILE f, struct acctv3 av2);
83		83
84	/* external functions in usrdb.c */	84	/* external functions in usrdb.c */
85	int usracct_init(void);	85	int usracct_init(void);

Lines 310-316 usage(void) Link Here

(-)b/usr.sbin/sa/main.c (-1 / +1 lines)
310	static FILE *	310	static FILE *
311	acct_load(const char *pn, int wr)	311	acct_load(const char *pn, int wr)
312	{	312	{
313	struct acctv2 ac;	313	struct acctv3 ac;
314	struct cmdinfo ci;	314	struct cmdinfo ci;
315	ssize_t rv;	315	ssize_t rv;
316	FILE *f;	316	FILE *f;

Return to bug 218320

Lines 1337-1348 procstat_get_vnode_info_sysctl(struct filestat fst, struct vnstat vn, Link Here

(-)b/lib/libprocstat/libprocstat.c (-5 / +7 lines)
1337	struct statfs stbuf;	1337	struct statfs stbuf;
1338	struct kinfo_file *kif;	1338	struct kinfo_file *kif;
1339	struct kinfo_vmentry *kve;	1339	struct kinfo_vmentry *kve;
		1340	char name, path;
1340	uint64_t fileid;	1341	uint64_t fileid;
1341	uint64_t size;	1342	uint64_t size;
1342	char name, path;	1343	uint64_t fsid;
1343	uint32_t fsid;	1344	uint64_t rdev;
1344	uint16_t mode;	1345	uint16_t mode;
1345	uint32_t rdev;
1346	int vntype;	1346	int vntype;
1347	int status;	1347	int status;
1348		1348
Lines 1545-1552 procstat_get_socket_info_sysctl(struct filestat fst, struct sockstat sock, Link Here
1545	sock->dom_family = kif->kf_sock_domain;	1545	sock->dom_family = kif->kf_sock_domain;
1546	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;	1546	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
1547	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));	1547	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
1548	bcopy(&kif->kf_sa_local, &sock->sa_local, kif->kf_sa_local.ss_len);	1548	bcopy(&kif->kf_un.kf_sock.kf_sa_local, &sock->sa_local,
1549	bcopy(&kif->kf_sa_peer, &sock->sa_peer, kif->kf_sa_peer.ss_len);	1549	kif->kf_un.kf_sock.kf_sa_local.ss_len);
		1550	bcopy(&kif->kf_un.kf_sock.kf_sa_peer, &sock->sa_peer,
		1551	kif->kf_un.kf_sock.kf_sa_peer.ss_len);
1550		1552
1551	/*	1553	/*
1552	* Protocol specific data.	1554	* Protocol specific data.

Lines 1347-1354 ino_adjust(struct suj_ino *sino) Link Here

(-)b/sbin/fsck_ffs/suj.c (-4 / +4 lines)
1347	struct suj_ino *stmp;	1347	struct suj_ino *stmp;
1348	union dinode *ip;	1348	union dinode *ip;
1349	nlink_t nlink;	1349	nlink_t nlink;
		1350	nlink_t reqlink;
1350	int recmode;	1351	int recmode;
1351	int reqlink;
1352	int isdot;	1352	int isdot;
1353	int mode;	1353	int mode;
1354	ino_t ino;	1354	ino_t ino;
Lines 1635-1643 ino_check(struct suj_ino *sino) Link Here
1635	struct suj_rec *srec;	1635	struct suj_rec *srec;
1636	struct jrefrec *rrec;	1636	struct jrefrec *rrec;
1637	nlink_t dotlinks;	1637	nlink_t dotlinks;
1638	int newlinks;	1638	nlink_t newlinks;
1639	int removes;	1639	nlink_t removes;
1640	int nlink;	1640	nlink_t nlink;
1641	ino_t ino;	1641	ino_t ino;
1642	int isdot;	1642	int isdot;
1643	int isat;	1643	int isat;

Added Link Here

(-)b/abi.sh (+50 lines)
1	#!/bin/sh
2
3	set -e
4	PATH=$HOME/bin:$PATH
5
6	PRISTINE_BASE=/scratch/tmp/kib/obj/scratch/tmp/kib/ino64_master/
7	CHANGED_BASE=/scratch/tmp/kib/obj/scratch/tmp/kib/ino64/
8	objs=$(find $CHANGED_BASE \! -regex '.test.' \! -regex '.private.' \
9	-type f -name '.so..full' \| sed 's@^'${CHANGED_BASE}'@@' )
10
11	exclude_list="libhx509.so.11 libgssapi_ntlm.so.10"
12	subs_list="libarchive.so.6@libarchive.so.7 libmilter.so.5@libmilter.so.6 libzfs.so.2@libzfs.so.3"
13
14	mkdir -p tmp
15	rm -rf compat_reports tmp/*
16	troubles=
17	for obj in $objs; do
18	# -public-headers ${PRISTINE_BASE}/tmp/usr/include
19	if echo $obj \| grep world32 ; then
20	suffix=-32
21	else
22	suffix=""
23	fi
24	libname1=$(basename ${obj} \| sed 's/\.full//')
25	libname=${libname1}${suffix}
26	for x in $exclude_list; do
27	if [ ${x}${suffix} \= $libname ] ; then
28	continue 2
29	fi
30	done
31	changed_obj=${CHANGED_BASE}/${obj}
32	pristine_obj=$(echo ${changed_obj} \| sed s/ino64/ino64_master/g)
33	for x in ${subs_list} ; do
34	name1=$(echo ${x} \| sed 's/@.*$//')
35	name2=$(echo ${x} \| sed 's/^.*@//')
36	if [ ${name2} \= ${libname1} ]
37	$pristine_obj=$(echo ${pristine_obj} \| sed s/${name2}/${name1}/)
38	fi
39	abi-dumper.pl ${pristine_obj} \
40	-lver pristine -o tmp/${libname}-pristine.dump
41	abi-dumper.pl ${changed_obj} \
42	-lver ino64 -o tmp/${libname}-ino64.dump
43	if abi-compliance-checker.pl -l ${libname} \
44	-old tmp/${libname}-pristine.dump \
45	-new tmp/${libname}-ino64.dump ; then : ; else
46	troubles="${troubles} ${libname}"
47	fi
48	done
49
50	echo "Troublesome libraries: " ${troubles}

Lines 264-275 audit_set_terminal_host(uint32_t *m) Link Here

(-)b/contrib/openbsm/libbsm/bsm_wrappers.c (-1 / +3 lines)
264	int	264	int
265	audit_set_terminal_id(au_tid_t *tid)	265	audit_set_terminal_id(au_tid_t *tid)
266	{	266	{
		267	dev_t port;
267	int ret;	268	int ret;
268		269
269	if (tid == NULL)	270	if (tid == NULL)
270	return (kAUBadParamErr);	271	return (kAUBadParamErr);
271	if ((ret = audit_set_terminal_port(&tid->port)) != kAUNoErr)	272	if ((ret = audit_set_terminal_port(&port)) != kAUNoErr)
272	return (ret);	273	return (ret);
		274	tid->port = port;
273	return (audit_set_terminal_host(&tid->machine));	275	return (audit_set_terminal_host(&tid->machine));
274	}	276	}
275		277

Lines 41-46 Link Here

(-)b/include/dirent.h (-2 / +17 lines)
41	#include <sys/_types.h>	41	#include <sys/_types.h>
42	#include <sys/dirent.h>	42	#include <sys/dirent.h>
43		43
		44	#ifndef _SIZE_T_DECLARED
		45	typedef __size_t size_t;
		46	#define _SIZE_T_DECLARED
		47	#endif
		48
		49	#ifndef _SSIZE_T_DECLARED
		50	typedef __ssize_t ssize_t;
		51	#define _SSIZE_T_DECLARED
		52	#endif
		53
		54	#ifndef _OFF_T_DECLARED
		55	typedef __off_t off_t;
		56	#define _OFF_T_DECLARED
		57	#endif
		58
44	#if __XSI_VISIBLE	59	#if __XSI_VISIBLE
45		60
46	#ifndef _INO_T_DECLARED	61	#ifndef _INO_T_DECLARED
Lines 89-96 int dirfd(DIR *); Link Here
89	#if __BSD_VISIBLE	104	#if __BSD_VISIBLE
90	DIR __opendir2(const char , int);	105	DIR __opendir2(const char , int);
91	int fdclosedir(DIR *);	106	int fdclosedir(DIR *);
92	int getdents(int, char *, int);	107	ssize_t getdents(int, char *, size_t);
93	int getdirentries(int, char , int, long );	108	ssize_t getdirentries(int, char , size_t, off_t );
94	#endif	109	#endif
95	DIR opendir(const char );	110	DIR opendir(const char );
96	DIR *fdopendir(int);	111	DIR *fdopendir(int);

Lines 75-82 FBSD_1.0 { Link Here

(-)b/lib/libc/gen/Symbol.map (-20 / +20 lines)
75	ctermid;	75	ctermid;
76	ctermid_r;	76	ctermid_r;
77	daemon;	77	daemon;
78	devname;
79	devname_r;
80	getdiskbyname;	78	getdiskbyname;
81	dladdr;	79	dladdr;
82	dlclose;	80	dlclose;
Lines 128-136 FBSD_1.0 { Link Here
128	setfsent;	126	setfsent;
129	endfsent;	127	endfsent;
130	ftok;	128	ftok;
131	ftw;
132	glob;
133	globfree;
134	getbootfile;	129	getbootfile;
135	getbsize;	130	getbsize;
136	cgetset;	131	cgetset;
Lines 163-169 FBSD_1.0 { Link Here
163	getloadavg;	158	getloadavg;
164	getlogin;	159	getlogin;
165	getlogin_r;	160	getlogin_r;
166	getmntinfo;
167	setnetgrent;	161	setnetgrent;
168	getnetgrent;	162	getnetgrent;
169	endnetgrent;	163	endnetgrent;
Lines 209-215 FBSD_1.0 { Link Here
209	lrand48;	203	lrand48;
210	modf;	204	modf;
211	mrand48;	205	mrand48;
212	nftw;
213	nice;	206	nice;
214	nlist;	207	nlist;
215	nrand48;	208	nrand48;
Lines 220-232 FBSD_1.0 { Link Here
220	pclose;	213	pclose;
221	psignal;	214	psignal;
222	raise;	215	raise;
223	readdir;
224	readdir_r;
225	readpassphrase;	216	readpassphrase;
226	getpass;	217	getpass;
227	rewinddir;	218	rewinddir;
228	scandir;
229	alphasort;
230	seed48;	219	seed48;
231	seekdir;	220	seekdir;
232	user_from_uid;	221	user_from_uid;
Lines 314-327 FBSD_1.1 { Link Here
314	fdevname_r;	303	fdevname_r;
315	fdopendir;	304	fdopendir;
316	feature_present;	305	feature_present;
317	fts_children;
318	fts_close;
319	fts_get_clientptr;
320	fts_get_stream;
321	fts_open;
322	fts_read;
323	fts_set;
324	fts_set_clientptr;
325	posix_spawn;	306	posix_spawn;
326	posix_spawn_file_actions_addclose;	307	posix_spawn_file_actions_addclose;
327	posix_spawn_file_actions_adddup2;	308	posix_spawn_file_actions_adddup2;
Lines 408-420 FBSD_1.4 { Link Here
408	pthread_mutex_consistent;	389	pthread_mutex_consistent;
409	pthread_mutexattr_getrobust;	390	pthread_mutexattr_getrobust;
410	pthread_mutexattr_setrobust;	391	pthread_mutexattr_setrobust;
411	scandir_b;
412	stravis;	392	stravis;
413	};	393	};
414		394
415	FBSD_1.5 {	395	FBSD_1.5 {
		396	alphasort;
416	basename;	397	basename;
		398	devname;
		399	devname_r;
417	dirname;	400	dirname;
		401	fts_children;
		402	fts_close;
		403	fts_get_clientptr;
		404	fts_get_stream;
		405	fts_open;
		406	fts_read;
		407	fts_set;
		408	fts_set_clientptr;
		409	ftw;
		410	getmntinfo;
		411	glob;
		412	globfree;
		413	nftw;
		414	readdir;
		415	readdir_r;
		416	scandir;
		417	scandir_b;
418	sem_clockwait_np;	418	sem_clockwait_np;
419	};	419	};
420		420

Added Link Here

(-)b/lib/libc/gen/devname-compat11.c (+50 lines)
1	/*-
2	* Copyright (c) 2011 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include <sys/types.h>
31	#include <sys/stat.h>
32	#include <stdlib.h>
33	#include "gen-compat.h"
34
35	char *
36	freebsd11_devname(uint32_t dev, mode_t type)
37	{
38
39	return (devname(dev, type));
40	}
41
42	char *
43	freebsd11_devname_r(uint32_t dev, mode_t type, char *buf, int len)
44	{
45
46	return (devname_r(dev, type, buf, len));
47	}
48
49	__sym_compat(devname, freebsd11_devname, FBSD_1.0);
50	__sym_compat(devname_r, freebsd11_devname_r, FBSD_1.0);

Lines 40-54 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/fts-compat.c (-14 / +19 lines)
40		40
41	#include "namespace.h"	41	#include "namespace.h"
42	#include <sys/param.h>	42	#include <sys/param.h>
		43	#define _WANT_FREEBSD11_STATFS
43	#include <sys/mount.h>	44	#include <sys/mount.h>
		45	#define _WANT_FREEBSD11_STAT
44	#include <sys/stat.h>	46	#include <sys/stat.h>
45		47
		48	#define _WANT_FREEBSD11_DIRENT
46	#include <dirent.h>	49	#include <dirent.h>
47	#include <errno.h>	50	#include <errno.h>
48	#include <fcntl.h>	51	#include <fcntl.h>
49	#include <stdlib.h>	52	#include <stdlib.h>
50	#include <string.h>	53	#include <string.h>
51	#include <unistd.h>	54	#include <unistd.h>
		55	#include "gen-compat.h"
52	#include "fts-compat.h"	56	#include "fts-compat.h"
53	#include "un-namespace.h"	57	#include "un-namespace.h"
54		58
Lines 96-103 static int fts_ufslinks(FTS , const FTSENT ); Link Here
96	*/	100	*/
97	struct _fts_private {	101	struct _fts_private {
98	FTS ftsp_fts;	102	FTS ftsp_fts;
99	struct statfs ftsp_statfs;	103	struct freebsd11_statfs ftsp_statfs;
100	dev_t ftsp_dev;	104	uint32_t ftsp_dev;
101	int ftsp_linksreliable;	105	int ftsp_linksreliable;
102	};	106	};
103		107
Lines 626-632 __fts_set_clientptr_44bsd(FTS sp, void clientptr) Link Here
626	static FTSENT *	630	static FTSENT *
627	fts_build(FTS *sp, int type)	631	fts_build(FTS *sp, int type)
628	{	632	{
629	struct dirent *dp;	633	struct freebsd11_dirent *dp;
630	FTSENT p, head;	634	FTSENT p, head;
631	int nitems;	635	int nitems;
632	FTSENT cur, tail;	636	FTSENT cur, tail;
Lines 738-744 fts_build(FTS *sp, int type) Link Here
738		742
739	/* Read the directory, attaching each entry to the `link' pointer. */	743	/* Read the directory, attaching each entry to the `link' pointer. */
740	doadjust = 0;	744	doadjust = 0;
741	for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {	745	for (head = tail = NULL, nitems = 0;
		746	dirp && (dp = freebsd11_readdir(dirp));) {
742	dnamlen = dp->d_namlen;	747	dnamlen = dp->d_namlen;
743	if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))	748	if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
744	continue;	749	continue;
Lines 891-899 static u_short Link Here
891	fts_stat(FTS sp, FTSENT p, int follow)	896	fts_stat(FTS sp, FTSENT p, int follow)
892	{	897	{
893	FTSENT *t;	898	FTSENT *t;
894	dev_t dev;	899	uint32_t dev;
895	ino_t ino;	900	uint32_t ino;
896	struct stat *sbp, sb;	901	struct freebsd11_stat *sbp, sb;
897	int saved_errno;	902	int saved_errno;
898		903
899	/* If user needs stat info, stat buffer already allocated. */	904	/* If user needs stat info, stat buffer already allocated. */
Lines 916-931 fts_stat(FTS sp, FTSENT p, int follow) Link Here
916	* fail, set the errno from the stat call.	921	* fail, set the errno from the stat call.
917	*/	922	*/
918	if (ISSET(FTS_LOGICAL) \|\| follow) {	923	if (ISSET(FTS_LOGICAL) \|\| follow) {
919	if (stat(p->fts_accpath, sbp)) {	924	if (freebsd11_stat(p->fts_accpath, sbp)) {
920	saved_errno = errno;	925	saved_errno = errno;
921	if (!lstat(p->fts_accpath, sbp)) {	926	if (!freebsd11_lstat(p->fts_accpath, sbp)) {
922	errno = 0;	927	errno = 0;
923	return (FTS_SLNONE);	928	return (FTS_SLNONE);
924	}	929	}
925	p->fts_errno = saved_errno;	930	p->fts_errno = saved_errno;
926	goto err;	931	goto err;
927	}	932	}
928	} else if (lstat(p->fts_accpath, sbp)) {	933	} else if (freebsd11_lstat(p->fts_accpath, sbp)) {
929	p->fts_errno = errno;	934	p->fts_errno = errno;
930	err: memset(sbp, 0, sizeof(struct stat));	935	err: memset(sbp, 0, sizeof(struct stat));
931	return (FTS_NS);	936	return (FTS_NS);
Lines 1019-1025 fts_alloc(FTS sp, char name, int namelen) Link Here
1019		1024
1020	struct ftsent_withstat {	1025	struct ftsent_withstat {
1021	FTSENT ent;	1026	FTSENT ent;
1022	struct stat statbuf;	1027	struct freebsd11_stat statbuf;
1023	};	1028	};
1024		1029
1025	/*	1030	/*
Lines 1145-1158 static int Link Here
1145	fts_safe_changedir(FTS sp, FTSENT p, int fd, char *path)	1150	fts_safe_changedir(FTS sp, FTSENT p, int fd, char *path)
1146	{	1151	{
1147	int ret, oerrno, newfd;	1152	int ret, oerrno, newfd;
1148	struct stat sb;	1153	struct freebsd11_stat sb;
1149		1154
1150	newfd = fd;	1155	newfd = fd;
1151	if (ISSET(FTS_NOCHDIR))	1156	if (ISSET(FTS_NOCHDIR))
1152	return (0);	1157	return (0);
1153	if (fd < 0 && (newfd = _open(path, O_RDONLY \| O_CLOEXEC, 0)) < 0)	1158	if (fd < 0 && (newfd = _open(path, O_RDONLY \| O_CLOEXEC, 0)) < 0)
1154	return (-1);	1159	return (-1);
1155	if (_fstat(newfd, &sb)) {	1160	if (freebsd11_fstat(newfd, &sb)) {
1156	ret = -1;	1161	ret = -1;
1157	goto bail;	1162	goto bail;
1158	}	1163	}
Lines 1187-1193 fts_ufslinks(FTS sp, const FTSENT ent) Link Here
1187	* avoidance.	1192	* avoidance.
1188	*/	1193	*/
1189	if (priv->ftsp_dev != ent->fts_dev) {	1194	if (priv->ftsp_dev != ent->fts_dev) {
1190	if (statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {	1195	if (freebsd11_statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
1191	priv->ftsp_dev = ent->fts_dev;	1196	priv->ftsp_dev = ent->fts_dev;
1192	priv->ftsp_linksreliable = 0;	1197	priv->ftsp_linksreliable = 0;
1193	for (cpp = ufslike_filesystems; *cpp; cpp++) {	1198	for (cpp = ufslike_filesystems; *cpp; cpp++) {

Lines 37-43 typedef struct { Link Here

(-)b/lib/libc/gen/fts-compat.h (-5 / +5 lines)
37	struct _ftsent fts_cur; / current node */	37	struct _ftsent fts_cur; / current node */
38	struct _ftsent fts_child; / linked list of children */	38	struct _ftsent fts_child; / linked list of children */
39	struct _ftsent *fts_array; / sort array */	39	struct _ftsent *fts_array; / sort array */
40	dev_t fts_dev; /* starting device # */	40	uint32_t fts_dev; /* starting device # */
41	char fts_path; / path for this descent */	41	char fts_path; / path for this descent */
42	int fts_rfd; /* fd for root */	42	int fts_rfd; /* fd for root */
43	int fts_pathlen; /* sizeof(path) */	43	int fts_pathlen; /* sizeof(path) */
Lines 82-90 typedef struct _ftsent { Link Here
82	u_short fts_pathlen; /* strlen(fts_path) */	82	u_short fts_pathlen; /* strlen(fts_path) */
83	u_short fts_namelen; /* strlen(fts_name) */	83	u_short fts_namelen; /* strlen(fts_name) */
84		84
85	ino_t fts_ino; /* inode */	85	uint32_t fts_ino; /* inode */
86	dev_t fts_dev; /* device */	86	uint32_t fts_dev; /* device */
87	nlink_t fts_nlink; /* link count */	87	uint16_t fts_nlink; /* link count */
88		88
89	#define FTS_ROOTPARENTLEVEL -1	89	#define FTS_ROOTPARENTLEVEL -1
90	#define FTS_ROOTLEVEL 0	90	#define FTS_ROOTLEVEL 0
Lines 117-123 typedef struct _ftsent { Link Here
117	#define FTS_SKIP 4 /* discard node */	117	#define FTS_SKIP 4 /* discard node */
118	u_short fts_instr; /* fts_set() instructions */	118	u_short fts_instr; /* fts_set() instructions */
119		119
120	struct stat fts_statp; / stat(2) information */	120	struct freebsd11_stat fts_statp; / stat(2) information */
121	char fts_name; / file name */	121	char fts_name; / file name */
122	FTS fts_fts; / back pointer to main FTS */	122	FTS fts_fts; / back pointer to main FTS */
123	} FTSENT;	123	} FTSENT;

Added Link Here

(-)b/lib/libc/gen/fts-compat11.h (+95 lines)
1	/*
2	* Copyright (c) 1989, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* @(#)fts.h 8.3 (Berkeley) 8/14/94
30	* $FreeBSD$
31	*/
32
33	#ifndef _FTS_COPMAT11_H_
34	#define _FTS_COPMAT11_H_
35
36	typedef struct {
37	struct _ftsent11 fts_cur; / current node */
38	struct _ftsent11 fts_child; / linked list of children */
39	struct _ftsent11 *fts_array; / sort array */
40	uint32_t fts_dev; /* starting device # */
41	char fts_path; / path for this descent */
42	int fts_rfd; /* fd for root */
43	__size_t fts_pathlen; /* sizeof(path) */
44	__size_t fts_nitems; /* elements in the sort array */
45	int (fts_compar) / compare function */
46	(const struct _ftsent11 * const *,
47	const struct _ftsent11 * const *);
48	int fts_options; /* fts_open options, global flags */
49	void fts_clientptr; / thunk for sort function */
50	} FTS11;
51
52	typedef struct _ftsent11 {
53	struct _ftsent11 fts_cycle; / cycle node */
54	struct _ftsent11 fts_parent; / parent directory */
55	struct _ftsent11 fts_link; / next file in directory */
56	long long fts_number; /* local numeric value */
57	void fts_pointer; / local address value */
58	char fts_accpath; / access path */
59	char fts_path; / root path */
60	int fts_errno; /* errno for this node */
61	int fts_symfd; /* fd for symlink */
62	__size_t fts_pathlen; /* strlen(fts_path) */
63	__size_t fts_namelen; /* strlen(fts_name) */
64
65	uint32_t fts_ino; /* inode */
66	uint32_t fts_dev; /* device */
67	uint16_t fts_nlink; /* link count */
68
69	long fts_level; /* depth (-1 to N) */
70
71	int fts_info; /* user status for FTSENT structure */
72
73	unsigned fts_flags; /* private flags for FTSENT structure */
74
75	int fts_instr; /* fts_set() instructions */
76
77	struct freebsd11_stat fts_statp; / stat(2) information */
78	char fts_name; / file name */
79	FTS11 fts_fts; / back pointer to main FTS */
80	} FTSENT11;
81
82	FTSENT11 freebsd11_fts_children(FTS11 , int);
83	int freebsd11_fts_close(FTS11 *);
84	void freebsd11_fts_get_clientptr(FTS11 );
85	#define freebsd11_fts_get_clientptr(fts) ((fts)->fts_clientptr)
86	FTS11 freebsd11_fts_get_stream(FTSENT11 );
87	#define freebsd11_fts_get_stream(ftsent) ((ftsent)->fts_fts)
88	FTS11 freebsd11_fts_open(char const *, int,
89	int ()(const FTSENT11 const *,
90	const FTSENT11 * const *));
91	FTSENT11 freebsd11_fts_read(FTS11 );
92	int freebsd11_fts_set(FTS11 , FTSENT11 , int);
93	void freebsd11_fts_set_clientptr(FTS11 , void );
94
95	#endif /* !_FTS_COMPAT11_H_ */

Added Link Here

(-)b/lib/libc/gen/ftw-compat11.c (+98 lines)
1	/* $OpenBSD: ftw.c,v 1.5 2005/08/08 08:05:34 espie Exp $ */
2
3	/*
4	* Copyright (c) 2003, 2004 Todd C. Miller <Todd.Miller@courtesan.com>
5	*
6	* Permission to use, copy, modify, and distribute this software for any
7	* purpose with or without fee is hereby granted, provided that the above
8	* copyright notice and this permission notice appear in all copies.
9	*
10	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17	*
18	* Sponsored in part by the Defense Advanced Research Projects
19	* Agency (DARPA) and Air Force Research Laboratory, Air Force
20	* Materiel Command, USAF, under agreement number F39502-99-1-0512.
21	*
22	* from: $FreeBSD$
23	*/
24
25	#include <sys/cdefs.h>
26	__FBSDID("$FreeBSD$");
27
28	#include <sys/types.h>
29	#include <sys/stat.h>
30	#include <errno.h>
31	#include <fts.h>
32	#include <ftw.h>
33
34	#include "fts-compat11.h"
35
36	int
37	freebsd11_ftw(const char *path,
38	int (fn)(const char , const struct freebsd11_stat *, int), int nfds)
39	{
40	char * const paths[2] = { (char *)path, NULL };
41	FTSENT11 *cur;
42	FTS11 *ftsp;
43	int error = 0, fnflag, sverrno;
44
45	/* XXX - nfds is currently unused */
46	if (nfds < 1) {
47	errno = EINVAL;
48	return (-1);
49	}
50
51	ftsp = freebsd11_fts_open(paths,
52	FTS_LOGICAL \| FTS_COMFOLLOW \| FTS_NOCHDIR, NULL);
53	if (ftsp == NULL)
54	return (-1);
55	while ((cur = freebsd11_fts_read(ftsp)) != NULL) {
56	switch (cur->fts_info) {
57	case FTS_D:
58	fnflag = FTW_D;
59	break;
60	case FTS_DNR:
61	fnflag = FTW_DNR;
62	break;
63	case FTS_DP:
64	/* we only visit in preorder */
65	continue;
66	case FTS_F:
67	case FTS_DEFAULT:
68	fnflag = FTW_F;
69	break;
70	case FTS_NS:
71	case FTS_NSOK:
72	case FTS_SLNONE:
73	fnflag = FTW_NS;
74	break;
75	case FTS_SL:
76	fnflag = FTW_SL;
77	break;
78	case FTS_DC:
79	errno = ELOOP;
80	/* FALLTHROUGH */
81	default:
82	error = -1;
83	goto done;
84	}
85	error = fn(cur->fts_path, cur->fts_statp, fnflag);
86	if (error != 0)
87	break;
88	}
89	done:
90	sverrno = errno;
91	if (freebsd11_fts_close(ftsp) != 0 && error == 0)
92	error = -1;
93	else
94	errno = sverrno;
95	return (error);
96	}
97
98	__sym_compat(ftw, freebsd11_ftw, FBSD_1.0);

Added Link Here

(-)b/lib/libc/gen/gen-compat.h (+57 lines)
1	/*-
2	* Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*
26	* $FreeBSD$
27	*/
28
29	#ifndef _GEN_COMPAT_H_
30	#define _GEN_COMPAT_H_
31
32	#include <dirent.h>
33
34	#define FREEBSD11_DIRSIZ(dp) \
35	(sizeof(struct freebsd11_dirent) - sizeof((dp)->d_name) + \
36	(((dp)->d_namlen + 1 + 3) &~ 3))
37
38	struct freebsd11_dirent;
39	struct freebsd11_stat;
40	struct freebsd11_statfs;
41
42	struct freebsd11_dirent freebsd11_readdir(DIR );
43	int freebsd11_readdir_r(DIR , struct freebsd11_dirent ,
44	struct freebsd11_dirent **);
45	int freebsd11_stat(const char , struct freebsd11_stat );
46	int freebsd11_lstat(const char , struct freebsd11_stat );
47	int freebsd11_fstat(int, struct freebsd11_stat *);
48	int freebsd11_fstatat(int, const char , struct freebsd11_stat , int);
49
50	int freebsd11_statfs(const char , struct freebsd11_statfs );
51	int freebsd11_getfsstat(struct freebsd11_statfs *, long, int);
52	int freebsd11_getmntinfo(struct freebsd11_statfs **, int);
53
54	char *freebsd11_devname(__uint32_t dev, __mode_t type);
55	char freebsd11_devname_r(__uint32_t dev, __mode_t type, char buf, int len);
56
57	#endif /* _GEN_COMPAT_H_ */

Added Link Here

(-)b/lib/libc/gen/getmntinfo-compat11.c (+72 lines)
1	/*
2	* Copyright (c) 1989, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*/
29
30	#if defined(LIBC_SCCS) && !defined(lint)
31	static char sccsid[] = "@(#)getmntinfo.c 8.1 (Berkeley) 6/4/93";
32	#endif /* LIBC_SCCS and not lint */
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/param.h>
37	#include <sys/ucred.h>
38	#define _WANT_FREEBSD11_STATFS
39	#include <sys/mount.h>
40	#include <stdlib.h>
41	#include "gen-compat.h"
42
43	/*
44	* Return information about mounted filesystems.
45	*/
46	int
47	freebsd11_getmntinfo(struct freebsd11_statfs **mntbufp, int flags)
48	{
49	static struct freebsd11_statfs *mntbuf;
50	static int mntsize;
51	static long bufsize;
52
53	if (mntsize <= 0 &&
54	(mntsize = freebsd11_getfsstat(0, 0, MNT_NOWAIT)) < 0)
55	return (0);
56	if (bufsize > 0 &&
57	(mntsize = freebsd11_getfsstat(mntbuf, bufsize, flags)) < 0)
58	return (0);
59	while (bufsize <= mntsize * sizeof(struct freebsd11_statfs)) {
60	if (mntbuf)
61	free(mntbuf);
62	bufsize = (mntsize + 1) * sizeof(struct freebsd11_statfs);
63	if ((mntbuf = (struct freebsd11_statfs *)malloc(bufsize)) == 0)
64	return (0);
65	if ((mntsize = freebsd11_getfsstat(mntbuf, bufsize, flags)) < 0)
66	return (0);
67	}
68	*mntbufp = mntbuf;
69	return (mntsize);
70	}
71
72	__sym_compat(getmntinfo, freebsd11_getmntinfo, FBSD_1.0);

Added Link Here

(-)b/lib/libc/gen/glob-compat11.h (+72 lines)
1	/*
2	* Copyright (c) 1989, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* This code is derived from software contributed to Berkeley by
6	* Guido van Rossum.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.
13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.
16	* 3. Neither the name of the University nor the names of its contributors
17	* may be used to endorse or promote products derived from this software
18	* without specific prior written permission.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30	* SUCH DAMAGE.
31	*
32	* @(#)glob.h 8.1 (Berkeley) 6/2/93
33	* from: $FreeBSD$
34	* $FreeBSD$
35	*/
36
37	#ifndef _GLOB_COMPAT11_H_
38	#define _GLOB_COMPAT11_H_
39
40	#include <sys/cdefs.h>
41	#include <sys/types.h>
42	#include <glob.h>
43
44	struct freebsd11_stat;
45	typedef struct {
46	size_t gl_pathc; /* Count of total paths so far. */
47	size_t gl_matchc; /* Count of paths matching pattern. */
48	size_t gl_offs; /* Reserved at beginning of gl_pathv. */
49	int gl_flags; /* Copy of flags parameter to glob. */
50	char *gl_pathv; / List of paths matching pattern. */
51	/* Copy of errfunc parameter to glob. */
52	int (gl_errfunc)(const char , int);
53
54	/*
55	* Alternate filesystem access methods for glob; replacement
56	* versions of closedir(3), readdir(3), opendir(3), stat(2)
57	* and lstat(2).
58	*/
59	void (gl_closedir)(void );
60	struct freebsd11_dirent (gl_readdir)(void *);
61	void (gl_opendir)(const char *);
62	int (gl_lstat)(const char , struct freebsd11_stat *);
63	int (gl_stat)(const char , struct freebsd11_stat *);
64	} glob11_t;
65
66	__BEGIN_DECLS
67	int freebsd11_glob(const char * __restrict, int,
68	int ()(const char , int), glob11_t * __restrict);
69	void freebsd11_globfree(glob11_t *);
70	__END_DECLS
71
72	#endif /* !_GLOB_COMPAT11_H_ */

Added Link Here

(-)b/lib/libc/gen/nftw-compat11.c (+115 lines)
1	/*
2	* Copyright (c) 2003, 2004 Todd C. Miller <Todd.Miller@courtesan.com>
3	*
4	* Permission to use, copy, modify, and distribute this software for any
5	* purpose with or without fee is hereby granted, provided that the above
6	* copyright notice and this permission notice appear in all copies.
7	*
8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15	*
16	* Sponsored in part by the Defense Advanced Research Projects
17	* Agency (DARPA) and Air Force Research Laboratory, Air Force
18	* Materiel Command, USAF, under agreement number F39502-99-1-0512.
19	*
20	* from: $OpenBSD: nftw.c,v 1.7 2006/03/31 19:41:44 millert Exp $
21	* from: $FreeBSD$
22	*/
23
24	#include <sys/cdefs.h>
25	__FBSDID("$FreeBSD$");
26
27	#include <sys/types.h>
28	#include <sys/stat.h>
29	#include <errno.h>
30	#include <fts.h>
31	#include <ftw.h>
32
33	#include "fts-compat11.h"
34
35	int
36	freebsd11_nftw(const char *path,
37	int (fn)(const char , const struct freebsd11_stat , int, struct FTW ),
38	int nfds, int ftwflags)
39	{
40	char * const paths[2] = { (char *)path, NULL };
41	struct FTW ftw;
42	FTSENT11 *cur;
43	FTS11 *ftsp;
44	int error = 0, ftsflags, fnflag, postorder, sverrno;
45
46	/* XXX - nfds is currently unused */
47	if (nfds < 1) {
48	errno = EINVAL;
49	return (-1);
50	}
51
52	ftsflags = FTS_COMFOLLOW;
53	if (!(ftwflags & FTW_CHDIR))
54	ftsflags \|= FTS_NOCHDIR;
55	if (ftwflags & FTW_MOUNT)
56	ftsflags \|= FTS_XDEV;
57	if (ftwflags & FTW_PHYS)
58	ftsflags \|= FTS_PHYSICAL;
59	else
60	ftsflags \|= FTS_LOGICAL;
61	postorder = (ftwflags & FTW_DEPTH) != 0;
62	ftsp = freebsd11_fts_open(paths, ftsflags, NULL);
63	if (ftsp == NULL)
64	return (-1);
65	while ((cur = freebsd11_fts_read(ftsp)) != NULL) {
66	switch (cur->fts_info) {
67	case FTS_D:
68	if (postorder)
69	continue;
70	fnflag = FTW_D;
71	break;
72	case FTS_DC:
73	continue;
74	case FTS_DNR:
75	fnflag = FTW_DNR;
76	break;
77	case FTS_DP:
78	if (!postorder)
79	continue;
80	fnflag = FTW_DP;
81	break;
82	case FTS_F:
83	case FTS_DEFAULT:
84	fnflag = FTW_F;
85	break;
86	case FTS_NS:
87	case FTS_NSOK:
88	fnflag = FTW_NS;
89	break;
90	case FTS_SL:
91	fnflag = FTW_SL;
92	break;
93	case FTS_SLNONE:
94	fnflag = FTW_SLN;
95	break;
96	default:
97	error = -1;
98	goto done;
99	}
100	ftw.base = cur->fts_pathlen - cur->fts_namelen;
101	ftw.level = cur->fts_level;
102	error = fn(cur->fts_path, cur->fts_statp, fnflag, &ftw);
103	if (error != 0)
104	break;
105	}
106	done:
107	sverrno = errno;
108	if (freebsd11_fts_close(ftsp) != 0 && error == 0)
109	error = -1;
110	else
111	errno = sverrno;
112	return (error);
113	}
114
115	__sym_compat(nftw, freebsd11_nftw, FBSD_1.0);

Added Link Here

(-)b/lib/libc/gen/readdir-compat11.c (+121 lines)
1	/*
2	* Copyright (c) 1983, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* from:
30	* $FreeBSD$
31	*/
32
33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)readdir.c 8.3 (Berkeley) 9/29/94";
35	#endif /* LIBC_SCCS and not lint */
36	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");
38
39	#include "namespace.h"
40	#include <sys/param.h>
41	#define _WANT_FREEBSD11_DIRENT
42	#include <dirent.h>
43	#include <errno.h>
44	#include <stddef.h>
45	#include <stdlib.h>
46	#include <string.h>
47	#include <pthread.h>
48	#include "un-namespace.h"
49
50	#include "libc_private.h"
51	#include "gen-private.h"
52	#include "telldir.h"
53
54	#include "gen-compat.h"
55
56	static int
57	freebsd11_cvtdirent(struct freebsd11_dirent dstdp, struct dirent srcdp)
58	{
59
60	if (srcdp->d_namlen > sizeof(dstdp->d_name) - 1)
61	return (ENAMETOOLONG);
62	dstdp->d_type = srcdp->d_type;
63	dstdp->d_namlen = srcdp->d_namlen;
64	dstdp->d_fileno = srcdp->d_fileno; /* truncate */
65	dstdp->d_reclen = FREEBSD11_DIRSIZ(dstdp);
66	bcopy(srcdp->d_name, dstdp->d_name, dstdp->d_namlen);
67	bzero(dstdp->d_name + dstdp->d_namlen,
68	dstdp->d_reclen - offsetof(struct freebsd11_dirent, d_name) -
69	dstdp->d_namlen);
70	return (0);
71	}
72
73	struct freebsd11_dirent *
74	freebsd11_readdir(DIR *dirp)
75	{
76	static struct freebsd11_dirent *compatbuf;
77	struct freebsd11_dirent *dstdp;
78	struct dirent *dp;
79
80	if (__isthreaded)
81	_pthread_mutex_lock(&dirp->dd_lock);
82	again:
83	dp = _readdir_unlocked(dirp, 1);
84	if (dp != NULL) {
85	if (compatbuf == NULL)
86	compatbuf = malloc(sizeof(struct freebsd11_dirent));
87	if (freebsd11_cvtdirent(compatbuf, dp) != 0)
88	goto again;
89	dstdp = compatbuf;
90	} else
91	dstdp = NULL;
92	if (__isthreaded)
93	_pthread_mutex_unlock(&dirp->dd_lock);
94
95	return (dstdp);
96	}
97
98	int
99	freebsd11_readdir_r(DIR dirp, struct freebsd11_dirent entry,
100	struct freebsd11_dirent **result)
101	{
102	struct dirent xentry;
103	struct dirent *xresult;
104	int error;
105
106	again:
107	error = readdir_r(dirp, &xentry, &xresult);
108
109	if (error != 0)
110	return (error);
111	if (xresult != NULL) {
112	if (freebsd11_cvtdirent(entry, &xentry) != 0)
113	goto again;
114	*result = entry;
115	} else
116	*result = NULL;
117	return (0);
118	}
119
120	__sym_compat(readdir, freebsd11_readdir, FBSD_1.0);
121	__sym_compat(readdir_r, freebsd11_readdir_r, FBSD_1.0);

Added Link Here

(-)b/lib/libc/gen/scandir-compat11.c (+175 lines)
1	/*
2	* Copyright (c) 1983, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* from:
30	* $FreeBSD$
31	*/
32
33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)scandir.c 8.3 (Berkeley) 1/2/94";
35	#endif /* LIBC_SCCS and not lint */
36	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");
38
39	/*
40	* Scan the directory dirname calling select to make a list of selected
41	* directory entries then sort using qsort and compare routine dcomp.
42	* Returns the number of entries and a pointer to a list of pointers to
43	* struct dirent (through namelist). Returns -1 if there were any errors.
44	*/
45
46	#include "namespace.h"
47	#define _WANT_FREEBSD11_DIRENT
48	#include <dirent.h>
49	#include <stdlib.h>
50	#include <string.h>
51	#include "un-namespace.h"
52
53	#include "gen-compat.h"
54
55	#ifdef I_AM_SCANDIR_B
56	#include "block_abi.h"
57	#define SELECT(x) CALL_BLOCK(select, x)
58	#ifndef __BLOCKS__
59	void
60	qsort_b(void , size_t, size_t, void);
61	#endif
62	#else
63	#define SELECT(x) select(x)
64	#endif
65
66	static int freebsd11_alphasort_thunk(void thunk, const void p1,
67	const void *p2);
68
69	int
70	#ifdef I_AM_SCANDIR_B
71	freebsd11_scandir_b(const char dirname, struct freebsd11_dirent **namelist,
72	DECLARE_BLOCK(int, select, const struct freebsd11_dirent *),
73	DECLARE_BLOCK(int, dcomp, const struct freebsd11_dirent **,
74	const struct freebsd11_dirent **))
75	#else
76	freebsd11_scandir(const char dirname, struct freebsd11_dirent **namelist,
77	int (select)(const struct freebsd11_dirent ),
78	int (dcomp)(const struct freebsd11_dirent *,
79	const struct freebsd11_dirent **))
80	#endif
81	{
82	struct freebsd11_dirent d, p, **names = NULL;
83	size_t numitems;
84	long arraysz;
85	DIR *dirp;
86
87	if ((dirp = opendir(dirname)) == NULL)
88	return(-1);
89
90	numitems = 0;
91	arraysz = 32; /* initial estimate of the array size */
92	names = (struct freebsd11_dirent **)malloc(
93	arraysz * sizeof(struct freebsd11_dirent *));
94	if (names == NULL)
95	goto fail;
96
97	while ((d = freebsd11_readdir(dirp)) != NULL) {
98	if (select != NULL && !SELECT(d))
99	continue; /* just selected names */
100	/*
101	* Make a minimum size copy of the data
102	*/
103	p = (struct freebsd11_dirent *)malloc(FREEBSD11_DIRSIZ(d));
104	if (p == NULL)
105	goto fail;
106	p->d_fileno = d->d_fileno;
107	p->d_type = d->d_type;
108	p->d_reclen = d->d_reclen;
109	p->d_namlen = d->d_namlen;
110	bcopy(d->d_name, p->d_name, p->d_namlen + 1);
111	/*
112	* Check to make sure the array has space left and
113	* realloc the maximum size.
114	*/
115	if (numitems >= arraysz) {
116	struct freebsd11_dirent **names2;
117
118	names2 = reallocarray(names, arraysz,
119	2 * sizeof(struct freebsd11_dirent *));
120	if (names2 == NULL) {
121	free(p);
122	goto fail;
123	}
124	names = names2;
125	arraysz *= 2;
126	}
127	names[numitems++] = p;
128	}
129	closedir(dirp);
130	if (numitems && dcomp != NULL)
131	#ifdef I_AM_SCANDIR_B
132	qsort_b(names, numitems, sizeof(struct freebsd11_dirent *),
133	(void*)dcomp);
134	#else
135	qsort_r(names, numitems, sizeof(struct freebsd11_dirent *),
136	&dcomp, freebsd11_alphasort_thunk);
137	#endif
138	*namelist = names;
139	return (numitems);
140
141	fail:
142	while (numitems > 0)
143	free(names[--numitems]);
144	free(names);
145	closedir(dirp);
146	return (-1);
147	}
148
149	/*
150	* Alphabetic order comparison routine for those who want it.
151	* POSIX 2008 requires that alphasort() uses strcoll().
152	*/
153	int
154	freebsd11_alphasort(const struct freebsd11_dirent **d1,
155	const struct freebsd11_dirent **d2)
156	{
157
158	return (strcoll((d1)->d_name, (d2)->d_name));
159	}
160
161	static int
162	freebsd11_alphasort_thunk(void thunk, const void p1, const void *p2)
163	{
164	int (dc)(const struct freebsd11_dirent *, const struct
165	freebsd11_dirent **);
166
167	dc = (int ()(const struct freebsd11_dirent *,
168	const struct freebsd11_dirent **))thunk;
169	return (dc((const struct freebsd11_dirent **)p1,
170	(const struct freebsd11_dirent **)p2));
171	}
172
173	__sym_compat(alphasort, freebsd11_alphasort, FBSD_1.0);
174	__sym_compat(scandir, freebsd11_scandir, FBSD_1.0);
175	__sym_compat(scandir_b, freebsd11_scandir_b, FBSD_1.4);

Lines 59-75 qsort_b(void , size_t, size_t, void); Link Here

(-)b/lib/libc/gen/scandir.c (-12 / +1 lines)
59		59
60	static int alphasort_thunk(void thunk, const void p1, const void *p2);	60	static int alphasort_thunk(void thunk, const void p1, const void *p2);
61		61
62	/*
63	* The DIRSIZ macro is the minimum record length which will hold the directory
64	* entry. This requires the amount of space in struct dirent without the
65	* d_name field, plus enough space for the name and a terminating nul byte
66	* (dp->d_namlen + 1), rounded up to a 4 byte boundary.
67	*/
68	#undef DIRSIZ
69	#define DIRSIZ(dp) \
70	((sizeof(struct dirent) - sizeof(dp)->d_name) + \
71	(((dp)->d_namlen + 1 + 3) &~ 3))
72
73	int	62	int
74	#ifdef I_AM_SCANDIR_B	63	#ifdef I_AM_SCANDIR_B
75	scandir_b(const char dirname, struct dirent **namelist,	64	scandir_b(const char dirname, struct dirent **namelist,
Lines 101-107 scandir(const char dirname, struct dirent **namelist, Link Here
101	/*	90	/*
102	* Make a minimum size copy of the data	91	* Make a minimum size copy of the data
103	*/	92	*/
104	p = (struct dirent *)malloc(DIRSIZ(d));	93	p = (struct dirent *)malloc(_GENERIC_DIRSIZ(d));
105	if (p == NULL)	94	if (p == NULL)
106	goto fail;	95	goto fail;
107	p->d_fileno = d->d_fileno;	96	p->d_fileno = d->d_fileno;

Lines 44-49 __sym_compat(msgctl, freebsd7_msgctl, FBSD_1.0); Link Here

(-)b/lib/libc/include/compat.h (+21 lines)
44	__sym_compat(shmctl, freebsd7_shmctl, FBSD_1.0);	44	__sym_compat(shmctl, freebsd7_shmctl, FBSD_1.0);
45	#endif	45	#endif
46		46
		47	__sym_compat(nfstat, freebsd11_nfstat, FBSD_1.0);
		48	__sym_compat(nlstat, freebsd11_nlstat, FBSD_1.0);
		49	__sym_compat(nstat, freebsd11_nstat, FBSD_1.0);
		50
		51	__sym_compat(fhstat, freebsd11_fhstat, FBSD_1.0);
		52	__sym_compat(fstat, freebsd11_fstat, FBSD_1.0);
		53	__sym_compat(fstatat, freebsd11_fstatat, FBSD_1.1);
		54	__sym_compat(lstat, freebsd11_lstat, FBSD_1.0);
		55	__sym_compat(stat, freebsd11_stat, FBSD_1.0);
		56
		57	__sym_compat(getdents, freebsd11_getdents, FBSD_1.0);
		58	__sym_compat(getdirentries, freebsd11_getdirentries, FBSD_1.0);
		59
		60	__sym_compat(getfsstat, freebsd11_getfsstat, FBSD_1.0);
		61	__sym_compat(fhstatfs, freebsd11_fhstatfs, FBSD_1.0);
		62	__sym_compat(fstatfs, freebsd11_fstatfs, FBSD_1.0);
		63	__sym_compat(statfs, freebsd11_statfs, FBSD_1.0);
		64
		65	__sym_compat(mknod, freebsd11_mknod, FBSD_1.0);
		66	__sym_compat(mknodat, freebsd11_mknodat, FBSD_1.1);
		67
47	#undef __sym_compat	68	#undef __sym_compat
48		69
49	#define __weak_reference(sym,alias) \	70	#define __weak_reference(sym,alias) \

Lines 307-312 struct pollfd; Link Here

(-)b/lib/libc/include/libc_private.h (+3 lines)
307	struct rusage;	307	struct rusage;
308	struct sigaction;	308	struct sigaction;
309	struct sockaddr;	309	struct sockaddr;
		310	struct stat;
310	struct timespec;	311	struct timespec;
311	struct timeval;	312	struct timeval;
312	struct timezone;	313	struct timezone;
Lines 323-330 int __sys_clock_nanosleep(__clockid_t, int, Link Here
323	const struct timespec , struct timespec );	324	const struct timespec , struct timespec );
324	int __sys_close(int);	325	int __sys_close(int);
325	int __sys_connect(int, const struct sockaddr *, __socklen_t);	326	int __sys_connect(int, const struct sockaddr *, __socklen_t);
		327	__ssize_t __sys_getdirentries(int, char , __size_t, __off_t );
326	int __sys_fcntl(int, int, ...);	328	int __sys_fcntl(int, int, ...);
327	int __sys_fdatasync(int);	329	int __sys_fdatasync(int);
		330	int __sys_fstatat(int, const char , struct stat , int);
328	int __sys_fsync(int);	331	int __sys_fsync(int);
329	__pid_t __sys_fork(void);	332	__pid_t __sys_fork(void);
330	int __sys_ftruncate(int, __off_t);	333	int __sys_ftruncate(int, __off_t);

Lines 85-110 FBSD_1.0 { Link Here

(-)b/lib/libc/sys/Symbol.map (-28 / +13 lines)
85	fchown;	85	fchown;
86	fcntl;	86	fcntl;
87	fhopen;	87	fhopen;
88	fhstat;
89	fhstatfs;
90	flock;	88	flock;
91	fork;	89	fork;
92	fpathconf;	90	fpathconf;
93	fstat;
94	fstatfs;
95	fsync;	91	fsync;
96	futimes;	92	futimes;
97	getaudit;	93	getaudit;
98	getaudit_addr;	94	getaudit_addr;
99	getauid;	95	getauid;
100	getcontext;	96	getcontext;
101	getdents;
102	getdirentries;
103	getdtablesize;	97	getdtablesize;
104	getegid;	98	getegid;
105	geteuid;	99	geteuid;
106	getfh;	100	getfh;
107	getfsstat;
108	getgid;	101	getgid;
109	getgroups;	102	getgroups;
110	getitimer;	103	getitimer;
Lines 163-169 FBSD_1.0 { Link Here
163	link;	156	link;
164	lio_listio;	157	lio_listio;
165	listen;	158	listen;
166	lstat;
167	lutimes;	159	lutimes;
168	mac_syscall;	160	mac_syscall;
169	madvise;	161	madvise;
Lines 171-177 FBSD_1.0 { Link Here
171	minherit;	163	minherit;
172	mkdir;	164	mkdir;
173	mkfifo;	165	mkfifo;
174	mknod;
175	mlock;	166	mlock;
176	mlockall;	167	mlockall;
177	modfind;	168	modfind;
Lines 192-201 FBSD_1.0 { Link Here
192	netbsd_lchown;	183	netbsd_lchown;
193	netbsd_msync;	184	netbsd_msync;
194	nfssvc;	185	nfssvc;
195	nfstat;
196	nlstat;
197	nmount;	186	nmount;
198	nstat;
199	ntp_adjtime;	187	ntp_adjtime;
200	ntp_gettime;	188	ntp_gettime;
201	open;	189	open;
Lines 275-282 FBSD_1.0 { Link Here
275	sigwaitinfo;	263	sigwaitinfo;
276	socket;	264	socket;
277	socketpair;	265	socketpair;
278	stat;
279	statfs;
280	swapoff;	266	swapoff;
281	swapon;	267	swapon;
282	symlink;	268	symlink;
Lines 330-336 FBSD_1.1 { Link Here
330	fchmodat;	316	fchmodat;
331	fchownat;	317	fchownat;
332	fexecve;	318	fexecve;
333	fstatat;
334	futimesat;	319	futimesat;
335	jail_get;	320	jail_get;
336	jail_set;	321	jail_set;
Lines 339-345 FBSD_1.1 { Link Here
339	lpathconf;	324	lpathconf;
340	mkdirat;	325	mkdirat;
341	mkfifoat;	326	mkfifoat;
342	mknodat;
343	msgctl;	327	msgctl;
344	readlinkat;	328	readlinkat;
345	renameat;	329	renameat;
Lines 401-406 FBSD_1.4 { Link Here
401	FBSD_1.5 {	385	FBSD_1.5 {
402	clock_nanosleep;	386	clock_nanosleep;
403	fdatasync;	387	fdatasync;
		388	fhstat;
		389	fhstatfs;
		390	fstat;
		391	fstatat;
		392	fstatfs;
		393	getdents;
		394	getdirentries;
		395	getfsstat;
		396	lstat;
		397	mknod;
		398	mknodat;
		399	stat;
		400	statfs;
404	};	401	};
405		402
406	FBSDprivate_1.0 {	403	FBSDprivate_1.0 {
Lines 606-613 FBSDprivate_1.0 { Link Here
606	__sys_getauid;	603	__sys_getauid;
607	_getcontext;	604	_getcontext;
608	__sys_getcontext;	605	__sys_getcontext;
609	_getdents;
610	__sys_getdents;
611	_getdirentries;	606	_getdirentries;
612	__sys_getdirentries;	607	__sys_getdirentries;
613	_getdtablesize;	608	_getdtablesize;
Lines 736-743 FBSDprivate_1.0 { Link Here
736	__sys_lio_listio;	731	__sys_lio_listio;
737	_listen;	732	_listen;
738	__sys_listen;	733	__sys_listen;
739	_lstat;
740	__sys_lstat;
741	_lutimes;	734	_lutimes;
742	__sys_lutimes;	735	__sys_lutimes;
743	_mac_syscall;	736	_mac_syscall;
Lines 796-809 FBSDprivate_1.0 { Link Here
796	__sys_netbsd_msync;	789	__sys_netbsd_msync;
797	_nfssvc;	790	_nfssvc;
798	__sys_nfssvc;	791	__sys_nfssvc;
799	_nfstat;
800	__sys_nfstat;
801	_nlstat;
802	__sys_nlstat;
803	_nmount;	792	_nmount;
804	__sys_nmount;	793	__sys_nmount;
805	_nstat;
806	__sys_nstat;
807	_ntp_adjtime;	794	_ntp_adjtime;
808	__sys_ntp_adjtime;	795	__sys_ntp_adjtime;
809	_ntp_gettime;	796	_ntp_gettime;
Lines 971-978 FBSDprivate_1.0 { Link Here
971	__sys_socket;	958	__sys_socket;
972	_socketpair;	959	_socketpair;
973	__sys_socketpair;	960	__sys_socketpair;
974	_stat;
975	__sys_stat;
976	_statfs;	961	_statfs;
977	__sys_statfs;	962	__sys_statfs;
978	_swapcontext;	963	_swapcontext;

Added Link Here

(-)b/lib/libc/sys/getdents.c (+41 lines)
1	/*-
2	* Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include "namespace.h"
31	#include <sys/param.h>
32	#include <sys/syscall.h>
33	#include <dirent.h>
34	#include "libc_private.h"
35
36	ssize_t
37	getdents(int fd, char *buf, size_t nbytes)
38	{
39
40	return (__sys_getdirentries(fd, buf, nbytes, NULL));
41	}

Added Link Here

(-)b/lib/libc/sys/lstat.c (+43 lines)
1	/*-
2	* Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include "namespace.h"
31	#include <sys/param.h>
32	#include <sys/fcntl.h>
33	#include <sys/syscall.h>
34	#include <sys/stat.h>
35	#include <unistd.h>
36	#include "libc_private.h"
37
38	int
39	lstat(const char path, struct stat sb)
40	{
41
42	return (__sys_fstatat(AT_FDCWD, path, sb, AT_SYMLINK_NOFOLLOW));
43	}

Added Link Here

(-)b/lib/libc/sys/mknod.c (+45 lines)
1	/*-
2	* Copyright (c) 2011 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include "namespace.h"
31	#include <sys/param.h>
32	#include <sys/fcntl.h>
33	#include <sys/syscall.h>
34	#include <sys/stat.h>
35	#include <unistd.h>
36	#include "libc_private.h"
37
38	int __sys_mknodat(int, const char *, mode_t, dev_t);
39
40	int
41	mknod(const char *path, mode_t mode, dev_t dev)
42	{
43
44	return (__sys_mknodat(AT_FDCWD, path, mode, dev));
45	}

Added Link Here

(-)b/lib/libc/sys/stat.c (+43 lines)
1	/*-
2	* Copyright (c) 2012 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include "namespace.h"
31	#include <sys/param.h>
32	#include <sys/fcntl.h>
33	#include <sys/syscall.h>
34	#include <sys/stat.h>
35	#include <unistd.h>
36	#include "libc_private.h"
37
38	int
39	stat(const char path, struct stat sb)
40	{
41
42	return (__sys_fstatat(AT_FDCWD, path, sb, 0));
43	}

Lines 6-14 FBSD_1.2 { Link Here

(-)b/lib/libprocstat/Symbol.map (-4 / +4 lines)
6	procstat_freefiles;	6	procstat_freefiles;
7	procstat_freeprocs;	7	procstat_freeprocs;
8	procstat_get_pipe_info;	8	procstat_get_pipe_info;
9	procstat_get_pts_info;
10	procstat_get_socket_info;	9	procstat_get_socket_info;
11	procstat_get_vnode_info;
12	procstat_getfiles;	10	procstat_getfiles;
13	procstat_getprocs;	11	procstat_getprocs;
14	procstat_open_kvm;	12	procstat_open_kvm;
Lines 22-29 FBSD_1.3 { Link Here
22	procstat_freegroups;	20	procstat_freegroups;
23	procstat_freekstack;	21	procstat_freekstack;
24	procstat_freevmmap;	22	procstat_freevmmap;
25	procstat_get_sem_info;
26	procstat_get_shm_info;
27	procstat_getargv;	23	procstat_getargv;
28	procstat_getauxv;	24	procstat_getauxv;
29	procstat_getenvv;	25	procstat_getenvv;
Lines 40-43 FBSD_1.3 { Link Here
40	FBSD_1.5 {	36	FBSD_1.5 {
41	procstat_freeptlwpinfo;	37	procstat_freeptlwpinfo;
42	procstat_getptlwpinfo;	38	procstat_getptlwpinfo;
		39	procstat_get_pts_info;
		40	procstat_get_sem_info;
		41	procstat_get_shm_info;
		42	procstat_get_vnode_info;
43	};	43	};

Lines 120-134 struct filestat { Link Here

(-)b/lib/libprocstat/libprocstat.h (-3 / +3 lines)
120	struct vnstat {	120	struct vnstat {
121	uint64_t vn_fileid;	121	uint64_t vn_fileid;
122	uint64_t vn_size;	122	uint64_t vn_size;
		123	uint64_t vn_dev;
		124	uint64_t vn_fsid;
123	char *vn_mntdir;	125	char *vn_mntdir;
124	uint32_t vn_dev;
125	uint32_t vn_fsid;
126	int vn_type;	126	int vn_type;
127	uint16_t vn_mode;	127	uint16_t vn_mode;
128	char vn_devname[SPECNAMELEN + 1];	128	char vn_devname[SPECNAMELEN + 1];
129	};	129	};
130	struct ptsstat {	130	struct ptsstat {
131	uint32_t dev;	131	uint64_t dev;
132	char devname[SPECNAMELEN + 1];	132	char devname[SPECNAMELEN + 1];
133	};	133	};
134	struct pipestat {	134	struct pipestat {

Added Link Here

(-)b/lib/libprocstat/libprocstat_compat.c (+144 lines)
1	/*-
2	* Copyright (c) 2014 Gleb Kurtsou <gleb@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*
26	* $FreeBSD$
27	*/
28
29	#include <sys/cdefs.h>
30	__FBSDID("$FreeBSD$");
31
32	#include <sys/param.h>
33	#include <sys/user.h>
34	#include <sys/socket.h>
35	#include <string.h>
36
37	#include "libprocstat.h"
38
39	struct freebsd11_ptsstat {
40	uint32_t dev;
41	char devname[SPECNAMELEN + 1];
42	};
43
44	struct freebsd11_vnstat {
45	uint64_t vn_fileid;
46	uint64_t vn_size;
47	char *vn_mntdir;
48	uint32_t vn_dev;
49	uint32_t vn_fsid;
50	int vn_type;
51	uint16_t vn_mode;
52	char vn_devname[SPECNAMELEN + 1];
53	};
54	struct freebsd11_semstat {
55	uint32_t value;
56	uint16_t mode;
57	};
58	struct freebsd11_shmstat {
59	uint64_t size;
60	uint16_t mode;
61	};
62
63	int freebsd11_procstat_get_pts_info(struct procstat *procstat,
64	struct filestat fst, struct freebsd11_ptsstat pts, char *errbuf);
65	int freebsd11_procstat_get_sem_info(struct procstat *procstat,
66	struct filestat fst, struct freebsd11_semstat sem, char *errbuf);
67	int freebsd11_procstat_get_shm_info(struct procstat *procstat,
68	struct filestat fst, struct freebsd11_shmstat shm, char *errbuf);
69	int freebsd11_procstat_get_vnode_info(struct procstat *procstat,
70	struct filestat fst, struct freebsd11_vnstat vn, char *errbuf);
71
72	int
73	freebsd11_procstat_get_pts_info(struct procstat *procstat,
74	struct filestat fst, struct freebsd11_ptsstat pts_compat, char *errbuf)
75	{
76	struct ptsstat pts;
77	int r;
78
79	r = procstat_get_pts_info(procstat, fst, &pts, errbuf);
80	if (r != 0)
81	return (r);
82	pts_compat->dev = pts.dev;
83	memcpy(pts_compat->devname, pts.devname,
84	sizeof(pts_compat->devname));
85	return (0);
86	}
87
88	int
89	freebsd11_procstat_get_sem_info(struct procstat *procstat,
90	struct filestat fst, struct freebsd11_semstat sem_compat, char *errbuf)
91	{
92	struct semstat sem;
93	int r;
94
95	r = procstat_get_sem_info(procstat, fst, &sem, errbuf);
96	if (r != 0)
97	return (r);
98	sem_compat->value = sem.value;
99	sem_compat->mode = sem.mode;
100	return (0);
101	}
102
103	int
104	freebsd11_procstat_get_shm_info(struct procstat *procstat,
105	struct filestat fst, struct freebsd11_shmstat shm_compat, char *errbuf)
106	{
107	struct shmstat shm;
108	int r;
109
110	r = procstat_get_shm_info(procstat, fst, &shm, errbuf);
111	if (r != 0)
112	return (r);
113	shm_compat->size = shm.size;
114	shm_compat->mode = shm.mode;
115	return (0);
116	}
117
118	int
119	freebsd11_procstat_get_vnode_info(struct procstat *procstat,
120	struct filestat fst, struct freebsd11_vnstat vn_compat, char *errbuf)
121	{
122	struct vnstat vn;
123	int r;
124
125	r = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
126	if (r != 0)
127	return (r);
128	vn_compat->vn_fileid = vn.vn_fileid;
129	vn_compat->vn_size = vn.vn_size;
130	vn_compat->vn_mntdir = vn.vn_mntdir;
131	vn_compat->vn_dev = vn.vn_dev;
132	vn_compat->vn_fsid = vn.vn_fsid;
133	vn_compat->vn_type = vn.vn_type;
134	vn_compat->vn_mode = vn.vn_mode;
135	memcpy(vn_compat->vn_devname, vn.vn_devname,
136	sizeof(vn_compat->vn_devname));
137	return (0);
138	}
139
140	__sym_compat(procstat_get_pts_info, freebsd11_procstat_get_pts_info, FBSD_1.2);
141	__sym_compat(procstat_get_vnode_info, freebsd11_procstat_get_vnode_info,
142	FBSD_1.2);
143	__sym_compat(procstat_get_sem_info, freebsd11_procstat_get_sem_info, FBSD_1.3);
144	__sym_compat(procstat_get_shm_info, freebsd11_procstat_get_shm_info, FBSD_1.3);

Added Link Here

(-)b/preapply.sh (+69 lines)
1	Index: devel/llvm39/Makefile
2	===================================================================
3	--- devel/llvm39/Makefile (revision 437547)
4	+++ devel/llvm39/Makefile (working copy)
5	@@ -326,6 +326,7 @@
6
7	post-patch-COMPILER_RT-on:
8	cd ${WRKSRC_compiler_rt} && patch < ${PATCHDIR}/compiler-rt-patch-svn-294806
9	+ cd ${WRKSRC_compiler_rt} && patch < ${PATCHDIR}/compiler-rt-patch-ino64
10
11	post-build-COMPILER_RT-on:
12	${MKDIR} ${WRKDIR}/compiler-rt-build
13	Index: devel/llvm39/files/compiler-rt-patch-ino64
14	===================================================================
15	--- devel/llvm39/files/compiler-rt-patch-ino64 (nonexistent)
16	+++ devel/llvm39/files/compiler-rt-patch-ino64 (working copy)
17	@@ -0,0 +1,49 @@
18	+diff --git lib/sanitizer_common/sanitizer_linux.cc lib/sanitizer_common/sanitizer_linux.cc
19	+index 7328a5c0ac1..4b59a39ee27 100644
20	+--- lib/sanitizer_common/sanitizer_linux.cc
21	++++ lib/sanitizer_common/sanitizer_linux.cc
22	+@@ -223,7 +223,8 @@ static void kernel_stat_to_stat(struct kernel_stat in, struct stat out) {
23	+
24	+ uptr internal_stat(const char path, void buf) {
25	+ #if SANITIZER_FREEBSD
26	+- return internal_syscall(SYSCALL(stat), path, buf);
Added Link Here
1	#!/bin/sh
2	if [ x"$INO64GIT" = x ]; then
3	echo "set INO64GIT env var to point to the git mirror of ino64"
4	exit 1
5	fi
6	xxx=$(svn st 2>&1)
7	if [ x"$xxx" \!= x ]; then
8	echo "working directory is not clean, check with svn status"
9	exit 1
10	fi
11	set -e
12	svn cp include/fts.h lib/libc/gen/fts-compat11.h
13	rm lib/libc/gen/fts-compat11.h
14	svn cp include/glob.h lib/libc/gen/glob-compat11.h
15	rm lib/libc/gen/glob-compat11.h
16	svn cp lib/libc/gen/fts.c lib/libc/gen/fts-compat11.c
17	rm lib/libc/gen/fts-compat11.c
18	svn cp lib/libc/gen/ftw.c lib/libc/gen/ftw-compat11.c
19	rm lib/libc/gen/ftw-compat11.c
20	svn cp lib/libc/gen/nftw.c lib/libc/gen/nftw-compat11.c
21	rm lib/libc/gen/nftw-compat11.c
22	svn cp lib/libc/gen/glob.c lib/libc/gen/glob-compat11.c
23	rm lib/libc/gen/glob-compat11.c
24	svn cp lib/libc/gen/getmntinfo.c lib/libc/gen/getmntinfo-compat11.c
25	rm lib/libc/gen/getmntinfo-compat11.c
26	svn cp lib/libc/gen/readdir.c lib/libc/gen/readdir-compat11.c
27	rm lib/libc/gen/readdir-compat11.c
28	svn cp lib/libc/gen/scandir.c lib/libc/gen/scandir-compat11.c
29	rm lib/libc/gen/scandir-compat11.c
30	(cd $INO64GIT && git diff origin/master ino64) \| gpatch -p1
31	add_files="lib/libc/sys/getdents.c lib/libc/sys/lstat.c"
32	add_files="$add_files lib/libc/sys/mknod.c lib/libc/sys/stat.c"
33	add_files="$add_files lib/libc/gen/gen-compat.h lib/libc/gen/devname-compat11.c"
34	add_files="$add_files lib/libprocstat/libprocstat_compat.c"
35	svn add $add_files
36	svn propset svn:keywords 'FreeBSD=%H' $add_files
37	rm -f TODO.ino64 preapply.sh abi.sh ports.patch
38	xxx=$(svn st \| awk '$1 ~ /^\?$/ {print $2}')
39	if [ x"$xxx" \!= x ]; then
40	echo "unmanaged files were found after patching, check"
41	exit 1
42	fi
43	echo "Looks good"

Lines 129-147 main(int argc, char *argv[]) Link Here

(-)b/sbin/badsect/badsect.c (-12 / +1 lines)
129	err(8, "%s", *argv);	129	err(8, "%s", *argv);
130	if (chkuse(number, 1))	130	if (chkuse(number, 1))
131	continue;	131	continue;
132	/*
133	* Print a warning if converting the block number to a dev_t
134	* will truncate it. badsect was not very useful in versions
135	* of BSD before 4.4 because dev_t was 16 bits and another
136	* bit was lost by bogus sign extensions.
137	*/
138	diskbn = dbtofsb(fs, number);	132	diskbn = dbtofsb(fs, number);
139	if ((dev_t)diskbn != diskbn) {	133	if (mknod(*argv, IFMT\|0600, (dev_t)diskbn) < 0) {
140	printf("sector %ld cannot be represented as a dev_t\n",
141	(long)number);
142	errs++;
143	}
144	else if (mknod(*argv, IFMT\|0600, (dev_t)diskbn) < 0) {
145	warn("%s", *argv);	134	warn("%s", *argv);
146	errs++;	135	errs++;
147	}	136	}

Lines 28-34 Link Here

(-)b/share/man/man5/acct.5 (-4 / +4 lines)
28	.\" @(#)acct.5 8.1 (Berkeley) 6/5/93	28	.\" @(#)acct.5 8.1 (Berkeley) 6/5/93
29	.\" $FreeBSD$	29	.\" $FreeBSD$
30	.\"	30	.\"
31	.Dd May 15, 2007	31	.Dd February 13, 2017
32	.Dt ACCT 5	32	.Dt ACCT 5
33	.Os	33	.Os
34	.Sh NAME	34	.Sh NAME
Lines 51-62 to the accounting file. Link Here
51	#define AC_COMM_LEN 16	51	#define AC_COMM_LEN 16
52		52
53	/*	53	/*
54	* Accounting structure version 2 (current).	54	* Accounting structure version 3 (current).
55	* The first byte is always zero.	55	* The first byte is always zero.
56	* Time units are microseconds.	56	* Time units are microseconds.
57	*/	57	*/
58		58
59	struct acctv2 {	59	struct acctv3 {
60	uint8_t ac_zero; /* zero identifies new version */	60	uint8_t ac_zero; /* zero identifies new version */
61	uint8_t ac_version; /* record version number */	61	uint8_t ac_version; /* record version number */
62	uint16_t ac_len; /* record length */	62	uint16_t ac_len; /* record length */
Lines 74-80 struct acctv2 { Link Here
74		74
75	uint16_t ac_len2; /* record length */	75	uint16_t ac_len2; /* record length */
76	union {	76	union {
77	__dev_t ac_align; /* force v1 compatible alignment */	77	uint32_t ac_align; /* force v1 compatible alignment */
78		78
79	#define AFORK 0x01 /* forked but not exec'ed */	79	#define AFORK 0x01 /* forked but not exec'ed */
80	/* ASU is no longer supported */	80	/* ASU is no longer supported */

Lines 28-34 Link Here

(-)b/share/man/man5/dir.5 (-10 / +21 lines)
28	.\" @(#)dir.5 8.3 (Berkeley) 4/19/94	28	.\" @(#)dir.5 8.3 (Berkeley) 4/19/94
29	.\" $FreeBSD$	29	.\" $FreeBSD$
30	.\"	30	.\"
31	.Dd April 19, 1994	31	.Dd February 13, 2017
32	.Dt DIR 5	32	.Dt DIR 5
33	.Os	33	.Os
34	.Sh NAME	34	.Sh NAME
Lines 93-110 The directory entry format is defined in the file Link Here
93	* contained in the entry. These are followed by the name padded to a 4	93	* contained in the entry. These are followed by the name padded to a 4
94	* byte boundary with null bytes. All names are guaranteed null terminated.	94	* byte boundary with null bytes. All names are guaranteed null terminated.
95	* The maximum length of a name in a directory is MAXNAMLEN.	95	* The maximum length of a name in a directory is MAXNAMLEN.
		96	* Explicit pad is added between the last member of the header and
		97	* d_name, to avoid having the ABI padding in the end of dirent on
		98	* LP64 arches. There is code depending on d_name being last. Also,
		99	* keeping this pad for ILP32 architectures simplifies compat32 layer.
96	*/	100	*/
97		101
98	struct dirent {	102	struct dirent {
99	__uint32_t d_fileno; /* file number of entry */	103	ino_t d_fileno; /* file number of entry */
		104	off_t d_off; /* directory offset of entry */
100	__uint16_t d_reclen; /* length of this record */	105	__uint16_t d_reclen; /* length of this record */
101	__uint8_t d_type; /* file type, see below */	106	__uint8_t d_type; /* file type, see below */
102	__uint8_t d_namlen; /* length of string in d_name */	107	__uint8_t d_namlen; /* length of string in d_name */
103	#ifdef _POSIX_SOURCE	108	__uint32_t d_pad0;
104	char d_name[255 + 1]; /* name must be no longer than this */	109	#if __BSD_VISIBLE
105	#else
106	#define MAXNAMLEN 255	110	#define MAXNAMLEN 255
107	char d_name[MAXNAMLEN + 1]; /* name must be no longer than this */	111	char d_name[MAXNAMLEN + 1]; /* name must be no longer than this */
		112	#else
		113	char d_name[255 + 1]; /* name must be no longer than this */
108	#endif	114	#endif
109	};	115	};
110		116
Lines 129-140 struct dirent { Link Here
129		135
130	/*	136	/*
131	* The _GENERIC_DIRSIZ macro gives the minimum record length which will hold	137	* The _GENERIC_DIRSIZ macro gives the minimum record length which will hold
132	* the directory entry. This requires the amount of space in struct direct	138	* the directory entry. This returns the amount of space in struct direct
133	* without the d_name field, plus enough space for the name with a terminating	139	* without the d_name field, plus enough space for the name with a terminating
134	* null byte (dp->d_namlen+1), rounded up to a 4 byte boundary.	140	* null byte (dp->d_namlen+1), rounded up to a 8 byte boundary.
		141	*
		142	* XXX although this macro is in the implementation namespace, it requires
		143	* a manifest constant that is not.
135	*/	144	*/
136	#define _GENERIC_DIRSIZ(dp) \	145	#define _GENERIC_DIRLEN(namlen) \
137	((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))	146	((__offsetof(struct dirent, d_name) + (namlen) + 1 + 7) & ~7)
		147	#define _GENERIC_DIRSIZ(dp) _GENERIC_DIRLEN((dp)->d_namlen)
		148	#endif /* __BSD_VISIBLE */
138		149
139	#ifdef _KERNEL	150	#ifdef _KERNEL
140	#define GENERIC_DIRSIZ(dp) _GENERIC_DIRSIZ(dp)	151	#define GENERIC_DIRSIZ(dp) _GENERIC_DIRSIZ(dp)