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

TOMOYO Linux Cross Reference
Linux/kernel/irq/irqdesc.c

Version: ~ [ linux-5.4 ] ~ [ linux-5.3.13 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.86 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.156 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.203 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.202 ] ~ [ 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.78 ] ~ [ 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  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
  3  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
  4  *
  5  * This file contains the interrupt descriptor management code
  6  *
  7  * Detailed information is available in Documentation/DocBook/genericirq
  8  *
  9  */
 10 #include <linux/irq.h>
 11 #include <linux/slab.h>
 12 #include <linux/export.h>
 13 #include <linux/interrupt.h>
 14 #include <linux/kernel_stat.h>
 15 #include <linux/radix-tree.h>
 16 #include <linux/bitmap.h>
 17 #include <linux/irqdomain.h>
 18 
 19 #include "internals.h"
 20 
 21 /*
 22  * lockdep: we want to handle all irq_desc locks as a single lock-class:
 23  */
 24 static struct lock_class_key irq_desc_lock_class;
 25 
 26 #if defined(CONFIG_SMP)
 27 static void __init init_irq_default_affinity(void)
 28 {
 29         alloc_cpumask_var(&irq_default_affinity, GFP_NOWAIT);
 30         cpumask_setall(irq_default_affinity);
 31 }
 32 #else
 33 static void __init init_irq_default_affinity(void)
 34 {
 35 }
 36 #endif
 37 
 38 #ifdef CONFIG_SMP
 39 static int alloc_masks(struct irq_desc *desc, gfp_t gfp, int node)
 40 {
 41         if (!zalloc_cpumask_var_node(&desc->irq_common_data.affinity,
 42                                      gfp, node))
 43                 return -ENOMEM;
 44 
 45 #ifdef CONFIG_GENERIC_PENDING_IRQ
 46         if (!zalloc_cpumask_var_node(&desc->pending_mask, gfp, node)) {
 47                 free_cpumask_var(desc->irq_common_data.affinity);
 48                 return -ENOMEM;
 49         }
 50 #endif
 51         return 0;
 52 }
 53 
 54 static void desc_smp_init(struct irq_desc *desc, int node)
 55 {
 56         cpumask_copy(desc->irq_common_data.affinity, irq_default_affinity);
 57 #ifdef CONFIG_GENERIC_PENDING_IRQ
 58         cpumask_clear(desc->pending_mask);
 59 #endif
 60 #ifdef CONFIG_NUMA
 61         desc->irq_common_data.node = node;
 62 #endif
 63 }
 64 
 65 #else
 66 static inline int
 67 alloc_masks(struct irq_desc *desc, gfp_t gfp, int node) { return 0; }
 68 static inline void desc_smp_init(struct irq_desc *desc, int node) { }
 69 #endif
 70 
 71 static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node,
 72                 struct module *owner)
 73 {
 74         int cpu;
 75 
 76         desc->irq_common_data.handler_data = NULL;
 77         desc->irq_common_data.msi_desc = NULL;
 78 
 79         desc->irq_data.common = &desc->irq_common_data;
 80         desc->irq_data.irq = irq;
 81         desc->irq_data.chip = &no_irq_chip;
 82         desc->irq_data.chip_data = NULL;
 83         irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
 84         irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
 85         desc->handle_irq = handle_bad_irq;
 86         desc->depth = 1;
 87         desc->irq_count = 0;
 88         desc->irqs_unhandled = 0;
 89         desc->name = NULL;
 90         desc->owner = owner;
 91         for_each_possible_cpu(cpu)
 92                 *per_cpu_ptr(desc->kstat_irqs, cpu) = 0;
 93         desc_smp_init(desc, node);
 94 }
 95 
 96 int nr_irqs = NR_IRQS;
 97 EXPORT_SYMBOL_GPL(nr_irqs);
 98 
 99 static DEFINE_MUTEX(sparse_irq_lock);
