chpid.c

   1 /* gcc -Wall -O2 -g chpid.c -o chpid */
   2 #define _XOPEN_SOURCE
   3 #define _XOPEN_SOURCE_EXTENDED
   4 #define _SVID_SOURCE
   5 #define _GNU_SOURCE
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <string.h>
   9 #include <stdlib.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <sys/syscall.h>
  13 #include <sys/wait.h>
  14 #include <sys/time.h>
  15 #include <sys/resource.h>
  16 #include <sys/mount.h>
  17 #include <sys/vfs.h>
  18 #include <fcntl.h>
  19 #include <unistd.h>
  20 #include <sched.h>
  21 #include <stdarg.h>
  22 #include <dirent.h>
  23
  24 #ifndef MNT_FORCE
  25 #define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
  26 #endif /* MNT_FORCE */
  27 #ifndef MNT_DETACH
  28 #define MNT_DETACH      0x00000002      /* Just detach from the tree */
  29 #endif /* MNT_DETACH */
  30 #ifndef MNT_EXPIRE
  31 #define MNT_EXPIRE      0x00000004      /* Mark for expiry */
  32 #endif /* MNT_EXPIRE */
  33
  34 #ifndef MS_MOVE
  35 #define MS_MOVE 8192
  36 #endif
  37 #ifndef MS_REC
  38 #define MS_REC 16384
  39 #endif
  40
  41 #ifdef OLD
  42 # ifndef CLONE_NPSPACE
  43 # define CLONE_NPSPACE  0x04000000      /* New process space */
  44 # endif
  45 # ifndef CLONE_NSYSVIPC
  46 # define CLONE_NSYSVIPC 0x08000000      /* New sysvipc space */
  47 # endif
  48 # ifndef CLONE_NHOST
  49 # define CLONE_NHOST    0x10000000      /* New networking host context (lo, hostname, etc) */
  50 # endif
  51 # ifndef CLONE_NDEV
  52 # define CLONE_NDEV     0x20000000      /* New hash of devices I can touch */
  53 # endif
  54 # ifndef CLONE_NUSERS
  55 # define CLONE_NUSERS   0x40000000      /* New users */
  56 # endif
  57 # ifndef CLONE_NTIME
  58 # define CLONE_NTIME    0x80000000      /* New time context??? */
  59 # endif
  60 # ifndef CLONE_NS_NOSUID
  61 # define CLONE_NS_NOSUID        0x00001000      /* Force MNT_NOSUID on all mounts in the namespace */
  62 # endif
  63 #endif
  64
  65 #ifndef CLONE_NEWUTS
  66 #define CLONE_NEWUTS    0x04000000      /* New uts namespace (uname) */
  67 #endif
  68 #ifndef CLONE_NEWIPC
  69 #define CLONE_NEWIPC    0x08000000      /* New sysvipc namespace */
  70 #endif
  71 #ifndef CLONE_NEWUID
  72 #define CLONE_NEWUID    0x10000000      /* New users */
  73 #endif
  74 #ifndef CLONE_NEWNET
  75 #define CLONE_NEWNET    0x40000000      /* New network namespace (lo, device, names sockets, etc) */
  76 #endif
  77 #ifndef CLONE_NEWPID
  78 #define CLONE_NEWPID    0x80000000      /* New process space */
  79 #endif
  80 #ifndef CLONE_NEWTIME
  81 #define CLONE_NEWTIME   0x40000000      /* New time context??? */
  82 #endif
  83 #ifndef CLONE_NEWDEV
  84 #define CLONE_NEWDEV    0x00001000      /* New has of devices I can touch */
  85 #endif
  86
  87
  88 #ifndef PROC_SUPER_MAGIC
  89 #define PROC_SUPER_MAGIC 0x9fa0
  90 #endif /* PROC_SUPER_MAGIC */
  91
  92 struct user_desc;
  93 static pid_t raw_clone(int flags, void *child_stack,
  94        int *parent_tidptr, struct user_desc *newtls, int *child_tidptr)
  95 {
  96        return syscall(__NR_clone, flags, child_stack, parent_tidptr, newtls, child_tidptr);
  97 }
  98
  99 static int raw_pivot_root(const char *new_root, const char *old_root)
 100 {
 101        return syscall(__NR_pivot_root, new_root, old_root);
 102 }
 103
 104 static void (*my_exit)(int status) = exit;
 105
 106 static void die(char *fmt, ...)
 107 {
 108        va_list ap;
 109        va_start(ap, fmt);
 110        vfprintf(stderr, fmt, ap);
 111        va_end(ap);
 112        fflush(stderr);
 113        fflush(stdout);
 114        my_exit(1);
 115 }
 116
 117 static void *xmalloc(size_t size)
 118 {
 119        void *ptr;
 120        ptr = malloc(size);
 121        if (!ptr) die("malloc of %d bytes failed: %s\n", size, strerror(errno));
 122        return ptr;
 123 }
 124
 125 static void umount_buffer(char *line)
 126 {
 127        char *next, *mnt, *end, *type;
 128        int result;
 129        if (!line || !*line)
 130                return;
 131        next = strchr(line, '\n');
 132        *next++ = '0';
 133        type = line;
 134        mnt = strchr(line, ' ');
 135        *mnt++ = '\0';
 136        end = strchr(mnt, ' ');
 137        *end = '\0';
 138        umount_buffer(next);
 139
 140 #if 0
 141        /* For debugging list what I am unounting */
 142        write(STDOUT_FILENO, mnt, strlen(mnt));
 143        write(STDOUT_FILENO, "\n", 1);
 144 #endif
 145
 146        if (strcmp(type, "rootfs"))
 147                return;
 148        result = umount2(mnt, MNT_DETACH);
 149        if (result < 0)
 150                die("umount of '%s' failed: %d: %s\n",
 151                        mnt, errno, strerror(errno));
 152 }
 153
 154 static void umount_all(void)
 155 {
 156        static const char mounts[] = "/proc/self/mounts";
 157        char *buf;
 158        ssize_t bufsz, bytes;
 159        int fd, result;
 160        buf = NULL;
 161        bufsz = 4096;
 162
 163        /* Temporarily mount /proc at / so I know I have it */
 164        result = mount("proc", "/proc", "proc", 0, NULL);
 165        if (result < 0)
 166                die("mount of proc failed: %d: %s\n",
 167                        errno, strerror(errno));
 168 #if 0
 169        DIR *dir;
 170        struct dirent *entry;
 171        dir = opendir("/");
 172        while((entry = readdir(dir)) != NULL) {
 173                write(STDOUT_FILENO, entry->d_name, strlen(entry->d_name));
 174                write(STDOUT_FILENO, "\n", 1);
 175        }
 176        closedir(dir);
 177 #endif
 178        fd = open(mounts, O_RDONLY);
 179        if (fd < 0)
 180                die("open of %s failed: %d: %s\n",
 181                        mounts, errno, strerror(errno));
 182
 183        /* Read in all of the mount points */
 184        do {
 185                buf = xmalloc(bufsz);
 186                result = lseek(fd, 0, SEEK_SET);
 187                if (result != 0)
 188                        die("lseek failed: %d:%s\n",
 189                                errno, strerror(errno));
 190                bytes = read(fd, buf, bufsz);
 191                if (bytes < 0)
 192                        die("Read of %s failed: %d:%s\n",
 193                                mounts, errno, strerror(errno));
 194                if (bytes != bufsz) {
 195                        /* Terminate the buffer */
 196                        buf[bytes] = '\0';
 197                } else {
 198                        /* Free the buffer and try again */
 199                        free(buf);
 200                        buf = NULL;
 201                        bufsz <<= 1;
 202                }
 203        } while(!buf);
 204        /* Be good and close the file descriptor */
 205        result = close(fd);
 206        if (result < 0)
 207                fprintf(stderr, "close of %s failed: %d:%s\n",
 208                        mounts, errno, strerror(errno));
 209
 210 #if 0
 211        /* For debugging print the list of mounts */
 212        write(STDOUT_FILENO, buf, bufsz);
 213        write(STDOUT_FILENO, "\n\n", 2);
 214 #endif
 215
 216        umount_buffer(buf);
 217 }
 218
 219 int main(int argc, char **argv, char **envp)
 220 {
 221        pid_t pid;
 222        int status;
 223        struct rlimit rlim;
 224        int clone_flags;
 225        char **cmd_argv, *shell_argv[2];
 226        char *root = "/", *old = "/mnt";
 227        char *label = "none";
 228        int i;
 229        int tty, tty_force;
 230
 231        tty = 0;
 232        tty_force = 0;
 233        clone_flags = SIGCHLD;
 234
 235        for (i = 1; (i < argc) && (argv[i][0] == '-'); i++) {
 236                if (strcmp(argv[i], "--") == 0) {
 237                        break;
 238                }
 239                else if (((argc - i) >= 2) && (strcmp(argv[i], "-r") == 0)) {
 240                        clone_flags |= CLONE_NEWNS;
 241                        root = argv[i + 1];
 242                        i++;
 243                }
 244                else if (((argc - i) >= 2) && (strcmp(argv[i], "-o") == 0)) {
 245                        old = argv[i + 1];
 246                        i++;
 247                }
 248                else if (((argc - i) >= 2) && (strcmp(argv[i], "-l") == 0)) {
 249                        clone_flags |= CLONE_NEWNS;
 250                        label = argv[i + 1];
 251                        i++;
 252                }
 253                else if (strcmp(argv[i], "-m") == 0) {
 254                        clone_flags |= CLONE_NEWNS;
 255                }
 256                else if (strcmp(argv[i], "-h") == 0) {
 257                        clone_flags |= CLONE_NEWUTS;
 258                }
 259                else if (strcmp(argv[i], "-i") == 0) {
 260                        clone_flags |= CLONE_NEWIPC;
 261                }
 262                else if (strcmp(argv[i], "-n") == 0) {
 263                        clone_flags |= CLONE_NEWNET;
 264                }
 265                else if (strcmp(argv[i], "-p") == 0) {
 266                        clone_flags |= CLONE_NEWPID;
 267                }
 268                else if (strcmp(argv[i], "-u") == 0) {
 269                        clone_flags |= CLONE_NEWUID;
 270                }
 271                else if (strcmp(argv[i], "-d") == 0) {
 272                        clone_flags |= CLONE_NEWDEV;
 273                }
 274                else if (strcmp(argv[i], "-t") == 0) {
 275                        clone_flags |= CLONE_NEWTIME;
 276                }
 277                else if (strcmp(argv[i], "--tty") == 0) {
 278                        tty = 1;
 279                }
 280                else if (strcmp(argv[i], "--tty-force") == 0) {
 281                        tty = 1; tty_force = 1;
 282                }
 283                else {
 284                        die("Bad argument %s\n", argv[i]);
 285                }
 286        }
 287        cmd_argv = argv + i;
 288        if (cmd_argv[0] == NULL) {
 289                cmd_argv = shell_argv;
 290                shell_argv[0] = getenv("SHELL");
 291                shell_argv[1] = NULL;
 292        }
 293        if (cmd_argv[0] == NULL) {
 294                die("No command specified\n");
 295        }
 296 #if 1
 297        fprintf(stderr, "cmd_argv: %s\n", cmd_argv[0]);
 298 #endif
 299        if (root[0] != '/') {
 300                die("root path: '%s' not absolute\n", root);
 301        }
 302        if (old[0] != '/') {
 303                die("old path: '%s' not absolute\n", old);
 304        }
 305
 306 #if 0
 307        status = getrlimit(RLIMIT_NPROC, &rlim);
 308        if (status < 0) {
 309                fprintf(stderr, "getrlimit RLIMIT_NPROC failed: %s\n",
 310                        strerror(errno));
 311                exit(1);
 312        }
 313        fprintf(stderr, "RLIMIT_NPROC: %llu %llu\n",
 314                (unsigned long long)rlim.rlim_cur, (unsigned long long)rlim.rlim_max);
 315 #endif
 316 #if 0
 317        rlim.rlim_cur = 256;
 318        status = setrlimit(RLIMIT_NPROC, &rlim);
 319        if (status < 0) {
 320                fprintf(stderr, "setrlimit RLIMIT_NPROC %lu %lu failed: %s\n",
 321                        (unsigned long)rlim.rlim_cur, (unsigned long)rlim.rlim_max,
 322                        strerror(errno));
 323                exit(2);
 324        }
 325 #endif
 326        printf("Clone flags: %lx\n", clone_flags);
 327        pid = raw_clone(clone_flags, NULL, NULL, NULL, NULL);
 328        if (pid < 0) {
 329                fprintf(stderr, "clone_failed: pid: %d %d:%s\n",
 330                        pid, errno, strerror(errno));
 331                exit(2);
 332        }
 333        if (pid == 0) {
 334                /* In the child */
 335                int result;
 336                my_exit = _exit;
 337
 338                /* FIXME allocate a process inside for controlling the new process space */
 339                if (clone_flags & CLONE_NEWPID) {
 340                        fprintf(stderr, "pid: %d, ppid: %d pgrp: %d sid: %d\n",
 341                                getpid(), getppid(), getpgid(0), getsid(0));
 342                        /* If CLONE_NEWPID isn't implemented exit */
 343                        if (getpid() != 1)
 344                                die("CLONE_NEWPID not implemented\n");
 345                }
 346
 347                if (clone_flags & CLONE_NEWNS) {
 348                        struct statfs stfs;
 349 #if 0
 350                        if (strcmp(root, "/") != 0) {
 351                                /* FIXME find a way to remove unreachable filesystems
 352                                 * from the namespace.
 353                                 */
 354                                result = chdir(root);
 355                                if (result < 0)
 356                                        die("chdir to '%s' failed: %d:%s\n",
 357                                                root, errno, strerror(errno));
 358                                /* Convert the current working directory into a mount point */
 359                                result = mount(".", ".", NULL, MS_BIND | MS_REC, NULL);
 360                                if (result < 0)
 361                                        die("bind of '%s' failed: %d: %s\n",
 362                                                root, errno, strerror(errno));
 363                                /* Update the current working directory */
 364                                result = chdir(root);
 365                                if (result < 0)
 366                                        die("chdir to '%s' failed: %d:%s\n",
 367                                                ".", errno, strerror(errno));
 368                                result = mount(".", "/", NULL, MS_MOVE, NULL);
 369                                if (result < 0)
 370                                        die("mount of '%s' failed: %d:%s\n",
 371                                                root, errno, strerror(errno));
 372                                result = chroot(".");
 373                                if (result < 0)
 374                                        die("chroot to '%s' failed: %d:%s\n",
 375                                                root, errno, strerror(errno));
 376                        }
 377 #endif
 378 #if 1
 379                        if (strcmp(root, "/") != 0) {
 380                                char put_old[PATH_MAX];
 381                                result = snprintf(put_old, sizeof(put_old), "%s%s", root, old);
 382                                if (result >= sizeof(put_old))
 383                                        die("path name to long\n");
 384                                if (result < 0)
 385                                        die("snprintf failed: %d:%s\n",
 386                                                errno, strerror(errno));
 387
 388                                /* Ensure I have a mount point at the directory I want to export */
 389                                result = mount(root, root, NULL, MS_BIND | MS_REC, NULL);
 390                                if (result < 0)
 391                                        die("bind of '%s' failed: %d:%s\n",
 392                                                root, errno, strerror(errno));
 393
 394                                /* Switch the mount points */
 395                                result = raw_pivot_root(root, put_old);
 396                                if (result < 0)
 397                                        die("pivot_root('%s', '%s') failed: %d:%s\n",
 398                                                root, put_old, errno, strerror(errno));
 399
 400                                /* Unmount all of the old mounts */
 401                                result = umount2(old, MNT_DETACH);
 402                                if (result < 0)
 403                                        die("umount2 of '%s' failed: %d:%s\n",
 404                                                put_old, errno, strerror(errno));
 405                        }
 406 #endif
 407
 408                        result = statfs("/proc", &stfs);
 409                        if ((result == 0) && (stfs.f_type == PROC_SUPER_MAGIC))  {
 410                                 printf ("Umounting proc\n");
 411                                /* Unmount and remount proc so it reflects the new pid space */
 412                                result = umount2("/proc", MNT_DETACH);
 413                                if (result < 0)
 414                                        die("umount failed: %d:%s\n", errno, strerror(errno));
 415
 416                                result = mount(label, "/proc", "proc", 0, NULL);
 417                                if (result < 0)
 418                                        die("mount failed: %d:%s\n",
 419                                                errno, strerror(errno));
 420                        }
 421                }
 422                if (tty) {
 423                        pid_t sid, pgrp;
 424                        sid = setsid();
 425                        if (sid < 0)
 426                                die("setsid failed: %d:%s\n",
 427                                        errno, strerror(errno));
 428                        fprintf(stderr, "pid: %d, ppid: %d pgrp: %d sid: %d\n",
 429                                getpid(), getppid(), getpgid(0), getsid(0));
 430
 431                        result = ioctl(STDIN_FILENO, TIOCSCTTY, tty_force);
 432                        if (result < 0)
 433                                die("tiocsctty failed: %d:%s\n",
 434                                        errno, strerror(errno));
 435
 436                        pgrp = tcgetpgrp(STDIN_FILENO);
 437
 438                        fprintf(stderr, "pgrp: %d\n", pgrp);
 439
 440                        fprintf(stderr, "pid: %d, ppid: %d pgrp: %d sid: %d\n",
 441                                getpid(), getppid(), getpgid(0), getsid(0));
 442
 443                }
 444                result = execve(cmd_argv[0], cmd_argv, envp);
 445                die("execve of %s failed: %d:%s\n",
 446                        cmd_argv[0], errno, strerror(errno));
 447        }
 448        /* In the parent */
 449        fprintf(stderr, "child pid: %d\n", pid);
 450        pid = waitpid(pid, &status, 0);
 451        fprintf(stderr, "pid: %d exited status: %d\n",
 452                pid, status);
 453        if (pid < 0) {
 454                fprintf(stderr, "waitpid failed: %d %s\n",
 455                        errno, strerror(errno));
 456                exit(9);
 457        }
 458        if (pid == 0) {
 459                fprintf(stderr, "waitpid returned no pid!\n");
 460                exit(10);
 461        }
 462        if (WIFEXITED(status)) {
 463                fprintf(stderr, "pid: %d exited: %d\n",
 464                        pid, WEXITSTATUS(status));
 465        }
 466        if (WIFSIGNALED(status)) {
 467                fprintf(stderr, "pid: %d exited with a uncaught signal: %d %s\n",
 468                        pid, WTERMSIG(status), strsignal(WTERMSIG(status)));
 469        }
 470        if (WIFSTOPPED(status)) {
 471                fprintf(stderr, "pid: %d stopped with signal: %d\n",
 472                        pid, WSTOPSIG(status));
 473        }
 474        return 0;
 475 }