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

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/x86/ldt_gdt.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  * ldt_gdt.c - Test cases for LDT and GDT access
  3  * Copyright (c) 2015 Andrew Lutomirski
  4  */
  5 
  6 #define _GNU_SOURCE
  7 #include <err.h>
  8 #include <stdio.h>
  9 #include <stdint.h>
 10 #include <signal.h>
 11 #include <setjmp.h>
 12 #include <stdlib.h>
 13 #include <string.h>
 14 #include <errno.h>
 15 #include <unistd.h>
 16 #include <sys/syscall.h>
 17 #include <asm/ldt.h>
 18 #include <sys/types.h>
 19 #include <sys/wait.h>
 20 #include <stdbool.h>
 21 #include <pthread.h>
 22 #include <sched.h>
 23 #include <linux/futex.h>
 24 
 25 #define AR_ACCESSED             (1<<8)
 26 
 27 #define AR_TYPE_RODATA          (0 * (1<<9))
 28 #define AR_TYPE_RWDATA          (1 * (1<<9))
 29 #define AR_TYPE_RODATA_EXPDOWN  (2 * (1<<9))
 30 #define AR_TYPE_RWDATA_EXPDOWN  (3 * (1<<9))
 31 #define AR_TYPE_XOCODE          (4 * (1<<9))
 32 #define AR_TYPE_XRCODE          (5 * (1<<9))
 33 #define AR_TYPE_XOCODE_CONF     (6 * (1<<9))
 34 #define AR_TYPE_XRCODE_CONF     (7 * (1<<9))
 35 
 36 #define AR_DPL3                 (3 * (1<<13))
 37 
 38 #define AR_S                    (1 << 12)
 39 #define AR_P                    (1 << 15)
 40 #define AR_AVL                  (1 << 20)
 41 #define AR_L                    (1 << 21)
 42 #define AR_DB                   (1 << 22)
 43 #define AR_G                    (1 << 23)
 44 
 45 static int nerrs;
 46 
 47 static void check_invalid_segment(uint16_t index, int ldt)
 48 {
 49         uint32_t has_limit = 0, has_ar = 0, limit, ar;
 50         uint32_t selector = (index << 3) | (ldt << 2) | 3;
 51 
 52         asm ("lsl %[selector], %[limit]\n\t"
 53              "jnz 1f\n\t"
 54              "movl $1, %[has_limit]\n\t"
 55              "1:"
 56              : [limit] "=r" (limit), [has_limit] "+rm" (has_limit)
 57              : [selector] "r" (selector));
 58         asm ("larl %[selector], %[ar]\n\t"
 59              "jnz 1f\n\t"
 60              "movl $1, %[has_ar]\n\t"
 61              "1:"
 62              : [ar] "=r" (ar), [has_ar] "+rm" (has_ar)
 63              : [selector] "r" (selector));
 64 
 65         if (has_limit || has_ar) {
 66                 printf("[FAIL]\t%s entry %hu is valid but should be invalid\n",
 67                        (ldt ? "LDT" : "GDT"), index);
 68                 nerrs++;
 69         } else {
 70                 printf("[OK]\t%s entry %hu is invalid\n",
 71                        (ldt ? "LDT" : "GDT"), index);
 72         }
 73 }
 74 
 75 static void check_valid_segment(uint16_t index, int ldt,
 76                                 uint32_t expected_ar, uint32_t expected_limit,
 77                                 bool verbose)
 78 {
 79         uint32_t has_limit = 0, has_ar = 0, limit, ar;
 80         uint32_t selector = (index << 3) | (ldt << 2) | 3;
 81 
 82         asm ("lsl %[selector], %[limit]\n\t"
 83              "jnz 1f\n\t"
 84              "movl $1, %[has_limit]\n\t"
 85              "1:"
 86              : [limit] "=r" (limit), [has_limit] "+rm" (has_limit)
 87              : [selector] "r" (selector));
 88         asm ("larl %[selector], %[ar]\n\t"
 89              "jnz 1f\n\t"
 90              "movl $1, %[has_ar]\n\t"
 91              "1:"
 92              : [ar] "=r" (ar), [has_ar] "+rm" (has_ar)
 93              : [selector] "r" (selector));
 94 
 95         if (!has_limit || !has_ar) {
 96                 printf("[FAIL]\t%s entry %hu is invalid but should be valid\n",
 97                        (ldt ? "LDT" : "GDT"), index);
 98                 nerrs++;
 99                 return;
100         }
101 
102         if (ar != expected_ar) {
103                 printf("[FAIL]\t%s entry %hu has AR 0x%08X but expected 0x%08X\n",
104                        (ldt ? "LDT" : "GDT"), index, ar, expected_ar);
105                 nerrs++;
106         } else if (limit != expected_limit) {
107                 printf("[FAIL]\t%s entry %hu has limit 0x%08X but expected 0x%08X\n",
108                        (ldt ? "LDT" : "GDT"), index, limit, expected_limit);
109                 nerrs++;
110         } else if (verbose) {
111                 printf("[OK]\t%s entry %hu has AR 0x%08X and limit 0x%08X\n",
112                        (ldt ? "LDT" : "GDT"), index, ar, limit);
113         }
114 }
115 
116 static bool install_valid_mode(const struct user_desc *desc, uint32_t ar,
117                                bool oldmode)
118 {
119         int ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
120                           desc, sizeof(*desc));
121         if (ret < -1)
122                 errno = -ret;
123         if (ret == 0) {
124                 uint32_t limit = desc->limit;
125                 if (desc->limit_in_pages)
126                         limit = (limit << 12) + 4095;
127                 check_valid_segment(desc->entry_number, 1, ar, limit, true);
128                 return true;
129         } else if (errno == ENOSYS) {
130                 printf("[OK]\tmodify_ldt returned -ENOSYS\n");
131                 return false;
132         } else {
133                 if (desc->seg_32bit) {
134                         printf("[FAIL]\tUnexpected modify_ldt failure %d\n",
135                                errno);
136                         nerrs++;
137                         return false;
138                 } else {
139                         printf("[OK]\tmodify_ldt rejected 16 bit segment\n");
140                         return false;
141                 }
142         }
143 }
144 
145 static bool install_valid(const struct user_desc *desc, uint32_t ar)
146 {
147         return install_valid_mode(desc, ar, false);
148 }
149 
150 static void install_invalid(const struct user_desc *desc, bool oldmode)
151 {
152         int ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
153                           desc, sizeof(*desc));
154         if (ret < -1)
155                 errno = -ret;
156         if (ret == 0) {
157                 check_invalid_segment(desc->entry_number, 1);
158         } else if (errno == ENOSYS) {
159                 printf("[OK]\tmodify_ldt returned -ENOSYS\n");
160         } else {
161                 if (desc->seg_32bit) {
162                         printf("[FAIL]\tUnexpected modify_ldt failure %d\n",
163                                errno);
164                         nerrs++;
165                 } else {
166                         printf("[OK]\tmodify_ldt rejected 16 bit segment\n");
167                 }
168         }
169 }
170 
171 static int safe_modify_ldt(int func, struct user_desc *ptr,
172                            unsigned long bytecount)
173 {
174         int ret = syscall(SYS_modify_ldt, 0x11, ptr, bytecount);
175         if (ret < -1)
176                 errno = -ret;
177         return ret;
178 }
179 
180 static void fail_install(struct user_desc *desc)
181 {
182         if (safe_modify_ldt(0x11, desc, sizeof(*desc)) == 0) {
183                 printf("[FAIL]\tmodify_ldt accepted a bad descriptor\n");
184                 nerrs++;
185         } else if (errno == ENOSYS) {
186                 printf("[OK]\tmodify_ldt returned -ENOSYS\n");
187         } else {
188                 printf("[OK]\tmodify_ldt failure %d\n", errno);
189         }
190 }
191 
192 static void do_simple_tests(void)
193 {
194         struct user_desc desc = {
195                 .entry_number    = 0,
196                 .base_addr       = 0,
197                 .limit           = 10,
198                 .seg_32bit       = 1,
199                 .contents        = 2, /* Code, not conforming */
200                 .read_exec_only  = 0,
201                 .limit_in_pages  = 0,
202                 .seg_not_present = 0,
203                 .useable         = 0
204         };
205         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE | AR_S | AR_P | AR_DB);
206 
207         desc.limit_in_pages = 1;
208         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
209                       AR_S | AR_P | AR_DB | AR_G);
210 
211         check_invalid_segment(1, 1);
212 
213         desc.entry_number = 2;
214         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
215                       AR_S | AR_P | AR_DB | AR_G);
216 
217         check_invalid_segment(1, 1);
218 
219         desc.base_addr = 0xf0000000;
220         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
221                       AR_S | AR_P | AR_DB | AR_G);
222 
223         desc.useable = 1;
224         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
225                       AR_S | AR_P | AR_DB | AR_G | AR_AVL);
226 
227         desc.seg_not_present = 1;
228         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
229                       AR_S | AR_DB | AR_G | AR_AVL);
230 
231         desc.seg_32bit = 0;
232         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
233                       AR_S | AR_G | AR_AVL);
234 
235         desc.seg_32bit = 1;
236         desc.contents = 0;
237         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA |
238                       AR_S | AR_DB | AR_G | AR_AVL);
239 
240         desc.read_exec_only = 1;
241         install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA |
242                       AR_S | AR_DB | AR_G | AR_AVL);
243 
244         desc.contents = 1;
245         install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA_EXPDOWN |
246                       AR_S | AR_DB | AR_G | AR_AVL);
247 
248         desc.read_exec_only = 0;
249         desc.limit_in_pages = 0;
250         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA_EXPDOWN |
251                       AR_S | AR_DB | AR_AVL);
252 
253         desc.contents = 3;
254         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE_CONF |
255                       AR_S | AR_DB | AR_AVL);
256 
257         desc.read_exec_only = 1;
258         install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE_CONF |
259                       AR_S | AR_DB | AR_AVL);
260 
261         desc.read_exec_only = 0;
262         desc.contents = 2;
263         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
264                       AR_S | AR_DB | AR_AVL);
265 
266         desc.read_exec_only = 1;
267 
268 #ifdef __x86_64__
269         desc.lm = 1;
270         install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE |
271                       AR_S | AR_DB | AR_AVL);
272         desc.lm = 0;
273 #endif
274 
275         bool entry1_okay = install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE |
276                                          AR_S | AR_DB | AR_AVL);
277 
278         if (entry1_okay) {
279                 printf("[RUN]\tTest fork\n");
280                 pid_t child = fork();
281                 if (child == 0) {
282                         nerrs = 0;
283                         check_valid_segment(desc.entry_number, 1,
284                                             AR_DPL3 | AR_TYPE_XOCODE |
285                                             AR_S | AR_DB | AR_AVL, desc.limit,
286                                             true);
287                         check_invalid_segment(1, 1);
288                         exit(nerrs ? 1 : 0);
289                 } else {
290                         int status;
291                         if (waitpid(child, &status, 0) != child ||
292                             !WIFEXITED(status)) {
293                                 printf("[FAIL]\tChild died\n");
294                                 nerrs++;
295                         } else if (WEXITSTATUS(status) != 0) {
296                                 printf("[FAIL]\tChild failed\n");
297                                 nerrs++;
298                         } else {
299                                 printf("[OK]\tChild succeeded\n");
300                         }
301                 }
302 
303                 printf("[RUN]\tTest size\n");
304                 int i;
305                 for (i = 0; i < 8192; i++) {
306                         desc.entry_number = i;
307                         desc.limit = i;
308                         if (safe_modify_ldt(0x11, &desc, sizeof(desc)) != 0) {
309                                 printf("[FAIL]\tFailed to install entry %d\n", i);
310                                 nerrs++;
311                                 break;
312                         }
313                 }
314                 for (int j = 0; j < i; j++) {
315                         check_valid_segment(j, 1, AR_DPL3 | AR_TYPE_XOCODE |
316                                             AR_S | AR_DB | AR_AVL, j, false);
317                 }
318                 printf("[DONE]\tSize test\n");
319         } else {
320                 printf("[SKIP]\tSkipping fork and size tests because we have no LDT\n");
321         }
322 
323         /* Test entry_number too high. */
324         desc.entry_number = 8192;
325         fail_install(&desc);
326 
327         /* Test deletion and actions mistakeable for deletion. */
328         memset(&desc, 0, sizeof(desc));
329         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P);
330 
331         desc.seg_not_present = 1;
332         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S);
333 
334         desc.seg_not_present = 0;
335         desc.read_exec_only = 1;
336         install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S | AR_P);
337 
338         desc.read_exec_only = 0;
339         desc.seg_not_present = 1;
340         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S);
341 
342         desc.read_exec_only = 1;
343         desc.limit = 1;
344         install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S);
345 
346         desc.limit = 0;
347         desc.base_addr = 1;
348         install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S);
349 
350         desc.base_addr = 0;
351         install_invalid(&desc, false);
352 
353         desc.seg_not_present = 0;
354         desc.read_exec_only = 0;
355         desc.seg_32bit = 1;
356         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P | AR_DB);
357         install_invalid(&desc, true);
358 }
359 
360 /*
361  * 0: thread is idle
362  * 1: thread armed
363  * 2: thread should clear LDT entry 0
364  * 3: thread should exit
365  */
366 static volatile unsigned int ftx;
367 
368 static void *threadproc(void *ctx)
369 {
370         cpu_set_t cpuset;
371         CPU_ZERO(&cpuset);
372         CPU_SET(1, &cpuset);
373         if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0)
374                 err(1, "sched_setaffinity to CPU 1");   /* should never fail */
375 
376         while (1) {
377                 syscall(SYS_futex, &ftx, FUTEX_WAIT, 0, NULL, NULL, 0);
378                 while (ftx != 2) {
379                         if (ftx >= 3)
380                                 return NULL;
381                 }
382 
383                 /* clear LDT entry 0 */
384                 const struct user_desc desc = {};
385                 if (syscall(SYS_modify_ldt, 1, &desc, sizeof(desc)) != 0)
386                         err(1, "modify_ldt");
387 
388                 /* If ftx == 2, set it to zero.  If ftx == 100, quit. */
389                 unsigned int x = -2;
390                 asm volatile ("lock xaddl %[x], %[ftx]" :
391                               [x] "+r" (x), [ftx] "+m" (ftx));
392                 if (x != 2)
393                         return NULL;
394         }
395 }
396 
397 static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
398                        int flags)
399 {
400         struct sigaction sa;
401         memset(&sa, 0, sizeof(sa));
402         sa.sa_sigaction = handler;
403         sa.sa_flags = SA_SIGINFO | flags;
404         sigemptyset(&sa.sa_mask);
405         if (sigaction(sig, &sa, 0))
406                 err(1, "sigaction");
407 
408 }
409 
410 static jmp_buf jmpbuf;
411 
412 static void sigsegv(int sig, siginfo_t *info, void *ctx_void)
413 {
414         siglongjmp(jmpbuf, 1);
415 }
416 
417 static void do_multicpu_tests(void)
418 {
419         cpu_set_t cpuset;
420         pthread_t thread;
421         int failures = 0, iters = 5, i;
422         unsigned short orig_ss;
423 
424         CPU_ZERO(&cpuset);
425         CPU_SET(1, &cpuset);
426         if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) {
427                 printf("[SKIP]\tCannot set affinity to CPU 1\n");
428                 return;
429         }
430 
431         CPU_ZERO(&cpuset);
432         CPU_SET(0, &cpuset);
433         if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) {
434                 printf("[SKIP]\tCannot set affinity to CPU 0\n");
435                 return;
436         }
437 
438         sethandler(SIGSEGV, sigsegv, 0);
439 #ifdef __i386__
440         /* True 32-bit kernels send SIGILL instead of SIGSEGV on IRET faults. */
441         sethandler(SIGILL, sigsegv, 0);
442 #endif
443 
444         printf("[RUN]\tCross-CPU LDT invalidation\n");
445 
446         if (pthread_create(&thread, 0, threadproc, 0) != 0)
447                 err(1, "pthread_create");
448 
449         asm volatile ("mov %%ss, %0" : "=rm" (orig_ss));
450 
451         for (i = 0; i < 5; i++) {
452                 if (sigsetjmp(jmpbuf, 1) != 0)
453                         continue;
454 
455                 /* Make sure the thread is ready after the last test. */
456                 while (ftx != 0)
457                         ;
458 
459                 struct user_desc desc = {
460                         .entry_number    = 0,
461                         .base_addr       = 0,
462                         .limit           = 0xfffff,
463                         .seg_32bit       = 1,
464                         .contents        = 0, /* Data */
465                         .read_exec_only  = 0,
466                         .limit_in_pages  = 1,
467                         .seg_not_present = 0,
468                         .useable         = 0
469                 };
470 
471                 if (safe_modify_ldt(0x11, &desc, sizeof(desc)) != 0) {
472                         if (errno != ENOSYS)
473                                 err(1, "modify_ldt");
474                         printf("[SKIP]\tmodify_ldt unavailable\n");
475                         break;
476                 }
477 
478                 /* Arm the thread. */
479                 ftx = 1;
480                 syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
481 
482                 asm volatile ("mov %0, %%ss" : : "r" (0x7));
483 
484                 /* Go! */
485                 ftx = 2;
486 
487                 while (ftx != 0)
488                         ;
489 
490                 /*
491                  * On success, modify_ldt will segfault us synchronously,
492                  * and we'll escape via siglongjmp.
493                  */
494 
495                 failures++;
496                 asm volatile ("mov %0, %%ss" : : "rm" (orig_ss));
497         };
498 
499         ftx = 100;  /* Kill the thread. */
500         syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
501 
502         if (pthread_join(thread, NULL) != 0)
503                 err(1, "pthread_join");
504 
505         if (failures) {
506                 printf("[FAIL]\t%d of %d iterations failed\n", failures, iters);
507                 nerrs++;
508         } else {
509                 printf("[OK]\tAll %d iterations succeeded\n", iters);
510         }
511 }
512 
513 static int finish_exec_test(void)
514 {
515         /*
516          * In a sensible world, this would be check_invalid_segment(0, 1);
517          * For better or for worse, though, the LDT is inherited across exec.
518          * We can probably change this safely, but for now we test it.
519          */
520         check_valid_segment(0, 1,
521                             AR_DPL3 | AR_TYPE_XRCODE | AR_S | AR_P | AR_DB,
522                             42, true);
523 
524         return nerrs ? 1 : 0;
525 }
526 
527 static void do_exec_test(void)
528 {
529         printf("[RUN]\tTest exec\n");
530 
531         struct user_desc desc = {
532                 .entry_number    = 0,
533                 .base_addr       = 0,
534                 .limit           = 42,
535                 .seg_32bit       = 1,
536                 .contents        = 2, /* Code, not conforming */
537                 .read_exec_only  = 0,
538                 .limit_in_pages  = 0,
539                 .seg_not_present = 0,
540                 .useable         = 0
541         };
542         install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE | AR_S | AR_P | AR_DB);
543 
544         pid_t child = fork();
545         if (child == 0) {
546                 execl("/proc/self/exe", "ldt_gdt_test_exec", NULL);
547                 printf("[FAIL]\tCould not exec self\n");
548                 exit(1);        /* exec failed */
549         } else {
550                 int status;
551                 if (waitpid(child, &status, 0) != child ||
552                     !WIFEXITED(status)) {
553                         printf("[FAIL]\tChild died\n");
554                         nerrs++;
555                 } else if (WEXITSTATUS(status) != 0) {
556                         printf("[FAIL]\tChild failed\n");
557                         nerrs++;
558                 } else {
559                         printf("[OK]\tChild succeeded\n");
560                 }
561         }
562 }
563 
564 int main(int argc, char **argv)
565 {
566         if (argc == 1 && !strcmp(argv[0], "ldt_gdt_test_exec"))
567                 return finish_exec_test();
568 
569         do_simple_tests();
570 
571         do_multicpu_tests();
572 
573         do_exec_test();
574 
575         return nerrs ? 1 : 0;
576 }
577 

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