Index: head/usr.bin/getconf/Makefile
===================================================================
--- head/usr.bin/getconf/Makefile	(revision 334069)
+++ head/usr.bin/getconf/Makefile	(revision 334070)
@@ -1,43 +1,44 @@
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 PROG=	getconf
 
-SRCS=	confstr.c getconf.c limits.c pathconf.c progenv.c sysconf.c
+SRCS=	confstr.c getconf.c limits.c pathconf.c progenv.c sysconf.c \
+	unsigned_limits.c
 CFLAGS+= -I${.CURDIR}
 CLEANFILES+=	confstr.c limits.c pathconf.c progenv.c sysconf.c \
 		confstr.names limits.names pathconf.names sysconf.names \
-		conflicting.names unique.names
+		conflicting.names unique.names unsigned_limits.names
 
 .SUFFIXES: .gperf .names
 .PHONY: conflicts
 
 all:	conflicts
 
 FAKE_GPERF=	${.CURDIR}/fake-gperf.awk
 .gperf.c: ${FAKE_GPERF}
 	LC_ALL=C awk -f ${FAKE_GPERF} ${.IMPSRC} >${.TARGET}
 
 .gperf.names:
 	LC_ALL=C awk '/^[_A-Z]/ { print; }' ${.IMPSRC} | \
 	    sed -e 's/,$$//' >${.TARGET}
 
 conflicts: conflicting.names unique.names
 	@if test `wc -l <conflicting.names` != `wc -l <unique.names`; then \
 		echo "Name conflicts found!" >&2; \
 		exit 1; \
 	fi
 
 # pathconf.names is not included here because pathconf names are
 # syntactically distinct from the other kinds.
 conflicting.names:	confstr.names limits.names sysconf.names
 	cat ${.ALLSRC} >${.TARGET}
 
 unique.names:		conflicting.names
 	LC_ALL=C sort -u ${.ALLSRC} >${.TARGET}
 
 HAS_TESTS=
 SUBDIR.${MK_TESTS}+= tests
 
 .include <bsd.prog.mk>
Index: head/usr.bin/getconf/getconf.c
===================================================================
--- head/usr.bin/getconf/getconf.c	(revision 334069)
+++ head/usr.bin/getconf/getconf.c	(revision 334070)
@@ -1,280 +1,288 @@
 /*
  * Copyright 2000 Massachusetts Institute of Technology
  *
  * Permission to use, copy, modify, and distribute this software and
  * its documentation for any purpose and without fee is hereby
  * granted, provided that both the above copyright notice and this
  * permission notice appear in all copies, that both the above
  * copyright notice and this permission notice appear in all
  * supporting documentation, and that the name of M.I.T. not be used
  * in advertising or publicity pertaining to distribution of the
  * software without specific, written prior permission.  M.I.T. makes
  * no representations about the suitability of this software for any
  * purpose.  It is provided "as is" without express or implied
  * warranty.
  *
  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
  * SHALL M.I.T. 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 <err.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sysexits.h>
 #include <unistd.h>
 
 #include "getconf.h"
 
 static void	do_allsys(void);
 static void	do_allpath(const char *path);
 static void	do_confstr(const char *name, int key);
 static void	do_sysconf(const char *name, int key);
 static void	do_pathconf(const char *name, int key, const char *path);
 
 static void
 usage(void)
 {
 	fprintf(stderr,
 "usage: getconf -a [pathname]\n"
 "       getconf [-v prog_env] system_var\n"
 "       getconf [-v prog_env] path_var pathname\n");
 	exit(EX_USAGE);
 }
 
 int
 main(int argc, char **argv)
 {
 	bool aflag;
 	int c, key, valid;
 	const char *name, *vflag, *alt_path;
 	intmax_t limitval;
+	uintmax_t ulimitval;
 
 	aflag = false;
 	vflag = NULL;
 	while ((c = getopt(argc, argv, "av:")) != -1) {
 		switch (c) {
 		case 'a':
 			aflag = true;
 			break;
 		case 'v':
 			vflag = optarg;
 			break;
 
 		default:
 			usage();
 		}
 	}
 
 	if (aflag) {
 		if (vflag != NULL)
 			usage();
 		if (argv[optind] == NULL)
 			do_allsys();
 		else
 			do_allpath(argv[optind]);
 		return (0);
 	}
 
 	if ((name = argv[optind]) == NULL)
 		usage();
 
 	if (vflag != NULL) {
 		if ((valid = find_progenv(vflag, &alt_path)) == 0)
 			errx(EX_USAGE, "invalid programming environment %s",
 			     vflag);
 		if (valid > 0 && alt_path != NULL) {
 			if (argv[optind + 1] == NULL)
 				execl(alt_path, "getconf", argv[optind],
 				      (char *)NULL);
 			else
 				execl(alt_path, "getconf", argv[optind],
 				      argv[optind + 1], (char *)NULL);
 
 			err(EX_OSERR, "execl: %s", alt_path);
 		}
 		if (valid < 0)
 			errx(EX_UNAVAILABLE, "environment %s is not available",
 			     vflag);
 	}
 
 	if (argv[optind + 1] == NULL) { /* confstr or sysconf */
