Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#define _GNU_SOURCE
#include <sched.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <syscall.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
/* For our clone experiments, we are working on a very low level and
* fiddle around with threading. This leads to a problem with the
* libc, which must perform some user-space operations to setup a
* new thread. For example, in a clone()ed thread, we cannot simply
* use printf(). Therefore, we provide you with a simple function to
* output a string and a number. The writing to stdout (fd=1) is done
* with plain system calls.
*
* Example: syscall_write("foobar = ", 23);
*/
int syscall_write(char *msg, int number) {
write(1, msg, strlen(msg));
if (number != 0) {
char buffer[sizeof(number) * 3];
char *p = &buffer[sizeof(number) * 3];
int len = 1;
*(--p) = '\n';
if (number < 0) {
write(1, "-", 1);
number *= -1;
}
while (number > 0) {
*(--p) = (number % 10) + '0';
number /= 10;
len ++;
}
write(1, p, len);
} else {
write(1, "0\n", 2);
}
return 0;
}
// For the new task, we always require an stack area. To make our life
// easier, we just statically allocate an global variable of PAGE_SIZE.
char stack[4096];
// To demonstrate whether child and parent are within the same
// namespace, we count up a global variable. If they are within the
// same address space, we will see modification to this counter in
// both namespaces
volatile int counter = 0;
int child_entry(void* arg) {
// We just give a little bit of information to the user.
syscall_write(": Hello from child_entry", 0);
syscall_write(": getppid() = ", getppid()); // What is our parent PID
syscall_write(": getpid() = ", getpid()); // What is our thread group/process id
syscall_write(": gettid() = ", gettid()); // The ID of this thread!
syscall_write(": getuid() = ", getuid()); // What is the user id of this thread.
// We increment the global counter in one second intervals. If we
// are in our own address space, this will have no influence on
// the parent!
while (counter < 4) {
counter++;
sleep(1);
}
return 0;
}
int main(int argc, char *argv[]) {
if (argc != 2) {
printf("usage: %s MODE\n", argv[0]);
printf("MODE:\n");
printf(" - fork -- emulate fork with clone\n");
printf(" - chimera -- create process/thread chimera\n");
printf(" - thread -- create a new thread in a process\n");
printf(" - user -- create a new process and alter its UID namespace\n");
return -1;
}
syscall_write("> Hello from main!", 0);
syscall_write("> getppid() = ", getppid());
syscall_write("> getpid() = ", getpid());
syscall_write("> gettid() = ", gettid());
syscall_write("> getuid() = ", getuid());
int flags = 0;
void *arg = NULL;
if (!strcmp(argv[1], "fork")) {
// TODO: Implement multiple clone modes.
} else {
printf("Invalid clone() mode: %s\n", argv[1]);
return -1;
}
// TODO: Call clone here!
syscall_write("\n!!!!! Press C-c to terminate. !!!!!", 0);
while(counter < 4) {
syscall_write("counter = ", counter);
sleep(1);
}
return 0;
}