~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/ptrace.c

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/kernel/ptrace.c
  3  *
  4  * (C) Copyright 1999 Linus Torvalds
  5  *
  6  * Common interfaces for "ptrace()" which we do not want
  7  * to continually duplicate across every architecture.
  8  */
  9 
 10 #include <linux/capability.h>
 11 #include <linux/export.h>
 12 #include <linux/sched.h>
 13 #include <linux/sched/mm.h>
 14 #include <linux/sched/coredump.h>
 15 #include <linux/sched/task.h>
 16 #include <linux/errno.h>
 17 #include <linux/mm.h>
 18 #include <linux/highmem.h>
 19 #include <linux/pagemap.h>
 20 #include <linux/ptrace.h>
 21 #include <linux/security.h>
 22 #include <linux/signal.h>
 23 #include <linux/uio.h>
 24 #include <linux/audit.h>
 25 #include <linux/pid_namespace.h>
 26 #include <linux/syscalls.h>
 27 #include <linux/uaccess.h>
 28 #include <linux/regset.h>
 29 #include <linux/hw_breakpoint.h>
 30 #include <linux/cn_proc.h>
 31 #include <linux/compat.h>
 32 #include <linux/sched/signal.h>
 33 
 34 /*
 35  * Access another process' address space via ptrace.
 36  * Source/target buffer must be kernel space,
 37  * Do not walk the page table directly, use get_user_pages
 38  */
 39 int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
 40                      void *buf, int len, unsigned int gup_flags)
 41 {
 42         struct mm_struct *mm;
 43         int ret;
 44 
 45         mm = get_task_mm(tsk);
 46         if (!mm)
 47                 return 0;
 48 
 49         if (!tsk->ptrace ||
 50             (current != tsk->parent) ||
 51             ((get_dumpable(mm) != SUID_DUMP_USER) &&
 52              !ptracer_capable(tsk, mm->user_ns))) {
 53                 mmput(mm);
 54                 return 0;
 55         }
 56 
 57         ret = __access_remote_vm(tsk, mm, addr, buf, len, gup_flags);
 58         mmput(mm);
 59 
 60         return ret;
 61 }
 62 
 63 
 64 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
 65                    const struct cred *ptracer_cred)
 66 {
 67         BUG_ON(!list_empty(&child->ptrace_entry));
 68         list_add(&child->ptrace_entry, &new_parent->ptraced);
 69         child->parent = new_parent;
 70         child->ptracer_cred = get_cred(ptracer_cred);
 71 }
 72 
 73 /*
 74  * ptrace a task: make the debugger its new parent and
 75  * move it to the ptrace list.
 76  *
 77  * Must be called with the tasklist lock write-held.
 78  */
 79 static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
 80 {
 81         __ptrace_link(child, new_parent, current_cred());
 82 }
 83 
 84 /**
 85  * __ptrace_unlink - unlink ptracee and restore its execution state
 86  * @child: ptracee to be unlinked
 87  *
 88  * Remove @child from the ptrace list, move it back to the original parent,
 89  * and restore the execution state so that it conforms to the group stop
 90  * state.
 91  *
 92  * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer
 93  * exiting.  For PTRACE_DETACH, unless the ptracee has been killed between
 94  * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED.
 95  * If the ptracer is exiting, the ptracee can be in any state.
 96  *
 97  * After detach, the ptracee should be in a state which conforms to the
 98  * group stop.  If the group is stopped or in the process of stopping, the
 99  * ptracee should be put into TASK_STOPPED; otherwise, it should be woken
100  * up from TASK_TRACED.
101  *
102  * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED,
103  * it goes through TRACED -> RUNNING -> STOPPED transition which is similar
104  * to but in the opposite direction of what happens while attaching to a
105  * stopped task.  However, in this direction, the intermediate RUNNING
106  * state is not hidden even from the current ptracer and if it immediately
107  * re-attaches and performs a WNOHANG wait(2), it may fail.
108  *
109  * CONTEXT:
110  * write_lock_irq(tasklist_lock)
111  */
112 void __ptrace_unlink(struct task_struct *child)
113 {
114         const struct cred *old_cred;
115         BUG_ON(!child->ptrace);
116 
117         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
118 
119         child->parent = child->real_parent;
120         list_del_init(&child->ptrace_entry);
121         old_cred = child->ptracer_cred;
122         child->ptracer_cred = NULL;
123         put_cred(old_cred);
124 
125         spin_lock(&child->sighand->siglock);
126         child->ptrace = 0;
127         /*
128          * Clear all pending traps and TRAPPING.  TRAPPING should be
129          * cleared regardless of JOBCTL_STOP_PENDING.  Do it explicitly.
130          */
131         task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK);
132         task_clear_jobctl_trapping(child);
133 
134         /*
135          * Reinstate JOBCTL_STOP_PENDING if group stop is in effect and
136          * @child isn't dead.
137          */
138         if (!(child->flags & PF_EXITING) &&
139             (child->signal->flags & SIGNAL_STOP_STOPPED ||
140              child->signal->group_stop_count)) {
141                 child->jobctl |= JOBCTL_STOP_PENDING;
142 
143                 /*
144                  * This is only possible if this thread was cloned by the
145                  * traced task running in the stopped group, set the signal
146                  * for the future reports.
147                  * FIXME: we should change ptrace_init_task() to handle this
148                  * case.
149                  */
150                 if (!(child->jobctl & JOBCTL_STOP_SIGMASK))
151                         child->jobctl |= SIGSTOP;
152         }
153 
154         /*
155          * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick
156          * @child in the butt.  Note that @resume should be used iff @child
157          * is in TASK_TRACED; otherwise, we might unduly disrupt
158          * TASK_KILLABLE sleeps.
159          */
160         if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child))
161                 ptrace_signal_wake_up(child, true);
162 
163         spin_unlock(&child->sighand->siglock);
164 }
165 
166 /* Ensure that nothing can wake it up, even SIGKILL */
167 static bool ptrace_freeze_traced(struct task_struct *task)
168 {
169         bool ret = false;
170 
171         /* Lockless, nobody but us can set this flag */
172         if (task->jobctl & JOBCTL_LISTENING)
173                 return ret;
174 
175         spin_lock_irq(&task->sighand->siglock);
176         if (task_is_traced(task) && !__fatal_signal_pending(task)) {
177                 task->state = __TASK_TRACED;
178                 ret = true;
179         }
180         spin_unlock_irq(&task->sighand->siglock);
181 
182         return ret;
183 }
184 
185 static void ptrace_unfreeze_traced(struct task_struct *task)
186 {
187         if (task->state != __TASK_TRACED)
188                 return;
189 
190         WARN_ON(!task->ptrace || task->parent != current);
191 
192         /*
193          * PTRACE_LISTEN can allow ptrace_trap_notify to wake us up remotely.
194          * Recheck state under the lock to close this race.
195          */
196         spin_lock_irq(&task->sighand->siglock);
197         if (task->state == __TASK_TRACED) {
198                 if (__fatal_signal_pending(task))
199                         wake_up_state(task, __TASK_TRACED);
200                 else
201                         task->state = TASK_TRACED;
202         }
203         spin_unlock_irq(&task->sighand->siglock);
204 }
205 
206 /**
207  * ptrace_check_attach - check whether ptracee is ready for ptrace operation
208  * @child: ptracee to check for
209  * @ignore_state: don't check whether @child is currently %TASK_TRACED
210  *
211  * Check whether @child is being ptraced by %current and ready for further
212  * ptrace operations.  If @ignore_state is %false, @child also should be in
213  * %TASK_TRACED state and on return the child is guaranteed to be traced
214  * and not executing.  If @ignore_state is %true, @child can be in any
215  * state.
216  *
217  * CONTEXT:
218  * Grabs and releases tasklist_lock and @child->sighand->siglock.
219  *
220  * RETURNS:
221  * 0 on success, -ESRCH if %child is not ready.
222  */
223 static int ptrace_check_attach(struct task_struct *child, bool ignore_state)
224 {
225         int ret = -ESRCH;
226 
227         /*
228          * We take the read lock around doing both checks to close a
229          * possible race where someone else was tracing our child and
230          * detached between these two checks.  After this locked check,
231          * we are sure that this is our traced child and that can only
232          * be changed by us so it's not changing right after this.
233          */
234         read_lock(&tasklist_lock);
235         if (child->ptrace && child->parent == current) {
236                 WARN_ON(child->state == __TASK_TRACED);
237                 /*
238                  * child->sighand can't be NULL, release_task()
239                  * does ptrace_unlink() before __exit_signal().
240                  */
241                 if (ignore_state || ptrace_freeze_traced(child))
242                         ret = 0;
243         }
244         read_unlock(&tasklist_lock);
245 
246         if (!ret && !ignore_state) {
247                 if (!wait_task_inactive(child, __TASK_TRACED)) {
248                         /*
249                          * This can only happen if may_ptrace_stop() fails and
250                          * ptrace_stop() changes ->state back to TASK_RUNNING,
251                          * so we should not worry about leaking __TASK_TRACED.
252                          */
253                         WARN_ON(child->state == __TASK_TRACED);
254                         ret = -ESRCH;
255                 }
256         }
257 
258         return ret;
259 }
260 
261 static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
262 {
263         if (mode & PTRACE_MODE_NOAUDIT)
264                 return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE);
265         else
266                 return has_ns_capability(current, ns, CAP_SYS_PTRACE);
267 }
268 
269 /* Returns 0 on success, -errno on denial. */
270 static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
271 {
272         const struct cred *cred = current_cred(), *tcred;
273         struct mm_struct *mm;
274         kuid_t caller_uid;
275         kgid_t caller_gid;
276 
277         if (!(mode & PTRACE_MODE_FSCREDS) == !(mode & PTRACE_MODE_REALCREDS)) {
278                 WARN(1, "denying ptrace access check without PTRACE_MODE_*CREDS\n");
279                 return -EPERM;
280         }
281 
282         /* May we inspect the given task?
283          * This check is used both for attaching with ptrace
284          * and for allowing access to sensitive information in /proc.
285          *
286          * ptrace_attach denies several cases that /proc allows
287          * because setting up the necessary parent/child relationship
288          * or halting the specified task is impossible.
289          */
290 
291         /* Don't let security modules deny introspection */
292         if (same_thread_group(task, current))
293                 return 0;
294         rcu_read_lock();
295         if (mode & PTRACE_MODE_FSCREDS) {
296                 caller_uid = cred->fsuid;
297                 caller_gid = cred->fsgid;
298         } else {
299                 /*
300                  * Using the euid would make more sense here, but something
301                  * in userland might rely on the old behavior, and this
302                  * shouldn't be a security problem since
303                  * PTRACE_MODE_REALCREDS implies that the caller explicitly
304                  * used a syscall that requests access to another process
305                  * (and not a filesystem syscall to procfs).
306                  */
307                 caller_uid = cred->uid;
308                 caller_gid = cred->gid;
309         }
310         tcred = __task_cred(task);
311         if (uid_eq(caller_uid, tcred->euid) &&
312             uid_eq(caller_uid, tcred->suid) &&
313             uid_eq(caller_uid, tcred->uid)  &&
314             gid_eq(caller_gid, tcred->egid) &&
315             gid_eq(caller_gid, tcred->sgid) &&
316             gid_eq(caller_gid, tcred->gid))
317                 goto ok;
318         if (ptrace_has_cap(tcred->user_ns, mode))
319                 goto ok;
320         rcu_read_unlock();
321         return -EPERM;
322 ok:
323         rcu_read_unlock();
324         /*
325          * If a task drops privileges and becomes nondumpable (through a syscall
326          * like setresuid()) while we are trying to access it, we must ensure
327          * that the dumpability is read after the credentials; otherwise,
328          * we may be able to attach to a task that we shouldn't be able to
329          * attach to (as if the task had dropped privileges without becoming
330          * nondumpable).
331          * Pairs with a write barrier in commit_creds().
332          */
333         smp_rmb();
334         mm = task->mm;
335         if (mm &&
336             ((get_dumpable(mm) != SUID_DUMP_USER) &&
337              !ptrace_has_cap(mm->user_ns, mode)))
338             return -EPERM;
339 
340         return security_ptrace_access_check(task, mode);
341 }
342 
343 bool ptrace_may_access(struct task_struct *task, unsigned int mode)
344 {
345         int err;
346         task_lock(task);
347         err = __ptrace_may_access(task, mode);
348         task_unlock(task);
349         return !err;
350 }
351 
352 static int ptrace_attach(struct task_struct *task, long request,
353                          unsigned long addr,
354                          unsigned long flags)
355 {
356         bool seize = (request == PTRACE_SEIZE);
357         int retval;
358 
359         retval = -EIO;
360         if (seize) {
361                 if (addr != 0)
362                         goto out;
363                 if (flags & ~(unsigned long)PTRACE_O_MASK)
364                         goto out;
365                 flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT);
366         } else {
367                 flags = PT_PTRACED;
368         }
369 
370         audit_ptrace(task);
371 
372         retval = -EPERM;
373         if (unlikely(task->flags & PF_KTHREAD))
374                 goto out;
375         if (same_thread_group(task, current))
376                 goto out;
377 
378         /*
379          * Protect exec's credential calculations against our interference;
380          * SUID, SGID and LSM creds get determined differently
381          * under ptrace.
382          */
383         retval = -ERESTARTNOINTR;
384         if (mutex_lock_interruptible(&task->signal->cred_guard_mutex))
385                 goto out;
386 
387         task_lock(task);
388         retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH_REALCREDS);
389         task_unlock(task);
390         if (retval)
391                 goto unlock_creds;
392 
393         write_lock_irq(&tasklist_lock);
394         retval = -EPERM;
395         if (unlikely(task->exit_state))
396                 goto unlock_tasklist;
397         if (task->ptrace)
398                 goto unlock_tasklist;
399 
400         if (seize)
401                 flags |= PT_SEIZED;
402         task->ptrace = flags;
403 
404         ptrace_link(task, current);
405 
406         /* SEIZE doesn't trap tracee on attach */
407         if (!seize)
408                 send_sig_info(SIGSTOP, SEND_SIG_PRIV, task);
409 
410         spin_lock(&task->sighand->siglock);
411 
412         /*
413          * If the task is already STOPPED, set JOBCTL_TRAP_STOP and
414          * TRAPPING, and kick it so that it transits to TRACED.  TRAPPING
415          * will be cleared if the child completes the transition or any
416          * event which clears the group stop states happens.  We'll wait
417          * for the transition to complete before returning from this
418          * function.
419          *
420          * This hides STOPPED -> RUNNING -> TRACED transition from the
421          * attaching thread but a different thread in the same group can
422          * still observe the transient RUNNING state.  IOW, if another
423          * thread's WNOHANG wait(2) on the stopped tracee races against
424          * ATTACH, the wait(2) may fail due to the transient RUNNING.
425          *
426          * The following task_is_stopped() test is safe as both transitions
427          * in and out of STOPPED are protected by siglock.
428          */
429         if (task_is_stopped(task) &&
430             task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING))
431                 signal_wake_up_state(task, __TASK_STOPPED);
432 
433         spin_unlock(&task->sighand->siglock);
434 
435         retval = 0;
436 unlock_tasklist:
437         write_unlock_irq(&tasklist_lock);
438 unlock_creds:
439         mutex_unlock(&task->signal->cred_guard_mutex);
440 out:
441         if (!retval) {
442                 /*
443                  * We do not bother to change retval or clear JOBCTL_TRAPPING
444                  * if wait_on_bit() was interrupted by SIGKILL. The tracer will
445                  * not return to user-mode, it will exit and clear this bit in
446                  * __ptrace_unlink() if it wasn't already cleared by the tracee;
447                  * and until then nobody can ptrace this task.
448                  */
449                 wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT, TASK_KILLABLE);
450                 proc_ptrace_connector(task, PTRACE_ATTACH);
451         }
452 
453         return retval;
454 }
455 
456 /**
457  * ptrace_traceme  --  helper for PTRACE_TRACEME
458  *
459  * Performs checks and sets PT_PTRACED.
460  * Should be used by all ptrace implementations for PTRACE_TRACEME.
461  */
462 static int ptrace_traceme(void)
463 {
464         int ret = -EPERM;
465 
466         write_lock_irq(&tasklist_lock);
467         /* Are we already being traced? */
468         if (!current->ptrace) {
469                 ret = security_ptrace_traceme(current->parent);
470                 /*
471                  * Check PF_EXITING to ensure ->real_parent has not passed
472                  * exit_ptrace(). Otherwise we don't report the error but
473                  * pretend ->real_parent untraces us right after return.
474                  */
475                 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
476                         current->ptrace = PT_PTRACED;
477                         ptrace_link(current, current->real_parent);
478                 }
479         }
480         write_unlock_irq(&tasklist_lock);
481 
482         return ret;
483 }
484 
485 /*
486  * Called with irqs disabled, returns true if childs should reap themselves.
487  */
488 static int ignoring_children(struct sighand_struct *sigh)
489 {
490         int ret;
491         spin_lock(&sigh->siglock);
492         ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) ||
493               (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT);
494         spin_unlock(&sigh->siglock);
495         return ret;
496 }
497 
498 /*
499  * Called with tasklist_lock held for writing.
500  * Unlink a traced task, and clean it up if it was a traced zombie.
501  * Return true if it needs to be reaped with release_task().
502  * (We can't call release_task() here because we already hold tasklist_lock.)
503  *
504  * If it's a zombie, our attachedness prevented normal parent notification
505  * or self-reaping.  Do notification now if it would have happened earlier.
506  * If it should reap itself, return true.
507  *
508  * If it's our own child, there is no notification to do. But if our normal
509  * children self-reap, then this child was prevented by ptrace and we must
510  * reap it now, in that case we must also wake up sub-threads sleeping in
511  * do_wait().
512  */
513 static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
514 {
515         bool dead;
516 
517         __ptrace_unlink(p);
518 
519         if (p->exit_state != EXIT_ZOMBIE)
520                 return false;
521 
522         dead = !thread_group_leader(p);
523 
524         if (!dead && thread_group_empty(p)) {
525                 if (!same_thread_group(p->real_parent, tracer))
526                         dead = do_notify_parent(p, p->exit_signal);
527                 else if (ignoring_children(tracer->sighand)) {
528                         __wake_up_parent(p, tracer);
529                         dead = true;
530                 }
531         }
532         /* Mark it as in the process of being reaped. */
533         if (dead)
534                 p->exit_state = EXIT_DEAD;
535         return dead;
536 }
537 
538 static int ptrace_detach(struct task_struct *child, unsigned int data)
539 {
540         if (!valid_signal(data))
541                 return -EIO;
542 
543         /* Architecture-specific hardware disable .. */
544         ptrace_disable(child);
545 
546         write_lock_irq(&tasklist_lock);
547         /*
548          * We rely on ptrace_freeze_traced(). It can't be killed and
549          * untraced by another thread, it can't be a zombie.
550          */
551         WARN_ON(!child->ptrace || child->exit_state);
552         /*
553          * tasklist_lock avoids the race with wait_task_stopped(), see
554          * the comment in ptrace_resume().
555          */
556         child->exit_code = data;
557         __ptrace_detach(current, child);
558         write_unlock_irq(&tasklist_lock);
559 
560         proc_ptrace_connector(child, PTRACE_DETACH);
561 
562         return 0;
563 }
564 
565 /*
566  * Detach all tasks we were using ptrace on. Called with tasklist held
567  * for writing.
568  */
569 void exit_ptrace(struct task_struct *tracer, struct list_head *dead)
570 {
571         struct task_struct *p, *n;
572 
573         list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) {
574                 if (unlikely(p->ptrace & PT_EXITKILL))
575                         send_sig_info(SIGKILL, SEND_SIG_PRIV, p);
576 
577                 if (__ptrace_detach(tracer, p))
578                         list_add(&p->ptrace_entry, dead);
579         }
580 }
581 
582 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
583 {
584         int copied = 0;
585 
586         while (len > 0) {
587                 char buf[128];
588                 int this_len, retval;
589 
590                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
591                 retval = ptrace_access_vm(tsk, src, buf, this_len, FOLL_FORCE);
592 
593                 if (!retval) {
594                         if (copied)
595                                 break;
596                         return -EIO;
597                 }
598                 if (copy_to_user(dst, buf, retval))
599                         return -EFAULT;
600                 copied += retval;
601                 src += retval;
602                 dst += retval;
603                 len -= retval;
604         }
605         return copied;
606 }
607 
608 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
609 {
610         int copied = 0;
611 
612         while (len > 0) {
613                 char buf[128];
614                 int this_len, retval;
615 
616                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
617                 if (copy_from_user(buf, src, this_len))
618                         return -EFAULT;
619                 retval = ptrace_access_vm(tsk, dst, buf, this_len,
620                                 FOLL_FORCE | FOLL_WRITE);
621                 if (!retval) {
622                         if (copied)
623                                 break;
624                         return -EIO;
625                 }
626                 copied += retval;
627                 src += retval;
628                 dst += retval;
629                 len -= retval;
630         }
631         return copied;
632 }
633 
634 static int ptrace_setoptions(struct task_struct *child, unsigned long data)
635 {
636         unsigned flags;
637 
638         if (data & ~(unsigned long)PTRACE_O_MASK)
639                 return -EINVAL;
640 
641         if (unlikely(data & PTRACE_O_SUSPEND_SECCOMP)) {
642                 if (!IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) ||
643                     !IS_ENABLED(CONFIG_SECCOMP))
644                         return -EINVAL;
645 
646                 if (!capable(CAP_SYS_ADMIN))
647                         return -EPERM;
648 
649                 if (seccomp_mode(&current->seccomp) != SECCOMP_MODE_DISABLED ||
650                     current->ptrace & PT_SUSPEND_SECCOMP)
651                         return -EPERM;
652         }
653 
654         /* Avoid intermediate state when all opts are cleared */
655         flags = child->ptrace;
656         flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT);
657         flags |= (data << PT_OPT_FLAG_SHIFT);
658         child->ptrace = flags;
659 
660         return 0;
661 }
662 
663 static int ptrace_getsiginfo(struct task_struct *child, kernel_siginfo_t *info)
664 {
665         unsigned long flags;
666         int error = -ESRCH;
667 
668         if (lock_task_sighand(child, &flags)) {
669                 error = -EINVAL;
670                 if (likely(child->last_siginfo != NULL)) {
671                         copy_siginfo(info, child->last_siginfo);
672                         error = 0;
673                 }
674                 unlock_task_sighand(child, &flags);
675         }
676         return error;
677 }
678 
679 static int ptrace_setsiginfo(struct task_struct *child, const kernel_siginfo_t *info)
680 {
681         unsigned long flags;
682         int error = -ESRCH;
683 
684         if (lock_task_sighand(child, &flags)) {
685                 error = -EINVAL;
686                 if (likely(child->last_siginfo != NULL)) {
687                         copy_siginfo(child->last_siginfo, info);
688                         error = 0;
689                 }
690                 unlock_task_sighand(child, &flags);
691         }
692         return error;
693 }
694 
695 static int ptrace_peek_siginfo(struct task_struct *child,
696                                 unsigned long addr,
697                                 unsigned long data)
698 {
699         struct ptrace_peeksiginfo_args arg;
700         struct sigpending *pending;
701         struct sigqueue *q;
702         int ret, i;
703 
704         ret = copy_from_user(&arg, (void __user *) addr,
705                                 sizeof(struct ptrace_peeksiginfo_args));
706         if (ret)
707                 return -EFAULT;
708 
709         if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
710                 return -EINVAL; /* unknown flags */
711 
712         if (arg.nr < 0)
713                 return -EINVAL;
714 
715         /* Ensure arg.off fits in an unsigned long */
716         if (arg.off > ULONG_MAX)
717                 return 0;
718 
719         if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
720                 pending = &child->signal->shared_pending;
721         else
722                 pending = &child->pending;
723 
724         for (i = 0; i < arg.nr; ) {
725                 kernel_siginfo_t info;
726                 unsigned long off = arg.off + i;
727                 bool found = false;
728 
729                 spin_lock_irq(&child->sighand->siglock);
730                 list_for_each_entry(q, &pending->list, list) {
731                         if (!off--) {
732                                 found = true;
733                                 copy_siginfo(&info, &q->info);
734                                 break;
735                         }
736                 }
737                 spin_unlock_irq(&child->sighand->siglock);
738 
739                 if (!found) /* beyond the end of the list */
740                         break;
741 
742 #ifdef CONFIG_COMPAT
743                 if (unlikely(in_compat_syscall())) {
744                         compat_siginfo_t __user *uinfo = compat_ptr(data);
745 
746                         if (copy_siginfo_to_user32(uinfo, &info)) {
747                                 ret = -EFAULT;
748                                 break;
749                         }
750 
751                 } else
752 #endif
753                 {
754                         siginfo_t __user *uinfo = (siginfo_t __user *) data;
755 
756                         if (copy_siginfo_to_user(uinfo, &info)) {
757                                 ret = -EFAULT;
758                                 break;
759                         }
760                 }
761 
762                 data += sizeof(siginfo_t);
763                 i++;
764 
765                 if (signal_pending(current))
766                         break;
767 
768                 cond_resched();
769         }
770 
771         if (i > 0)
772                 return i;
773 
774         return ret;
775 }
776 
777 #ifdef PTRACE_SINGLESTEP
778 #define is_singlestep(request)          ((request) == PTRACE_SINGLESTEP)
779 #else
780 #define is_singlestep(request)          0
781 #endif
782 
783 #ifdef PTRACE_SINGLEBLOCK
784 #define is_singleblock(request)         ((request) == PTRACE_SINGLEBLOCK)
785 #else
786 #define is_singleblock(request)         0
787 #endif
788 
789 #ifdef PTRACE_SYSEMU
790 #define is_sysemu_singlestep(request)   ((request) == PTRACE_SYSEMU_SINGLESTEP)
791 #else
792 #define is_sysemu_singlestep(request)   0
793 #endif
794 
795 static int ptrace_resume(struct task_struct *child, long request,
796                          unsigned long data)
797 {
798         bool need_siglock;
799 
800         if (!valid_signal(data))
801                 return -EIO;
802 
803         if (request == PTRACE_SYSCALL)
804                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
805         else
806                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
807 
808 #ifdef TIF_SYSCALL_EMU
809         if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
810                 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
811         else
812                 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
813 #endif
814 
815         if (is_singleblock(request)) {
816                 if (unlikely(!arch_has_block_step()))
817                         return -EIO;
818                 user_enable_block_step(child);
819         } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
820                 if (unlikely(!arch_has_single_step()))
821                         return -EIO;
822                 user_enable_single_step(child);
823         } else {
824                 user_disable_single_step(child);
825         }
826 
827         /*
828          * Change ->exit_code and ->state under siglock to avoid the race
829          * with wait_task_stopped() in between; a non-zero ->exit_code will
830          * wrongly look like another report from tracee.
831          *
832          * Note that we need siglock even if ->exit_code == data and/or this
833          * status was not reported yet, the new status must not be cleared by
834          * wait_task_stopped() after resume.
835          *
836          * If data == 0 we do not care if wait_task_stopped() reports the old
837          * status and clears the code too; this can't race with the tracee, it
838          * takes siglock after resume.
839          */
840         need_siglock = data && !thread_group_empty(current);
841         if (need_siglock)
842                 spin_lock_irq(&child->sighand->siglock);
843         child->exit_code = data;
844         wake_up_state(child, __TASK_TRACED);
845         if (need_siglock)
846                 spin_unlock_irq(&child->sighand->siglock);
847 
848         return 0;
849 }
850 
851 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
852 
853 static const struct user_regset *
854 find_regset(const struct user_regset_view *view, unsigned int type)
855 {
856         const struct user_regset *regset;
857         int n;
858 
859         for (n = 0; n < view->n; ++n) {
860                 regset = view->regsets + n;
861                 if (regset->core_note_type == type)
862                         return regset;
863         }
864 
865         return NULL;
866 }
867 
868 static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
869                          struct iovec *kiov)
870 {
871         const struct user_regset_view *view = task_user_regset_view(task);
872         const struct user_regset *regset = find_regset(view, type);
873         int regset_no;
874 
875         if (!regset || (kiov->iov_len % regset->size) != 0)
876                 return -EINVAL;
877 
878         regset_no = regset - view->regsets;
879         kiov->iov_len = min(kiov->iov_len,
880                             (__kernel_size_t) (regset->n * regset->size));
881 
882         if (req == PTRACE_GETREGSET)
883                 return copy_regset_to_user(task, view, regset_no, 0,
884                                            kiov->iov_len, kiov->iov_base);
885         else
886                 return copy_regset_from_user(task, view, regset_no, 0,
887                                              kiov->iov_len, kiov->iov_base);
888 }
889 
890 /*
891  * This is declared in linux/regset.h and defined in machine-dependent
892  * code.  We put the export here, near the primary machine-neutral use,
893  * to ensure no machine forgets it.
894  */
895 EXPORT_SYMBOL_GPL(task_user_regset_view);
896 #endif
897 
898 int ptrace_request(struct task_struct *child, long request,
899                    unsigned long addr, unsigned long data)
900 {
901         bool seized = child->ptrace & PT_SEIZED;
902         int ret = -EIO;
903         kernel_siginfo_t siginfo, *si;
904         void __user *datavp = (void __user *) data;
905         unsigned long __user *datalp = datavp;
906         unsigned long flags;
907 
908         switch (request) {
909         case PTRACE_PEEKTEXT:
910         case PTRACE_PEEKDATA:
911                 return generic_ptrace_peekdata(child, addr, data);
912         case PTRACE_POKETEXT:
913         case PTRACE_POKEDATA:
914                 return generic_ptrace_pokedata(child, addr, data);
915 
916 #ifdef PTRACE_OLDSETOPTIONS
917         case PTRACE_OLDSETOPTIONS:
918 #endif
919         case PTRACE_SETOPTIONS:
920                 ret = ptrace_setoptions(child, data);
921                 break;
922         case PTRACE_GETEVENTMSG:
923                 ret = put_user(child->ptrace_message, datalp);
924                 break;
925 
926         case PTRACE_PEEKSIGINFO:
927                 ret = ptrace_peek_siginfo(child, addr, data);
928                 break;
929 
930         case PTRACE_GETSIGINFO:
931                 ret = ptrace_getsiginfo(child, &siginfo);
932                 if (!ret)
933                         ret = copy_siginfo_to_user(datavp, &siginfo);
934                 break;
935 
936         case PTRACE_SETSIGINFO:
937                 ret = copy_siginfo_from_user(&siginfo, datavp);
938                 if (!ret)
939                         ret = ptrace_setsiginfo(child, &siginfo);
940                 break;
941 
942         case PTRACE_GETSIGMASK: {
943                 sigset_t *mask;
944 
945                 if (addr != sizeof(sigset_t)) {
946                         ret = -EINVAL;
947                         break;
948                 }
949 
950                 if (test_tsk_restore_sigmask(child))
951                         mask = &child->saved_sigmask;
952                 else
953                         mask = &child->blocked;
954 
955                 if (copy_to_user(datavp, mask, sizeof(sigset_t)))
956                         ret = -EFAULT;
957                 else
958                         ret = 0;
959 
960                 break;
961         }
962 
963         case PTRACE_SETSIGMASK: {
964                 sigset_t new_set;
965 
966                 if (addr != sizeof(sigset_t)) {
967                         ret = -EINVAL;
968                         break;
969                 }
970 
971                 if (copy_from_user(&new_set, datavp, sizeof(sigset_t))) {
972                         ret = -EFAULT;
973                         break;
974                 }
975 
976                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
977 
978                 /*
979                  * Every thread does recalc_sigpending() after resume, so
980                  * retarget_shared_pending() and recalc_sigpending() are not
981                  * called here.
982                  */
983                 spin_lock_irq(&child->sighand->siglock);
984                 child->blocked = new_set;
985                 spin_unlock_irq(&child->sighand->siglock);
986 
987                 clear_tsk_restore_sigmask(child);
988 
989                 ret = 0;
990                 break;
991         }
992 
993         case PTRACE_INTERRUPT:
994                 /*
995                  * Stop tracee without any side-effect on signal or job
996                  * control.  At least one trap is guaranteed to happen
997                  * after this request.  If @child is already trapped, the
998                  * current trap is not disturbed and another trap will
999                  * happen after the current trap is ended with PTRACE_CONT.
1000                  *
1001                  * The actual trap might not be PTRACE_EVENT_STOP trap but
1002                  * the pending condition is cleared regardless.
1003                  */
1004                 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
1005                         break;
1006 
1007                 /*
1008                  * INTERRUPT doesn't disturb existing trap sans one
1009                  * exception.  If ptracer issued LISTEN for the current
1010                  * STOP, this INTERRUPT should clear LISTEN and re-trap
1011                  * tracee into STOP.
1012                  */
1013                 if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP)))
1014                         ptrace_signal_wake_up(child, child->jobctl & JOBCTL_LISTENING);
1015 
1016                 unlock_task_sighand(child, &flags);
1017                 ret = 0;
1018                 break;
1019 
1020         case PTRACE_LISTEN:
1021                 /*
1022                  * Listen for events.  Tracee must be in STOP.  It's not
1023                  * resumed per-se but is not considered to be in TRACED by
1024                  * wait(2) or ptrace(2).  If an async event (e.g. group
1025                  * stop state change) happens, tracee will enter STOP trap
1026                  * again.  Alternatively, ptracer can issue INTERRUPT to
1027                  * finish listening and re-trap tracee into STOP.
1028                  */
1029                 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
1030                         break;
1031 
1032                 si = child->last_siginfo;
1033                 if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) {
1034                         child->jobctl |= JOBCTL_LISTENING;
1035                         /*
1036                          * If NOTIFY is set, it means event happened between
1037                          * start of this trap and now.  Trigger re-trap.
1038                          */
1039                         if (child->jobctl & JOBCTL_TRAP_NOTIFY)
1040                                 ptrace_signal_wake_up(child, true);
1041                         ret = 0;
1042                 }
1043                 unlock_task_sighand(child, &flags);
1044                 break;
1045 
1046         case PTRACE_DETACH:      /* detach a process that was attached. */
1047                 ret = ptrace_detach(child, data);
1048                 break;
1049 
1050 #ifdef CONFIG_BINFMT_ELF_FDPIC
1051         case PTRACE_GETFDPIC: {
1052                 struct mm_struct *mm = get_task_mm(child);
1053                 unsigned long tmp = 0;
1054 
1055                 ret = -ESRCH;
1056                 if (!mm)
1057                         break;
1058 
1059                 switch (addr) {
1060                 case PTRACE_GETFDPIC_EXEC:
1061                         tmp = mm->context.exec_fdpic_loadmap;
1062                         break;
1063                 case PTRACE_GETFDPIC_INTERP:
1064                         tmp = mm->context.interp_fdpic_loadmap;
1065                         break;
1066                 default:
1067                         break;
1068                 }
1069                 mmput(mm);
1070 
1071                 ret = put_user(tmp, datalp);
1072                 break;
1073         }
1074 #endif
1075 
1076 #ifdef PTRACE_SINGLESTEP
1077         case PTRACE_SINGLESTEP:
1078 #endif
1079 #ifdef PTRACE_SINGLEBLOCK
1080         case PTRACE_SINGLEBLOCK:
1081 #endif
1082 #ifdef PTRACE_SYSEMU
1083         case PTRACE_SYSEMU:
1084         case PTRACE_SYSEMU_SINGLESTEP:
1085 #endif
1086         case PTRACE_SYSCALL:
1087         case PTRACE_CONT:
1088                 return ptrace_resume(child, request, data);
1089 
1090         case PTRACE_KILL:
1091                 if (child->exit_state)  /* already dead */
1092                         return 0;
1093                 return ptrace_resume(child, request, SIGKILL);
1094 
1095 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
1096         case PTRACE_GETREGSET:
1097         case PTRACE_SETREGSET: {
1098                 struct iovec kiov;
1099                 struct iovec __user *uiov = datavp;
1100 
1101                 if (!access_ok(uiov, sizeof(*uiov)))
1102                         return -EFAULT;
1103 
1104                 if (__get_user(kiov.iov_base, &uiov->iov_base) ||
1105                     __get_user(kiov.iov_len, &uiov->iov_len))
1106                         return -EFAULT;
1107 
1108                 ret = ptrace_regset(child, request, addr, &kiov);
1109                 if (!ret)
1110                         ret = __put_user(kiov.iov_len, &uiov->iov_len);
1111                 break;
1112         }
1113 #endif
1114 
1115         case PTRACE_SECCOMP_GET_FILTER:
1116                 ret = seccomp_get_filter(child, addr, datavp);
1117                 break;
1118 
1119         case PTRACE_SECCOMP_GET_METADATA:
1120                 ret = seccomp_get_metadata(child, addr, datavp);
1121                 break;
1122 
1123         default:
1124                 break;
1125         }
1126 
1127         return ret;
1128 }
1129 
1130 #ifndef arch_ptrace_attach
1131 #define arch_ptrace_attach(child)       do { } while (0)
1132 #endif
1133 
1134 SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
1135                 unsigned long, data)
1136 {
1137         struct task_struct *child;
1138         long ret;
1139         {
1140                 const int rc = ccs_ptrace_permission(request, pid);
1141                 if (rc)
1142                         return rc;
1143         }
1144 
1145         if (request == PTRACE_TRACEME) {
1146                 ret = ptrace_traceme();
1147                 if (!ret)
1148                         arch_ptrace_attach(current);
1149                 goto out;
1150         }
1151 
1152         child = find_get_task_by_vpid(pid);
1153         if (!child) {
1154                 ret = -ESRCH;
1155                 goto out;
1156         }
1157 
1158         if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
1159                 ret = ptrace_attach(child, request, addr, data);
1160                 /*
1161                  * Some architectures need to do book-keeping after
1162                  * a ptrace attach.
1163                  */
1164                 if (!ret)
1165                         arch_ptrace_attach(child);
1166                 goto out_put_task_struct;
1167         }
1168 
1169         ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1170                                   request == PTRACE_INTERRUPT);
1171         if (ret < 0)
1172                 goto out_put_task_struct;
1173 
1174         ret = arch_ptrace(child, request, addr, data);
1175         if (ret || request != PTRACE_DETACH)
1176                 ptrace_unfreeze_traced(child);
1177 
1178  out_put_task_struct:
1179         put_task_struct(child);
1180  out:
1181         return ret;
1182 }
1183 
1184 int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
1185                             unsigned long data)
1186 {
1187         unsigned long tmp;
1188         int copied;
1189 
1190         copied = ptrace_access_vm(tsk, addr, &tmp, sizeof(tmp), FOLL_FORCE);
1191         if (copied != sizeof(tmp))
1192                 return -EIO;
1193         return put_user(tmp, (unsigned long __user *)data);
1194 }
1195 
1196 int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
1197                             unsigned long data)
1198 {
1199         int copied;
1200 
1201         copied = ptrace_access_vm(tsk, addr, &data, sizeof(data),
1202                         FOLL_FORCE | FOLL_WRITE);
1203         return (copied == sizeof(data)) ? 0 : -EIO;
1204 }
1205 
1206 #if defined CONFIG_COMPAT
1207 
1208 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
1209                           compat_ulong_t addr, compat_ulong_t data)
1210 {
1211         compat_ulong_t __user *datap = compat_ptr(data);
1212         compat_ulong_t word;
1213         kernel_siginfo_t siginfo;
1214         int ret;
1215 
1216         switch (request) {
1217         case PTRACE_PEEKTEXT:
1218         case PTRACE_PEEKDATA:
1219                 ret = ptrace_access_vm(child, addr, &word, sizeof(word),
1220                                 FOLL_FORCE);
1221                 if (ret != sizeof(word))
1222                         ret = -EIO;
1223                 else
1224                         ret = put_user(word, datap);
1225                 break;
1226 
1227         case PTRACE_POKETEXT:
1228         case PTRACE_POKEDATA:
1229                 ret = ptrace_access_vm(child, addr, &data, sizeof(data),
1230                                 FOLL_FORCE | FOLL_WRITE);
1231                 ret = (ret != sizeof(data) ? -EIO : 0);
1232                 break;
1233 
1234         case PTRACE_GETEVENTMSG:
1235                 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
1236                 break;
1237 
1238         case PTRACE_GETSIGINFO:
1239                 ret = ptrace_getsiginfo(child, &siginfo);
1240                 if (!ret)
1241                         ret = copy_siginfo_to_user32(
1242                                 (struct compat_siginfo __user *) datap,
1243                                 &siginfo);
1244                 break;
1245 
1246         case PTRACE_SETSIGINFO:
1247                 ret = copy_siginfo_from_user32(
1248                         &siginfo, (struct compat_siginfo __user *) datap);
1249                 if (!ret)
1250                         ret = ptrace_setsiginfo(child, &siginfo);
1251                 break;
1252 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
1253         case PTRACE_GETREGSET:
1254         case PTRACE_SETREGSET:
1255         {
1256                 struct iovec kiov;
1257                 struct compat_iovec __user *uiov =
1258                         (struct compat_iovec __user *) datap;
1259                 compat_uptr_t ptr;
1260                 compat_size_t len;
1261 
1262                 if (!access_ok(uiov, sizeof(*uiov)))
1263                         return -EFAULT;
1264 
1265                 if (__get_user(ptr, &uiov->iov_base) ||
1266                     __get_user(len, &uiov->iov_len))
1267                         return -EFAULT;
1268 
1269                 kiov.iov_base = compat_ptr(ptr);
1270                 kiov.iov_len = len;
1271 
1272                 ret = ptrace_regset(child, request, addr, &kiov);
1273                 if (!ret)
1274                         ret = __put_user(kiov.iov_len, &uiov->iov_len);
1275                 break;
1276         }
1277 #endif
1278 
1279         default:
1280                 ret = ptrace_request(child, request, addr, data);
1281         }
1282 
1283         return ret;
1284 }
1285 
1286 COMPAT_SYSCALL_DEFINE4(ptrace, compat_long_t, request, compat_long_t, pid,
1287                        compat_long_t, addr, compat_long_t, data)
1288 {
1289         struct task_struct *child;
1290         long ret;
1291         {
1292                 const int rc = ccs_ptrace_permission(request, pid);
1293                 if (rc)
1294                         return rc;
1295         }
1296 
1297         if (request == PTRACE_TRACEME) {
1298                 ret = ptrace_traceme();
1299                 goto out;
1300         }
1301 
1302         child = find_get_task_by_vpid(pid);
1303         if (!child) {
1304                 ret = -ESRCH;
1305                 goto out;
1306         }
1307 
1308         if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
1309                 ret = ptrace_attach(child, request, addr, data);
1310                 /*
1311                  * Some architectures need to do book-keeping after
1312                  * a ptrace attach.
1313                  */
1314                 if (!ret)
1315                         arch_ptrace_attach(child);
1316                 goto out_put_task_struct;
1317         }
1318 
1319         ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1320                                   request == PTRACE_INTERRUPT);
1321         if (!ret) {
1322                 ret = compat_arch_ptrace(child, request, addr, data);
1323                 if (ret || request != PTRACE_DETACH)
1324                         ptrace_unfreeze_traced(child);
1325         }
1326 
1327  out_put_task_struct:
1328         put_task_struct(child);
1329  out:
1330         return ret;
1331 }
1332 #endif  /* CONFIG_COMPAT */
1333 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp