# Licensed under the GPL v2, see the file LICENSE in this tarball.
lib-y:=
-lib-$(CONFIG_ASH) += ash.o ash_ptr_hack.o shell_common.o builtin_read.o
-lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o builtin_read.o
+lib-$(CONFIG_ASH) += ash.o ash_ptr_hack.o shell_common.o builtin_read.o builtin_ulimit.o
+lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o builtin_read.o builtin_ulimit.o
lib-$(CONFIG_CTTYHACK) += cttyhack.o
lib-$(CONFIG_SH_MATH_SUPPORT) += math.o
#include "shell_common.h"
#include "builtin_read.h"
+#include "builtin_ulimit.h"
#include "math.h"
#if ENABLE_ASH_RANDOM_SUPPORT
# include "random.h"
return 0;
}
-/*
- * ulimit builtin
- *
- * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
- * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
- * ash by J.T. Conklin.
- *
- * Public domain.
- */
-struct limits {
- uint8_t cmd; /* RLIMIT_xxx fit into it */
- uint8_t factor_shift; /* shift by to get rlim_{cur,max} values */
- char option;
-};
-
-static const struct limits limits_tbl[] = {
-#ifdef RLIMIT_CPU
- { RLIMIT_CPU, 0, 't' },
-#endif
-#ifdef RLIMIT_FSIZE
- { RLIMIT_FSIZE, 9, 'f' },
-#endif
-#ifdef RLIMIT_DATA
- { RLIMIT_DATA, 10, 'd' },
-#endif
-#ifdef RLIMIT_STACK
- { RLIMIT_STACK, 10, 's' },
-#endif
-#ifdef RLIMIT_CORE
- { RLIMIT_CORE, 9, 'c' },
-#endif
-#ifdef RLIMIT_RSS
- { RLIMIT_RSS, 10, 'm' },
-#endif
-#ifdef RLIMIT_MEMLOCK
- { RLIMIT_MEMLOCK, 10, 'l' },
-#endif
-#ifdef RLIMIT_NPROC
- { RLIMIT_NPROC, 0, 'p' },
-#endif
-#ifdef RLIMIT_NOFILE
- { RLIMIT_NOFILE, 0, 'n' },
-#endif
-#ifdef RLIMIT_AS
- { RLIMIT_AS, 10, 'v' },
-#endif
-#ifdef RLIMIT_LOCKS
- { RLIMIT_LOCKS, 0, 'w' },
-#endif
-};
-static const char limits_name[] =
-#ifdef RLIMIT_CPU
- "time(seconds)" "\0"
-#endif
-#ifdef RLIMIT_FSIZE
- "file(blocks)" "\0"
-#endif
-#ifdef RLIMIT_DATA
- "data(kb)" "\0"
-#endif
-#ifdef RLIMIT_STACK
- "stack(kb)" "\0"
-#endif
-#ifdef RLIMIT_CORE
- "coredump(blocks)" "\0"
-#endif
-#ifdef RLIMIT_RSS
- "memory(kb)" "\0"
-#endif
-#ifdef RLIMIT_MEMLOCK
- "locked memory(kb)" "\0"
-#endif
-#ifdef RLIMIT_NPROC
- "process" "\0"
-#endif
-#ifdef RLIMIT_NOFILE
- "nofiles" "\0"
-#endif
-#ifdef RLIMIT_AS
- "vmemory(kb)" "\0"
-#endif
-#ifdef RLIMIT_LOCKS
- "locks" "\0"
-#endif
-;
-
-enum limtype { SOFT = 0x1, HARD = 0x2 };
-
-static void
-printlim(enum limtype how, const struct rlimit *limit,
- const struct limits *l)
-{
- rlim_t val;
-
- val = limit->rlim_max;
- if (how & SOFT)
- val = limit->rlim_cur;
-
- if (val == RLIM_INFINITY)
- out1fmt("unlimited\n");
- else {
- val >>= l->factor_shift;
- out1fmt("%lld\n", (long long) val);
- }
-}
-
static int FAST_FUNC
-ulimitcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
+ulimitcmd(int argc UNUSED_PARAM, char **argv)
{
- rlim_t val;
- enum limtype how = SOFT | HARD;
- const struct limits *l;
- int set, all = 0;
- int optc, what;
- struct rlimit limit;
-
- what = 'f';
- while ((optc = nextopt("HSa"
-#ifdef RLIMIT_CPU
- "t"
-#endif
-#ifdef RLIMIT_FSIZE
- "f"
-#endif
-#ifdef RLIMIT_DATA
- "d"
-#endif
-#ifdef RLIMIT_STACK
- "s"
-#endif
-#ifdef RLIMIT_CORE
- "c"
-#endif
-#ifdef RLIMIT_RSS
- "m"
-#endif
-#ifdef RLIMIT_MEMLOCK
- "l"
-#endif
-#ifdef RLIMIT_NPROC
- "p"
-#endif
-#ifdef RLIMIT_NOFILE
- "n"
-#endif
-#ifdef RLIMIT_AS
- "v"
-#endif
-#ifdef RLIMIT_LOCKS
- "w"
-#endif
- )) != '\0')
- switch (optc) {
- case 'H':
- how = HARD;
- break;
- case 'S':
- how = SOFT;
- break;
- case 'a':
- all = 1;
- break;
- default:
- what = optc;
- }
-
- for (l = limits_tbl; l->option != what; l++)
- continue;
-
- set = *argptr ? 1 : 0;
- val = 0;
- if (set) {
- char *p = *argptr;
-
- if (all || argptr[1])
- ash_msg_and_raise_error("too many arguments");
- if (strncmp(p, "unlimited\n", 9) == 0)
- val = RLIM_INFINITY;
- else {
- if (sizeof(val) == sizeof(int))
- val = bb_strtou(p, NULL, 10);
- else if (sizeof(val) == sizeof(long))
- val = bb_strtoul(p, NULL, 10);
- else
- val = bb_strtoull(p, NULL, 10);
- if (errno)
- ash_msg_and_raise_error("bad number");
- val <<= l->factor_shift;
- }
- }
- if (all) {
- const char *lname = limits_name;
- for (l = limits_tbl; l != &limits_tbl[ARRAY_SIZE(limits_tbl)]; l++) {
- getrlimit(l->cmd, &limit);
- out1fmt("%-20s ", lname);
- lname += strlen(lname) + 1;
- printlim(how, &limit, l);
- }
- return 0;
- }
-
- getrlimit(l->cmd, &limit);
- if (set) {
- if (how & HARD)
- limit.rlim_max = val;
- if (how & SOFT)
- limit.rlim_cur = val;
- if (setrlimit(l->cmd, &limit) < 0)
- ash_msg_and_raise_error("error setting limit (%m)");
- } else {
- printlim(how, &limit, l);
- }
- return 0;
+ return shell_builtin_ulimit(argv);
}
/* ============ main() and helpers */
--- /dev/null
+/* vi: set sw=4 ts=4: */
+/*
+ * ulimit builtin
+ *
+ * Adapted from ash applet code
+ *
+ * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
+ * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
+ * ash by J.T. Conklin.
+ *
+ * Public domain.
+ *
+ * Copyright (c) 2010 Tobias Klauser
+ * Split from ash.c and slightly adapted.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+#include "libbb.h"
+#include "builtin_ulimit.h"
+
+
+struct limits {
+ uint8_t cmd; /* RLIMIT_xxx fit into it */
+ uint8_t factor_shift; /* shift by to get rlim_{cur,max} values */
+ char option;
+ const char *name;
+};
+
+static const struct limits limits_tbl[] = {
+#ifdef RLIMIT_FSIZE
+ { RLIMIT_FSIZE, 9, 'f', "file size (blocks)" },
+#endif
+#ifdef RLIMIT_CPU
+ { RLIMIT_CPU, 0, 't', "cpu time (seconds)" },
+#endif
+#ifdef RLIMIT_DATA
+ { RLIMIT_DATA, 10, 'd', "data seg size (kb)" },
+#endif
+#ifdef RLIMIT_STACK
+ { RLIMIT_STACK, 10, 's', "stack size (kb)" },
+#endif
+#ifdef RLIMIT_CORE
+ { RLIMIT_CORE, 9, 'c', "core file size (blocks)" },
+#endif
+#ifdef RLIMIT_RSS
+ { RLIMIT_RSS, 10, 'm', "resident set size (kb)" },
+#endif
+#ifdef RLIMIT_MEMLOCK
+ { RLIMIT_MEMLOCK, 10, 'l', "locked memory (kb)" },
+#endif
+#ifdef RLIMIT_NPROC
+ { RLIMIT_NPROC, 0, 'p', "processes" },
+#endif
+#ifdef RLIMIT_NOFILE
+ { RLIMIT_NOFILE, 0, 'n', "file descriptors" },
+#endif
+#ifdef RLIMIT_AS
+ { RLIMIT_AS, 10, 'v', "address space (kb)" },
+#endif
+#ifdef RLIMIT_LOCKS
+ { RLIMIT_LOCKS, 0, 'w', "locks" },
+#endif
+};
+
+enum {
+ OPT_hard = (1 << 0),
+ OPT_soft = (1 << 1),
+};
+
+/* "-": treat args as parameters of option with ASCII code 1 */
+static const char ulimit_opt_string[] = "-HSa"
+#ifdef RLIMIT_FSIZE
+ "f::"
+#endif
+#ifdef RLIMIT_CPU
+ "t::"
+#endif
+#ifdef RLIMIT_DATA
+ "d::"
+#endif
+#ifdef RLIMIT_STACK
+ "s::"
+#endif
+#ifdef RLIMIT_CORE
+ "c::"
+#endif
+#ifdef RLIMIT_RSS
+ "m::"
+#endif
+#ifdef RLIMIT_MEMLOCK
+ "l::"
+#endif
+#ifdef RLIMIT_NPROC
+ "p::"
+#endif
+#ifdef RLIMIT_NOFILE
+ "n::"
+#endif
+#ifdef RLIMIT_AS
+ "v::"
+#endif
+#ifdef RLIMIT_LOCKS
+ "w::"
+#endif
+ ;
+
+static void printlim(unsigned opts, const struct rlimit *limit,
+ const struct limits *l)
+{
+ rlim_t val;
+
+ val = limit->rlim_max;
+ if (!(opts & OPT_hard))
+ val = limit->rlim_cur;
+
+ if (val == RLIM_INFINITY)
+ printf("unlimited\n");
+ else {
+ val >>= l->factor_shift;
+ printf("%llu\n", (long long) val);
+ }
+}
+
+int FAST_FUNC shell_builtin_ulimit(char **argv)
+{
+ unsigned opts;
+ unsigned argc;
+
+ /* We can't use getopt32: need to handle commands like
+ * ulimit 123 -c2 -l 456
+ */
+
+ /* In case getopt was already called:
+ * reset the libc getopt() function, which keeps internal state.
+ */
+#ifdef __GLIBC__
+ optind = 0;
+#else /* BSD style */
+ optind = 1;
+ /* optreset = 1; */
+#endif
+ /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
+
+ argc = 1;
+ while (argv[argc])
+ argc++;
+
+ opts = 0;
+ while (1) {
+ struct rlimit limit;
+ const struct limits *l;
+ int opt_char = getopt(argc, argv, ulimit_opt_string);
+
+ if (opt_char == -1)
+ break;
+ if (opt_char == 'H') {
+ opts |= OPT_hard;
+ continue;
+ }
+ if (opt_char == 'S') {
+ opts |= OPT_soft;
+ continue;
+ }
+
+ if (opt_char == 'a') {
+ for (l = limits_tbl; l != &limits_tbl[ARRAY_SIZE(limits_tbl)]; l++) {
+ getrlimit(l->cmd, &limit);
+ printf("-%c: %-30s ", l->option, l->name);
+ printlim(opts, &limit, l);
+ }
+ continue;
+ }
+
+ if (opt_char == 1)
+ opt_char = 'f';
+ for (l = limits_tbl; l != &limits_tbl[ARRAY_SIZE(limits_tbl)]; l++) {
+ if (opt_char == l->option) {
+ char *val_str = optarg ? optarg : (argv[optind] && argv[optind][0] != '-' ? argv[optind] : NULL);
+
+ getrlimit(l->cmd, &limit);
+ if (val_str) {
+ rlim_t val;
+
+ if (!optarg) /* -c NNN: make getopt skip NNN */
+ optind++;
+
+ if (strcmp(val_str, "unlimited") == 0)
+ val = RLIM_INFINITY;
+ else {
+ if (sizeof(val) == sizeof(int))
+ val = bb_strtou(val_str, NULL, 10);
+ else if (sizeof(val) == sizeof(long))
+ val = bb_strtoul(val_str, NULL, 10);
+ else
+ val = bb_strtoull(val_str, NULL, 10);
+ if (errno) {
+ bb_error_msg("bad number");
+ return EXIT_FAILURE;
+ }
+ val <<= l->factor_shift;
+ }
+//bb_error_msg("opt %c val_str:'%s' val:%lld", opt_char, val_str, (long long)val);
+ if (opts & OPT_hard)
+ limit.rlim_max = val;
+ if ((opts & OPT_soft) || opts == 0)
+ limit.rlim_cur = val;
+//bb_error_msg("setrlimit(%d, %lld, %lld)", l->cmd, (long long)limit.rlim_cur, (long long)limit.rlim_max);
+ if (setrlimit(l->cmd, &limit) < 0) {
+ bb_perror_msg("error setting limit");
+ return EXIT_FAILURE;
+ }
+ } else {
+ printlim(opts, &limit, l);
+ }
+ break;
+ }
+ } /* for (every possible opt) */
+
+ if (l == &limits_tbl[ARRAY_SIZE(limits_tbl)]) {
+ /* bad option. getopt already complained. */
+ break;
+ }
+
+ } /* while (there are options) */
+
+ return 0;
+}
--- /dev/null
+/* vi: set sw=4 ts=4: */
+/*
+ * Adapted from ash applet code
+ *
+ * Copyright (c) 2010 Tobias Klauser
+ * Split from ash.c and slightly adapted.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+#ifndef SHELL_BUILTIN_ULIMIT_H
+#define SHELL_BUILTIN_ULIMIT_H 1
+
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
+
+int FAST_FUNC shell_builtin_ulimit(char **argv);
+
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif
*
* TODOs:
* grep for "TODO" and fix (some of them are easy)
- * builtins: ulimit
* special variables (done: PWD)
* follow IFS rules more precisely, including update semantics
* export builtin should be special, its arguments are assignments
#include "shell_common.h"
#include "builtin_read.h"
+#include "builtin_ulimit.h"
#include "math.h"
#include "match.h"
#if ENABLE_HUSH_RANDOM_SUPPORT
BLTIN("shift" , builtin_shift , "Shift positional parameters"),
BLTIN("trap" , builtin_trap , "Trap signals"),
BLTIN("type" , builtin_type , "Write a description of command type"),
-// BLTIN("ulimit" , builtin_ulimit , "Control resource limits"),
+ BLTIN("ulimit" , shell_builtin_ulimit , "Control resource limits"),
BLTIN("umask" , builtin_umask , "Set file creation mask"),
BLTIN("unset" , builtin_unset , "Unset variables"),
BLTIN("wait" , builtin_wait , "Wait for process"),
projects / oweals / busybox.git / commitdiff