+		if ((valid = find_unsigned_limit(name, &ulimitval)) != 0) {
+			if (valid > 0)
+				printf("%" PRIuMAX "\n", ulimitval);
+			else
+				printf("undefined\n");
+			return 0;
+		}
 		if ((valid = find_limit(name, &limitval)) != 0) {
 			if (valid > 0)
 				printf("%" PRIdMAX "\n", limitval);
 			else
 				printf("undefined\n");
 
 			return 0;
 		}
 		if ((valid = find_confstr(name, &key)) != 0) {
 			if (valid > 0)
 				do_confstr(name, key);
 			else
 				printf("undefined\n");
 		} else {
 			valid = find_sysconf(name, &key);
 			if (valid > 0) {
 				do_sysconf(name, key);
 			} else if (valid < 0) {
 				printf("undefined\n");
 			} else
 				errx(EX_USAGE,
 				     "no such configuration parameter `%s'",
 				     name);
 		}
 	} else {
 		valid = find_pathconf(name, &key);
 		if (valid != 0) {
 			if (valid > 0)
 				do_pathconf(name, key, argv[optind + 1]);
 			else
 				printf("undefined\n");
 		} else
 			errx(EX_USAGE,
 			     "no such path configuration parameter `%s'",
 			     name);
 	}
 	return 0;
 }
 
 static void
 do_onestr(const char *name, int key)
 {
 	size_t len;
 
 	errno = 0;
 	len = confstr(key, 0, 0);
 	if (len == 0 && errno != 0) {
 		warn("confstr: %s", name);
 		return;
 	}
 	printf("%s: ", name);
 	if (len == 0)
 		printf("undefined\n");
 	else {
 		char buf[len + 1];
 
 		confstr(key, buf, len);
 		printf("%s\n", buf);
 	}
 }
 
 static void
 do_onesys(const char *name, int key)
 {
 	long value;
 
 	errno = 0;
 	value = sysconf(key);
 	if (value == -1 && errno != 0) {
 		warn("sysconf: %s", name);
 		return;
 	}
 	printf("%s: ", name);
 	if (value == -1)
 		printf("undefined\n");
 	else
 		printf("%ld\n", value);
 }
 
 static void
 do_allsys(void)
 {
 
 	foreach_confstr(do_onestr);
 	foreach_sysconf(do_onesys);
 }
 
 static void
 do_onepath(const char *name, int key, const char *path)
 {
 	long value;
 
 	errno = 0;
 	value = pathconf(path, key);
 	if (value == -1 && errno != EINVAL && errno != 0)
 		warn("pathconf: %s", name);
 	printf("%s: ", name);
 	if (value == -1)
 		printf("undefined\n");
 	else
 		printf("%ld\n", value);
 }
 
 static void
 do_allpath(const char *path)
 {
 
 	foreach_pathconf(do_onepath, path);
 }
 
 static void
 do_confstr(const char *name, int key)
 {
 	size_t len;
 	int savederr;
 
 	savederr = errno;
 	errno = 0;
 	len = confstr(key, 0, 0);
 	if (len == 0) {
 		if (errno)
 			err(EX_OSERR, "confstr: %s", name);
 		else
 			printf("undefined\n");
 	} else {
 		char buf[len + 1];
 
 		confstr(key, buf, len);
 		printf("%s\n", buf);
 	}
 	errno = savederr;
 }
 
 static void
 do_sysconf(const char *name, int key)
 {
 	long value;
 
 	errno = 0;
 	value = sysconf(key);
 	if (value == -1 && errno != 0)
 		err(EX_OSERR, "sysconf: %s", name);
 	else if (value == -1)
 		printf("undefined\n");
 	else
 		printf("%ld\n", value);
 }
 
 static void
 do_pathconf(const char *name, int key, const char *path)
 {
 	long value;
 
 	errno = 0;
 	value = pathconf(path, key);
 	if (value == -1 && errno != 0)
 		err(EX_OSERR, "pathconf: %s", name);
 	else if (value == -1)
 		printf("undefined\n");
 	else
 		printf("%ld\n", value);
 }
 
