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

TOMOYO Linux Cross Reference
Linux/net/sched/cls_api.c

Version: ~ [ linux-5.12-rc6 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ 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 /*
  2  * net/sched/cls_api.c  Packet classifier API.
  3  *
  4  *              This program is free software; you can redistribute it and/or
  5  *              modify it under the terms of the GNU General Public License
  6  *              as published by the Free Software Foundation; either version
  7  *              2 of the License, or (at your option) any later version.
  8  *
  9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 10  *
 11  * Changes:
 12  *
 13  * Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support
 14  *
 15  */
 16 
 17 #include <linux/module.h>
 18 #include <linux/types.h>
 19 #include <linux/kernel.h>
 20 #include <linux/string.h>
 21 #include <linux/errno.h>
 22 #include <linux/skbuff.h>
 23 #include <linux/init.h>
 24 #include <linux/kmod.h>
 25 #include <linux/err.h>
 26 #include <linux/slab.h>
 27 #include <net/net_namespace.h>
 28 #include <net/sock.h>
 29 #include <net/netlink.h>
 30 #include <net/pkt_sched.h>
 31 #include <net/pkt_cls.h>
 32 
 33 /* The list of all installed classifier types */
 34 static LIST_HEAD(tcf_proto_base);
 35 
 36 /* Protects list of registered TC modules. It is pure SMP lock. */
 37 static DEFINE_RWLOCK(cls_mod_lock);
 38 
 39 /* Find classifier type by string name */
 40 
 41 static const struct tcf_proto_ops *tcf_proto_lookup_ops(struct nlattr *kind)
 42 {
 43         const struct tcf_proto_ops *t, *res = NULL;
 44 
 45         if (kind) {
 46                 read_lock(&cls_mod_lock);
 47                 list_for_each_entry(t, &tcf_proto_base, head) {
 48                         if (nla_strcmp(kind, t->kind) == 0) {
 49                                 if (try_module_get(t->owner))
 50                                         res = t;
 51                                 break;
 52                         }
 53                 }
 54                 read_unlock(&cls_mod_lock);
 55         }
 56         return res;
 57 }
 58 
 59 /* Register(unregister) new classifier type */
 60 
 61 int register_tcf_proto_ops(struct tcf_proto_ops *ops)
 62 {
 63         struct tcf_proto_ops *t;
 64         int rc = -EEXIST;
 65 
 66         write_lock(&cls_mod_lock);
 67         list_for_each_entry(t, &tcf_proto_base, head)
 68                 if (!strcmp(ops->kind, t->kind))
 69                         goto out;
 70 
 71         list_add_tail(&ops->head, &tcf_proto_base);
 72         rc = 0;
 73 out:
 74         write_unlock(&cls_mod_lock);
 75         return rc;
 76 }
 77 EXPORT_SYMBOL(register_tcf_proto_ops);
 78 
 79 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops)
 80 {
 81         struct tcf_proto_ops *t;
 82         int rc = -ENOENT;
 83 
 84         write_lock(&cls_mod_lock);
 85         list_for_each_entry(t, &tcf_proto_base, head) {
 86                 if (t == ops) {
 87                         list_del(&t->head);
 88                         rc = 0;
 89                         break;
 90                 }
 91         }
 92         write_unlock(&cls_mod_lock);
 93         return rc;
 94 }
 95 EXPORT_SYMBOL(unregister_tcf_proto_ops);
 96 
 97 static int tfilter_notify(struct net *net, struct sk_buff *oskb,
 98                           struct nlmsghdr *n, struct tcf_proto *tp,
 99                           unsigned long fh, int event);
