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

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/signal.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  *    Copyright IBM Corp. 1999, 2006
  4  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  5  *
  6  *    Based on Intel version
  7  * 
  8  *  Copyright (C) 1991, 1992  Linus Torvalds
  9  *
 10  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 11  */
 12 
 13 #include <linux/sched.h>
 14 #include <linux/sched/task_stack.h>
 15 #include <linux/mm.h>
 16 #include <linux/smp.h>
 17 #include <linux/kernel.h>
 18 #include <linux/signal.h>
 19 #include <linux/errno.h>
 20 #include <linux/wait.h>
 21 #include <linux/ptrace.h>
 22 #include <linux/unistd.h>
 23 #include <linux/stddef.h>
 24 #include <linux/tty.h>
 25 #include <linux/personality.h>
 26 #include <linux/binfmts.h>
 27 #include <linux/tracehook.h>
 28 #include <linux/syscalls.h>
 29 #include <linux/compat.h>
 30 #include <asm/ucontext.h>
 31 #include <linux/uaccess.h>
 32 #include <asm/lowcore.h>
 33 #include <asm/switch_to.h>
 34 #include "entry.h"
 35 
 36 /*
 37  * Layout of an old-style signal-frame:
 38  *      -----------------------------------------
 39  *      | save area (_SIGNAL_FRAMESIZE)         |
 40  *      -----------------------------------------
 41  *      | struct sigcontext                     |
 42  *      |       oldmask                         |
 43  *      |       _sigregs *                      |
 44  *      -----------------------------------------
 45  *      | _sigregs with                         |
 46  *      |       _s390_regs_common               |
 47  *      |       _s390_fp_regs                   |
 48  *      -----------------------------------------
 49  *      | int signo                             |
 50  *      -----------------------------------------
 51  *      | _sigregs_ext with                     |
 52  *      |       gprs_high 64 byte (opt)         |
 53  *      |       vxrs_low 128 byte (opt)         |
 54  *      |       vxrs_high 256 byte (opt)        |
 55  *      |       reserved 128 byte (opt)         |
 56  *      -----------------------------------------
 57  *      | __u16 svc_insn                        |
 58  *      -----------------------------------------
 59  * The svc_insn entry with the sigreturn system call opcode does not
 60  * have a fixed position and moves if gprs_high or vxrs exist.
 61  * Future extensions will be added to _sigregs_ext.
 62  */
 63 struct sigframe
 64 {
 65         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
 66         struct sigcontext sc;
 67         _sigregs sregs;
 68         int signo;
 69         _sigregs_ext sregs_ext;
 70         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
 71 };
 72 
 73 /*
 74  * Layout of an rt signal-frame:
 75  *      -----------------------------------------
 76  *      | save area (_SIGNAL_FRAMESIZE)         |
 77  *      -----------------------------------------
 78  *      | svc __NR_rt_sigreturn 2 byte          |
 79  *      -----------------------------------------
 80  *      | struct siginfo                        |
 81  *      -----------------------------------------
 82  *      | struct ucontext_extended with         |
 83  *      |       unsigned long uc_flags          |
 84  *      |       struct ucontext *uc_link        |
 85  *      |       stack_t uc_stack                |
 86  *      |       _sigregs uc_mcontext with       |
 87  *      |               _s390_regs_common       |
 88  *      |               _s390_fp_regs           |
 89  *      |       sigset_t uc_sigmask             |
 90  *      |       _sigregs_ext uc_mcontext_ext    |
 91  *      |               gprs_high 64 byte (opt) |
 92  *      |               vxrs_low 128 byte (opt) |
 93  *      |               vxrs_high 256 byte (opt)|
 94  *      |               reserved 128 byte (opt) |
 95  *      -----------------------------------------
 96  * Future extensions will be added to _sigregs_ext.
 97  */
 98 struct rt_sigframe
 99 {
100         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
101         __u16 svc_insn;
102         struct siginfo info;
103         struct ucontext_extended uc;
104 };
105 
106 /* Store registers needed to create the signal frame */
107 static void store_sigregs(void)
108 {
109         save_access_regs(current->thread.acrs);
110         save_fpu_regs();
111 }
112 
113 /* Load registers after signal return */
114 static void load_sigregs(void)
115 {
116         restore_access_regs(current->thread.acrs);
117 }
118 
119 /* Returns non-zero on fault. */
120 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
121 {
122         _sigregs user_sregs;
123 
124         /* Copy a 'clean' PSW mask to the user to avoid leaking
125            information about whether PER is currently on.  */
126         user_sregs.regs.psw.mask = PSW_USER_BITS |
127                 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
128         user_sregs.regs.psw.addr = regs->psw.addr;
129         memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
130         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
131                sizeof(user_sregs.regs.acrs));
132         fpregs_store(&user_sregs.fpregs, &current->thread.fpu);
133         if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
134                 return -EFAULT;
135         return 0;
136 }
137 
138 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
139 {
140         _sigregs user_sregs;
141 
142         /* Alwys make any pending restarted system call return -EINTR */
143         current->restart_block.fn = do_no_restart_syscall;
144 
145         if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
146                 return -EFAULT;
147 
148         if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
149                 return -EINVAL;
150 
151         /* Test the floating-point-control word. */
152         if (test_fp_ctl(user_sregs.fpregs.fpc))
153                 return -EINVAL;
154 
155         /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
156         regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
157                 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
158         /* Check for invalid user address space control. */
159         if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
160                 regs->psw.mask = PSW_ASC_PRIMARY |
161                         (regs->psw.mask & ~PSW_MASK_ASC);
162         /* Check for invalid amode */
163         if (regs->psw.mask & PSW_MASK_EA)
164                 regs->psw.mask |= PSW_MASK_BA;
165         regs->psw.addr = user_sregs.regs.psw.addr;
166         memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
167         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
168                sizeof(current->thread.acrs));
169 
170         fpregs_load(&user_sregs.fpregs, &current->thread.fpu);
171 
172         clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
173         return 0;
174 }
175 
176 /* Returns non-zero on fault. */
177 static int save_sigregs_ext(struct pt_regs *regs,
178                             _sigregs_ext __user *sregs_ext)
179 {
180         __u64 vxrs[__NUM_VXRS_LOW];
181         int i;
182 
183         /* Save vector registers to signal stack */
184         if (MACHINE_HAS_VX) {
185                 for (i = 0; i < __NUM_VXRS_LOW; i++)
186                         vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
187                 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
188                                    sizeof(sregs_ext->vxrs_low)) ||
189                     __copy_to_user(&sregs_ext->vxrs_high,
190                                    current->thread.fpu.vxrs + __NUM_VXRS_LOW,
191                                    sizeof(sregs_ext->vxrs_high)))
192                         return -EFAULT;
193         }
194         return 0;
195 }
196 
197 static int restore_sigregs_ext(struct pt_regs *regs,
198                                _sigregs_ext __user *sregs_ext)
199 {
200         __u64 vxrs[__NUM_VXRS_LOW];
201         int i;
202 
203         /* Restore vector registers from signal stack */
204         if (MACHINE_HAS_VX) {
205                 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
206                                      sizeof(sregs_ext->vxrs_low)) ||
207                     __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
208                                      &sregs_ext->vxrs_high,
209                                      sizeof(sregs_ext->vxrs_high)))
210                         return -EFAULT;
211                 for (i = 0; i < __NUM_VXRS_LOW; i++)
212                         *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
213         }
214         return 0;
215 }
216 
217 SYSCALL_DEFINE0(sigreturn)
218 {
219         struct pt_regs *regs = task_pt_regs(current);
220         struct sigframe __user *frame =
221                 (struct sigframe __user *) regs->gprs[15];
222         sigset_t set;
223 
224         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
225                 goto badframe;
226         set_current_blocked(&set);
227         save_fpu_regs();
228         if (restore_sigregs(regs, &frame->sregs))
229                 goto badframe;
230         if (restore_sigregs_ext(regs, &frame->sregs_ext))
231                 goto badframe;
232         load_sigregs();
233         return regs->gprs[2];
234 badframe:
235         force_sig(SIGSEGV, current);
236         return 0;
237 }
238 
239 SYSCALL_DEFINE0(rt_sigreturn)
240 {
241         struct pt_regs *regs = task_pt_regs(current);
242         struct rt_sigframe __user *frame =
243                 (struct rt_sigframe __user *)regs->gprs[15];
244         sigset_t set;
245 
246         if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
247                 goto badframe;
248         set_current_blocked(&set);
249         if (restore_altstack(&frame->uc.uc_stack))
250                 goto badframe;
251         save_fpu_regs();
252         if (restore_sigregs(regs, &frame->uc.uc_mcontext))
253                 goto badframe;
254         if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
255                 goto badframe;
256         load_sigregs();
257         return regs->gprs[2];
258 badframe:
259         force_sig(SIGSEGV, current);
260         return 0;
261 }
262 
263 /*
264  * Determine which stack to use..
265  */
266 static inline void __user *
267 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
268 {
269         unsigned long sp;
270 
271         /* Default to using normal stack */
272         sp = regs->gprs[15];
273 
274         /* Overflow on alternate signal stack gives SIGSEGV. */
275         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
276                 return (void __user *) -1UL;
277 
278         /* This is the X/Open sanctioned signal stack switching.  */
279         if (ka->sa.sa_flags & SA_ONSTACK) {
280                 if (! sas_ss_flags(sp))
281                         sp = current->sas_ss_sp + current->sas_ss_size;
282         }
283 
284         return (void __user *)((sp - frame_size) & -8ul);
285 }
286 
287 static int setup_frame(int sig, struct k_sigaction *ka,
288                        sigset_t *set, struct pt_regs * regs)
289 {
290         struct sigframe __user *frame;
291         struct sigcontext sc;
292         unsigned long restorer;
293         size_t frame_size;
294 
295         /*
296          * gprs_high are only present for a 31-bit task running on
297          * a 64-bit kernel (see compat_signal.c) but the space for
298          * gprs_high need to be allocated if vector registers are
299          * included in the signal frame on a 31-bit system.
300          */
301         frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
302         if (MACHINE_HAS_VX)
303                 frame_size += sizeof(frame->sregs_ext);
304         frame = get_sigframe(ka, regs, frame_size);
305         if (frame == (void __user *) -1UL)
306                 return -EFAULT;
307 
308         /* Set up backchain. */
309         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
310                 return -EFAULT;
311 
312         /* Create struct sigcontext on the signal stack */
313         memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
314         sc.sregs = (_sigregs __user __force *) &frame->sregs;
315         if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
316                 return -EFAULT;
317 
318         /* Store registers needed to create the signal frame */
319         store_sigregs();
320 
321         /* Create _sigregs on the signal stack */
322         if (save_sigregs(regs, &frame->sregs))
323                 return -EFAULT;
324 
325         /* Place signal number on stack to allow backtrace from handler.  */
326         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
327                 return -EFAULT;
328 
329         /* Create _sigregs_ext on the signal stack */
330         if (save_sigregs_ext(regs, &frame->sregs_ext))
331                 return -EFAULT;
332 
333         /* Set up to return from userspace.  If provided, use a stub
334            already in userspace.  */
335         if (ka->sa.sa_flags & SA_RESTORER) {
336                 restorer = (unsigned long) ka->sa.sa_restorer;
337         } else {
338                 /* Signal frame without vector registers are short ! */
339                 __u16 __user *svc = (void __user *) frame + frame_size - 2;
340                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
341                         return -EFAULT;
342                 restorer = (unsigned long) svc;
343         }
344 
345         /* Set up registers for signal handler */
346         regs->gprs[14] = restorer;
347         regs->gprs[15] = (unsigned long) frame;
348         /* Force default amode and default user address space control. */
349         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
350                 (PSW_USER_BITS & PSW_MASK_ASC) |
351                 (regs->psw.mask & ~PSW_MASK_ASC);
352         regs->psw.addr = (unsigned long) ka->sa.sa_handler;
353 
354         regs->gprs[2] = sig;
355         regs->gprs[3] = (unsigned long) &frame->sc;
356 
357         /* We forgot to include these in the sigcontext.
358            To avoid breaking binary compatibility, they are passed as args. */
359         if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
360             sig == SIGTRAP || sig == SIGFPE) {
361                 /* set extra registers only for synchronous signals */
362                 regs->gprs[4] = regs->int_code & 127;
363                 regs->gprs[5] = regs->int_parm_long;
364                 regs->gprs[6] = current->thread.last_break;
365         }
366         return 0;
367 }
368 
369 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
370                           struct pt_regs *regs)
371 {
372         struct rt_sigframe __user *frame;
373         unsigned long uc_flags, restorer;
374         size_t frame_size;
375 
376         frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
377         /*
378          * gprs_high are only present for a 31-bit task running on
379          * a 64-bit kernel (see compat_signal.c) but the space for
380          * gprs_high need to be allocated if vector registers are
381          * included in the signal frame on a 31-bit system.
382          */
383         uc_flags = 0;
384         if (MACHINE_HAS_VX) {
385                 frame_size += sizeof(_sigregs_ext);
386                 uc_flags |= UC_VXRS;
387         }
388         frame = get_sigframe(&ksig->ka, regs, frame_size);
389         if (frame == (void __user *) -1UL)
390                 return -EFAULT;
391 
392         /* Set up backchain. */
393         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
394                 return -EFAULT;
395 
396         /* Set up to return from userspace.  If provided, use a stub
397            already in userspace.  */
398         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
399                 restorer = (unsigned long) ksig->ka.sa.sa_restorer;
400         } else {
401                 __u16 __user *svc = &frame->svc_insn;
402                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
403                         return -EFAULT;
404                 restorer = (unsigned long) svc;
405         }
406 
407         /* Create siginfo on the signal stack */
408         if (copy_siginfo_to_user(&frame->info, &ksig->info))
409                 return -EFAULT;
410 
411         /* Store registers needed to create the signal frame */
412         store_sigregs();
413 
414         /* Create ucontext on the signal stack. */
415         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
416             __put_user(NULL, &frame->uc.uc_link) ||
417             __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
418             save_sigregs(regs, &frame->uc.uc_mcontext) ||
419             __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
420             save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
421                 return -EFAULT;
422 
423         /* Set up registers for signal handler */
424         regs->gprs[14] = restorer;
425         regs->gprs[15] = (unsigned long) frame;
426         /* Force default amode and default user address space control. */
427         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
428                 (PSW_USER_BITS & PSW_MASK_ASC) |
429                 (regs->psw.mask & ~PSW_MASK_ASC);
430         regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
431 
432         regs->gprs[2] = ksig->sig;
433         regs->gprs[3] = (unsigned long) &frame->info;
434         regs->gprs[4] = (unsigned long) &frame->uc;
435         regs->gprs[5] = current->thread.last_break;
436         return 0;
437 }
438 
439 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
440                           struct pt_regs *regs)
441 {
442         int ret;
443 
444         /* Set up the stack frame */
445         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
446                 ret = setup_rt_frame(ksig, oldset, regs);
447         else
448                 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
449 
450         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
451 }
452 
453 /*
454  * Note that 'init' is a special process: it doesn't get signals it doesn't
455  * want to handle. Thus you cannot kill init even with a SIGKILL even by
456  * mistake.
457  *
458  * Note that we go through the signals twice: once to check the signals that
459  * the kernel can handle, and then we build all the user-level signal handling
460  * stack-frames in one go after that.
461  */
462 void do_signal(struct pt_regs *regs)
463 {
464         struct ksignal ksig;
465         sigset_t *oldset = sigmask_to_save();
466 
467         /*
468          * Get signal to deliver. When running under ptrace, at this point
469          * the debugger may change all our registers, including the system
470          * call information.
471          */
472         current->thread.system_call =
473                 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
474 
475         if (get_signal(&ksig)) {
476                 /* Whee!  Actually deliver the signal.  */
477                 if (current->thread.system_call) {
478                         regs->int_code = current->thread.system_call;
479                         /* Check for system call restarting. */
480                         switch (regs->gprs[2]) {
481                         case -ERESTART_RESTARTBLOCK:
482                         case -ERESTARTNOHAND:
483                                 regs->gprs[2] = -EINTR;
484                                 break;
485                         case -ERESTARTSYS:
486                                 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
487                                         regs->gprs[2] = -EINTR;
488                                         break;
489                                 }
490                         /* fallthrough */
491                         case -ERESTARTNOINTR:
492                                 regs->gprs[2] = regs->orig_gpr2;
493                                 regs->psw.addr =
494                                         __rewind_psw(regs->psw,
495                                                      regs->int_code >> 16);
496                                 break;
497                         }
498                 }
499                 /* No longer in a system call */
500                 clear_pt_regs_flag(regs, PIF_SYSCALL);
501 
502                 if (is_compat_task())
503                         handle_signal32(&ksig, oldset, regs);
504                 else
505                         handle_signal(&ksig, oldset, regs);
506                 return;
507         }
508 
509         /* No handlers present - check for system call restart */
510         clear_pt_regs_flag(regs, PIF_SYSCALL);
511         if (current->thread.system_call) {
512                 regs->int_code = current->thread.system_call;
513                 switch (regs->gprs[2]) {
514                 case -ERESTART_RESTARTBLOCK:
515                         /* Restart with sys_restart_syscall */
516                         regs->int_code = __NR_restart_syscall;
517                 /* fallthrough */
518                 case -ERESTARTNOHAND:
519                 case -ERESTARTSYS:
520                 case -ERESTARTNOINTR:
521                         /* Restart system call with magic TIF bit. */
522                         regs->gprs[2] = regs->orig_gpr2;
523                         set_pt_regs_flag(regs, PIF_SYSCALL);
524                         if (test_thread_flag(TIF_SINGLE_STEP))
525                                 clear_pt_regs_flag(regs, PIF_PER_TRAP);
526                         break;
527                 }
528         }
529 
530         /*
531          * If there's no signal to deliver, we just put the saved sigmask back.
532          */
533         restore_saved_sigmask();
534 }
535 
536 void do_notify_resume(struct pt_regs *regs)
537 {
538         clear_thread_flag(TIF_NOTIFY_RESUME);
539         tracehook_notify_resume(regs);
540 }
541 

~ [ 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