granicus.if.org Git - strace/blob - clone.c

   1 #include "defs.h"
   2
   3 /* defines copied from linux/sched.h since we can't include that
   4  * ourselves (it conflicts with *lots* of libc includes)
   5  */
   6 #define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
   7 #define CLONE_VM        0x00000100      /* set if VM shared between processes */
   8 #define CLONE_FS        0x00000200      /* set if fs info shared between processes */
   9 #define CLONE_FILES     0x00000400      /* set if open files shared between processes */
  10 #define CLONE_SIGHAND   0x00000800      /* set if signal handlers shared */
  11 #define CLONE_IDLETASK  0x00001000      /* kernel-only flag */
  12 #define CLONE_PTRACE    0x00002000      /* set if we want to let tracing continue on the child too */
  13 #define CLONE_VFORK     0x00004000      /* set if the parent wants the child to wake it up on mm_release */
  14 #define CLONE_PARENT    0x00008000      /* set if we want to have the same parent as the cloner */
  15 #define CLONE_THREAD    0x00010000      /* Same thread group? */
  16 #define CLONE_NEWNS     0x00020000      /* New namespace group? */
  17 #define CLONE_SYSVSEM   0x00040000      /* share system V SEM_UNDO semantics */
  18 #define CLONE_SETTLS    0x00080000      /* create a new TLS for the child */
  19 #define CLONE_PARENT_SETTID     0x00100000      /* set the TID in the parent */
  20 #define CLONE_CHILD_CLEARTID    0x00200000      /* clear the TID in the child */
  21 #define CLONE_UNTRACED          0x00800000      /* set if the tracing process can't force CLONE_PTRACE on this clone */
  22 #define CLONE_CHILD_SETTID      0x01000000      /* set the TID in the child */
  23 #define CLONE_STOPPED           0x02000000      /* Start in stopped state */
  24 #define CLONE_NEWUTS            0x04000000      /* New utsname group? */
  25 #define CLONE_NEWIPC            0x08000000      /* New ipcs */
  26 #define CLONE_NEWUSER           0x10000000      /* New user namespace */
  27 #define CLONE_NEWPID            0x20000000      /* New pid namespace */
  28 #define CLONE_NEWNET            0x40000000      /* New network namespace */
  29 #define CLONE_IO                0x80000000      /* Clone io context */
  30
  31 #include "xlat/clone_flags.h"
  32
  33 #if defined IA64
  34 # define ARG_FLAGS      0
  35 # define ARG_STACK      1
  36 # define ARG_STACKSIZE  (tcp->scno == SYS_clone2 ? 2 : -1)
  37 # define ARG_PTID       (tcp->scno == SYS_clone2 ? 3 : 2)
  38 # define ARG_CTID       (tcp->scno == SYS_clone2 ? 4 : 3)
  39 # define ARG_TLS        (tcp->scno == SYS_clone2 ? 5 : 4)
  40 #elif defined S390 || defined S390X || defined CRISV10 || defined CRISV32
  41 # define ARG_STACK      0
  42 # define ARG_FLAGS      1
  43 # define ARG_PTID       2
  44 # define ARG_CTID       3
  45 # define ARG_TLS        4
  46 #elif defined X86_64 || defined X32
  47 /* x86 personality processes have the last two arguments flipped. */
  48 # define ARG_FLAGS      0
  49 # define ARG_STACK      1
  50 # define ARG_PTID       2
  51 # define ARG_CTID       ((current_personality != 1) ? 3 : 4)
  52 # define ARG_TLS        ((current_personality != 1) ? 4 : 3)
  53 #elif defined ALPHA || defined TILE || defined OR1K
  54 # define ARG_FLAGS      0
  55 # define ARG_STACK      1
  56 # define ARG_PTID       2
  57 # define ARG_CTID       3
  58 # define ARG_TLS        4
  59 #else
  60 # define ARG_FLAGS      0
  61 # define ARG_STACK      1
  62 # define ARG_PTID       2
  63 # define ARG_TLS        3
  64 # define ARG_CTID       4
  65 #endif
  66
  67 #if defined I386 || defined X86_64 || defined X32
  68 extern void print_user_desc(struct tcb *, long);
  69 #endif /* I386 || X86_64 || X32 */
  70
  71 int
  72 sys_clone(struct tcb *tcp)
  73 {
  74         if (exiting(tcp)) {
  75                 const char *sep = "|";
  76                 unsigned long flags = tcp->u_arg[ARG_FLAGS];
  77                 tprintf("child_stack=%#lx, ", tcp->u_arg[ARG_STACK]);
  78 #ifdef ARG_STACKSIZE
  79                 if (ARG_STACKSIZE != -1)
  80                         tprintf("stack_size=%#lx, ",
  81                                 tcp->u_arg[ARG_STACKSIZE]);
  82 #endif
  83                 tprints("flags=");
  84                 if (!printflags(clone_flags, flags &~ CSIGNAL, NULL))
  85                         sep = "";
  86                 if ((flags & CSIGNAL) != 0)
  87                         tprintf("%s%s", sep, signame(flags & CSIGNAL));
  88                 if ((flags & (CLONE_PARENT_SETTID|CLONE_CHILD_SETTID
  89                               |CLONE_CHILD_CLEARTID|CLONE_SETTLS)) == 0)
  90                         return 0;
  91                 if (flags & CLONE_PARENT_SETTID)
  92                         tprintf(", parent_tidptr=%#lx", tcp->u_arg[ARG_PTID]);
  93                 if (flags & CLONE_SETTLS) {
  94 #if defined I386 || defined X86_64 || defined X32
  95 # ifndef I386
  96                         if (current_personality == 1)
  97 # endif
  98                         {
  99                                 tprints(", tls=");
 100                                 print_user_desc(tcp, tcp->u_arg[ARG_TLS]);
 101                         }
 102 # ifndef I386
 103                         else
 104 # endif
 105 #endif /* I386 || X86_64 || X32 */
 106                                 tprintf(", tls=%#lx", tcp->u_arg[ARG_TLS]);
 107                 }
 108                 if (flags & (CLONE_CHILD_SETTID|CLONE_CHILD_CLEARTID))
 109                         tprintf(", child_tidptr=%#lx", tcp->u_arg[ARG_CTID]);
 110         }
 111         /* TODO on syscall entry:
 112          * We can clear CLONE_PTRACE here since it is an ancient hack
 113          * to allow us to catch children, and we use another hack for that.
 114          * But CLONE_PTRACE can conceivably be used by malicious programs
 115          * to subvert us. By clearing this bit, we can defend against it:
 116          * in untraced execution, CLONE_PTRACE should have no effect.
 117          *
 118          * We can also clear CLONE_UNTRACED, since it allows to start
 119          * children outside of our control. At the moment
 120          * I'm trying to figure out whether there is a *legitimate*
 121          * use of this flag which we should respect.
 122          */
 123         return 0;
 124 }
 125
 126 int
 127 sys_setns(struct tcb *tcp)
 128 {
 129         if (entering(tcp)) {
 130                 printfd(tcp, tcp->u_arg[0]);
 131                 tprints(", ");
 132                 printflags(clone_flags, tcp->u_arg[1], "CLONE_???");
 133         }
 134         return 0;
 135 }
 136
 137 int
 138 sys_unshare(struct tcb *tcp)
 139 {
 140         if (entering(tcp))
 141                 printflags(clone_flags, tcp->u_arg[0], "CLONE_???");
 142         return 0;
 143 }
 144
 145 int
 146 sys_fork(struct tcb *tcp)
 147 {
 148         if (exiting(tcp))
 149                 return RVAL_UDECIMAL;
 150         return 0;
 151 }