]> mj.ucw.cz Git - moe.git/blob - isolate/isolate.c
isolate: Switch to libcgroup-based directory hierarchy of /sys/fs/cgroup.
[moe.git] / isolate / isolate.c
1 /*
2  *      A Process Isolator based on Linux Containers
3  *
4  *      (c) 2012-2013 Martin Mares <mj@ucw.cz>
5  *      (c) 2012-2013 Bernard Blackham <bernard@blackham.com.au>
6  */
7
8 #define _GNU_SOURCE
9
10 #include "autoconf.h"
11
12 #include <errno.h>
13 #include <stdio.h>
14 #include <fcntl.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <stdarg.h>
18 #include <stdint.h>
19 #include <unistd.h>
20 #include <getopt.h>
21 #include <sched.h>
22 #include <time.h>
23 #include <grp.h>
24 #include <mntent.h>
25 #include <limits.h>
26 #include <sys/wait.h>
27 #include <sys/time.h>
28 #include <sys/signal.h>
29 #include <sys/resource.h>
30 #include <sys/mount.h>
31 #include <sys/stat.h>
32 #include <sys/quota.h>
33 #include <sys/vfs.h>
34
35 #define NONRET __attribute__((noreturn))
36 #define UNUSED __attribute__((unused))
37 #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
38
39 static int timeout;                     /* milliseconds */
40 static int wall_timeout;
41 static int extra_timeout;
42 static int pass_environ;
43 static int verbose;
44 static int memory_limit;
45 static int stack_limit;
46 static int block_quota;
47 static int inode_quota;
48 static int max_processes = 1;
49 static char *redir_stdin, *redir_stdout, *redir_stderr;
50 static char *set_cwd;
51
52 static int cg_enable;
53 static int cg_memory_limit;
54 static int cg_timing;
55
56 static int box_id;
57 static char box_dir[1024];
58 static pid_t box_pid;
59
60 static uid_t box_uid;
61 static gid_t box_gid;
62 static uid_t orig_uid;
63 static gid_t orig_gid;
64
65 static int partial_line;
66 static char cleanup_cmd[256];
67
68 static struct timeval start_time;
69 static int ticks_per_sec;
70 static int total_ms, wall_ms;
71 static volatile sig_atomic_t timer_tick;
72
73 static int error_pipes[2];
74 static int write_errors_to_fd;
75 static int read_errors_from_fd;
76
77 static void die(char *msg, ...) NONRET;
78 static void cg_stats(void);
79 static int get_wall_time_ms(void);
80 static int get_run_time_ms(struct rusage *rus);
81
82 /*** Meta-files ***/
83
84 static FILE *metafile;
85
86 static void
87 meta_open(const char *name)
88 {
89   if (!strcmp(name, "-"))
90     {
91       metafile = stdout;
92       return;
93     }
94   metafile = fopen(name, "w");
95   if (!metafile)
96     die("Failed to open metafile '%s'",name);
97 }
98
99 static void
100 meta_close(void)
101 {
102   if (metafile && metafile != stdout)
103     fclose(metafile);
104 }
105
106 static void __attribute__((format(printf,1,2)))
107 meta_printf(const char *fmt, ...)
108 {
109   if (!metafile)
110     return;
111
112   va_list args;
113   va_start(args, fmt);
114   vfprintf(metafile, fmt, args);
115   va_end(args);
116 }
117
118 static void
119 final_stats(struct rusage *rus)
120 {
121   total_ms = get_run_time_ms(rus);
122   wall_ms = get_wall_time_ms();
123
124   meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
125   meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
126   meta_printf("max-rss:%ld\n", rus->ru_maxrss);
127   meta_printf("csw-voluntary:%ld\n", rus->ru_nvcsw);
128   meta_printf("csw-forced:%ld\n", rus->ru_nivcsw);
129
130   cg_stats();
131 }
132
133 /*** Messages and exits ***/
134
135 static void
136 xsystem(const char *cmd)
137 {
138   int ret = system(cmd);
139   if (ret < 0)
140     die("system(\"%s\"): %m", cmd);
141   if (!WIFEXITED(ret) || WEXITSTATUS(ret))
142     die("system(\"%s\"): Exited with status %d", cmd, ret);
143 }
144
145 static void NONRET
146 box_exit(int rc)
147 {
148   if (box_pid > 0)
149     {
150       kill(-box_pid, SIGKILL);
151       kill(box_pid, SIGKILL);
152       meta_printf("killed:1\n");
153
154       struct rusage rus;
155       int p, stat;
156       do
157         p = wait4(box_pid, &stat, 0, &rus);
158       while (p < 0 && errno == EINTR);
159       if (p < 0)
160         fprintf(stderr, "UGH: Lost track of the process (%m)\n");
161       else
162         final_stats(&rus);
163     }
164
165   if (rc < 2 && cleanup_cmd[0])
166     xsystem(cleanup_cmd);
167
168   meta_close();
169   exit(rc);
170 }
171
172 static void
173 flush_line(void)
174 {
175   if (partial_line)
176     fputc('\n', stderr);
177   partial_line = 0;
178 }
179
180 /* Report an error of the sandbox itself */
181 static void NONRET __attribute__((format(printf,1,2)))
182 die(char *msg, ...)
183 {
184   va_list args;
185   va_start(args, msg);
186   char buf[1024];
187   int n = vsnprintf(buf, sizeof(buf), msg, args);
188
189   if (write_errors_to_fd)
190     {
191       // We are inside the box, have to use error pipe for error reporting.
192       // We hope that the whole error message fits in PIPE_BUF bytes.
193       write(write_errors_to_fd, buf, n);
194       exit(2);
195     }
196
197   // Otherwise, we in the box keeper process, so we report errors normally
198   flush_line();
199   meta_printf("status:XX\nmessage:%s\n", buf);
200   fputs(buf, stderr);
201   fputc('\n', stderr);
202   box_exit(2);
203 }
204
205 /* Report an error of the program inside the sandbox */
206 static void NONRET __attribute__((format(printf,1,2)))
207 err(char *msg, ...)
208 {
209   va_list args;
210   va_start(args, msg);
211   flush_line();
212   if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
213     {
214       meta_printf("status:%c%c\n", msg[0], msg[1]);
215       msg += 4;
216     }
217   char buf[1024];
218   vsnprintf(buf, sizeof(buf), msg, args);
219   meta_printf("message:%s\n", buf);
220   fputs(buf, stderr);
221   fputc('\n', stderr);
222   box_exit(1);
223 }
224
225 /* Write a message, but only if in verbose mode */
226 static void __attribute__((format(printf,1,2)))
227 msg(char *msg, ...)
228 {
229   va_list args;
230   va_start(args, msg);
231   if (verbose)
232     {
233       int len = strlen(msg);
234       if (len > 0)
235         partial_line = (msg[len-1] != '\n');
236       vfprintf(stderr, msg, args);
237       fflush(stderr);
238     }
239   va_end(args);
240 }
241
242 /*** Utility functions ***/
243
244 static void *
245 xmalloc(size_t size)
246 {
247   void *p = malloc(size);
248   if (!p)
249     die("Out of memory");
250   return p;
251 }
252
253 static char *
254 xstrdup(char *str)
255 {
256   char *p = strdup(str);
257   if (!p)
258     die("Out of memory");
259   return p;
260 }
261
262 static int dir_exists(char *path)
263 {
264   struct stat st;
265   return (stat(path, &st) >= 0 && S_ISDIR(st.st_mode));
266 }
267
268 /*** Environment rules ***/
269
270 struct env_rule {
271   char *var;                    // Variable to match
272   char *val;                    // ""=clear, NULL=inherit
273   int var_len;
274   struct env_rule *next;
275 };
276
277 static struct env_rule *first_env_rule;
278 static struct env_rule **last_env_rule = &first_env_rule;
279
280 static struct env_rule default_env_rules[] = {
281   { "LIBC_FATAL_STDERR_", "1" }
282 };
283
284 static int
285 set_env_action(char *a0)
286 {
287   struct env_rule *r = xmalloc(sizeof(*r) + strlen(a0) + 1);
288   char *a = (char *)(r+1);
289   strcpy(a, a0);
290
291   char *sep = strchr(a, '=');
292   if (sep == a)
293     return 0;
294   r->var = a;
295   if (sep)
296     {
297       *sep++ = 0;
298       r->val = sep;
299     }
300   else
301     r->val = NULL;
302   *last_env_rule = r;
303   last_env_rule = &r->next;
304   r->next = NULL;
305   return 1;
306 }
307
308 static int
309 match_env_var(char *env_entry, struct env_rule *r)
310 {
311   if (strncmp(env_entry, r->var, r->var_len))
312     return 0;
313   return (env_entry[r->var_len] == '=');
314 }
315
316 static void
317 apply_env_rule(char **env, int *env_sizep, struct env_rule *r)
318 {
319   // First remove the variable if already set
320   int pos = 0;
321   while (pos < *env_sizep && !match_env_var(env[pos], r))
322     pos++;
323   if (pos < *env_sizep)
324     {
325       (*env_sizep)--;
326       env[pos] = env[*env_sizep];
327       env[*env_sizep] = NULL;
328     }
329
330   // What is the new value?
331   char *new;
332   if (r->val)
333     {
334       if (!r->val[0])
335         return;
336       new = xmalloc(r->var_len + 1 + strlen(r->val) + 1);
337       sprintf(new, "%s=%s", r->var, r->val);
338     }
339   else
340     {
341       pos = 0;
342       while (environ[pos] && !match_env_var(environ[pos], r))
343         pos++;
344       if (!(new = environ[pos]))
345         return;
346     }
347
348   // Add it at the end of the array
349   env[(*env_sizep)++] = new;
350   env[*env_sizep] = NULL;
351 }
352
353 static char **
354 setup_environment(void)
355 {
356   // Link built-in rules with user rules
357   for (int i=ARRAY_SIZE(default_env_rules)-1; i >= 0; i--)
358     {
359       default_env_rules[i].next = first_env_rule;
360       first_env_rule = &default_env_rules[i];
361     }
362
363   // Scan the original environment
364   char **orig_env = environ;
365   int orig_size = 0;
366   while (orig_env[orig_size])
367     orig_size++;
368
369   // For each rule, reserve one more slot and calculate length
370   int num_rules = 0;
371   for (struct env_rule *r = first_env_rule; r; r=r->next)
372     {
373       num_rules++;
374       r->var_len = strlen(r->var);
375     }
376
377   // Create a new environment
378   char **env = xmalloc((orig_size + num_rules + 1) * sizeof(char *));
379   int size;
380   if (pass_environ)
381     {
382       memcpy(env, environ, orig_size * sizeof(char *));
383       size = orig_size;
384     }
385   else
386     size = 0;
387   env[size] = NULL;
388
389   // Apply the rules one by one
390   for (struct env_rule *r = first_env_rule; r; r=r->next)
391     apply_env_rule(env, &size, r);
392
393   // Return the new env and pass some gossip
394   if (verbose > 1)
395     {
396       fprintf(stderr, "Passing environment:\n");
397       for (int i=0; env[i]; i++)
398         fprintf(stderr, "\t%s\n", env[i]);
399     }
400   return env;
401 }
402
403 /*** Directory rules ***/
404
405 struct dir_rule {
406   char *inside;                 // A relative path
407   char *outside;                // This can be an absolute path or a relative path starting with "./"
408   unsigned int flags;           // DIR_FLAG_xxx
409   struct dir_rule *next;
410 };
411
412 enum dir_rule_flags {
413   DIR_FLAG_RW = 1,
414   DIR_FLAG_NOEXEC = 2,
415   DIR_FLAG_FS = 4,
416   DIR_FLAG_MAYBE = 8,
417   DIR_FLAG_DEV = 16,
418 };
419
420 static const char * const dir_flag_names[] = { "rw", "noexec", "fs", "maybe", "dev" };
421
422 static struct dir_rule *first_dir_rule;
423 static struct dir_rule **last_dir_rule = &first_dir_rule;
424
425 static int add_dir_rule(char *in, char *out, unsigned int flags)
426 {
427   // Make sure that "in" is relative
428   while (in[0] == '/')
429     in++;
430   if (!*in)
431     return 0;
432
433   // Check "out"
434   if (flags & DIR_FLAG_FS)
435     {
436       if (!out || out[0] == '/')
437         return 0;
438     }
439   else
440     {
441       if (out && out[0] != '/' && strncmp(out, "./", 2))
442         return 0;
443     }
444
445   // Override an existing rule
446   struct dir_rule *r;
447   for (r = first_dir_rule; r; r = r->next)
448     if (!strcmp(r->inside, in))
449       break;
450
451   // Add a new rule
452   if (!r)
453     {
454       r = xmalloc(sizeof(*r));
455       r->inside = in;
456       *last_dir_rule = r;
457       last_dir_rule = &r->next;
458       r->next = NULL;
459     }
460   r->outside = out;
461   r->flags = flags;
462   return 1;
463 }
464
465 static unsigned int parse_dir_option(char *opt)
466 {
467   for (unsigned int i = 0; i < ARRAY_SIZE(dir_flag_names); i++)
468     if (!strcmp(opt, dir_flag_names[i]))
469       return 1U << i;
470   die("Unknown directory option %s", opt);
471 }
472
473 static int set_dir_action(char *arg)
474 {
475   arg = xstrdup(arg);
476
477   char *colon = strchr(arg, ':');
478   unsigned int flags = 0;
479   while (colon)
480     {
481       *colon++ = 0;
482       char *next = strchr(colon, ':');
483       if (next)
484         *next = 0;
485       flags |= parse_dir_option(colon);
486       colon = next;
487     }
488
489   char *eq = strchr(arg, '=');
490   if (eq)
491     {
492       *eq++ = 0;
493       return add_dir_rule(arg, (*eq ? eq : NULL), flags);
494     }
495   else
496     {
497       char *out = xmalloc(1 + strlen(arg) + 1);
498       sprintf(out, "/%s", arg);
499       return add_dir_rule(arg, out, flags);
500     }
501 }
502
503 static void init_dir_rules(void)
504 {
505   set_dir_action("box=./box:rw");
506   set_dir_action("bin");
507   set_dir_action("dev:dev");
508   set_dir_action("lib");
509   set_dir_action("lib64:maybe");
510   set_dir_action("proc=proc:fs");
511   set_dir_action("usr");
512 }
513
514 static void make_dir(char *path)
515 {
516   char *sep = (path[0] == '/' ? path+1 : path);
517
518   for (;;)
519     {
520       sep = strchr(sep, '/');
521       if (sep)
522         *sep = 0;
523
524       if (!dir_exists(path) && mkdir(path, 0777) < 0)
525         die("Cannot create directory %s: %m\n", path);
526
527       if (!sep)
528         return;
529       *sep++ = '/';
530     }
531 }
532
533 static void apply_dir_rules(void)
534 {
535   for (struct dir_rule *r = first_dir_rule; r; r=r->next)
536     {
537       char *in = r->inside;
538       char *out = r->outside;
539       if (!out)
540         {
541           msg("Not binding anything on %s\n", r->inside);
542           continue;
543         }
544
545       if ((r->flags & DIR_FLAG_MAYBE) && !dir_exists(out))
546         {
547           msg("Not binding %s on %s (does not exist)\n", out, r->inside);
548           continue;
549         }
550
551       char root_in[1024];
552       snprintf(root_in, sizeof(root_in), "root/%s", in);
553       make_dir(root_in);
554
555       unsigned long mount_flags = 0;
556       if (!(r->flags & DIR_FLAG_RW))
557         mount_flags |= MS_RDONLY;
558       if (r->flags & DIR_FLAG_NOEXEC)
559         mount_flags |= MS_NOEXEC;
560       if (!(r->flags & DIR_FLAG_DEV))
561         mount_flags |= MS_NODEV;
562
563       if (r->flags & DIR_FLAG_FS)
564         {
565           msg("Mounting %s on %s (flags %lx)\n", out, in, mount_flags);
566           if (mount("none", root_in, out, mount_flags, "") < 0)
567             die("Cannot mount %s on %s: %m", out, in);
568         }
569       else
570         {
571           mount_flags |= MS_BIND | MS_NOSUID;
572           msg("Binding %s on %s (flags %lx)\n", out, in, mount_flags);
573           // Most mount flags need remount to work
574           if (mount(out, root_in, "none", mount_flags, "") < 0 ||
575               mount(out, root_in, "none", MS_REMOUNT | mount_flags, "") < 0)
576             die("Cannot mount %s on %s: %m", out, in);
577         }
578     }
579 }
580
581 /*** Control groups ***/
582
583 struct cg_controller_desc {
584   const char *name;
585   int optional;
586 };
587
588 typedef enum {
589   CG_MEMORY = 0,
590   CG_CPUACCT,
591   CG_CPUSET,
592   CG_NUM_CONTROLLERS,
593 } cg_controller;
594
595 static const struct cg_controller_desc cg_controllers[CG_NUM_CONTROLLERS+1] = {
596   [CG_MEMORY]  = { "memory",  0 },
597   [CG_CPUACCT] = { "cpuacct", 0 },
598   [CG_CPUSET]  = { "cpuset",  1 },
599   [CG_NUM_CONTROLLERS] = { NULL, 0 },
600 };
601
602 #define FOREACH_CG_CONTROLLER(_controller) \
603   for (cg_controller (_controller) = 0; \
604       (_controller) < CG_NUM_CONTROLLERS; (_controller)++)
605
606 static const char *cg_controller_name(cg_controller c)
607 {
608   return cg_controllers[c].name;
609 }
610
611 static const int cg_controller_optional(cg_controller c)
612 {
613   return cg_controllers[c].optional;
614 }
615
616 static char cg_name[256];
617
618 #define CG_BUFSIZE 1024
619
620 static void
621 cg_makepath(char *buf, size_t len, cg_controller c, const char *attr)
622 {
623   const char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
624   snprintf(buf, len, "%s/%s/%s/%s", cg_root, cg_controller_name(c), cg_name, attr);
625 }
626
627 static int
628 cg_read(cg_controller controller, const char *attr, char *buf)
629 {
630   int maybe = 0;
631   if (attr[0] == '?')
632     {
633       attr++;
634       maybe = 1;
635     }
636
637   char path[256];
638   cg_makepath(path, sizeof(path), controller, attr);
639
640   int fd = open(path, O_RDONLY);
641   if (fd < 0)
642     {
643       if (maybe)
644         return 0;
645       die("Cannot read %s: %m", path);
646     }
647
648   int n = read(fd, buf, CG_BUFSIZE);
649   if (n < 0)
650     die("Cannot read %s: %m", path);
651   if (n >= CG_BUFSIZE - 1)
652     die("Attribute %s too long", path);
653   if (n > 0 && buf[n-1] == '\n')
654     n--;
655   buf[n] = 0;
656
657   if (verbose > 1)
658     msg("CG: Read %s = %s\n", attr, buf);
659
660   close(fd);
661   return 1;
662 }
663
664 static void __attribute__((format(printf,3,4)))
665 cg_write(cg_controller controller, const char *attr, const char *fmt, ...)
666 {
667   int maybe = 0;
668   if (attr[0] == '?')
669     {
670       attr++;
671       maybe = 1;
672     }
673
674   va_list args;
675   va_start(args, fmt);
676
677   char buf[CG_BUFSIZE];
678   int n = vsnprintf(buf, sizeof(buf), fmt, args);
679   if (n >= CG_BUFSIZE)
680     die("cg_write: Value for attribute %s is too long", attr);
681
682   if (verbose > 1)
683     msg("CG: Write %s = %s", attr, buf);
684
685   char path[256];
686   cg_makepath(path, sizeof(path), controller, attr);
687
688   int fd = open(path, O_WRONLY | O_TRUNC);
689   if (fd < 0)
690     {
691       if (maybe)
692         return;
693       else
694         die("Cannot write %s: %m", path);
695     }
696
697   int written = write(fd, buf, n);
698   if (written < 0)
699     {
700       if (maybe)
701         return;
702       else
703         die("Cannot set %s to %s: %m", path, buf);
704     }
705   if (written != n)
706     die("Short write to %s (%d out of %d bytes)", path, written, n);
707
708   close(fd);
709   va_end(args);
710 }
711
712 static void
713 cg_init(void)
714 {
715   if (!cg_enable)
716     return;
717
718   char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
719   if (!dir_exists(cg_root))
720     die("Control group filesystem at %s not mounted", cg_root);
721
722   snprintf(cg_name, sizeof(cg_name), "box-%d", box_id);
723   msg("Using control group %s\n", cg_name);
724 }
725
726 static void
727 cg_prepare(void)
728 {
729   if (!cg_enable)
730     return;
731
732   struct stat st;
733   char buf[CG_BUFSIZE];
734   char path[256];
735
736   FOREACH_CG_CONTROLLER(controller)
737     {
738       cg_makepath(path, sizeof(path), controller, "");
739       if (stat(path, &st) >= 0 || errno != ENOENT)
740         {
741           msg("Control group %s already exists, trying to empty it.\n", path);
742           if (rmdir(path) < 0)
743             die("Failed to reset control group %s: %m", path);
744         }
745
746       if (mkdir(path, 0777) < 0 && !cg_controller_optional(controller))
747         die("Failed to create control group %s: %m", path);
748     }
749
750   // If cpuset module is enabled, copy allowed cpus and memory nodes from parent group
751   if (cg_read(CG_CPUSET, "?cpuset.cpus", buf))
752     cg_write(CG_CPUSET, "cpuset.cpus", "%s", buf);
753   if (cg_read(CG_CPUSET, "?cpuset.mems", buf))
754     cg_write(CG_CPUSET, "cpuset.mems", "%s", buf);
755 }
756
757 static void
758 cg_enter(void)
759 {
760   if (!cg_enable)
761     return;
762
763   msg("Entering control group %s\n", cg_name);
764
765   FOREACH_CG_CONTROLLER(controller)
766     {
767       if (cg_controller_optional(controller))
768         cg_write(controller, "?tasks", "%d\n", (int) getpid());
769       else
770         cg_write(controller, "tasks", "%d\n", (int) getpid());
771     }
772
773   if (cg_memory_limit)
774     {
775       cg_write(CG_MEMORY, "memory.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
776       cg_write(CG_MEMORY, "memory.memsw.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
777     }
778
779   if (cg_timing)
780     cg_write(CG_CPUACCT, "cpuacct.usage", "0\n");
781 }
782
783 static int
784 cg_get_run_time_ms(void)
785 {
786   if (!cg_enable)
787     return 0;
788
789   char buf[CG_BUFSIZE];
790   cg_read(CG_CPUACCT, "cpuacct.usage", buf);
791   unsigned long long ns = atoll(buf);
792   return ns / 1000000;
793 }
794
795 static void
796 cg_stats(void)
797 {
798   if (!cg_enable)
799     return;
800
801   char buf[CG_BUFSIZE];
802
803   // Memory usage statistics
804   unsigned long long mem=0, memsw=0;
805   if (cg_read(CG_MEMORY, "?memory.max_usage_in_bytes", buf))
806     mem = atoll(buf);
807   if (cg_read(CG_MEMORY, "?memory.memsw.max_usage_in_bytes", buf))
808     {
809       memsw = atoll(buf);
810       if (memsw > mem)
811         mem = memsw;
812     }
813   if (mem)
814     meta_printf("cg-mem:%lld\n", mem >> 10);
815 }
816
817 static void
818 cg_remove(void)
819 {
820   char buf[CG_BUFSIZE];
821
822   if (!cg_enable)
823     return;
824
825   FOREACH_CG_CONTROLLER(controller)
826     {
827       if (cg_controller_optional(controller)) {
828         if (!cg_read(controller, "?tasks", buf))
829           continue;
830       } else
831         cg_read(controller, "tasks", buf);
832
833       if (buf[0])
834         die("Some tasks left in controller %s of cgroup %s, failed to remove it",
835             cg_controller_name(controller), cg_name);
836
837       char path[256];
838       cg_makepath(path, sizeof(path), controller, "");
839
840       if (rmdir(path) < 0)
841         die("Cannot remove control group %s: %m", path);
842     }
843 }
844
845 /*** Disk quotas ***/
846
847 static int
848 path_begins_with(char *path, char *with)
849 {
850   while (*with)
851     if (*path++ != *with++)
852       return 0;
853   return (!*with || *with == '/');
854 }
855
856 static char *
857 find_device(char *path)
858 {
859   FILE *f = setmntent("/proc/mounts", "r");
860   if (!f)
861     die("Cannot open /proc/mounts: %m");
862
863   struct mntent *me;
864   int best_len = 0;
865   char *best_dev = NULL;
866   while (me = getmntent(f))
867     {
868       if (!path_begins_with(me->mnt_fsname, "/dev"))
869         continue;
870       if (path_begins_with(path, me->mnt_dir))
871         {
872           int len = strlen(me->mnt_dir);
873           if (len > best_len)
874             {
875               best_len = len;
876               free(best_dev);
877               best_dev = xstrdup(me->mnt_fsname);
878             }
879         }
880     }
881   endmntent(f);
882   return best_dev;
883 }
884
885 static void
886 set_quota(void)
887 {
888   if (!block_quota)
889     return;
890
891   char cwd[PATH_MAX];
892   if (!getcwd(cwd, sizeof(cwd)))
893     die("getcwd: %m");
894
895   char *dev = find_device(cwd);
896   if (!dev)
897     die("Cannot identify filesystem which contains %s", cwd);
898   msg("Quota: Mapped path %s to a filesystem on %s\n", cwd, dev);
899
900   // Sanity check
901   struct stat dev_st, cwd_st;
902   if (stat(dev, &dev_st) < 0)
903     die("Cannot identify block device %s: %m", dev);
904   if (!S_ISBLK(dev_st.st_mode))
905     die("Expected that %s is a block device", dev);
906   if (stat(".", &cwd_st) < 0)
907     die("Cannot stat cwd: %m");
908   if (cwd_st.st_dev != dev_st.st_rdev)
909     die("Identified %s as a filesystem on %s, but it is obviously false", cwd, dev);
910
911   struct dqblk dq = {
912     .dqb_bhardlimit = block_quota,
913     .dqb_bsoftlimit = block_quota,
914     .dqb_ihardlimit = inode_quota,
915     .dqb_isoftlimit = inode_quota,
916     .dqb_valid = QIF_LIMITS,
917   };
918   if (quotactl(QCMD(Q_SETQUOTA, USRQUOTA), dev, box_uid, (caddr_t) &dq) < 0)
919     die("Cannot set disk quota: %m");
920   msg("Quota: Set block quota %d and inode quota %d\n", block_quota, inode_quota);
921
922   free(dev);
923 }
924
925 /*** The keeper process ***/
926
927 static void
928 signal_alarm(int unused UNUSED)
929 {
930   /* Time limit checks are synchronous, so we only schedule them there. */
931   timer_tick = 1;
932   alarm(1);
933 }
934
935 static void
936 signal_int(int unused UNUSED)
937 {
938   /* Interrupts are fatal, so no synchronization requirements. */
939   meta_printf("exitsig:%d\n", SIGINT);
940   err("SG: Interrupted");
941 }
942
943 #define PROC_BUF_SIZE 4096
944 static void
945 read_proc_file(char *buf, char *name, int *fdp)
946 {
947   int c;
948
949   if (!*fdp)
950     {
951       sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
952       *fdp = open(buf, O_RDONLY);
953       if (*fdp < 0)
954         die("open(%s): %m", buf);
955     }
956   lseek(*fdp, 0, SEEK_SET);
957   if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
958     die("read on /proc/$pid/%s: %m", name);
959   if (c >= PROC_BUF_SIZE-1)
960     die("/proc/$pid/%s too long", name);
961   buf[c] = 0;
962 }
963
964 static int
965 get_wall_time_ms(void)
966 {
967   struct timeval now, wall;
968   gettimeofday(&now, NULL);
969   timersub(&now, &start_time, &wall);
970   return wall.tv_sec*1000 + wall.tv_usec/1000;
971 }
972
973 static int
974 get_run_time_ms(struct rusage *rus)
975 {
976   if (cg_timing)
977     return cg_get_run_time_ms();
978
979   if (rus)
980     {
981       struct timeval total;
982       timeradd(&rus->ru_utime, &rus->ru_stime, &total);
983       return total.tv_sec*1000 + total.tv_usec/1000;
984     }
985
986   char buf[PROC_BUF_SIZE], *x;
987   int utime, stime;
988   static int proc_stat_fd;
989
990   read_proc_file(buf, "stat", &proc_stat_fd);
991   x = buf;
992   while (*x && *x != ' ')
993     x++;
994   while (*x == ' ')
995     x++;
996   if (*x++ != '(')
997     die("proc stat syntax error 1");
998   while (*x && (*x != ')' || x[1] != ' '))
999     x++;
1000   while (*x == ')' || *x == ' ')
1001     x++;
1002   if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
1003     die("proc stat syntax error 2");
1004
1005   return (utime + stime) * 1000 / ticks_per_sec;
1006 }
1007
1008 static void
1009 check_timeout(void)
1010 {
1011   if (wall_timeout)
1012     {
1013       int wall_ms = get_wall_time_ms();
1014       if (wall_ms > wall_timeout)
1015         err("TO: Time limit exceeded (wall clock)");
1016       if (verbose > 1)
1017         fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
1018     }
1019   if (timeout)
1020     {
1021       int ms = get_run_time_ms(NULL);
1022       if (verbose > 1)
1023         fprintf(stderr, "[time check: %d msec]\n", ms);
1024       if (ms > timeout && ms > extra_timeout)
1025         err("TO: Time limit exceeded");
1026     }
1027 }
1028
1029 static void
1030 box_keeper(void)
1031 {
1032   read_errors_from_fd = error_pipes[0];
1033   close(error_pipes[1]);
1034
1035   struct sigaction sa;
1036   bzero(&sa, sizeof(sa));
1037   sa.sa_handler = signal_int;
1038   sigaction(SIGINT, &sa, NULL);
1039
1040   gettimeofday(&start_time, NULL);
1041   ticks_per_sec = sysconf(_SC_CLK_TCK);
1042   if (ticks_per_sec <= 0)
1043     die("Invalid ticks_per_sec!");
1044
1045   if (timeout || wall_timeout)
1046     {
1047       sa.sa_handler = signal_alarm;
1048       sigaction(SIGALRM, &sa, NULL);
1049       alarm(1);
1050     }
1051
1052   for(;;)
1053     {
1054       struct rusage rus;
1055       int stat;
1056       pid_t p;
1057       if (timer_tick)
1058         {
1059           check_timeout();
1060           timer_tick = 0;
1061         }
1062       p = wait4(box_pid, &stat, 0, &rus);
1063       if (p < 0)
1064         {
1065           if (errno == EINTR)
1066             continue;
1067           die("wait4: %m");
1068         }
1069       if (p != box_pid)
1070         die("wait4: unknown pid %d exited!", p);
1071       box_pid = 0;
1072
1073       // Check error pipe if there is an internal error passed from inside the box
1074       char interr[1024];
1075       int n = read(read_errors_from_fd, interr, sizeof(interr) - 1);
1076       if (n > 0)
1077         {
1078           interr[n] = 0;
1079           die("%s", interr);
1080         }
1081
1082       if (WIFEXITED(stat))
1083         {
1084           final_stats(&rus);
1085           if (WEXITSTATUS(stat))
1086             {
1087               meta_printf("exitcode:%d\n", WEXITSTATUS(stat));
1088               err("RE: Exited with error status %d", WEXITSTATUS(stat));
1089             }
1090           if (timeout && total_ms > timeout)
1091             err("TO: Time limit exceeded");
1092           if (wall_timeout && wall_ms > wall_timeout)
1093             err("TO: Time limit exceeded (wall clock)");
1094           flush_line();
1095           fprintf(stderr, "OK (%d.%03d sec real, %d.%03d sec wall)\n",
1096               total_ms/1000, total_ms%1000,
1097               wall_ms/1000, wall_ms%1000);
1098           box_exit(0);
1099         }
1100       else if (WIFSIGNALED(stat))
1101         {
1102           meta_printf("exitsig:%d\n", WTERMSIG(stat));
1103           final_stats(&rus);
1104           err("SG: Caught fatal signal %d", WTERMSIG(stat));
1105         }
1106       else if (WIFSTOPPED(stat))
1107         {
1108           meta_printf("exitsig:%d\n", WSTOPSIG(stat));
1109           final_stats(&rus);
1110           err("SG: Stopped by signal %d", WSTOPSIG(stat));
1111         }
1112       else
1113         die("wait4: unknown status %x, giving up!", stat);
1114     }
1115 }
1116
1117 /*** The process running inside the box ***/
1118
1119 static void
1120 setup_root(void)
1121 {
1122   if (mkdir("root", 0750) < 0 && errno != EEXIST)
1123     die("mkdir('root'): %m");
1124
1125   if (mount("none", "root", "tmpfs", 0, "mode=755") < 0)
1126     die("Cannot mount root ramdisk: %m");
1127
1128   apply_dir_rules();
1129
1130   if (chroot("root") < 0)
1131     die("Chroot failed: %m");
1132
1133   if (chdir("root/box") < 0)
1134     die("Cannot change current directory: %m");
1135 }
1136
1137 static void
1138 setup_credentials(void)
1139 {
1140   if (setresgid(box_gid, box_gid, box_gid) < 0)
1141     die("setresgid: %m");
1142   if (setgroups(0, NULL) < 0)
1143     die("setgroups: %m");
1144   if (setresuid(box_uid, box_uid, box_uid) < 0)
1145     die("setresuid: %m");
1146   setpgrp();
1147 }
1148
1149 static void
1150 setup_fds(void)
1151 {
1152   if (redir_stdin)
1153     {
1154       close(0);
1155       if (open(redir_stdin, O_RDONLY) != 0)
1156         die("open(\"%s\"): %m", redir_stdin);
1157     }
1158   if (redir_stdout)
1159     {
1160       close(1);
1161       if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
1162         die("open(\"%s\"): %m", redir_stdout);
1163     }
1164   if (redir_stderr)
1165     {
1166       close(2);
1167       if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
1168         die("open(\"%s\"): %m", redir_stderr);
1169     }
1170   else
1171     dup2(1, 2);
1172 }
1173
1174 static void
1175 setup_rlim(const char *res_name, int res, rlim_t limit)
1176 {
1177   struct rlimit rl = { .rlim_cur = limit, .rlim_max = limit };
1178   if (setrlimit(res, &rl) < 0)
1179     die("setrlimit(%s, %jd)", res_name, (intmax_t) limit);
1180 }
1181
1182 static void
1183 setup_rlimits(void)
1184 {
1185 #define RLIM(res, val) setup_rlim("RLIMIT_" #res, RLIMIT_##res, val)
1186
1187   if (memory_limit)
1188     RLIM(AS, memory_limit * 1024);
1189
1190   RLIM(STACK, (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY));
1191   RLIM(NOFILE, 64);
1192   RLIM(MEMLOCK, 0);
1193
1194   if (max_processes)
1195     RLIM(NPROC, max_processes);
1196
1197 #undef RLIM
1198 }
1199
1200 static int
1201 box_inside(void *arg)
1202 {
1203   char **args = arg;
1204   write_errors_to_fd = error_pipes[1];
1205   close(error_pipes[0]);
1206
1207   cg_enter();
1208   setup_root();
1209   setup_credentials();
1210   setup_fds();
1211   setup_rlimits();
1212   char **env = setup_environment();
1213
1214   if (set_cwd && chdir(set_cwd))
1215     die("chdir: %m");
1216
1217   execve(args[0], args, env);
1218   die("execve(\"%s\"): %m", args[0]);
1219 }
1220
1221 static void
1222 box_init(void)
1223 {
1224   if (box_id < 0 || box_id >= CONFIG_ISOLATE_NUM_BOXES)
1225     die("Sandbox ID out of range (allowed: 0-%d)", CONFIG_ISOLATE_NUM_BOXES-1);
1226   box_uid = CONFIG_ISOLATE_FIRST_UID + box_id;
1227   box_gid = CONFIG_ISOLATE_FIRST_GID + box_id;
1228
1229   snprintf(box_dir, sizeof(box_dir), "%s/%d", CONFIG_ISOLATE_BOX_DIR, box_id);
1230   make_dir(box_dir);
1231   if (chdir(box_dir) < 0)
1232     die("chdir(%s): %m", box_dir);
1233 }
1234
1235 /*** Commands ***/
1236
1237 static void
1238 init(void)
1239 {
1240   msg("Preparing sandbox directory\n");
1241   xsystem("rm -rf box");
1242   if (mkdir("box", 0700) < 0)
1243     die("Cannot create box: %m");
1244   if (chown("box", orig_uid, orig_gid) < 0)
1245     die("Cannot chown box: %m");
1246
1247   cg_prepare();
1248   set_quota();
1249
1250   puts(box_dir);
1251 }
1252
1253 static void
1254 cleanup(void)
1255 {
1256   if (!dir_exists("box"))
1257     die("Box directory not found, there isn't anything to clean up");
1258
1259   msg("Deleting sandbox directory\n");
1260   xsystem("rm -rf *");
1261   if (rmdir(box_dir) < 0)
1262     die("Cannot remove %s: %m", box_dir);
1263   cg_remove();
1264 }
1265
1266 static void
1267 run(char **argv)
1268 {
1269   if (!dir_exists("box"))
1270     die("Box directory not found, did you run `isolate --init'?");
1271
1272   char cmd[256];
1273   snprintf(cmd, sizeof(cmd), "chown -R %d.%d box", box_uid, box_gid);
1274   xsystem(cmd);
1275   snprintf(cleanup_cmd, sizeof(cleanup_cmd), "chown -R %d.%d box", orig_uid, orig_gid);
1276
1277   if (pipe(error_pipes) < 0)
1278     die("pipe: %m");
1279   for (int i=0; i<2; i++)
1280     if (fcntl(error_pipes[i], F_SETFD, fcntl(error_pipes[i], F_GETFD) | FD_CLOEXEC) < 0 ||
1281         fcntl(error_pipes[i], F_SETFL, fcntl(error_pipes[i], F_GETFL) | O_NONBLOCK) < 0)
1282       die("fcntl on pipe: %m");
1283
1284   box_pid = clone(
1285     box_inside,                 // Function to execute as the body of the new process
1286     argv,                       // Pass our stack
1287     SIGCHLD | CLONE_NEWIPC | CLONE_NEWNET | CLONE_NEWNS | CLONE_NEWPID,
1288     argv);                      // Pass the arguments
1289   if (box_pid < 0)
1290     die("clone: %m");
1291   if (!box_pid)
1292     die("clone returned 0");
1293   box_keeper();
1294 }
1295
1296 static void
1297 show_version(void)
1298 {
1299   printf("Process isolator 1.0\n");
1300   printf("(c) 2012 Martin Mares and Bernard Blackham\n");
1301   printf("\nCompile-time configuration:\n");
1302   printf("Sandbox directory: %s\n", CONFIG_ISOLATE_BOX_DIR);
1303   printf("Sandbox credentials: uid=%u-%u gid=%u-%u\n",
1304     CONFIG_ISOLATE_FIRST_UID,
1305     CONFIG_ISOLATE_FIRST_UID + CONFIG_ISOLATE_NUM_BOXES - 1,
1306     CONFIG_ISOLATE_FIRST_GID,
1307     CONFIG_ISOLATE_FIRST_GID + CONFIG_ISOLATE_NUM_BOXES - 1);
1308 }
1309
1310 /*** Options ***/
1311
1312 static void __attribute__((format(printf,1,2)))
1313 usage(const char *msg, ...)
1314 {
1315   if (msg != NULL)
1316     {
1317       va_list args;
1318       va_start(args, msg);
1319       vfprintf(stderr, msg, args);
1320       va_end(args);
1321     }
1322   printf("\
1323 Usage: isolate [<options>] <command>\n\
1324 \n\
1325 Options:\n\
1326 -b, --box-id=<id>\tWhen multiple sandboxes are used in parallel, each must get a unique ID\n\
1327 -c, --cg[=<parent>]\tPut process in a control group (optionally a sub-group of <parent>)\n\
1328     --cg-mem=<size>\tLimit memory usage of the control group to <size> KB\n\
1329     --cg-timing\t\tTime limits affects total run time of the control group\n\
1330 -d, --dir=<dir>\t\tMake a directory <dir> visible inside the sandbox\n\
1331     --dir=<in>=<out>\tMake a directory <out> outside visible as <in> inside\n\
1332     --dir=<in>=\t\tDelete a previously defined directory rule (even a default one)\n\
1333     --dir=...:<opt>\tSpecify options for a rule:\n\
1334 \t\t\t\tdev\tAllow access to special files\n\
1335 \t\t\t\tfs\tMount a filesystem (e.g., --dir=/proc:proc:fs)\n\
1336 \t\t\t\tmaybe\tSkip the rule if <out> does not exist\n\
1337 \t\t\t\tnoexec\tDo not allow execution of binaries\n\
1338 \t\t\t\trw\tAllow read-write access\n\
1339 -E, --env=<var>\t\tInherit the environment variable <var> from the parent process\n\
1340 -E, --env=<var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
1341 -x, --extra-time=<time>\tSet extra timeout, before which a timing-out program is not yet killed,\n\
1342 \t\t\tso that its real execution time is reported (seconds, fractions allowed)\n\
1343 -e, --full-env\t\tInherit full environment of the parent process\n\
1344 -m, --mem=<size>\tLimit address space to <size> KB\n\
1345 -M, --meta=<file>\tOutput process information to <file> (name:value)\n\
1346 -q, --quota=<blk>,<ino>\tSet disk quota to <blk> blocks and <ino> inodes\n\
1347 -k, --stack=<size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
1348 -r, --stderr=<file>\tRedirect stderr to <file>\n\
1349 -i, --stdin=<file>\tRedirect stdin from <file>\n\
1350 -o, --stdout=<file>\tRedirect stdout to <file>\n\
1351 -p, --processes[=<max>]\tEnable multiple processes (at most <max> of them); needs --cg\n\
1352 -t, --time=<time>\tSet run time limit (seconds, fractions allowed)\n\
1353 -v, --verbose\t\tBe verbose (use multiple times for even more verbosity)\n\
1354 -w, --wall-time=<time>\tSet wall clock time limit (seconds, fractions allowed)\n\
1355 \n\
1356 Commands:\n\
1357     --init\t\tInitialize sandbox (and its control group when --cg is used)\n\
1358     --run -- <cmd> ...\tRun given command within sandbox\n\
1359     --cleanup\t\tClean up sandbox\n\
1360     --version\t\tDisplay program version and configuration\n\
1361 ");
1362   exit(2);
1363 }
1364
1365 enum opt_code {
1366   OPT_INIT = 256,
1367   OPT_RUN,
1368   OPT_CLEANUP,
1369   OPT_VERSION,
1370   OPT_CG,
1371   OPT_CG_MEM,
1372   OPT_CG_TIMING,
1373 };
1374
1375 static const char short_opts[] = "b:c:d:eE:i:k:m:M:o:p::q:r:t:vw:x:";
1376
1377 static const struct option long_opts[] = {
1378   { "box-id",           1, NULL, 'b' },
1379   { "chdir",            1, NULL, 'c' },
1380   { "cg",               0, NULL, OPT_CG },
1381   { "cg-mem",           1, NULL, OPT_CG_MEM },
1382   { "cg-timing",        0, NULL, OPT_CG_TIMING },
1383   { "cleanup",          0, NULL, OPT_CLEANUP },
1384   { "dir",              1, NULL, 'd' },
1385   { "env",              1, NULL, 'E' },
1386   { "extra-time",       1, NULL, 'x' },
1387   { "full-env",         0, NULL, 'e' },
1388   { "init",             0, NULL, OPT_INIT },
1389   { "mem",              1, NULL, 'm' },
1390   { "meta",             1, NULL, 'M' },
1391   { "processes",        2, NULL, 'p' },
1392   { "quota",            1, NULL, 'q' },
1393   { "run",              0, NULL, OPT_RUN },
1394   { "stack",            1, NULL, 'k' },
1395   { "stderr",           1, NULL, 'r' },
1396   { "stdin",            1, NULL, 'i' },
1397   { "stdout",           1, NULL, 'o' },
1398   { "time",             1, NULL, 't' },
1399   { "verbose",          0, NULL, 'v' },
1400   { "version",          0, NULL, OPT_VERSION },
1401   { "wall-time",        1, NULL, 'w' },
1402   { NULL,               0, NULL, 0 }
1403 };
1404
1405 int
1406 main(int argc, char **argv)
1407 {
1408   int c;
1409   char *sep;
1410   enum opt_code mode = 0;
1411
1412   init_dir_rules();
1413
1414   while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) >= 0)
1415     switch (c)
1416       {
1417       case 'b':
1418         box_id = atoi(optarg);
1419         break;
1420       case 'c':
1421         set_cwd = optarg;
1422         break;
1423       case OPT_CG:
1424         cg_enable = 1;
1425         break;
1426       case 'd':
1427         if (!set_dir_action(optarg))
1428           usage("Invalid directory specified: %s\n", optarg);
1429         break;
1430       case 'e':
1431         pass_environ = 1;
1432         break;
1433       case 'E':
1434         if (!set_env_action(optarg))
1435           usage("Invalid environment specified: %s\n", optarg);
1436         break;
1437       case 'k':
1438         stack_limit = atoi(optarg);
1439         break;
1440       case 'i':
1441         redir_stdin = optarg;
1442         break;
1443       case 'm':
1444         memory_limit = atoi(optarg);
1445         break;
1446       case 'M':
1447         meta_open(optarg);
1448         break;
1449       case 'o':
1450         redir_stdout = optarg;
1451         break;
1452       case 'p':
1453         if (optarg)
1454           max_processes = atoi(optarg);
1455         else
1456           max_processes = 0;
1457         break;
1458       case 'q':
1459         sep = strchr(optarg, ',');
1460         if (!sep)
1461           usage("Invalid quota specified: %s\n", optarg);
1462         block_quota = atoi(optarg);
1463         inode_quota = atoi(sep+1);
1464         break;
1465       case 'r':
1466         redir_stderr = optarg;
1467         break;
1468       case 't':
1469         timeout = 1000*atof(optarg);
1470         break;
1471       case 'v':
1472         verbose++;
1473         break;
1474       case 'w':
1475         wall_timeout = 1000*atof(optarg);
1476         break;
1477       case 'x':
1478         extra_timeout = 1000*atof(optarg);
1479         break;
1480       case OPT_INIT:
1481       case OPT_RUN:
1482       case OPT_CLEANUP:
1483       case OPT_VERSION:
1484         if (!mode || mode == c)
1485           mode = c;
1486         else
1487           usage("Only one command is allowed.\n");
1488         break;
1489       case OPT_CG_MEM:
1490         cg_memory_limit = atoi(optarg);
1491         break;
1492       case OPT_CG_TIMING:
1493         cg_timing = 1;
1494         break;
1495       default:
1496         usage(NULL);
1497       }
1498
1499   if (!mode)
1500     usage("Please specify an isolate command (e.g. --init, --run).\n");
1501   if (mode == OPT_VERSION)
1502     {
1503       show_version();
1504       return 0;
1505     }
1506
1507   if (geteuid())
1508     die("Must be started as root");
1509   orig_uid = getuid();
1510   orig_gid = getgid();
1511
1512   umask(022);
1513   box_init();
1514   cg_init();
1515
1516   switch (mode)
1517     {
1518     case OPT_INIT:
1519       if (optind < argc)
1520         usage("--init mode takes no parameters\n");
1521       init();
1522       break;
1523     case OPT_RUN:
1524       if (optind >= argc)
1525         usage("--run mode requires a command to run\n");
1526       run(argv+optind);
1527       break;
1528     case OPT_CLEANUP:
1529       if (optind < argc)
1530         usage("--cleanup mode takes no parameters\n");
1531       cleanup();
1532       break;
1533     default:
1534       die("Internal error: mode mismatch");
1535     }
1536   exit(0);
1537 }