+/*** Directory rules ***/
+
+struct dir_rule {
+ char *inside; // A relative path
+ char *outside; // This can be an absolute path or a relative path starting with "./"
+ unsigned int flags; // DIR_FLAG_xxx
+ struct dir_rule *next;
+};
+
+enum dir_rule_flags {
+ DIR_FLAG_RW = 1,
+ DIR_FLAG_NOEXEC = 2,
+ DIR_FLAG_FS = 4,
+ DIR_FLAG_MAYBE = 8,
+ DIR_FLAG_DEV = 16,
+};
+
+static const char * const dir_flag_names[] = { "rw", "noexec", "fs", "maybe", "dev" };
+
+static struct dir_rule *first_dir_rule;
+static struct dir_rule **last_dir_rule = &first_dir_rule;
+
+static int add_dir_rule(char *in, char *out, unsigned int flags)
+{
+ // Make sure that "in" is relative
+ while (in[0] == '/')
+ in++;
+ if (!*in)
+ return 0;
+
+ // Check "out"
+ if (flags & DIR_FLAG_FS)
+ {
+ if (!out || out[0] == '/')
+ return 0;
+ }
+ else
+ {
+ if (out && out[0] != '/' && strncmp(out, "./", 2))
+ return 0;
+ }
+
+ // Override an existing rule
+ struct dir_rule *r;
+ for (r = first_dir_rule; r; r = r->next)
+ if (!strcmp(r->inside, in))
+ break;
+
+ // Add a new rule
+ if (!r)
+ {
+ r = xmalloc(sizeof(*r));
+ r->inside = in;
+ *last_dir_rule = r;
+ last_dir_rule = &r->next;
+ r->next = NULL;
+ }
+ r->outside = out;
+ r->flags = flags;
+ return 1;
+}
+
+static unsigned int parse_dir_option(char *opt)
+{
+ for (unsigned int i = 0; i < ARRAY_SIZE(dir_flag_names); i++)
+ if (!strcmp(opt, dir_flag_names[i]))
+ return 1U << i;
+ die("Unknown directory option %s", opt);
+}
+
+static int set_dir_action(char *arg)
+{
+ arg = xstrdup(arg);
+
+ char *colon = strchr(arg, ':');
+ unsigned int flags = 0;
+ while (colon)
+ {
+ *colon++ = 0;
+ char *next = strchr(colon, ':');
+ if (next)
+ *next = 0;
+ flags |= parse_dir_option(colon);
+ colon = next;
+ }
+
+ char *eq = strchr(arg, '=');
+ if (eq)
+ {
+ *eq++ = 0;
+ return add_dir_rule(arg, (*eq ? eq : NULL), flags);
+ }
+ else
+ {
+ char *out = xmalloc(1 + strlen(arg) + 1);
+ sprintf(out, "/%s", arg);
+ return add_dir_rule(arg, out, flags);
+ }
+}
+
+static void init_dir_rules(void)
+{
+ set_dir_action("box=./box:rw");
+ set_dir_action("bin");
+ set_dir_action("dev:dev");
+ set_dir_action("lib");
+ set_dir_action("lib64:maybe");
+ set_dir_action("proc=proc:fs");
+ set_dir_action("usr");
+}
+
+static void make_dir(char *path)
+{
+ char *sep = (path[0] == '/' ? path+1 : path);
+
+ for (;;)
+ {
+ sep = strchr(sep, '/');
+ if (sep)
+ *sep = 0;
+
+ if (!dir_exists(path) && mkdir(path, 0777) < 0)
+ die("Cannot create directory %s: %m\n", path);
+
+ if (!sep)
+ return;
+ *sep++ = '/';
+ }
+}
+
+static void apply_dir_rules(void)
+{
+ for (struct dir_rule *r = first_dir_rule; r; r=r->next)
+ {
+ char *in = r->inside;
+ char *out = r->outside;
+ if (!out)
+ {
+ msg("Not binding anything on %s\n", r->inside);
+ continue;
+ }
+
+ if ((r->flags & DIR_FLAG_MAYBE) && !dir_exists(out))
+ {
+ msg("Not binding %s on %s (does not exist)\n", out, r->inside);
+ continue;
+ }
+
+ char root_in[1024];
+ snprintf(root_in, sizeof(root_in), "root/%s", in);
+ make_dir(root_in);
+
+ unsigned long mount_flags = 0;
+ if (!(r->flags & DIR_FLAG_RW))
+ mount_flags |= MS_RDONLY;
+ if (r->flags & DIR_FLAG_NOEXEC)
+ mount_flags |= MS_NOEXEC;
+ if (!(r->flags & DIR_FLAG_DEV))
+ mount_flags |= MS_NODEV;
+
+ if (r->flags & DIR_FLAG_FS)
+ {
+ msg("Mounting %s on %s (flags %lx)\n", out, in, mount_flags);
+ if (mount("none", root_in, out, mount_flags, "") < 0)
+ die("Cannot mount %s on %s: %m", out, in);
+ }
+ else
+ {
+ mount_flags |= MS_BIND | MS_NOSUID;
+ msg("Binding %s on %s (flags %lx)\n", out, in, mount_flags);
+ // Most mount flags need remount to work
+ if (mount(out, root_in, "none", mount_flags, "") < 0 ||
+ mount(out, root_in, "none", MS_REMOUNT | mount_flags, "") < 0)
+ die("Cannot mount %s on %s: %m", out, in);
+ }
+ }
+}
+
+/*** Control groups ***/
+
+struct cg_controller_desc {
+ const char *name;
+ int optional;
+};
+
+typedef enum {
+ CG_MEMORY = 0,
+ CG_CPUACCT,
+ CG_CPUSET,
+ CG_NUM_CONTROLLERS,
+} cg_controller;
+
+static const struct cg_controller_desc cg_controllers[CG_NUM_CONTROLLERS+1] = {
+ [CG_MEMORY] = { "memory", 0 },
+ [CG_CPUACCT] = { "cpuacct", 0 },
+ [CG_CPUSET] = { "cpuset", 1 },
+ [CG_NUM_CONTROLLERS] = { NULL, 0 },
+};
+
+#define FOREACH_CG_CONTROLLER(_controller) \
+ for (cg_controller (_controller) = 0; \
+ (_controller) < CG_NUM_CONTROLLERS; (_controller)++)
+
+static const char *cg_controller_name(cg_controller c)
+{
+ return cg_controllers[c].name;
+}
+
+static const int cg_controller_optional(cg_controller c)
+{
+ return cg_controllers[c].optional;
+}
+
+static char cg_name[256];
+
+#define CG_BUFSIZE 1024
+
+static void
+cg_makepath(char *buf, size_t len, cg_controller c, const char *attr)
+{
+ const char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
+ snprintf(buf, len, "%s/%s/%s/%s", cg_root, cg_controller_name(c), cg_name, attr);
+}
+
+static int
+cg_read(cg_controller controller, const char *attr, char *buf)
+{
+ int maybe = 0;
+ if (attr[0] == '?')
+ {
+ attr++;
+ maybe = 1;
+ }
+
+ char path[256];
+ cg_makepath(path, sizeof(path), controller, attr);
+
+ int fd = open(path, O_RDONLY);
+ if (fd < 0)
+ {
+ if (maybe)
+ return 0;
+ die("Cannot read %s: %m", path);
+ }
+
+ int n = read(fd, buf, CG_BUFSIZE);
+ if (n < 0)
+ {
+ if (maybe)
+ return 0;
+ die("Cannot read %s: %m", path);
+ }
+ if (n >= CG_BUFSIZE - 1)
+ die("Attribute %s too long", path);
+ if (n > 0 && buf[n-1] == '\n')
+ n--;
+ buf[n] = 0;
+
+ if (verbose > 1)
+ msg("CG: Read %s = %s\n", attr, buf);
+
+ close(fd);
+ return 1;
+}
+
+static void __attribute__((format(printf,3,4)))
+cg_write(cg_controller controller, const char *attr, const char *fmt, ...)
+{
+ int maybe = 0;
+ if (attr[0] == '?')
+ {
+ attr++;
+ maybe = 1;
+ }
+
+ va_list args;
+ va_start(args, fmt);
+
+ char buf[CG_BUFSIZE];
+ int n = vsnprintf(buf, sizeof(buf), fmt, args);
+ if (n >= CG_BUFSIZE)
+ die("cg_write: Value for attribute %s is too long", attr);
+
+ if (verbose > 1)
+ msg("CG: Write %s = %s", attr, buf);
+
+ char path[256];
+ cg_makepath(path, sizeof(path), controller, attr);
+
+ int fd = open(path, O_WRONLY | O_TRUNC);
+ if (fd < 0)
+ {
+ if (maybe)
+ return;
+ else
+ die("Cannot write %s: %m", path);
+ }
+
+ int written = write(fd, buf, n);
+ if (written < 0)
+ {
+ if (maybe)
+ return;
+ else
+ die("Cannot set %s to %s: %m", path, buf);
+ }
+ if (written != n)
+ die("Short write to %s (%d out of %d bytes)", path, written, n);
+
+ close(fd);
+ va_end(args);
+}
+
+static void
+cg_init(void)
+{
+ if (!cg_enable)
+ return;
+
+ char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
+ if (!dir_exists(cg_root))
+ die("Control group filesystem at %s not mounted", cg_root);
+
+ snprintf(cg_name, sizeof(cg_name), "box-%d", box_id);
+ msg("Using control group %s\n", cg_name);
+}
+
+static void
+cg_prepare(void)
+{
+ if (!cg_enable)
+ return;
+
+ struct stat st;
+ char buf[CG_BUFSIZE];
+ char path[256];
+
+ FOREACH_CG_CONTROLLER(controller)
+ {
+ cg_makepath(path, sizeof(path), controller, "");
+ if (stat(path, &st) >= 0 || errno != ENOENT)
+ {
+ msg("Control group %s already exists, trying to empty it.\n", path);
+ if (rmdir(path) < 0)
+ die("Failed to reset control group %s: %m", path);
+ }
+
+ if (mkdir(path, 0777) < 0 && !cg_controller_optional(controller))
+ die("Failed to create control group %s: %m", path);
+ }
+
+ // If cpuset module is enabled, copy allowed cpus and memory nodes from parent group
+ if (cg_read(CG_CPUSET, "?cpuset.cpus", buf))
+ cg_write(CG_CPUSET, "cpuset.cpus", "%s", buf);
+ if (cg_read(CG_CPUSET, "?cpuset.mems", buf))
+ cg_write(CG_CPUSET, "cpuset.mems", "%s", buf);
+}
+
+static void
+cg_enter(void)
+{
+ if (!cg_enable)
+ return;
+
+ msg("Entering control group %s\n", cg_name);
+
+ FOREACH_CG_CONTROLLER(controller)
+ {
+ if (cg_controller_optional(controller))
+ cg_write(controller, "?tasks", "%d\n", (int) getpid());
+ else
+ cg_write(controller, "tasks", "%d\n", (int) getpid());
+ }
+
+ if (cg_memory_limit)
+ {
+ cg_write(CG_MEMORY, "memory.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
+ cg_write(CG_MEMORY, "?memory.memsw.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
+ }
+
+ if (cg_timing)
+ cg_write(CG_CPUACCT, "cpuacct.usage", "0\n");
+}
+
+static int
+cg_get_run_time_ms(void)
+{
+ if (!cg_enable)
+ return 0;
+
+ char buf[CG_BUFSIZE];
+ cg_read(CG_CPUACCT, "cpuacct.usage", buf);
+ unsigned long long ns = atoll(buf);
+ return ns / 1000000;
+}
+
+static void
+cg_stats(void)
+{
+ if (!cg_enable)
+ return;
+
+ char buf[CG_BUFSIZE];
+
+ // Memory usage statistics
+ unsigned long long mem=0, memsw=0;
+ if (cg_read(CG_MEMORY, "?memory.max_usage_in_bytes", buf))
+ mem = atoll(buf);
+ if (cg_read(CG_MEMORY, "?memory.memsw.max_usage_in_bytes", buf))
+ {
+ memsw = atoll(buf);
+ if (memsw > mem)
+ mem = memsw;
+ }
+ if (mem)
+ meta_printf("cg-mem:%lld\n", mem >> 10);
+}
+
+static void
+cg_remove(void)
+{
+ char buf[CG_BUFSIZE];
+
+ if (!cg_enable)
+ return;
+
+ FOREACH_CG_CONTROLLER(controller)
+ {
+ if (cg_controller_optional(controller)) {
+ if (!cg_read(controller, "?tasks", buf))
+ continue;
+ } else
+ cg_read(controller, "tasks", buf);
+
+ if (buf[0])
+ die("Some tasks left in controller %s of cgroup %s, failed to remove it",
+ cg_controller_name(controller), cg_name);
+
+ char path[256];
+ cg_makepath(path, sizeof(path), controller, "");
+
+ if (rmdir(path) < 0)
+ die("Cannot remove control group %s: %m", path);
+ }
+}
+
+/*** Disk quotas ***/
+
+static int
+path_begins_with(char *path, char *with)
+{
+ while (*with)
+ if (*path++ != *with++)
+ return 0;
+ return (!*with || *with == '/');
+}
+
+static char *
+find_device(char *path)
+{
+ FILE *f = setmntent("/proc/mounts", "r");
+ if (!f)
+ die("Cannot open /proc/mounts: %m");
+
+ struct mntent *me;
+ int best_len = 0;
+ char *best_dev = NULL;
+ while (me = getmntent(f))
+ {
+ if (!path_begins_with(me->mnt_fsname, "/dev"))
+ continue;
+ if (path_begins_with(path, me->mnt_dir))
+ {
+ int len = strlen(me->mnt_dir);
+ if (len > best_len)
+ {
+ best_len = len;
+ free(best_dev);
+ best_dev = xstrdup(me->mnt_fsname);
+ }
+ }
+ }
+ endmntent(f);
+ return best_dev;
+}
+
+static void
+set_quota(void)
+{
+ if (!block_quota)
+ return;
+
+ char cwd[PATH_MAX];
+ if (!getcwd(cwd, sizeof(cwd)))
+ die("getcwd: %m");
+
+ char *dev = find_device(cwd);
+ if (!dev)
+ die("Cannot identify filesystem which contains %s", cwd);
+ msg("Quota: Mapped path %s to a filesystem on %s\n", cwd, dev);
+
+ // Sanity check
+ struct stat dev_st, cwd_st;
+ if (stat(dev, &dev_st) < 0)
+ die("Cannot identify block device %s: %m", dev);
+ if (!S_ISBLK(dev_st.st_mode))
+ die("Expected that %s is a block device", dev);
+ if (stat(".", &cwd_st) < 0)
+ die("Cannot stat cwd: %m");
+ if (cwd_st.st_dev != dev_st.st_rdev)
+ die("Identified %s as a filesystem on %s, but it is obviously false", cwd, dev);
+
+ struct dqblk dq = {
+ .dqb_bhardlimit = block_quota,
+ .dqb_bsoftlimit = block_quota,
+ .dqb_ihardlimit = inode_quota,
+ .dqb_isoftlimit = inode_quota,
+ .dqb_valid = QIF_LIMITS,
+ };
+ if (quotactl(QCMD(Q_SETQUOTA, USRQUOTA), dev, box_uid, (caddr_t) &dq) < 0)
+ die("Cannot set disk quota: %m");
+ msg("Quota: Set block quota %d and inode quota %d\n", block_quota, inode_quota);
+
+ free(dev);
+}
+
+/*** The keeper process ***/