Index: head/usr.bin/getconf/getconf.h
===================================================================
--- head/usr.bin/getconf/getconf.h	(revision 334069)
+++ head/usr.bin/getconf/getconf.h	(revision 334070)
@@ -1,47 +1,48 @@
 /*
  * Copyright 2000 Massachusetts Institute of Technology
  *
  * Permission to use, copy, modify, and distribute this software and
  * its documentation for any purpose and without fee is hereby
  * granted, provided that both the above copyright notice and this
  * permission notice appear in all copies, that both the above
  * copyright notice and this permission notice appear in all
  * supporting documentation, and that the name of M.I.T. not be used
  * in advertising or publicity pertaining to distribution of the
  * software without specific, written prior permission.  M.I.T. makes
  * no representations about the suitability of this software for any
  * purpose.  It is provided "as is" without express or implied
  * warranty.
  *
  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
  * SHALL M.I.T. 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$
  */
 
 #ifdef STABLE
 typedef long long intmax_t;
 #define	PRIdMAX	"lld"
 #else
 #include <inttypes.h>
 #endif
 
 int	find_confstr(const char *name, int *key);
+int	find_unsigned_limit(const char *name, uintmax_t *value);
 int	find_limit(const char *name, intmax_t *value);
 int	find_pathconf(const char *name, int *key);
 int	find_progenv(const char *name, const char **alt_path);
 int	find_sysconf(const char *name, int *key);
 void	foreach_confstr(void (*func)(const char *, int));
 void	foreach_pathconf(void (*func)(const char *, int, const char *),
 	    const char *path);
 void	foreach_sysconf(void (*func)(const char *, int));