100 static DECLARE_BITMAP(allocated_irqs, IRQ_BITMAP_BITS);
101 
102 #ifdef CONFIG_SPARSE_IRQ
103 
104 static RADIX_TREE(irq_desc_tree, GFP_KERNEL);
105 
106 static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)
107 {
108         radix_tree_insert(&irq_desc_tree, irq, desc);
109 }
110 
111 struct irq_desc *irq_to_desc(unsigned int irq)
112 {
113         return radix_tree_lookup(&irq_desc_tree, irq);
114 }
115 EXPORT_SYMBOL(irq_to_desc);
116 
117 static void delete_irq_desc(unsigned int irq)
118 {
119         radix_tree_delete(&irq_desc_tree, irq);
120 }
121 
122 #ifdef CONFIG_SMP
123 static void free_masks(struct irq_desc *desc)
124 {
125 #ifdef CONFIG_GENERIC_PENDING_IRQ
126         free_cpumask_var(desc->pending_mask);
127 #endif
128         free_cpumask_var(desc->irq_common_data.affinity);
129 }
130 #else
131 static inline void free_masks(struct irq_desc *desc) { }
132 #endif
133 
134 void irq_lock_sparse(void)
135 {
136         mutex_lock(&sparse_irq_lock);
137 }
138 
139 void irq_unlock_sparse(void)
140 {
141         mutex_unlock(&sparse_irq_lock);
142 }
143 
144 static struct irq_desc *alloc_desc(int irq, int node, struct module *owner)
145 {
146         struct irq_desc *desc;
147         gfp_t gfp = GFP_KERNEL;
148 
149         desc = kzalloc_node(sizeof(*desc), gfp, node);
150         if (!desc)
151                 return NULL;
152         /* allocate based on nr_cpu_ids */
153         desc->kstat_irqs = alloc_percpu(unsigned int);
154         if (!desc->kstat_irqs)
155                 goto err_desc;
156 
157         if (alloc_masks(desc, gfp, node))
158                 goto err_kstat;
159 
160         raw_spin_lock_init(&desc->lock);
161         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
162 
163         desc_set_defaults(irq, desc, node, owner);
164 
165         return desc;
166 
167 err_kstat:
168         free_percpu(desc->kstat_irqs);
169 err_desc:
170         kfree(desc);
171         return NULL;
172 }
173 
174 static void free_desc(unsigned int irq)
175 {
176         struct irq_desc *desc = irq_to_desc(irq);
177 
178         unregister_irq_proc(irq, desc);
179 
180         /*
181          * sparse_irq_lock protects also show_interrupts() and
182          * kstat_irq_usr(). Once we deleted the descriptor from the
183          * sparse tree we can free it. Access in proc will fail to
184          * lookup the descriptor.
185          */
186         mutex_lock(&sparse_irq_lock);
187         delete_irq_desc(irq);
188         mutex_unlock(&sparse_irq_lock);
189 
190         free_masks(desc);
191         free_percpu(desc->kstat_irqs);
192         kfree(desc);
193 }
194 
195 static int alloc_descs(unsigned int start, unsigned int cnt, int node,
196                        struct module *owner)
197 {
198         struct irq_desc *desc;
199         int i;
200 
201         for (i = 0; i < cnt; i++) {
202                 desc = alloc_desc(start + i, node, owner);
203                 if (!desc)
204                         goto err;
205                 mutex_lock(&sparse_irq_lock);
206                 irq_insert_desc(start + i, desc);
207                 mutex_unlock(&sparse_irq_lock);
208         }
209         return start;
210 
211 err:
212         for (i--; i >= 0; i--)
213                 free_desc(start + i);
214 
215         mutex_lock(&sparse_irq_lock);
216         bitmap_clear(allocated_irqs, start, cnt);
217         mutex_unlock(&sparse_irq_lock);
218         return -ENOMEM;
219 }
220 
221 static int irq_expand_nr_irqs(unsigned int nr)
222 {
223         if (nr > IRQ_BITMAP_BITS)
224                 return -ENOMEM;
225         nr_irqs = nr;
226         return 0;
227 }
228 
229 int __init early_irq_init(void)
230 {
231         int i, initcnt, node = first_online_node;
232         struct irq_desc *desc;
233 
234         init_irq_default_affinity();
235 
236         /* Let arch update nr_irqs and return the nr of preallocated irqs */
237         initcnt = arch_probe_nr_irqs();
238         printk(KERN_INFO "NR_IRQS:%d nr_irqs:%d %d\n", NR_IRQS, nr_irqs, initcnt);
239 
240         if (WARN_ON(nr_irqs > IRQ_BITMAP_BITS))
241                 nr_irqs = IRQ_BITMAP_BITS;
242 
243         if (WARN_ON(initcnt > IRQ_BITMAP_BITS))
244                 initcnt = IRQ_BITMAP_BITS;
245 
246         if (initcnt > nr_irqs)
247                 nr_irqs = initcnt;
248 
249         for (i = 0; i < initcnt; i++) {
250                 desc = alloc_desc(i, node, NULL);
251                 set_bit(i, allocated_irqs);
252                 irq_insert_desc(i, desc);
253         }
254         return arch_early_irq_init();
255 }
256 
257 #else /* !CONFIG_SPARSE_IRQ */
258 
259 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
260         [0 ... NR_IRQS-1] = {
261                 .handle_irq     = handle_bad_irq,
262                 .depth          = 1,
263                 .lock           = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
264         }
265 };
266 
267 int __init early_irq_init(void)
268 {
269         int count, i, node = first_online_node;
270         struct irq_desc *desc;
271 
272         init_irq_default_affinity();
273 
274         printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);
275 
276         desc = irq_desc;
277         count = ARRAY_SIZE(irq_desc);
278 
279         for (i = 0; i < count; i++) {
280                 desc[i].kstat_irqs = alloc_percpu(unsigned int);
281                 alloc_masks(&desc[i], GFP_KERNEL, node);
282                 raw_spin_lock_init(&desc[i].lock);
283                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
284                 desc_set_defaults(i, &desc[i], node, NULL);
285         }
286         return arch_early_irq_init();
287 }
288 
289 struct irq_desc *irq_to_desc(unsigned int irq)
290 {
291         return (irq < NR_IRQS) ? irq_desc + irq : NULL;
292 }
293 EXPORT_SYMBOL(irq_to_desc);
294 
295 static void free_desc(unsigned int irq)
296 {
297         struct irq_desc *desc = irq_to_desc(irq);
298         unsigned long flags;
299 
300         raw_spin_lock_irqsave(&desc->lock, flags);
301         desc_set_defaults(irq, desc, irq_desc_get_node(desc), NULL);
302         raw_spin_unlock_irqrestore(&desc->lock, flags);
303 }
304 
305 static inline int alloc_descs(unsigned int start, unsigned int cnt, int node,
306                               struct module *owner)
307 {
308         u32 i;
309 
310         for (i = 0; i < cnt; i++) {
311                 struct irq_desc *desc = irq_to_desc(start + i);
312 
313                 desc->owner = owner;
314         }
315         return start;
316 }
317 
318 static int irq_expand_nr_irqs(unsigned int nr)
319 {
320         return -ENOMEM;
321 }
322 
323 void irq_mark_irq(unsigned int irq)
324 {
325         mutex_lock(&sparse_irq_lock);
326         bitmap_set(allocated_irqs, irq, 1);
327         mutex_unlock(&sparse_irq_lock);
328 }
329 
330 #ifdef CONFIG_GENERIC_IRQ_LEGACY
331 void irq_init_desc(unsigned int irq)
332 {
333         free_desc(irq);
334 }
335 #endif
336 
337 #endif /* !CONFIG_SPARSE_IRQ */
338 
339 /**
340  * generic_handle_irq - Invoke the handler for a particular irq
341  * @irq:        The irq number to handle
342  *
343  */
344 int generic_handle_irq(unsigned int irq)
345 {
346         struct irq_desc *desc = irq_to_desc(irq);
347 
348         if (!desc)
349                 return -EINVAL;
350         generic_handle_irq_desc(desc);
351         return 0;
352 }
353 EXPORT_SYMBOL_GPL(generic_handle_irq);
354 
355 #ifdef CONFIG_HANDLE_DOMAIN_IRQ
356 /**
357  * __handle_domain_irq - Invoke the handler for a HW irq belonging to a domain
358  * @domain:     The domain where to perform the lookup
359  * @hwirq:      The HW irq number to convert to a logical one
360  * @lookup:     Whether to perform the domain lookup or not
361  * @regs:       Register file coming from the low-level handling code
362  *
363  * Returns:     0 on success, or -EINVAL if conversion has failed
364  */
365 int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
366                         bool lookup, struct pt_regs *regs)
367 {
368         struct pt_regs *old_regs = set_irq_regs(regs);
369         unsigned int irq = hwirq;
370         int ret = 0;
371 
372         irq_enter();
373 
374 #ifdef CONFIG_IRQ_DOMAIN
375         if (lookup)
376                 irq = irq_find_mapping(domain, hwirq);
377 #endif
378 
379         /*
380          * Some hardware gives randomly wrong interrupts.  Rather
381          * than crashing, do something sensible.
382          */
383         if (unlikely(!irq || irq >= nr_irqs)) {
384                 ack_bad_irq(irq);
385                 ret = -EINVAL;
386         } else {
387                 generic_handle_irq(irq);
388         }
389 
390         irq_exit();
391         set_irq_regs(old_regs);
392         return ret;
393 }
394 #endif
395 
396 /* Dynamic interrupt handling */
397 
398 /**
399  * irq_free_descs - free irq descriptors
400  * @from:       Start of descriptor range
401  * @cnt:        Number of consecutive irqs to free
402  */
403 void irq_free_descs(unsigned int from, unsigned int cnt)
404 {
405         int i;
406 
407         if (from >= nr_irqs || (from + cnt) > nr_irqs)
408                 return;
409 
410         for (i = 0; i < cnt; i++)
411                 free_desc(from + i);
412 
413         mutex_lock(&sparse_irq_lock);
414         bitmap_clear(allocated_irqs, from, cnt);
415         mutex_unlock(&sparse_irq_lock);
416 }
417 EXPORT_SYMBOL_GPL(irq_free_descs);
418 
419 /**
420  * irq_alloc_descs - allocate and initialize a range of irq descriptors
421  * @irq:        Allocate for specific irq number if irq >= 0
422  * @from:       Start the search from this irq number
423  * @cnt:        Number of consecutive irqs to allocate.
424  * @node:       Preferred node on which the irq descriptor should be allocated
425  * @owner:      Owning module (can be NULL)
426  *
427  * Returns the first irq number or error code
428  */
429 int __ref
430 __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
431                   struct module *owner)
432 {
433         int start, ret;
434 
435         if (!cnt)
436                 return -EINVAL;
437 
438         if (irq >= 0) {
439                 if (from > irq)
440                         return -EINVAL;
441                 from = irq;
442         } else {
443                 /*
444                  * For interrupts which are freely allocated the
445                  * architecture can force a lower bound to the @from
446                  * argument. x86 uses this to exclude the GSI space.
447                  */
448                 from = arch_dynirq_lower_bound(from);
449         }
450 
451         mutex_lock(&sparse_irq_lock);
452 
453         start = bitmap_find_next_zero_area(allocated_irqs, IRQ_BITMAP_BITS,
454                                            from, cnt, 0);
455         ret = -EEXIST;
456         if (irq >=0 && start != irq)
457                 goto err;
458 
459         if (start + cnt > nr_irqs) {
460                 ret = irq_expand_nr_irqs(start + cnt);
461                 if (ret)
462                         goto err;
463         }
464 
465         bitmap_set(allocated_irqs, start, cnt);
466         mutex_unlock(&sparse_irq_lock);
467         return alloc_descs(start, cnt, node, owner);
468 
469 err:
470         mutex_unlock(&sparse_irq_lock);
471         return ret;
472 }
473 EXPORT_SYMBOL_GPL(__irq_alloc_descs);
474 
475 #ifdef CONFIG_GENERIC_IRQ_LEGACY_ALLOC_HWIRQ
476 /**
477  * irq_alloc_hwirqs - Allocate an irq descriptor and initialize the hardware
478  * @cnt:        number of interrupts to allocate
479  * @node:       node on which to allocate
480  *
481  * Returns an interrupt number > 0 or 0, if the allocation fails.
482  */
483 unsigned int irq_alloc_hwirqs(int cnt, int node)
484 {
485         int i, irq = __irq_alloc_descs(-1, 0, cnt, node, NULL);
486 
487         if (irq < 0)
488                 return 0;
489 
490         for (i = irq; cnt > 0; i++, cnt--) {
491                 if (arch_setup_hwirq(i, node))
492                         goto err;
493                 irq_clear_status_flags(i, _IRQ_NOREQUEST);
494         }
495         return irq;
496 
497 err:
498         for (i--; i >= irq; i--) {
499                 irq_set_status_flags(i, _IRQ_NOREQUEST | _IRQ_NOPROBE);
500                 arch_teardown_hwirq(i);
501         }
502         irq_free_descs(irq, cnt);
503         return 0;
504 }
505 EXPORT_SYMBOL_GPL(irq_alloc_hwirqs);
506 
507 /**
508  * irq_free_hwirqs - Free irq descriptor and cleanup the hardware
509  * @from:       Free from irq number
510  * @cnt:        number of interrupts to free
511  *
512  */
513 void irq_free_hwirqs(unsigned int from, int cnt)
514 {
515         int i, j;
516 
517         for (i = from, j = cnt; j > 0; i++, j--) {
518                 irq_set_status_flags(i, _IRQ_NOREQUEST | _IRQ_NOPROBE);
519                 arch_teardown_hwirq(i);
520         }
521         irq_free_descs(from, cnt);
522 }
523 EXPORT_SYMBOL_GPL(irq_free_hwirqs);
524 #endif
525 
526 /**
527  * irq_get_next_irq - get next allocated irq number
528  * @offset:     where to start the search
529  *
530  * Returns next irq number after offset or nr_irqs if none is found.
531  */
532 unsigned int irq_get_next_irq(unsigned int offset)
533 {
534         return find_next_bit(allocated_irqs, nr_irqs, offset);
535 }
536 
537 struct irq_desc *
538 __irq_get_desc_lock(unsigned int irq, unsigned long *flags, bool bus,
539                     unsigned int check)
540 {
541         struct irq_desc *desc = irq_to_desc(irq);
542 
543         if (desc) {
544                 if (check & _IRQ_DESC_CHECK) {
545                         if ((check & _IRQ_DESC_PERCPU) &&
546                             !irq_settings_is_per_cpu_devid(desc))
547                                 return NULL;
548 
549                         if (!(check & _IRQ_DESC_PERCPU) &&
550                             irq_settings_is_per_cpu_devid(desc))
551                                 return NULL;
552                 }
553 
554                 if (bus)
555                         chip_bus_lock(desc);
556                 raw_spin_lock_irqsave(&desc->lock, *flags);
557         }
558         return desc;
559 }
560 
561 void __irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags, bool bus)
562 {
563         raw_spin_unlock_irqrestore(&desc->lock, flags);
564         if (bus)
565                 chip_bus_sync_unlock(desc);
566 }
567 
568 int irq_set_percpu_devid(unsigned int irq)
569 {
570         struct irq_desc *desc = irq_to_desc(irq);
571 
572         if (!desc)
573                 return -EINVAL;
574 
575         if (desc->percpu_enabled)
576                 return -EINVAL;
577 
578         desc->percpu_enabled = kzalloc(sizeof(*desc->percpu_enabled), GFP_KERNEL);
579 
580         if (!desc->percpu_enabled)
581                 return -ENOMEM;
582 
583         irq_set_percpu_devid_flags(irq);
584         return 0;
585 }
586 
587 void kstat_incr_irq_this_cpu(unsigned int irq)
588 {
589         kstat_incr_irqs_this_cpu(irq_to_desc(irq));
590 }
591 
592 /**
593  * kstat_irqs_cpu - Get the statistics for an interrupt on a cpu
594  * @irq:        The interrupt number
595  * @cpu:        The cpu number
596  *
597  * Returns the sum of interrupt counts on @cpu since boot for
598  * @irq. The caller must ensure that the interrupt is not removed
599  * concurrently.
600  */
601 unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
602 {
603         struct irq_desc *desc = irq_to_desc(irq);
604 
605         return desc && desc->kstat_irqs ?
606                         *per_cpu_ptr(desc->kstat_irqs, cpu) : 0;
607 }
608 
609 /**
610  * kstat_irqs - Get the statistics for an interrupt
611  * @irq:        The interrupt number
612  *
613  * Returns the sum of interrupt counts on all cpus since boot for
614  * @irq. The caller must ensure that the interrupt is not removed
615  * concurrently.
616  */
617 unsigned int kstat_irqs(unsigned int irq)
618 {
619         struct irq_desc *desc = irq_to_desc(irq);
620         int cpu;
621         unsigned int sum = 0;
622 
623         if (!desc || !desc->kstat_irqs)
624                 return 0;
625         for_each_possible_cpu(cpu)
626                 sum += *per_cpu_ptr(desc->kstat_irqs, cpu);
627         return sum;
628 }
629 
630 /**
631  * kstat_irqs_usr - Get the statistics for an interrupt
632  * @irq:        The interrupt number
633  *
634  * Returns the sum of interrupt counts on all cpus since boot for
635  * @irq. Contrary to kstat_irqs() this can be called from any
636  * preemptible context. It's protected against concurrent removal of
637  * an interrupt descriptor when sparse irqs are enabled.
638  */
639 unsigned int kstat_irqs_usr(unsigned int irq)
640 {
641         unsigned int sum;
642 
643         irq_lock_sparse();
644         sum = kstat_irqs(irq);
645         irq_unlock_sparse();
646         return sum;
647 }
648 

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