Branch data Line data Source code
1 : : #include <unistd.h>
2 : :
3 : : #include <sys/stat.h>
4 : : #include <sys/wait.h>
5 : : #include <sys/mman.h>
6 : :
7 : : #include "protobuf.h"
8 : : #include "protobuf/sa.pb-c.h"
9 : : #include "protobuf/itimer.pb-c.h"
10 : : #include "protobuf/creds.pb-c.h"
11 : :
12 : : #include "syscall.h"
13 : : #include "ptrace.h"
14 : : #include "processor-flags.h"
15 : : #include "parasite-syscall.h"
16 : : #include "parasite-blob.h"
17 : : #include "parasite.h"
18 : : #include "crtools.h"
19 : : #include "namespaces.h"
20 : : #include "pstree.h"
21 : :
22 : : #include <string.h>
23 : : #include <stdlib.h>
24 : :
25 : : #ifdef CONFIG_X86_64
26 : : static const char code_syscall[] = {0x0f, 0x05, 0xcc, 0xcc,
27 : : 0xcc, 0xcc, 0xcc, 0xcc};
28 : :
29 : : #define code_syscall_size (round_up(sizeof(code_syscall), sizeof(long)))
30 : : #define parasite_size (round_up(sizeof(parasite_blob), sizeof(long)))
31 : :
32 : : static int can_run_syscall(unsigned long ip, unsigned long start, unsigned long end)
33 : : {
34 [ - + ]: 349 : return ip >= start && ip < (end - code_syscall_size);
35 : : }
36 : :
37 : : static int syscall_fits_vma_area(struct vma_area *vma_area)
38 : : {
39 : 349 : return can_run_syscall((unsigned long)vma_area->vma.start,
40 : : (unsigned long)vma_area->vma.start,
41 : : (unsigned long)vma_area->vma.end);
42 : : }
43 : :
44 : 349 : static struct vma_area *get_vma_by_ip(struct list_head *vma_area_list, unsigned long ip)
45 : : {
46 : : struct vma_area *vma_area;
47 : :
48 [ + - ]: 1843 : list_for_each_entry(vma_area, vma_area_list, list) {
49 [ + + ]: 1494 : if (!in_vma_area(vma_area, ip))
50 : 1145 : continue;
51 [ - + ]: 349 : if (!(vma_area->vma.prot & PROT_EXEC))
52 : 0 : continue;
53 [ - + ]: 349 : if (syscall_fits_vma_area(vma_area))
54 : : return vma_area;
55 : : }
56 : :
57 : : return NULL;
58 : : }
59 : :
60 : : /* Note it's destructive on @regs */
61 : : static void parasite_setup_regs(unsigned long new_ip, user_regs_struct_t *regs)
62 : : {
63 : 10024 : regs->ip = new_ip;
64 : :
65 : : /* Avoid end of syscall processing */
66 : 10024 : regs->orig_ax = -1;
67 : :
68 : : /* Make sure flags are in known state */
69 : 10024 : regs->flags &= ~(X86_EFLAGS_TF | X86_EFLAGS_DF | X86_EFLAGS_IF);
70 : : }
71 : :
72 : : /* we run at @regs->ip */
73 : 10024 : static int __parasite_execute(struct parasite_ctl *ctl, pid_t pid, user_regs_struct_t *regs)
74 : : {
75 : : siginfo_t siginfo;
76 : : int status;
77 : 10024 : int ret = -1;
78 : :
79 : : again:
80 [ - + ]: 10026 : if (ptrace(PTRACE_SETREGS, pid, NULL, regs)) {
81 : 0 : pr_err("Can't set registers (pid: %d)\n", pid);
82 : 0 : goto err;
83 : : }
84 : :
85 : : /*
86 : : * Most ideas are taken from Tejun Heo's parasite thread
87 : : * https://code.google.com/p/ptrace-parasite/
88 : : */
89 : :
90 [ - + ]: 10026 : if (ptrace(PTRACE_CONT, pid, NULL, NULL)) {
91 : 0 : pr_err("Can't continue (pid: %d)\n", pid);
92 : 0 : goto err;
93 : : }
94 : :
95 [ - + ]: 10026 : if (wait4(pid, &status, __WALL, NULL) != pid) {
96 : 0 : pr_err("Waited pid mismatch (pid: %d)\n", pid);
97 : 0 : goto err;
98 : : }
99 : :
100 [ - + ]: 10026 : if (!WIFSTOPPED(status)) {
101 : 0 : pr_err("Task is still running (pid: %d)\n", pid);
102 : 0 : goto err;
103 : : }
104 : :
105 [ - + ]: 10026 : if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)) {
106 : 0 : pr_err("Can't get siginfo (pid: %d)\n", pid);
107 : 0 : goto err;
108 : : }
109 : :
110 [ - + ]: 10026 : if (ptrace(PTRACE_GETREGS, pid, NULL, regs)) {
111 : 0 : pr_err("Can't obtain registers (pid: %d)\n", pid);
112 : 0 : goto err;
113 : : }
114 : :
115 [ + + ][ - + ]: 10026 : if (WSTOPSIG(status) != SIGTRAP || siginfo.si_code != SI_KERNEL) {
116 : : retry_signal:
117 : 2 : pr_debug("** delivering signal %d si_code=%d\n",
118 : : siginfo.si_signo, siginfo.si_code);
119 : :
120 [ - + ]: 2 : if (ctl->signals_blocked) {
121 : 0 : pr_err("Unexpected %d task interruption, aborting\n", pid);
122 : 0 : goto err;
123 : : }
124 : :
125 : : /* FIXME: jerr(siginfo.si_code > 0, err_restore); */
126 : :
127 : : /*
128 : : * This requires some explanation. If a signal from original
129 : : * program delivered while we're trying to execute our
130 : : * injected blob -- we need to setup original registers back
131 : : * so the kernel would make sigframe for us and update the
132 : : * former registers.
133 : : *
134 : : * Then we should swap registers back to our modified copy
135 : : * and retry.
136 : : */
137 : :
138 [ - + ]: 2 : if (ptrace(PTRACE_SETREGS, pid, NULL, &ctl->regs_orig)) {
139 : 0 : pr_err("Can't set registers (pid: %d)\n", pid);
140 : 0 : goto err;
141 : : }
142 : :
143 [ - + ]: 2 : if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL)) {
144 : 0 : pr_err("Can't interrupt (pid: %d)\n", pid);
145 : 0 : goto err;
146 : : }
147 : :
148 [ - + ]: 2 : if (ptrace(PTRACE_CONT, pid, NULL, (void *)(unsigned long)siginfo.si_signo)) {
149 : 0 : pr_err("Can't continue (pid: %d)\n", pid);
150 : 0 : goto err;
151 : : }
152 : :
153 [ - + ]: 2 : if (wait4(pid, &status, __WALL, NULL) != pid) {
154 : 0 : pr_err("Waited pid mismatch (pid: %d)\n", pid);
155 : 0 : goto err;
156 : : }
157 : :
158 [ - + ]: 2 : if (!WIFSTOPPED(status)) {
159 : 0 : pr_err("Task is still running (pid: %d)\n", pid);
160 : 0 : goto err;
161 : : }
162 : :
163 [ - + ]: 2 : if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)) {
164 : 0 : pr_err("Can't get siginfo (pid: %d)\n", pid);
165 : 0 : goto err;
166 : : }
167 : :
168 [ - + ]: 2 : if (SI_EVENT(siginfo.si_code) != PTRACE_EVENT_STOP)
169 : : goto retry_signal;
170 : :
171 : : /*
172 : : * Signal is delivered, so we should update
173 : : * original registers.
174 : : */
175 : : {
176 : : user_regs_struct_t r;
177 [ - + ]: 2 : if (ptrace(PTRACE_GETREGS, pid, NULL, &r)) {
178 : 0 : pr_err("Can't obtain registers (pid: %d)\n", pid);
179 : : goto err;
180 : : }
181 : 2 : ctl->regs_orig = r;
182 : : }
183 : :
184 : 2 : goto again;
185 : : }
186 : :
187 : : /*
188 : : * We've reached this point iif int3 is triggered inside our
189 : : * parasite code. So we're done.
190 : : */
191 : : ret = 0;
192 : : err:
193 : 10024 : return ret;
194 : : }
195 : :
196 : 349 : static void *parasite_args_s(struct parasite_ctl *ctl, int args_size)
197 : : {
198 [ - + ]: 349 : BUG_ON(args_size > PARASITE_ARG_SIZE);
199 : 349 : return ctl->addr_args;
200 : : }
201 : :
202 : : #define parasite_args(ctl, type) ({ \
203 : : BUILD_BUG_ON(sizeof(type) > PARASITE_ARG_SIZE); \
204 : : ctl->addr_args; \
205 : : })
206 : :
207 : 9326 : static int parasite_execute_by_pid(unsigned int cmd, struct parasite_ctl *ctl, pid_t pid)
208 : : {
209 : : int ret;
210 : : user_regs_struct_t regs_orig, regs;
211 : :
212 [ + + ]: 9326 : if (ctl->pid == pid)
213 : 9230 : regs = ctl->regs_orig;
214 : : else {
215 [ - + ]: 96 : if (ptrace(PTRACE_GETREGS, pid, NULL, ®s_orig)) {
216 : 0 : pr_err("Can't obtain registers (pid: %d)\n", pid);
217 : : return -1;
218 : : }
219 : 96 : regs = regs_orig;
220 : : }
221 : :
222 : 9326 : *ctl->addr_cmd = cmd;
223 : :
224 : 9326 : parasite_setup_regs(ctl->parasite_ip, ®s);
225 : :
226 : 9326 : ret = __parasite_execute(ctl, pid, ®s);
227 [ + - ]: 9326 : if (ret == 0)
228 : 9326 : ret = (int)regs.ax;
229 : :
230 [ - + ]: 9326 : if (ret)
231 : 0 : pr_err("Parasite exited with %d\n", ret);
232 : :
233 [ + + ]: 9326 : if (ctl->pid != pid)
234 [ - + ]: 96 : if (ptrace(PTRACE_SETREGS, pid, NULL, ®s_orig)) {
235 : 9326 : pr_err("Can't restore registers (pid: %d)\n", ctl->pid);
236 : : return -1;
237 : : }
238 : :
239 : : return ret;
240 : : }
241 : :
242 : 9230 : static int parasite_execute(unsigned int cmd, struct parasite_ctl *ctl)
243 : : {
244 : 9230 : return parasite_execute_by_pid(cmd, ctl, ctl->pid);
245 : : }
246 : :
247 : 698 : int syscall_seized(struct parasite_ctl *ctl, int nr, unsigned long *ret,
248 : : unsigned long arg1,
249 : : unsigned long arg2,
250 : : unsigned long arg3,
251 : : unsigned long arg4,
252 : : unsigned long arg5,
253 : : unsigned long arg6)
254 : : {
255 : 698 : user_regs_struct_t regs = ctl->regs_orig;
256 : : int err;
257 : :
258 : 698 : regs.ax = (unsigned long)nr;
259 : 698 : regs.di = arg1;
260 : 698 : regs.si = arg2;
261 : 698 : regs.dx = arg3;
262 : 698 : regs.r10 = arg4;
263 : 698 : regs.r8 = arg5;
264 : 698 : regs.r9 = arg6;
265 : :
266 : 698 : parasite_setup_regs(ctl->syscall_ip, ®s);
267 : 698 : err = __parasite_execute(ctl, ctl->pid, ®s);
268 [ + - ]: 698 : if (err)
269 : : return err;
270 : :
271 : 698 : *ret = regs.ax;
272 : : return 0;
273 : : }
274 : :
275 : 349 : static void *mmap_seized(struct parasite_ctl *ctl,
276 : : void *addr, size_t length, int prot,
277 : : int flags, int fd, off_t offset)
278 : : {
279 : : unsigned long map;
280 : : int err;
281 : :
282 : 349 : err = syscall_seized(ctl, __NR_mmap, &map,
283 : : (unsigned long)addr, length, prot, flags, fd, offset);
284 [ - + ][ + - ]: 349 : if (err < 0 || (long)map < 0)
285 : 0 : map = 0;
286 : :
287 : 349 : return (void *)map;
288 : : }
289 : :
290 : 349 : static int munmap_seized(struct parasite_ctl *ctl, void *addr, size_t length)
291 : : {
292 : : unsigned long x;
293 : :
294 : 349 : return syscall_seized(ctl, __NR_munmap, &x,
295 : : (unsigned long)addr, length, 0, 0, 0, 0);
296 : : }
297 : :
298 : 698 : static int gen_parasite_saddr(struct sockaddr_un *saddr, int key)
299 : : {
300 : : int sun_len;
301 : :
302 : 698 : saddr->sun_family = AF_UNIX;
303 : 698 : snprintf(saddr->sun_path, UNIX_PATH_MAX,
304 : : "X/crtools-pr-%d", key);
305 : :
306 : 698 : sun_len = SUN_LEN(saddr);
307 : 698 : *saddr->sun_path = '\0';
308 : :
309 : 698 : return sun_len;
310 : : }
311 : :
312 : 698 : static int parasite_send_fd(struct parasite_ctl *ctl, int fd)
313 : : {
314 [ - + ]: 698 : if (send_fd(ctl->tsock, NULL, 0, fd) < 0) {
315 : 698 : pr_perror("Can't send file descriptor");
316 : : return -1;
317 : : }
318 : : return 0;
319 : : }
320 : :
321 : 349 : static int parasite_set_logfd(struct parasite_ctl *ctl, pid_t pid)
322 : : {
323 : : int ret;
324 : : struct parasite_log_args *a;
325 : :
326 : 349 : ret = parasite_send_fd(ctl, log_get_fd());
327 [ + - ]: 349 : if (ret)
328 : : return ret;
329 : :
330 : 349 : a = parasite_args(ctl, struct parasite_log_args);
331 : 349 : a->log_level = log_get_loglevel();
332 : :
333 : 349 : ret = parasite_execute(PARASITE_CMD_CFG_LOG, ctl);
334 [ - + ]: 349 : if (ret < 0)
335 : : return ret;
336 : :
337 : : return 0;
338 : : }
339 : :
340 : 349 : static int parasite_init(struct parasite_ctl *ctl, pid_t pid, int nr_threads)
341 : : {
342 : : struct parasite_init_args *args;
343 : : static int sock = -1;
344 : :
345 : 349 : args = parasite_args(ctl, struct parasite_init_args);
346 : :
347 : 349 : pr_info("Putting tsock into pid %d\n", pid);
348 : 349 : args->h_addr_len = gen_parasite_saddr(&args->h_addr, getpid());
349 : 349 : args->p_addr_len = gen_parasite_saddr(&args->p_addr, pid);
350 : 349 : args->nr_threads = nr_threads;
351 : :
352 [ + + ]: 349 : if (sock == -1) {
353 : 166 : int rst = -1;
354 : :
355 [ + + ]: 166 : if (opts.namespaces_flags & CLONE_NEWNET) {
356 : 76 : pr_info("Switching to %d's net for tsock creation\n", pid);
357 : :
358 [ + - ]: 76 : if (switch_ns(pid, CLONE_NEWNET, "net", &rst))
359 : : return -1;
360 : : }
361 : :
362 : 166 : sock = socket(PF_UNIX, SOCK_DGRAM, 0);
363 [ - + ]: 166 : if (sock < 0) {
364 : 0 : pr_perror("Can't create socket");
365 : : return -1;
366 : : }
367 : :
368 [ - + ]: 166 : if (bind(sock, (struct sockaddr *)&args->h_addr, args->h_addr_len) < 0) {
369 : 0 : pr_perror("Can't bind socket");
370 : : goto err;
371 : : }
372 : :
373 [ + + ][ + - ]: 166 : if (rst > 0 && restore_ns(rst, CLONE_NEWNET) < 0)
374 : : goto err;
375 : : } else {
376 : 183 : struct sockaddr addr = { .sa_family = AF_UNSPEC, };
377 : :
378 : : /*
379 : : * When the peer of a dgram socket dies the original socket
380 : : * remains in connected state, thus denying any connections
381 : : * from "other" sources. Unconnect the socket by hands thus
382 : : * allowing for parasite to connect back.
383 : : */
384 : :
385 [ - + ]: 183 : if (connect(sock, &addr, sizeof(addr)) < 0) {
386 : 183 : pr_perror("Can't unconnect");
387 : : goto err;
388 : : }
389 : : }
390 : :
391 [ - + ]: 349 : if (parasite_execute(PARASITE_CMD_INIT, ctl) < 0) {
392 : 0 : pr_err("Can't init parasite\n");
393 : 0 : goto err;
394 : : }
395 : :
396 [ - + ]: 349 : if (connect(sock, (struct sockaddr *)&args->p_addr, args->p_addr_len) < 0) {
397 : 0 : pr_perror("Can't connect a transport socket");
398 : 0 : goto err;
399 : : }
400 : :
401 : 349 : ctl->tsock = sock;
402 : 349 : return 0;
403 : : err:
404 : 0 : close(sock);
405 : 349 : return -1;
406 : : }
407 : :
408 : 32 : int parasite_dump_thread_seized(struct parasite_ctl *ctl, pid_t pid,
409 : : unsigned int **tid_addr, pid_t *tid,
410 : : void *blocked)
411 : : {
412 : : struct parasite_dump_thread *args;
413 : : int ret;
414 : :
415 : 32 : args = parasite_args(ctl, struct parasite_dump_thread);
416 : :
417 : 32 : ret = parasite_execute_by_pid(PARASITE_CMD_DUMP_THREAD, ctl, pid);
418 : :
419 : 32 : memcpy(blocked, &args->blocked, sizeof(args->blocked));
420 : 32 : *tid_addr = args->tid_addr;
421 : 32 : *tid = args->tid;
422 : :
423 : 32 : return ret;
424 : : }
425 : :
426 : 349 : int parasite_dump_sigacts_seized(struct parasite_ctl *ctl, struct cr_fdset *cr_fdset)
427 : : {
428 : : struct parasite_dump_sa_args *args;
429 : : int ret, sig, fd;
430 : 349 : SaEntry se = SA_ENTRY__INIT;
431 : :
432 : 349 : args = parasite_args(ctl, struct parasite_dump_sa_args);
433 : :
434 : 349 : ret = parasite_execute(PARASITE_CMD_DUMP_SIGACTS, ctl);
435 [ + - ]: 349 : if (ret < 0)
436 : : return ret;
437 : :
438 : 349 : fd = fdset_fd(cr_fdset, CR_FD_SIGACT);
439 : :
440 [ + + ]: 22685 : for (sig = 1; sig <= SIGMAX; sig++) {
441 : 22336 : int i = sig - 1;
442 : :
443 [ + + ]: 22336 : if (sig == SIGSTOP || sig == SIGKILL)
444 : 698 : continue;
445 : :
446 : 21638 : ASSIGN_TYPED(se.sigaction, args->sas[i].rt_sa_handler);
447 : 21638 : ASSIGN_TYPED(se.flags, args->sas[i].rt_sa_flags);
448 : 21638 : ASSIGN_TYPED(se.restorer, args->sas[i].rt_sa_restorer);
449 : 21638 : ASSIGN_TYPED(se.mask, args->sas[i].rt_sa_mask.sig[0]);
450 : :
451 [ + - ]: 21638 : if (pb_write_one(fd, &se, PB_SIGACT) < 0)
452 : : return -1;
453 : : }
454 : :
455 : : return 0;
456 : : }
457 : :
458 : 1047 : static int dump_one_timer(struct itimerval *v, int fd)
459 : : {
460 : 1047 : ItimerEntry ie = ITIMER_ENTRY__INIT;
461 : :
462 : 1047 : ie.isec = v->it_interval.tv_sec;
463 : 1047 : ie.iusec = v->it_interval.tv_usec;
464 : 1047 : ie.vsec = v->it_value.tv_sec;
465 : 1047 : ie.vusec = v->it_value.tv_sec;
466 : :
467 : 1047 : return pb_write_one(fd, &ie, PB_ITIMERS);
468 : : }
469 : :
470 : 349 : int parasite_dump_itimers_seized(struct parasite_ctl *ctl, struct cr_fdset *cr_fdset)
471 : : {
472 : : struct parasite_dump_itimers_args *args;
473 : : int ret, fd;
474 : :
475 : 349 : args = parasite_args(ctl, struct parasite_dump_itimers_args);
476 : :
477 : 349 : ret = parasite_execute(PARASITE_CMD_DUMP_ITIMERS, ctl);
478 [ + - ]: 349 : if (ret < 0)
479 : : return ret;
480 : :
481 : 349 : fd = fdset_fd(cr_fdset, CR_FD_ITIMERS);
482 : :
483 : 349 : ret = dump_one_timer(&args->real, fd);
484 [ + - ]: 349 : if (!ret)
485 : 349 : ret = dump_one_timer(&args->virt, fd);
486 [ + - ]: 349 : if (!ret)
487 : 349 : ret = dump_one_timer(&args->prof, fd);
488 : :
489 : 349 : return ret;
490 : : }
491 : :
492 : 349 : int parasite_dump_misc_seized(struct parasite_ctl *ctl, struct parasite_dump_misc *misc)
493 : : {
494 : : struct parasite_dump_misc *ma;
495 : :
496 : 349 : ma = parasite_args(ctl, struct parasite_dump_misc);
497 [ + - ]: 349 : if (parasite_execute(PARASITE_CMD_DUMP_MISC, ctl) < 0)
498 : : return -1;
499 : :
500 : 349 : *misc = *ma;
501 : 349 : return 0;
502 : : }
503 : :
504 : 15 : struct parasite_tty_args *parasite_dump_tty(struct parasite_ctl *ctl, int fd)
505 : : {
506 : : struct parasite_tty_args *p;
507 : :
508 : 15 : p = parasite_args(ctl, struct parasite_tty_args);
509 : 15 : p->fd = fd;
510 : :
511 [ + - ]: 15 : if (parasite_execute(PARASITE_CMD_DUMP_TTY, ctl) < 0)
512 : : return NULL;
513 : :
514 : 15 : return p;
515 : : }
516 : :
517 : 349 : int parasite_dump_creds(struct parasite_ctl *ctl, CredsEntry *ce)
518 : : {
519 : : struct parasite_dump_creds *pc;
520 : :
521 : 349 : pc = parasite_args(ctl, struct parasite_dump_creds);
522 [ + - ]: 349 : if (parasite_execute(PARASITE_CMD_DUMP_CREDS, ctl) < 0)
523 : : return -1;
524 : :
525 : 349 : ce->secbits = pc->secbits;
526 : 349 : ce->n_groups = pc->ngroups;
527 : :
528 : : /*
529 : : * Achtung! We leak the parasite args pointer to the caller.
530 : : * It's not safe in general, but in our case is OK, since the
531 : : * latter doesn't go to parasite before using the data in it.
532 : : */
533 : :
534 : : BUILD_BUG_ON(sizeof(ce->groups[0]) != sizeof(pc->groups[0]));
535 : 349 : ce->groups = pc->groups;
536 : 349 : return 0;
537 : : }
538 : :
539 : : /*
540 : : * This routine drives parasite code (been previously injected into a victim
541 : : * process) and tells it to dump pages into the file.
542 : : */
543 : 349 : int parasite_dump_pages_seized(struct parasite_ctl *ctl, struct list_head *vma_area_list,
544 : : struct cr_fdset *cr_fdset)
545 : : {
546 : : struct parasite_dump_pages_args *parasite_dumppages;
547 : 349 : unsigned long nrpages_dumped = 0, nrpages_skipped = 0, nrpages_total = 0;
548 : : struct vma_area *vma_area;
549 : 349 : int ret = -1;
550 : :
551 : 349 : pr_info("\n");
552 : 349 : pr_info("Dumping pages (type: %d pid: %d)\n", CR_FD_PAGES, ctl->pid);
553 : 349 : pr_info("----------------------------------------\n");
554 : :
555 : 349 : ret = parasite_send_fd(ctl, fdset_fd(cr_fdset, CR_FD_PAGES));
556 [ + - ]: 349 : if (ret < 0)
557 : : goto out;
558 : :
559 : 349 : ret = parasite_execute(PARASITE_CMD_DUMPPAGES_INIT, ctl);
560 [ - + ]: 349 : if (ret < 0) {
561 : 0 : pr_err("Dumping pages failed with %i\n", ret);
562 : 0 : goto out;
563 : : }
564 : :
565 : 349 : parasite_dumppages = parasite_args(ctl, struct parasite_dump_pages_args);
566 : :
567 [ + + ]: 6404 : list_for_each_entry(vma_area, vma_area_list, list) {
568 : :
569 : : /*
570 : : * The special areas are not dumped.
571 : : */
572 [ + + ]: 6055 : if (!(vma_area->vma.status & VMA_AREA_REGULAR))
573 : 349 : continue;
574 : :
575 : : /* No dumps for file-shared mappings */
576 [ + + ]: 5706 : if (vma_area->vma.status & VMA_FILE_SHARED)
577 : 8 : continue;
578 : :
579 : : /* No dumps for SYSV IPC mappings */
580 [ + + ]: 5698 : if (vma_area->vma.status & VMA_AREA_SYSVIPC)
581 : 5 : continue;
582 : :
583 [ + + ]: 5693 : if (vma_area_is(vma_area, VMA_ANON_SHARED))
584 : 44 : continue;
585 : :
586 : 5649 : parasite_dumppages->vma_entry = vma_area->vma;
587 : :
588 [ - + ]: 5649 : if (!vma_area_is(vma_area, VMA_ANON_PRIVATE) &&
589 : : !vma_area_is(vma_area, VMA_FILE_PRIVATE)) {
590 : 0 : pr_warn("Unexpected VMA area found\n");
591 : 0 : continue;
592 : : }
593 : :
594 : 5649 : ret = parasite_execute(PARASITE_CMD_DUMPPAGES, ctl);
595 [ - + ]: 5649 : if (ret) {
596 : 0 : pr_err("Dumping pages failed with %d\n", ret);
597 : 0 : goto out_fini;
598 : : }
599 : :
600 : 5649 : pr_info("vma %lx-%lx dumped: %lu pages %lu skipped %lu total\n",
601 : : vma_area->vma.start, vma_area->vma.end,
602 : : parasite_dumppages->nrpages_dumped,
603 : : parasite_dumppages->nrpages_skipped,
604 : : parasite_dumppages->nrpages_total);
605 : :
606 : 5649 : nrpages_dumped += parasite_dumppages->nrpages_dumped;
607 : 5649 : nrpages_skipped += parasite_dumppages->nrpages_skipped;
608 : 5649 : nrpages_total += parasite_dumppages->nrpages_total;
609 : : }
610 : :
611 : 349 : pr_info("\n");
612 : 349 : pr_info("Summary: %lu dumped %lu skipped %lu total\n",
613 : : nrpages_dumped, nrpages_skipped, nrpages_total);
614 : 349 : ret = 0;
615 : :
616 : : out_fini:
617 : 349 : parasite_execute(PARASITE_CMD_DUMPPAGES_FINI, ctl);
618 : : out:
619 : 349 : pr_info("----------------------------------------\n");
620 : :
621 : 349 : return ret;
622 : : }
623 : :
624 : 349 : int parasite_drain_fds_seized(struct parasite_ctl *ctl,
625 : : struct parasite_drain_fd *dfds, int *lfds, struct fd_opts *opts)
626 : : {
627 : 349 : int ret = -1, size;
628 : : struct parasite_drain_fd *args;
629 : :
630 : 698 : size = drain_fds_size(dfds);
631 : 349 : args = parasite_args_s(ctl, size);
632 : 349 : memcpy(args, dfds, size);
633 : :
634 : 349 : ret = parasite_execute(PARASITE_CMD_DRAIN_FDS, ctl);
635 [ - + ]: 349 : if (ret) {
636 : 0 : pr_err("Parasite failed to drain descriptors\n");
637 : 0 : goto err;
638 : : }
639 : :
640 : 349 : ret = recv_fds(ctl->tsock, lfds, dfds->nr_fds, opts);
641 [ - + ]: 349 : if (ret) {
642 : 0 : pr_err("Can't retrieve FDs from socket\n");
643 : 0 : goto err;
644 : : }
645 : :
646 : : err:
647 : 349 : return ret;
648 : : }
649 : :
650 : 76 : int parasite_get_proc_fd_seized(struct parasite_ctl *ctl)
651 : : {
652 : 76 : int ret = -1, fd;
653 : :
654 : 76 : ret = parasite_execute(PARASITE_CMD_GET_PROC_FD, ctl);
655 [ - + ]: 76 : if (ret) {
656 : 0 : pr_err("Parasite failed to get proc fd\n");
657 : 0 : return ret;
658 : : }
659 : :
660 : 76 : fd = recv_fd(ctl->tsock);
661 [ - + ]: 76 : if (fd < 0) {
662 : 0 : pr_err("Can't retrieve FD from socket\n");
663 : 76 : return fd;
664 : : }
665 : :
666 : : return fd;
667 : : }
668 : :
669 : 349 : int parasite_init_threads_seized(struct parasite_ctl *ctl, struct pstree_item *item)
670 : : {
671 : 349 : int ret = 0, i;
672 : :
673 [ + + ]: 730 : for (i = 0; i < item->nr_threads; i++) {
674 [ + + ]: 381 : if (item->pid.real == item->threads[i].real)
675 : 349 : continue;
676 : :
677 : 32 : ret = parasite_execute_by_pid(PARASITE_CMD_INIT_THREAD, ctl,
678 : : item->threads[i].real);
679 [ - + ]: 32 : if (ret) {
680 : 0 : pr_err("Can't init thread in parasite %d\n",
681 : : item->threads[i].real);
682 : 0 : break;
683 : : }
684 : : }
685 : :
686 : 349 : return ret;
687 : : }
688 : :
689 : 349 : int parasite_fini_threads_seized(struct parasite_ctl *ctl, struct pstree_item *item)
690 : : {
691 : 349 : int ret = 0, i;
692 : :
693 [ + + ]: 730 : for (i = 0; i < item->nr_threads; i++) {
694 [ + + ]: 381 : if (item->pid.real == item->threads[i].real)
695 : 349 : continue;
696 : :
697 : 32 : ret = parasite_execute_by_pid(PARASITE_CMD_FINI_THREAD, ctl,
698 : : item->threads[i].real);
699 : : /*
700 : : * Note the thread's fini() can be called even when not
701 : : * all threads were init()'ed, say we're rolling back from
702 : : * error happened while we were init()'ing some thread, thus
703 : : * -ENOENT will be returned but we should continie for the
704 : : * rest of threads set.
705 : : *
706 : : * Strictly speaking we always init() threads in sequence thus
707 : : * we could simply break the loop once first -ENOENT returned
708 : : * but I prefer to be on a safe side even if some future changes
709 : : * would change the code logic.
710 : : */
711 [ - + ]: 32 : if (ret && ret != -ENOENT) {
712 : 0 : pr_err("Can't fini thread in parasite %d\n",
713 : : item->threads[i].real);
714 : 0 : break;
715 : : }
716 : : }
717 : :
718 : 349 : return ret;
719 : : }
720 : :
721 : 349 : int parasite_cure_seized(struct parasite_ctl *ctl, struct pstree_item *item)
722 : : {
723 : 349 : int ret = 0;
724 : :
725 : 349 : ctl->tsock = -1;
726 : :
727 [ + - ]: 349 : if (ctl->parasite_ip) {
728 : 349 : ctl->signals_blocked = 0;
729 : 349 : parasite_fini_threads_seized(ctl, item);
730 : 349 : parasite_execute(PARASITE_CMD_FINI, ctl);
731 : : }
732 : :
733 [ + - ]: 349 : if (ctl->remote_map) {
734 [ - + ]: 349 : if (munmap_seized(ctl, (void *)ctl->remote_map, ctl->map_length)) {
735 : 0 : pr_err("munmap_seized failed (pid: %d)\n", ctl->pid);
736 : 0 : ret = -1;
737 : : }
738 : : }
739 : :
740 [ + - ]: 349 : if (ctl->local_map) {
741 [ - + ]: 349 : if (munmap(ctl->local_map, ctl->map_length)) {
742 : 0 : pr_err("munmap failed (pid: %d)\n", ctl->pid);
743 : 0 : ret = -1;
744 : : }
745 : : }
746 : :
747 [ - + ]: 349 : if (ptrace_poke_area(ctl->pid, (void *)ctl->code_orig,
748 : 349 : (void *)ctl->syscall_ip, sizeof(ctl->code_orig))) {
749 : 0 : pr_err("Can't restore syscall blob (pid: %d)\n", ctl->pid);
750 : 0 : ret = -1;
751 : : }
752 : :
753 [ - + ]: 349 : if (ptrace(PTRACE_SETREGS, ctl->pid, NULL, &ctl->regs_orig)) {
754 : 0 : pr_err("Can't restore registers (pid: %d)\n", ctl->pid);
755 : 0 : ret = -1;
756 : : }
757 : :
758 : 349 : free(ctl);
759 : 349 : return ret;
760 : : }
761 : :
762 : 349 : struct parasite_ctl *parasite_prep_ctl(pid_t pid, struct list_head *vma_area_list)
763 : : {
764 : 349 : struct parasite_ctl *ctl = NULL;
765 : : struct vma_area *vma_area;
766 : :
767 : : /*
768 : : * Control block early setup.
769 : : */
770 [ - + ]: 349 : ctl = xzalloc(sizeof(*ctl));
771 [ - + ]: 349 : if (!ctl) {
772 : 0 : pr_err("Parasite control block allocation failed (pid: %d)\n", pid);
773 : 0 : goto err;
774 : : }
775 : :
776 : 349 : ctl->tsock = -1;
777 : :
778 [ - + ]: 349 : if (ptrace(PTRACE_GETREGS, pid, NULL, &ctl->regs_orig)) {
779 : 0 : pr_err("Can't obtain registers (pid: %d)\n", pid);
780 : 0 : goto err;
781 : : }
782 : :
783 : 349 : vma_area = get_vma_by_ip(vma_area_list, ctl->regs_orig.ip);
784 [ - + ]: 349 : if (!vma_area) {
785 : 0 : pr_err("No suitable VMA found to run parasite "
786 : : "bootstrap code (pid: %d)\n", pid);
787 : 0 : goto err;
788 : : }
789 : :
790 : 349 : ctl->pid = pid;
791 : 349 : ctl->syscall_ip = vma_area->vma.start;
792 : :
793 : : /*
794 : : * Inject syscall instruction and remember original code,
795 : : * we will need it to restore original program content.
796 : : */
797 : : BUILD_BUG_ON(sizeof(code_syscall) != sizeof(ctl->code_orig));
798 : : BUILD_BUG_ON(!is_log2(sizeof(code_syscall)));
799 : :
800 : 349 : memcpy(ctl->code_orig, code_syscall, sizeof(ctl->code_orig));
801 [ - + ]: 349 : if (ptrace_swap_area(ctl->pid, (void *)ctl->syscall_ip,
802 : 349 : (void *)ctl->code_orig, sizeof(ctl->code_orig))) {
803 : 0 : pr_err("Can't inject syscall blob (pid: %d)\n", pid);
804 : 0 : goto err;
805 : : }
806 : :
807 : : return ctl;
808 : :
809 : : err:
810 [ # # ]: 349 : xfree(ctl);
811 : : return NULL;
812 : : }
813 : :
814 : 349 : int parasite_map_exchange(struct parasite_ctl *ctl, unsigned long size)
815 : : {
816 : : int fd;
817 : :
818 : 349 : ctl->remote_map = mmap_seized(ctl, NULL, size,
819 : : PROT_READ | PROT_WRITE | PROT_EXEC,
820 : : MAP_ANONYMOUS | MAP_SHARED, -1, 0);
821 [ - + ]: 349 : if (!ctl->remote_map) {
822 : 0 : pr_err("Can't allocate memory for parasite blob (pid: %d)\n", ctl->pid);
823 : 0 : return -1;
824 : : }
825 : :
826 : 349 : ctl->map_length = round_up(size, PAGE_SIZE);
827 : :
828 [ - + ]: 349 : fd = open_proc_rw(ctl->pid, "map_files/%p-%p",
829 : : ctl->remote_map, ctl->remote_map + ctl->map_length);
830 [ + - ]: 349 : if (fd < 0)
831 : : return -1;
832 : :
833 : 349 : ctl->local_map = mmap(NULL, size, PROT_READ | PROT_WRITE,
834 : : MAP_SHARED | MAP_FILE, fd, 0);
835 : 349 : close(fd);
836 : :
837 [ - + ]: 349 : if (ctl->local_map == MAP_FAILED) {
838 : 0 : ctl->local_map = NULL;
839 : 0 : pr_perror("Can't map remote parasite map");
840 : 349 : return -1;
841 : : }
842 : :
843 : : return 0;
844 : : }
845 : :
846 : 349 : struct parasite_ctl *parasite_infect_seized(pid_t pid, struct pstree_item *item, struct list_head *vma_area_list)
847 : : {
848 : : int ret;
849 : : struct parasite_ctl *ctl;
850 : :
851 : 349 : ctl = parasite_prep_ctl(pid, vma_area_list);
852 [ + - ]: 349 : if (!ctl)
853 : : return NULL;
854 : :
855 : : /*
856 : : * Inject a parasite engine. Ie allocate memory inside alien
857 : : * space and copy engine code there. Then re-map the engine
858 : : * locally, so we will get an easy way to access engine memory
859 : : * without using ptrace at all.
860 : : */
861 : :
862 : 349 : ret = parasite_map_exchange(ctl, parasite_size);
863 [ + - ]: 349 : if (ret)
864 : : goto err_restore;
865 : :
866 : 349 : pr_info("Putting parasite blob into %p->%p\n", ctl->local_map, ctl->remote_map);
867 : 349 : memcpy(ctl->local_map, parasite_blob, sizeof(parasite_blob));
868 : :
869 : : /* Setup the rest of a control block */
870 : 349 : ctl->parasite_ip = (unsigned long)parasite_sym(ctl->remote_map, __export_parasite_head_start);
871 : 349 : ctl->addr_cmd = parasite_sym(ctl->local_map, __export_parasite_cmd);
872 : 349 : ctl->addr_args = parasite_sym(ctl->local_map, __export_parasite_args);
873 : :
874 : 349 : ret = parasite_init(ctl, pid, item->nr_threads);
875 [ - + ]: 349 : if (ret) {
876 : 0 : pr_err("%d: Can't create a transport socket\n", pid);
877 : 0 : goto err_restore;
878 : : }
879 : :
880 : 349 : ctl->signals_blocked = 1;
881 : :
882 : 349 : ret = parasite_set_logfd(ctl, pid);
883 [ - + ]: 349 : if (ret) {
884 : 0 : pr_err("%d: Can't set a logging descriptor\n", pid);
885 : 0 : goto err_restore;
886 : : }
887 : :
888 : 349 : ret = parasite_init_threads_seized(ctl, item);
889 [ - + ]: 349 : if (ret)
890 : : goto err_restore;
891 : :
892 : : return ctl;
893 : :
894 : : err_restore:
895 : 0 : parasite_cure_seized(ctl, item);
896 : 349 : return NULL;
897 : 3239 : }
898 : :
899 : : #else /* CONFIG_X86_64 */
900 : : # error x86-32 is not yet implemented
901 : : #endif /* CONFIG_X86_64 */
|
