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

TOMOYO Linux Cross Reference
Linux/net/tipc/server.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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  * net/tipc/server.c: TIPC server infrastructure
  3  *
  4  * Copyright (c) 2012-2013, Wind River Systems
  5  * All rights reserved.
  6  *
  7  * Redistribution and use in source and binary forms, with or without
  8  * modification, are permitted provided that the following conditions are met:
  9  *
 10  * 1. Redistributions of source code must retain the above copyright
 11  *    notice, this list of conditions and the following disclaimer.
 12  * 2. Redistributions in binary form must reproduce the above copyright
 13  *    notice, this list of conditions and the following disclaimer in the
 14  *    documentation and/or other materials provided with the distribution.
 15  * 3. Neither the names of the copyright holders nor the names of its
 16  *    contributors may be used to endorse or promote products derived from
 17  *    this software without specific prior written permission.
 18  *
 19  * Alternatively, this software may be distributed under the terms of the
 20  * GNU General Public License ("GPL") version 2 as published by the Free
 21  * Software Foundation.
 22  *
 23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 33  * POSSIBILITY OF SUCH DAMAGE.
 34  */
 35 
 36 #include "server.h"
 37 #include "core.h"
 38 #include "socket.h"
 39 #include <net/sock.h>
 40 #include <linux/module.h>
 41 
 42 /* Number of messages to send before rescheduling */
 43 #define MAX_SEND_MSG_COUNT      25
 44 #define MAX_RECV_MSG_COUNT      25
 45 #define CF_CONNECTED            1
 46 #define CF_SERVER               2
 47 
 48 #define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)
 49 
 50 /**
 51  * struct tipc_conn - TIPC connection structure
 52  * @kref: reference counter to connection object
 53  * @conid: connection identifier
 54  * @sock: socket handler associated with connection
 55  * @flags: indicates connection state
 56  * @server: pointer to connected server
 57  * @rwork: receive work item
 58  * @usr_data: user-specified field
 59  * @rx_action: what to do when connection socket is active
 60  * @outqueue: pointer to first outbound message in queue
 61  * @outqueue_lock: control access to the outqueue
 62  * @outqueue: list of connection objects for its server
 63  * @swork: send work item
 64  */
 65 struct tipc_conn {
 66         struct kref kref;
 67         int conid;
 68         struct socket *sock;
 69         unsigned long flags;
 70         struct tipc_server *server;
 71         struct work_struct rwork;
 72         int (*rx_action) (struct tipc_conn *con);
 73         void *usr_data;
 74         struct list_head outqueue;
 75         spinlock_t outqueue_lock;
 76         struct work_struct swork;
 77 };
 78 
 79 /* An entry waiting to be sent */
 80 struct outqueue_entry {
 81         struct list_head list;
 82         struct kvec iov;
 83         struct sockaddr_tipc dest;
 84 };
 85 
 86 static void tipc_recv_work(struct work_struct *work);
 87 static void tipc_send_work(struct work_struct *work);
 88 static void tipc_clean_outqueues(struct tipc_conn *con);
 89 static void tipc_sock_release(struct tipc_conn *con);
 90 
 91 static void tipc_conn_kref_release(struct kref *kref)
 92 {
 93         struct tipc_conn *con = container_of(kref, struct tipc_conn, kref);
 94         struct sockaddr_tipc *saddr = con->server->saddr;
 95         struct socket *sock = con->sock;
 96         struct sock *sk;
 97 
 98         if (sock) {
 99                 sk = sock->sk;
100                 if (test_bit(CF_SERVER, &con->flags)) {
101                         __module_get(sock->ops->owner);
102                         __module_get(sk->sk_prot_creator->owner);
103                 }
104                 saddr->scope = -TIPC_NODE_SCOPE;
105                 kernel_bind(sock, (struct sockaddr *)saddr, sizeof(*saddr));
106                 tipc_sock_release(con);
107                 sock_release(sock);
108                 con->sock = NULL;
109         }
110 
111         tipc_clean_outqueues(con);
112         kfree(con);
113 }
114 
115 static void conn_put(struct tipc_conn *con)
116 {
117         kref_put(&con->kref, tipc_conn_kref_release);
118 }
119 
120 static void conn_get(struct tipc_conn *con)
121 {
122         kref_get(&con->kref);
123 }
124 
125 static struct tipc_conn *tipc_conn_lookup(struct tipc_server *s, int conid)
126 {
127         struct tipc_conn *con;
128 
129         spin_lock_bh(&s->idr_lock);
130         con = idr_find(&s->conn_idr, conid);
131         if (con)
132                 conn_get(con);
133         spin_unlock_bh(&s->idr_lock);
134         return con;
135 }
136 
137 static void sock_data_ready(struct sock *sk)
138 {
139         struct tipc_conn *con;
140 
141         read_lock_bh(&sk->sk_callback_lock);
142         con = sock2con(sk);
143         if (con && test_bit(CF_CONNECTED, &con->flags)) {
144                 conn_get(con);
145                 if (!queue_work(con->server->rcv_wq, &con->rwork))
146                         conn_put(con);
147         }
148         read_unlock_bh(&sk->sk_callback_lock);
149 }
150 
151 static void sock_write_space(struct sock *sk)
152 {
153         struct tipc_conn *con;
154 
155         read_lock_bh(&sk->sk_callback_lock);
156         con = sock2con(sk);
157         if (con && test_bit(CF_CONNECTED, &con->flags)) {
158                 conn_get(con);
159                 if (!queue_work(con->server->send_wq, &con->swork))
160                         conn_put(con);
161         }
162         read_unlock_bh(&sk->sk_callback_lock);
163 }
164 
165 static void tipc_register_callbacks(struct socket *sock, struct tipc_conn *con)
166 {
167         struct sock *sk = sock->sk;
168 
169         write_lock_bh(&sk->sk_callback_lock);
170 
171         sk->sk_data_ready = sock_data_ready;
172         sk->sk_write_space = sock_write_space;
173         sk->sk_user_data = con;
174 
175         con->sock = sock;
176 
177         write_unlock_bh(&sk->sk_callback_lock);
178 }
179 
180 static void tipc_unregister_callbacks(struct tipc_conn *con)
181 {
182         struct sock *sk = con->sock->sk;
183 
184         write_lock_bh(&sk->sk_callback_lock);
185         sk->sk_user_data = NULL;
186         write_unlock_bh(&sk->sk_callback_lock);
187 }
188 
189 static void tipc_sock_release(struct tipc_conn *con)
190 {
191         struct tipc_server *s = con->server;
192 
193         if (con->conid)
194                 s->tipc_conn_release(con->conid, con->usr_data);
195 
196         tipc_unregister_callbacks(con);
197 }
198 
199 static void tipc_close_conn(struct tipc_conn *con)
200 {
201         struct tipc_server *s = con->server;
202 
203         if (test_and_clear_bit(CF_CONNECTED, &con->flags)) {
204 
205                 spin_lock_bh(&s->idr_lock);
206                 idr_remove(&s->conn_idr, con->conid);
207                 s->idr_in_use--;
208                 spin_unlock_bh(&s->idr_lock);
209 
210                 /* We shouldn't flush pending works as we may be in the
211                  * thread. In fact the races with pending rx/tx work structs
212                  * are harmless for us here as we have already deleted this
213                  * connection from server connection list.
214                  */
215                 kernel_sock_shutdown(con->sock, SHUT_RDWR);
216 
217                 conn_put(con);
218         }
219 }
220 
221 static struct tipc_conn *tipc_alloc_conn(struct tipc_server *s)
222 {
223         struct tipc_conn *con;
224         int ret;
225 
226         con = kzalloc(sizeof(struct tipc_conn), GFP_ATOMIC);
227         if (!con)
228                 return ERR_PTR(-ENOMEM);
229 
230         kref_init(&con->kref);
231         INIT_LIST_HEAD(&con->outqueue);
232         spin_lock_init(&con->outqueue_lock);
233         INIT_WORK(&con->swork, tipc_send_work);
234         INIT_WORK(&con->rwork, tipc_recv_work);
235 
236         spin_lock_bh(&s->idr_lock);
237         ret = idr_alloc(&s->conn_idr, con, 0, 0, GFP_ATOMIC);
238         if (ret < 0) {
239                 kfree(con);
240                 spin_unlock_bh(&s->idr_lock);
241                 return ERR_PTR(-ENOMEM);
242         }
243         con->conid = ret;
244         s->idr_in_use++;
245         spin_unlock_bh(&s->idr_lock);
246 
247         set_bit(CF_CONNECTED, &con->flags);
248         con->server = s;
249 
250         return con;
251 }
252 
253 static int tipc_receive_from_sock(struct tipc_conn *con)
254 {
255         struct msghdr msg = {};
256         struct tipc_server *s = con->server;
257         struct sockaddr_tipc addr;
258         struct kvec iov;
259         void *buf;
260         int ret;
261 
262         buf = kmem_cache_alloc(s->rcvbuf_cache, GFP_ATOMIC);
263         if (!buf) {
264                 ret = -ENOMEM;
265                 goto out_close;
266         }
267 
268         iov.iov_base = buf;
269         iov.iov_len = s->max_rcvbuf_size;
270         msg.msg_name = &addr;
271         ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len,
272                              MSG_DONTWAIT);
273         if (ret <= 0) {
274                 kmem_cache_free(s->rcvbuf_cache, buf);
275                 goto out_close;
276         }
277 
278         s->tipc_conn_recvmsg(sock_net(con->sock->sk), con->conid, &addr,
279                              con->usr_data, buf, ret);
280 
281         kmem_cache_free(s->rcvbuf_cache, buf);
282 
283         return 0;
284 
285 out_close:
286         if (ret != -EWOULDBLOCK)
287                 tipc_close_conn(con);
288         else if (ret == 0)
289                 /* Don't return success if we really got EOF */
290                 ret = -EAGAIN;
291 
292         return ret;
293 }
294 
295 static int tipc_accept_from_sock(struct tipc_conn *con)
296 {
297         struct tipc_server *s = con->server;
298         struct socket *sock = con->sock;
299         struct socket *newsock;
300         struct tipc_conn *newcon;
301         int ret;
302 
303         ret = kernel_accept(sock, &newsock, O_NONBLOCK);
304         if (ret < 0)
305                 return ret;
306 
307         newcon = tipc_alloc_conn(con->server);
308         if (IS_ERR(newcon)) {
309                 ret = PTR_ERR(newcon);
310                 sock_release(newsock);
311                 return ret;
312         }
313 
314         newcon->rx_action = tipc_receive_from_sock;
315         tipc_register_callbacks(newsock, newcon);
316 
317         /* Notify that new connection is incoming */
318         newcon->usr_data = s->tipc_conn_new(newcon->conid);
319         if (!newcon->usr_data) {
320                 sock_release(newsock);
321                 return -ENOMEM;
322         }
323 
324         /* Wake up receive process in case of 'SYN+' message */
325         newsock->sk->sk_data_ready(newsock->sk);
326         return ret;
327 }
328 
329 static struct socket *tipc_create_listen_sock(struct tipc_conn *con)
330 {
331         struct tipc_server *s = con->server;
332         struct socket *sock = NULL;
333         int ret;
334 
335         ret = sock_create_kern(s->net, AF_TIPC, SOCK_SEQPACKET, 0, &sock);
336         if (ret < 0)
337                 return NULL;
338         ret = kernel_setsockopt(sock, SOL_TIPC, TIPC_IMPORTANCE,
339                                 (char *)&s->imp, sizeof(s->imp));
340         if (ret < 0)
341                 goto create_err;
342         ret = kernel_bind(sock, (struct sockaddr *)s->saddr, sizeof(*s->saddr));
343         if (ret < 0)
344                 goto create_err;
345 
346         switch (s->type) {
347         case SOCK_STREAM:
348         case SOCK_SEQPACKET:
349                 con->rx_action = tipc_accept_from_sock;
350 
351                 ret = kernel_listen(sock, 0);
352                 if (ret < 0)
353                         goto create_err;
354                 break;
355         case SOCK_DGRAM:
356         case SOCK_RDM:
357                 con->rx_action = tipc_receive_from_sock;
358                 break;
359         default:
360                 pr_err("Unknown socket type %d\n", s->type);
361                 goto create_err;
362         }
363 
364         /* As server's listening socket owner and creator is the same module,
365          * we have to decrease TIPC module reference count to guarantee that
366          * it remains zero after the server socket is created, otherwise,
367          * executing "rmmod" command is unable to make TIPC module deleted
368          * after TIPC module is inserted successfully.
369          *
370          * However, the reference count is ever increased twice in
371          * sock_create_kern(): one is to increase the reference count of owner
372          * of TIPC socket's proto_ops struct; another is to increment the
373          * reference count of owner of TIPC proto struct. Therefore, we must
374          * decrement the module reference count twice to ensure that it keeps
375          * zero after server's listening socket is created. Of course, we
376          * must bump the module reference count twice as well before the socket
377          * is closed.
378          */
379         module_put(sock->ops->owner);
380         module_put(sock->sk->sk_prot_creator->owner);
381         set_bit(CF_SERVER, &con->flags);
382 
383         return sock;
384 
385 create_err:
386         kernel_sock_shutdown(sock, SHUT_RDWR);
387         sock_release(sock);
388         return NULL;
389 }
390 
391 static int tipc_open_listening_sock(struct tipc_server *s)
392 {
393         struct socket *sock;
394         struct tipc_conn *con;
395 
396         con = tipc_alloc_conn(s);
397         if (IS_ERR(con))
398                 return PTR_ERR(con);
399 
400         sock = tipc_create_listen_sock(con);
401         if (!sock) {
402                 idr_remove(&s->conn_idr, con->conid);
403                 s->idr_in_use--;
404                 kfree(con);
405                 return -EINVAL;
406         }
407 
408         tipc_register_callbacks(sock, con);
409         return 0;
410 }
411 
412 static struct outqueue_entry *tipc_alloc_entry(void *data, int len)
413 {
414         struct outqueue_entry *entry;
415         void *buf;
416 
417         entry = kmalloc(sizeof(struct outqueue_entry), GFP_ATOMIC);
418         if (!entry)
419                 return NULL;
420 
421         buf = kmemdup(data, len, GFP_ATOMIC);
422         if (!buf) {
423                 kfree(entry);
424                 return NULL;
425         }
426 
427         entry->iov.iov_base = buf;
428         entry->iov.iov_len = len;
429 
430         return entry;
431 }
432 
433 static void tipc_free_entry(struct outqueue_entry *e)
434 {
435         kfree(e->iov.iov_base);
436         kfree(e);
437 }
438 
439 static void tipc_clean_outqueues(struct tipc_conn *con)
440 {
441         struct outqueue_entry *e, *safe;
442 
443         spin_lock_bh(&con->outqueue_lock);
444         list_for_each_entry_safe(e, safe, &con->outqueue, list) {
445                 list_del(&e->list);
446                 tipc_free_entry(e);
447         }
448         spin_unlock_bh(&con->outqueue_lock);
449 }
450 
451 int tipc_conn_sendmsg(struct tipc_server *s, int conid,
452                       struct sockaddr_tipc *addr, void *data, size_t len)
453 {
454         struct outqueue_entry *e;
455         struct tipc_conn *con;
456 
457         con = tipc_conn_lookup(s, conid);
458         if (!con)
459                 return -EINVAL;
460 
461         e = tipc_alloc_entry(data, len);
462         if (!e) {
463                 conn_put(con);
464                 return -ENOMEM;
465         }
466 
467         if (addr)
468                 memcpy(&e->dest, addr, sizeof(struct sockaddr_tipc));
469 
470         spin_lock_bh(&con->outqueue_lock);
471         list_add_tail(&e->list, &con->outqueue);
472         spin_unlock_bh(&con->outqueue_lock);
473 
474         if (test_bit(CF_CONNECTED, &con->flags)) {
475                 if (!queue_work(s->send_wq, &con->swork))
476                         conn_put(con);
477         } else {
478                 conn_put(con);
479         }
480         return 0;
481 }
482 
483 void tipc_conn_terminate(struct tipc_server *s, int conid)
484 {
485         struct tipc_conn *con;
486 
487         con = tipc_conn_lookup(s, conid);
488         if (con) {
489                 tipc_close_conn(con);
490                 conn_put(con);
491         }
492 }
493 
494 static void tipc_send_to_sock(struct tipc_conn *con)
495 {
496         int count = 0;
497         struct tipc_server *s = con->server;
498         struct outqueue_entry *e;
499         struct msghdr msg;
500         int ret;
501 
502         spin_lock_bh(&con->outqueue_lock);
503         while (1) {
504                 e = list_entry(con->outqueue.next, struct outqueue_entry,
505                                list);
506                 if ((struct list_head *) e == &con->outqueue)
507                         break;
508                 spin_unlock_bh(&con->outqueue_lock);
509 
510                 memset(&msg, 0, sizeof(msg));
511                 msg.msg_flags = MSG_DONTWAIT;
512 
513                 if (s->type == SOCK_DGRAM || s->type == SOCK_RDM) {
514                         msg.msg_name = &e->dest;
515                         msg.msg_namelen = sizeof(struct sockaddr_tipc);
516                 }
517                 ret = kernel_sendmsg(con->sock, &msg, &e->iov, 1,
518                                      e->iov.iov_len);
519                 if (ret == -EWOULDBLOCK || ret == 0) {
520                         cond_resched();
521                         goto out;
522                 } else if (ret < 0) {
523                         goto send_err;
524                 }
525 
526                 /* Don't starve users filling buffers */
527                 if (++count >= MAX_SEND_MSG_COUNT) {
528                         cond_resched();
529                         count = 0;
530                 }
531 
532                 spin_lock_bh(&con->outqueue_lock);
533                 list_del(&e->list);
534                 tipc_free_entry(e);
535         }
536         spin_unlock_bh(&con->outqueue_lock);
537 out:
538         return;
539 
540 send_err:
541         tipc_close_conn(con);
542 }
543 
544 static void tipc_recv_work(struct work_struct *work)
545 {
546         struct tipc_conn *con = container_of(work, struct tipc_conn, rwork);
547         int count = 0;
548 
549         while (test_bit(CF_CONNECTED, &con->flags)) {
550                 if (con->rx_action(con))
551                         break;
552 
553                 /* Don't flood Rx machine */
554                 if (++count >= MAX_RECV_MSG_COUNT) {
555                         cond_resched();
556                         count = 0;
557                 }
558         }
559         conn_put(con);
560 }
561 
562 static void tipc_send_work(struct work_struct *work)
563 {
564         struct tipc_conn *con = container_of(work, struct tipc_conn, swork);
565 
566         if (test_bit(CF_CONNECTED, &con->flags))
567                 tipc_send_to_sock(con);
568 
569         conn_put(con);
570 }
571 
572 static void tipc_work_stop(struct tipc_server *s)
573 {
574         destroy_workqueue(s->rcv_wq);
575         destroy_workqueue(s->send_wq);
576 }
577 
578 static int tipc_work_start(struct tipc_server *s)
579 {
580         s->rcv_wq = alloc_ordered_workqueue("tipc_rcv", 0);
581         if (!s->rcv_wq) {
582                 pr_err("can't start tipc receive workqueue\n");
583                 return -ENOMEM;
584         }
585 
586         s->send_wq = alloc_ordered_workqueue("tipc_send", 0);
587         if (!s->send_wq) {
588                 pr_err("can't start tipc send workqueue\n");
589                 destroy_workqueue(s->rcv_wq);
590                 return -ENOMEM;
591         }
592 
593         return 0;
594 }
595 
596 int tipc_server_start(struct tipc_server *s)
597 {
598         int ret;
599 
600         spin_lock_init(&s->idr_lock);
601         idr_init(&s->conn_idr);
602         s->idr_in_use = 0;
603 
604         s->rcvbuf_cache = kmem_cache_create(s->name, s->max_rcvbuf_size,
605                                             0, SLAB_HWCACHE_ALIGN, NULL);
606         if (!s->rcvbuf_cache)
607                 return -ENOMEM;
608 
609         ret = tipc_work_start(s);
610         if (ret < 0) {
611                 kmem_cache_destroy(s->rcvbuf_cache);
612                 return ret;
613         }
614         ret = tipc_open_listening_sock(s);
615         if (ret < 0) {
616                 tipc_work_stop(s);
617                 kmem_cache_destroy(s->rcvbuf_cache);
618                 return ret;
619         }
620         return ret;
621 }
622 
623 void tipc_server_stop(struct tipc_server *s)
624 {
625         struct tipc_conn *con;
626         int total = 0;
627         int id;
628 
629         spin_lock_bh(&s->idr_lock);
630         for (id = 0; total < s->idr_in_use; id++) {
631                 con = idr_find(&s->conn_idr, id);
632                 if (con) {
633                         total++;
634                         spin_unlock_bh(&s->idr_lock);
635                         tipc_close_conn(con);
636                         spin_lock_bh(&s->idr_lock);
637                 }
638         }
639         spin_unlock_bh(&s->idr_lock);
640 
641         tipc_work_stop(s);
642         kmem_cache_destroy(s->rcvbuf_cache);
643         idr_destroy(&s->conn_idr);
644 }
645 

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