100 
101 
102 /* Select new prio value from the range, managed by kernel. */
103 
104 static inline u32 tcf_auto_prio(struct tcf_proto *tp)
105 {
106         u32 first = TC_H_MAKE(0xC0000000U, 0U);
107 
108         if (tp)
109                 first = tp->prio - 1;
110 
111         return first;
112 }
113 
114 /* Add/change/delete/get a filter node */
115 
116 static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n)
117 {
118         struct net *net = sock_net(skb->sk);
119         struct nlattr *tca[TCA_MAX + 1];
120         spinlock_t *root_lock;
121         struct tcmsg *t;
122         u32 protocol;
123         u32 prio;
124         u32 nprio;
125         u32 parent;
126         struct net_device *dev;
127         struct Qdisc  *q;
128         struct tcf_proto **back, **chain;
129         struct tcf_proto *tp;
130         const struct tcf_proto_ops *tp_ops;
131         const struct Qdisc_class_ops *cops;
132         unsigned long cl;
133         unsigned long fh;
134         int err;
135         int tp_created = 0;
136 
137         if ((n->nlmsg_type != RTM_GETTFILTER) && !netlink_capable(skb, CAP_NET_ADMIN))
138                 return -EPERM;
139 
140 replay:
141         err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL);
142         if (err < 0)
143                 return err;
144 
145         t = nlmsg_data(n);
146         protocol = TC_H_MIN(t->tcm_info);
147         prio = TC_H_MAJ(t->tcm_info);
148         nprio = prio;
149         parent = t->tcm_parent;
150         cl = 0;
151 
152         if (prio == 0) {
153                 /* If no priority is given, user wants we allocated it. */
154                 if (n->nlmsg_type != RTM_NEWTFILTER ||
155                     !(n->nlmsg_flags & NLM_F_CREATE))
156                         return -ENOENT;
157                 prio = TC_H_MAKE(0x80000000U, 0U);
158         }
159 
160         /* Find head of filter chain. */
161 
162         /* Find link */
163         dev = __dev_get_by_index(net, t->tcm_ifindex);
164         if (dev == NULL)
165                 return -ENODEV;
166 
167         /* Find qdisc */
168         if (!parent) {
169                 q = dev->qdisc;
170                 parent = q->handle;
171         } else {
172                 q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent));
173                 if (q == NULL)
174                         return -EINVAL;
175         }
176 
177         /* Is it classful? */
178         cops = q->ops->cl_ops;
179         if (!cops)
180                 return -EINVAL;
181 
182         if (cops->tcf_chain == NULL)
183                 return -EOPNOTSUPP;
184 
185         /* Do we search for filter, attached to class? */
186         if (TC_H_MIN(parent)) {
187                 cl = cops->get(q, parent);
188                 if (cl == 0)
189                         return -ENOENT;
190         }
191 
192         /* And the last stroke */
193         chain = cops->tcf_chain(q, cl);
194         err = -EINVAL;
195         if (chain == NULL)
196                 goto errout;
197 
198         /* Check the chain for existence of proto-tcf with this priority */
199         for (back = chain; (tp = *back) != NULL; back = &tp->next) {
200                 if (tp->prio >= prio) {
201                         if (tp->prio == prio) {
202                                 if (!nprio ||
203                                     (tp->protocol != protocol && protocol))
204                                         goto errout;
205                         } else
206                                 tp = NULL;
207                         break;
208                 }
209         }
210 
211         root_lock = qdisc_root_sleeping_lock(q);
212 
213         if (tp == NULL) {
214                 /* Proto-tcf does not exist, create new one */
215 
216                 if (tca[TCA_KIND] == NULL || !protocol)
217                         goto errout;
218 
219                 err = -ENOENT;
220                 if (n->nlmsg_type != RTM_NEWTFILTER ||
221                     !(n->nlmsg_flags & NLM_F_CREATE))
222                         goto errout;
223 
224 
225                 /* Create new proto tcf */
226 
227                 err = -ENOBUFS;
228                 tp = kzalloc(sizeof(*tp), GFP_KERNEL);
229                 if (tp == NULL)
230                         goto errout;
231                 err = -ENOENT;
232                 tp_ops = tcf_proto_lookup_ops(tca[TCA_KIND]);
233                 if (tp_ops == NULL) {
234 #ifdef CONFIG_MODULES
235                         struct nlattr *kind = tca[TCA_KIND];
236                         char name[IFNAMSIZ];
237 
238                         if (kind != NULL &&
239                             nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
240                                 rtnl_unlock();
241                                 request_module("cls_%s", name);
242                                 rtnl_lock();
243                                 tp_ops = tcf_proto_lookup_ops(kind);
244                                 /* We dropped the RTNL semaphore in order to
245                                  * perform the module load.  So, even if we
246                                  * succeeded in loading the module we have to
247                                  * replay the request.  We indicate this using
248                                  * -EAGAIN.
249                                  */
250                                 if (tp_ops != NULL) {
251                                         module_put(tp_ops->owner);
252                                         err = -EAGAIN;
253                                 }
254                         }
255 #endif
256                         kfree(tp);
257                         goto errout;
258                 }
259                 tp->ops = tp_ops;
260                 tp->protocol = protocol;
261                 tp->prio = nprio ? : TC_H_MAJ(tcf_auto_prio(*back));
262                 tp->q = q;
263                 tp->classify = tp_ops->classify;
264                 tp->classid = parent;
265 
266                 err = tp_ops->init(tp);
267                 if (err != 0) {
268                         module_put(tp_ops->owner);
269                         kfree(tp);
270                         goto errout;
271                 }
272 
273                 tp_created = 1;
274 
275         } else if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], tp->ops->kind))
276                 goto errout;
277 
278         fh = tp->ops->get(tp, t->tcm_handle);
279 
280         if (fh == 0) {
281                 if (n->nlmsg_type == RTM_DELTFILTER && t->tcm_handle == 0) {
282                         spin_lock_bh(root_lock);
283                         *back = tp->next;
284                         spin_unlock_bh(root_lock);
285 
286                         tfilter_notify(net, skb, n, tp, fh, RTM_DELTFILTER);
287                         tcf_destroy(tp);
288                         err = 0;
289                         goto errout;
290                 }
291 
292                 err = -ENOENT;
293                 if (n->nlmsg_type != RTM_NEWTFILTER ||
294                     !(n->nlmsg_flags & NLM_F_CREATE))
295                         goto errout;
296         } else {
297                 switch (n->nlmsg_type) {
298                 case RTM_NEWTFILTER:
299                         err = -EEXIST;
300                         if (n->nlmsg_flags & NLM_F_EXCL) {
301                                 if (tp_created)
302                                         tcf_destroy(tp);
303                                 goto errout;
304                         }
305                         break;
306                 case RTM_DELTFILTER:
307                         err = tp->ops->delete(tp, fh);
308                         if (err == 0)
309                                 tfilter_notify(net, skb, n, tp, fh, RTM_DELTFILTER);
310                         goto errout;
311                 case RTM_GETTFILTER:
312                         err = tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER);
313                         goto errout;
314                 default:
315                         err = -EINVAL;
316                         goto errout;
317                 }
318         }
319 
320         err = tp->ops->change(net, skb, tp, cl, t->tcm_handle, tca, &fh);
321         if (err == 0) {
322                 if (tp_created) {
323                         spin_lock_bh(root_lock);
324                         tp->next = *back;
325                         *back = tp;
326                         spin_unlock_bh(root_lock);
327                 }
328                 tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER);
329         } else {
330                 if (tp_created)
331                         tcf_destroy(tp);
332         }
333 
334 errout:
335         if (cl)
336                 cops->put(q, cl);
337         if (err == -EAGAIN)
338                 /* Replay the request. */
339                 goto replay;
340         return err;
341 }
342 
343 static int tcf_fill_node(struct net *net, struct sk_buff *skb, struct tcf_proto *tp,
344                          unsigned long fh, u32 portid, u32 seq, u16 flags, int event)
345 {
346         struct tcmsg *tcm;
347         struct nlmsghdr  *nlh;
348         unsigned char *b = skb_tail_pointer(skb);
349 
350         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
351         if (!nlh)
352                 goto out_nlmsg_trim;
353         tcm = nlmsg_data(nlh);
354         tcm->tcm_family = AF_UNSPEC;
355         tcm->tcm__pad1 = 0;
356         tcm->tcm__pad2 = 0;
357         tcm->tcm_ifindex = qdisc_dev(tp->q)->ifindex;
358         tcm->tcm_parent = tp->classid;
359         tcm->tcm_info = TC_H_MAKE(tp->prio, tp->protocol);
360         if (nla_put_string(skb, TCA_KIND, tp->ops->kind))
361                 goto nla_put_failure;
362         tcm->tcm_handle = fh;
363         if (RTM_DELTFILTER != event) {
364                 tcm->tcm_handle = 0;
365                 if (tp->ops->dump && tp->ops->dump(net, tp, fh, skb, tcm) < 0)
366                         goto nla_put_failure;
367         }
368         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
369         return skb->len;
370 
371 out_nlmsg_trim:
372 nla_put_failure:
373         nlmsg_trim(skb, b);
374         return -1;
375 }
376 
377 static int tfilter_notify(struct net *net, struct sk_buff *oskb,
378                           struct nlmsghdr *n, struct tcf_proto *tp,
379                           unsigned long fh, int event)
380 {
381         struct sk_buff *skb;
382         u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
383 
384         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
385         if (!skb)
386                 return -ENOBUFS;
387 
388         if (tcf_fill_node(net, skb, tp, fh, portid, n->nlmsg_seq, 0, event) <= 0) {
389                 kfree_skb(skb);
390                 return -EINVAL;
391         }
392 
393         return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
394                               n->nlmsg_flags & NLM_F_ECHO);
395 }
396 
397 struct tcf_dump_args {
398         struct tcf_walker w;
399         struct sk_buff *skb;
400         struct netlink_callback *cb;
401 };
402 
403 static int tcf_node_dump(struct tcf_proto *tp, unsigned long n,
404                          struct tcf_walker *arg)
405 {
406         struct tcf_dump_args *a = (void *)arg;
407         struct net *net = sock_net(a->skb->sk);
408 
409         return tcf_fill_node(net, a->skb, tp, n, NETLINK_CB(a->cb->skb).portid,
410                              a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTFILTER);
411 }
412 
413 /* called with RTNL */
414 static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
415 {
416         struct net *net = sock_net(skb->sk);
417         int t;
418         int s_t;
419         struct net_device *dev;
420         struct Qdisc *q;
421         struct tcf_proto *tp, **chain;
422         struct tcmsg *tcm = nlmsg_data(cb->nlh);
423         unsigned long cl = 0;
424         const struct Qdisc_class_ops *cops;
425         struct tcf_dump_args arg;
426 
427         if (nlmsg_len(cb->nlh) < sizeof(*tcm))
428                 return skb->len;
429         dev = __dev_get_by_index(net, tcm->tcm_ifindex);
430         if (!dev)
431                 return skb->len;
432 
433         if (!tcm->tcm_parent)
434                 q = dev->qdisc;
435         else
436                 q = qdisc_lookup(dev, TC_H_MAJ(tcm->tcm_parent));
437         if (!q)
438                 goto out;
439         cops = q->ops->cl_ops;
440         if (!cops)
441                 goto errout;
442         if (cops->tcf_chain == NULL)
443                 goto errout;
444         if (TC_H_MIN(tcm->tcm_parent)) {
445                 cl = cops->get(q, tcm->tcm_parent);
446                 if (cl == 0)
447                         goto errout;
448         }
449         chain = cops->tcf_chain(q, cl);
450         if (chain == NULL)
451                 goto errout;
452 
453         s_t = cb->args[0];
454 
455         for (tp = *chain, t = 0; tp; tp = tp->next, t++) {
456                 if (t < s_t)
457                         continue;
458                 if (TC_H_MAJ(tcm->tcm_info) &&
459                     TC_H_MAJ(tcm->tcm_info) != tp->prio)
460                         continue;
461                 if (TC_H_MIN(tcm->tcm_info) &&
462                     TC_H_MIN(tcm->tcm_info) != tp->protocol)
463                         continue;
464                 if (t > s_t)
465                         memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
466                 if (cb->args[1] == 0) {
467                         if (tcf_fill_node(net, skb, tp, 0, NETLINK_CB(cb->skb).portid,
468                                           cb->nlh->nlmsg_seq, NLM_F_MULTI,
469                                           RTM_NEWTFILTER) <= 0)
470                                 break;
471 
472                         cb->args[1] = 1;
473                 }
474                 if (tp->ops->walk == NULL)
475                         continue;
476                 arg.w.fn = tcf_node_dump;
477                 arg.skb = skb;
478                 arg.cb = cb;
479                 arg.w.stop = 0;
480                 arg.w.skip = cb->args[1] - 1;
481                 arg.w.count = 0;
482                 tp->ops->walk(tp, &arg.w);
483                 cb->args[1] = arg.w.count + 1;
484                 if (arg.w.stop)
485                         break;
486         }
487 
488         cb->args[0] = t;
489 
490 errout:
491         if (cl)
492                 cops->put(q, cl);
493 out:
494         return skb->len;
495 }
496 
497 void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts)
498 {
499 #ifdef CONFIG_NET_CLS_ACT
500         tcf_action_destroy(&exts->actions, TCA_ACT_UNBIND);
501         INIT_LIST_HEAD(&exts->actions);
502 #endif
503 }
504 EXPORT_SYMBOL(tcf_exts_destroy);
505 
506 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, struct nlattr **tb,
507                   struct nlattr *rate_tlv, struct tcf_exts *exts)
508 {
509 #ifdef CONFIG_NET_CLS_ACT
510         {
511                 struct tc_action *act;
512 
513                 INIT_LIST_HEAD(&exts->actions);
514                 if (exts->police && tb[exts->police]) {
515                         act = tcf_action_init_1(net, tb[exts->police], rate_tlv,
516                                                 "police", TCA_ACT_NOREPLACE,
517                                                 TCA_ACT_BIND);
518                         if (IS_ERR(act))
519                                 return PTR_ERR(act);
520 
521                         act->type = exts->type = TCA_OLD_COMPAT;
522                         list_add(&act->list, &exts->actions);
523                 } else if (exts->action && tb[exts->action]) {
524                         int err;
525                         err = tcf_action_init(net, tb[exts->action], rate_tlv,
526                                               NULL, TCA_ACT_NOREPLACE,
527                                               TCA_ACT_BIND, &exts->actions);
528                         if (err)
529                                 return err;
530                 }
531         }
532 #else
533         if ((exts->action && tb[exts->action]) ||
534             (exts->police && tb[exts->police]))
535                 return -EOPNOTSUPP;
536 #endif
537 
538         return 0;
539 }
540 EXPORT_SYMBOL(tcf_exts_validate);
541 
542 void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
543                      struct tcf_exts *src)
544 {
545 #ifdef CONFIG_NET_CLS_ACT
546         if (!list_empty(&src->actions)) {
547                 LIST_HEAD(tmp);
548                 tcf_tree_lock(tp);
549                 list_splice_init(&dst->actions, &tmp);
550                 list_splice(&src->actions, &dst->actions);
551                 tcf_tree_unlock(tp);
552                 tcf_action_destroy(&tmp, TCA_ACT_UNBIND);
553         }
554 #endif
555 }
556 EXPORT_SYMBOL(tcf_exts_change);
557 
558 #define tcf_exts_first_act(ext) \
559                 list_first_entry(&(exts)->actions, struct tc_action, list)
560 
561 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts)
562 {
563 #ifdef CONFIG_NET_CLS_ACT
564         if (exts->action && !list_empty(&exts->actions)) {
565                 /*
566                  * again for backward compatible mode - we want
567                  * to work with both old and new modes of entering
568                  * tc data even if iproute2  was newer - jhs
569                  */
570                 struct nlattr *nest;
571                 if (exts->type != TCA_OLD_COMPAT) {
572                         nest = nla_nest_start(skb, exts->action);
573                         if (nest == NULL)
574                                 goto nla_put_failure;
575                         if (tcf_action_dump(skb, &exts->actions, 0, 0) < 0)
576                                 goto nla_put_failure;
577                         nla_nest_end(skb, nest);
578                 } else if (exts->police) {
579                         struct tc_action *act = tcf_exts_first_act(exts);
580                         nest = nla_nest_start(skb, exts->police);
581                         if (nest == NULL || !act)
582                                 goto nla_put_failure;
583                         if (tcf_action_dump_old(skb, act, 0, 0) < 0)
584                                 goto nla_put_failure;
585                         nla_nest_end(skb, nest);
586                 }
587         }
588 #endif
589         return 0;
590 nla_put_failure: __attribute__ ((unused))
591         return -1;
592 }
593 EXPORT_SYMBOL(tcf_exts_dump);
594 
595 
596 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts)
597 {
598 #ifdef CONFIG_NET_CLS_ACT
599         struct tc_action *a = tcf_exts_first_act(exts);
600         if (tcf_action_copy_stats(skb, a, 1) < 0)
601                 return -1;
602 #endif
603         return 0;
604 }
605 EXPORT_SYMBOL(tcf_exts_dump_stats);
606 
607 static int __init tc_filter_init(void)
608 {
609         rtnl_register(PF_UNSPEC, RTM_NEWTFILTER, tc_ctl_tfilter, NULL, NULL);
610         rtnl_register(PF_UNSPEC, RTM_DELTFILTER, tc_ctl_tfilter, NULL, NULL);
611         rtnl_register(PF_UNSPEC, RTM_GETTFILTER, tc_ctl_tfilter,
612                       tc_dump_tfilter, NULL);
613 
614         return 0;
615 }
616 
617 subsys_initcall(tc_filter_init);
618 

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