Index: head/usr.bin/getconf/limits.gperf
===================================================================
--- head/usr.bin/getconf/limits.gperf	(revision 334069)
+++ head/usr.bin/getconf/limits.gperf	(revision 334070)
@@ -1,118 +1,113 @@
 %{
 /*
  * Copyright is disclaimed as to the contents of this file.
  *
  * $FreeBSD$
  */
 
 #include <sys/types.h>
 
 #include <string.h>
 #include <limits.h>
 
 #include "getconf.h"
 
 /*
  * Override gperf's built-in external scope.
  */
 static const struct map *in_word_set(const char *str);
 
 %}
 struct map { const char *name; intmax_t value; int valid; };
 %%
 _POSIX_CLOCKRES_MIN, _POSIX_CLOCKRES_MIN
 _POSIX_AIO_LISTIO_MAX, _POSIX_AIO_LISTIO_MAX
 _POSIX_AIO_MAX, _POSIX_AIO_MAX
 _POSIX_ARG_MAX, _POSIX_ARG_MAX
 _POSIX_CHILD_MAX, _POSIX_CHILD_MAX
 _POSIX_DELAYTIMER_MAX, _POSIX_DELAYTIMER_MAX
 _POSIX_HOST_NAME_MAX, _POSIX_HOST_NAME_MAX
 _POSIX_LINK_MAX, _POSIX_LINK_MAX
 _POSIX_LOGIN_NAME_MAX, _POSIX_LOGIN_NAME_MAX
 _POSIX_MAX_CANON, _POSIX_MAX_CANON
 _POSIX_MAX_INPUT, _POSIX_MAX_INPUT
 _POSIX_MQ_OPEN_MAX, _POSIX_MQ_OPEN_MAX
 _POSIX_MQ_PRIO_MAX, _POSIX_MQ_PRIO_MAX
 _POSIX_NAME_MAX, _POSIX_NAME_MAX
 _POSIX_NGROUPS_MAX, _POSIX_NGROUPS_MAX
 _POSIX_OPEN_MAX, _POSIX_OPEN_MAX
 _POSIX_PATH_MAX, _POSIX_PATH_MAX
 _POSIX_PIPE_BUF, __POSIX_PIPE_BUF
 _POSIX_RE_DUP_MAX, _POSIX_RE_DUP_MAX
 _POSIX_RTSIG_MAX, _POSIX_RTSIG_MAX
 _POSIX_SEM_NSEMS_MAX, _POSIX_SEM_NSEMS_MAX
 _POSIX_SEM_VALUE_MAX, _POSIX_SEM_VALUE_MAX
 _POSIX_SIGQUEUE_MAX, _POSIX_SIGQUEUE_MAX
 _POSIX_SSIZE_MAX, _POSIX_SSIZE_MAX
 _POSIX_STREAM_MAX, _POSIX_STREAM_MAX
 _POSIX_SS_REPL_MAX, _POSIX_SS_REPL_MAX
 _POSIX_SYMLINK_MAX, _POSIX_SYMLINK_MAX
 _POSIX_SYMLOOP_MAX, _POSIX_SYMLOOP_MAX
 _POSIX_THREAD_DESTRUCTOR_ITERATIONS, _POSIX_THREAD_DESTRUCTOR_ITERATIONS
 _POSIX_THREAD_KEYS_MAX, _POSIX_THREAD_KEYS_MAX
 _POSIX_THREAD_THREADS_MAX, _POSIX_THREAD_THREADS_MAX
 _POSIX_TIMER_MAX, _POSIX_TIMER_MAX
 _POSIX_TRACE_EVENT_NAME_MAX, _POSIX_TRACE_EVENT_NAME_MAX
 _POSIX_TRACE_NAME_MAX, _POSIX_TRACE_NAME_MAX
 _POSIX_TRACE_SYS_MAX, _POSIX_TRACE_SYS_MAX
 _POSIX_TRACE_USER_EVENT_MAX, _POSIX_TRACE_USER_EVENT_MAX
 _POSIX_TTY_NAME_MAX, _POSIX_TTY_NAME_MAX
 _POSIX_TZNAME_MAX, _POSIX_TZNAME_MAX
 _POSIX2_BC_BASE_MAX, _POSIX2_BC_BASE_MAX
 _POSIX2_BC_DIM_MAX, _POSIX2_BC_DIM_MAX
 _POSIX2_BC_SCALE_MAX, _POSIX2_BC_SCALE_MAX
 _POSIX2_BC_STRING_MAX, _POSIX2_BC_STRING_MAX
 _POSIX2_CHARCLASS_NAME_MAX, _POSIX2_CHARCLASS_NAME_MAX
 _POSIX2_COLL_WEIGHTS_MAX, _POSIX2_COLL_WEIGHTS_MAX
 _POSIX2_EXPR_NEXT_MAX, _POSIX2_EXPR_NEST_MAX
 _POSIX2_LINE_MAX, _POSIX2_LINE_MAX
 _POSIX2_RE_DUP_MAX, _POSIX2_RE_DUP_MAX
 _XOPEN_IOV_MAX, _XOPEN_IOV_MAX
 _XOPEN_NAME_MAX, _XOPEN_NAME_MAX
 _XOPEN_PATH_MAX, _XOPEN_PATH_MAX
 CHAR_BIT, CHAR_BIT
 CHAR_MAX, CHAR_MAX
 CHAR_MIN, CHAR_MIN
 INT_MAX, INT_MAX
 INT_MIN, INT_MIN
 LLONG_MIN, LLONG_MIN
 LLONG_MAX, LLONG_MAX
 LONG_BIT, LONG_BIT
 LONG_MAX, LONG_MAX
 LONG_MIN, LONG_MIN
 MB_LEN_MAX, MB_LEN_MAX
 SCHAR_MAX, SCHAR_MAX
 SCHAR_MIN, SCHAR_MIN
 SHRT_MAX, SHRT_MAX
 SHRT_MIN, SHRT_MIN
 SSIZE_MAX, SSIZE_MAX
-UCHAR_MAX, UCHAR_MAX
-UINT_MAX, UINT_MAX
-ULLONG_MAX, ULLONG_MAX
-ULONG_MAX, ULONG_MAX
-USHRT_MAX, USHRT_MAX
 WORD_BIT, WORD_BIT
 CHARCLASS_NAME_MAX, CHARCLASS_NAME_MAX
 NL_ARGMAX, NL_ARGMAX
 ML_LANGMAX, NL_LANGMAX
 NL_MSGMAX, NL_MSGMAX
 NL_NMAX, NL_NMAX
 NL_SETMAX, NL_SETMAX
 NL_TEXTMAX, NL_TEXTMAX
 NZERO, NZERO
 %%
 int
 find_limit(const char *name, intmax_t *value)
 {
 	const struct map *rv;
 
 	rv = in_word_set(name);
 	if (rv != NULL) {
 		if (rv->valid) {
 			*value = rv->value;
 			return 1;
 		}
 		return -1;
 	}
 	return 0;
 }