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

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

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

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