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

TOMOYO Linux Cross Reference
Linux/net/bluetooth/af_bluetooth.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ 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.85 ] ~ [ 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-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    BlueZ - Bluetooth protocol stack for Linux
  3    Copyright (C) 2000-2001 Qualcomm Incorporated
  4 
  5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
  6 
  7    This program is free software; you can redistribute it and/or modify
  8    it under the terms of the GNU General Public License version 2 as
  9    published by the Free Software Foundation;
 10 
 11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
 14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
 15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
 16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 19 
 20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
 21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
 22    SOFTWARE IS DISCLAIMED.
 23 */
 24 
 25 /* Bluetooth address family and sockets. */
 26 
 27 #include <linux/module.h>
 28 #include <asm/ioctls.h>
 29 
 30 #include <net/bluetooth/bluetooth.h>
 31 #include <linux/proc_fs.h>
 32 
 33 #define VERSION "2.16"
 34 
 35 /* Bluetooth sockets */
 36 #define BT_MAX_PROTO    8
 37 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
 38 static DEFINE_RWLOCK(bt_proto_lock);
 39 
 40 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
 41 static const char *const bt_key_strings[BT_MAX_PROTO] = {
 42         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
 43         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
 44         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
 45         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
 46         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
 47         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
 48         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
 49         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
 50 };
 51 
 52 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
 53 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
 54         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
 55         "slock-AF_BLUETOOTH-BTPROTO_HCI",
 56         "slock-AF_BLUETOOTH-BTPROTO_SCO",
 57         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
 58         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
 59         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
 60         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
 61         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
 62 };
 63 
 64 void bt_sock_reclassify_lock(struct sock *sk, int proto)
 65 {
 66         BUG_ON(!sk);
 67         BUG_ON(sock_owned_by_user(sk));
 68 
 69         sock_lock_init_class_and_name(sk,
 70                         bt_slock_key_strings[proto], &bt_slock_key[proto],
 71                                 bt_key_strings[proto], &bt_lock_key[proto]);
 72 }
 73 EXPORT_SYMBOL(bt_sock_reclassify_lock);
 74 
 75 int bt_sock_register(int proto, const struct net_proto_family *ops)
 76 {
 77         int err = 0;
 78 
 79         if (proto < 0 || proto >= BT_MAX_PROTO)
 80                 return -EINVAL;
 81 
 82         write_lock(&bt_proto_lock);
 83 
 84         if (bt_proto[proto])
 85                 err = -EEXIST;
 86         else
 87                 bt_proto[proto] = ops;
 88 
 89         write_unlock(&bt_proto_lock);
 90 
 91         return err;
 92 }
 93 EXPORT_SYMBOL(bt_sock_register);
 94 
 95 void bt_sock_unregister(int proto)
 96 {
 97         if (proto < 0 || proto >= BT_MAX_PROTO)
 98                 return;
 99 
100         write_lock(&bt_proto_lock);
101         bt_proto[proto] = NULL;
102         write_unlock(&bt_proto_lock);
103 }
104 EXPORT_SYMBOL(bt_sock_unregister);
105 
106 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
107                           int kern)
108 {
109         int err;
110 
111         if (net != &init_net)
112                 return -EAFNOSUPPORT;
113 
114         if (proto < 0 || proto >= BT_MAX_PROTO)
115                 return -EINVAL;
116 
117         if (!bt_proto[proto])
118                 request_module("bt-proto-%d", proto);
119 
120         err = -EPROTONOSUPPORT;
121 
122         read_lock(&bt_proto_lock);
123 
124         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
125                 err = bt_proto[proto]->create(net, sock, proto, kern);
126                 if (!err)
127                         bt_sock_reclassify_lock(sock->sk, proto);
128                 module_put(bt_proto[proto]->owner);
129         }
130 
131         read_unlock(&bt_proto_lock);
132 
133         return err;
134 }
135 
136 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
137 {
138         write_lock(&l->lock);
139         sk_add_node(sk, &l->head);
140         write_unlock(&l->lock);
141 }
142 EXPORT_SYMBOL(bt_sock_link);
143 
144 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
145 {
146         write_lock(&l->lock);
147         sk_del_node_init(sk);
148         write_unlock(&l->lock);
149 }
150 EXPORT_SYMBOL(bt_sock_unlink);
151 
152 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
153 {
154         BT_DBG("parent %p, sk %p", parent, sk);
155 
156         sock_hold(sk);
157         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
158         bt_sk(sk)->parent = parent;
159         parent->sk_ack_backlog++;
160 }
161 EXPORT_SYMBOL(bt_accept_enqueue);
162 
163 void bt_accept_unlink(struct sock *sk)
164 {
165         BT_DBG("sk %p state %d", sk, sk->sk_state);
166 
167         list_del_init(&bt_sk(sk)->accept_q);
168         bt_sk(sk)->parent->sk_ack_backlog--;
169         bt_sk(sk)->parent = NULL;
170         sock_put(sk);
171 }
172 EXPORT_SYMBOL(bt_accept_unlink);
173 
174 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
175 {
176         struct list_head *p, *n;
177         struct sock *sk;
178 
179         BT_DBG("parent %p", parent);
180 
181         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
182                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
183 
184                 lock_sock(sk);
185 
186                 /* FIXME: Is this check still needed */
187                 if (sk->sk_state == BT_CLOSED) {
188                         release_sock(sk);
189                         bt_accept_unlink(sk);
190                         continue;
191                 }
192 
193                 if (sk->sk_state == BT_CONNECTED || !newsock ||
194                     test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
195                         bt_accept_unlink(sk);
196                         if (newsock)
197                                 sock_graft(sk, newsock);
198 
199                         release_sock(sk);
200                         return sk;
201                 }
202 
203                 release_sock(sk);
204         }
205 
206         return NULL;
207 }
208 EXPORT_SYMBOL(bt_accept_dequeue);
209 
210 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
211                                 struct msghdr *msg, size_t len, int flags)
212 {
213         int noblock = flags & MSG_DONTWAIT;
214         struct sock *sk = sock->sk;
215         struct sk_buff *skb;
216         size_t copied;
217         int err;
218 
219         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
220 
221         if (flags & (MSG_OOB))
222                 return -EOPNOTSUPP;
223 
224         msg->msg_namelen = 0;
225 
226         skb = skb_recv_datagram(sk, flags, noblock, &err);
227         if (!skb) {
228                 if (sk->sk_shutdown & RCV_SHUTDOWN)
229                         return 0;
230                 return err;
231         }
232 
233         copied = skb->len;
234         if (len < copied) {
235                 msg->msg_flags |= MSG_TRUNC;
236                 copied = len;
237         }
238 
239         skb_reset_transport_header(skb);
240         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
241         if (err == 0)
242                 sock_recv_ts_and_drops(msg, sk, skb);
243 
244         skb_free_datagram(sk, skb);
245 
246         return err ? : copied;
247 }
248 EXPORT_SYMBOL(bt_sock_recvmsg);
249 
250 static long bt_sock_data_wait(struct sock *sk, long timeo)
251 {
252         DECLARE_WAITQUEUE(wait, current);
253 
254         add_wait_queue(sk_sleep(sk), &wait);
255         for (;;) {
256                 set_current_state(TASK_INTERRUPTIBLE);
257 
258                 if (!skb_queue_empty(&sk->sk_receive_queue))
259                         break;
260 
261                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
262                         break;
263 
264                 if (signal_pending(current) || !timeo)
265                         break;
266 
267                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
268                 release_sock(sk);
269                 timeo = schedule_timeout(timeo);
270                 lock_sock(sk);
271                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
272         }
273 
274         __set_current_state(TASK_RUNNING);
275         remove_wait_queue(sk_sleep(sk), &wait);
276         return timeo;
277 }
278 
279 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
280                                struct msghdr *msg, size_t size, int flags)
281 {
282         struct sock *sk = sock->sk;
283         int err = 0;
284         size_t target, copied = 0;
285         long timeo;
286 
287         if (flags & MSG_OOB)
288                 return -EOPNOTSUPP;
289 
290         msg->msg_namelen = 0;
291 
292         BT_DBG("sk %p size %zu", sk, size);
293 
294         lock_sock(sk);
295 
296         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
297         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
298 
299         do {
300                 struct sk_buff *skb;
301                 int chunk;
302 
303                 skb = skb_dequeue(&sk->sk_receive_queue);
304                 if (!skb) {
305                         if (copied >= target)
306                                 break;
307 
308                         err = sock_error(sk);
309                         if (err)
310                                 break;
311                         if (sk->sk_shutdown & RCV_SHUTDOWN)
312                                 break;
313 
314                         err = -EAGAIN;
315                         if (!timeo)
316                                 break;
317 
318                         timeo = bt_sock_data_wait(sk, timeo);
319 
320                         if (signal_pending(current)) {
321                                 err = sock_intr_errno(timeo);
322                                 goto out;
323                         }
324                         continue;
325                 }
326 
327                 chunk = min_t(unsigned int, skb->len, size);
328                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
329                         skb_queue_head(&sk->sk_receive_queue, skb);
330                         if (!copied)
331                                 copied = -EFAULT;
332                         break;
333                 }
334                 copied += chunk;
335                 size   -= chunk;
336 
337                 sock_recv_ts_and_drops(msg, sk, skb);
338 
339                 if (!(flags & MSG_PEEK)) {
340                         int skb_len = skb_headlen(skb);
341 
342                         if (chunk <= skb_len) {
343                                 __skb_pull(skb, chunk);
344                         } else {
345                                 struct sk_buff *frag;
346 
347                                 __skb_pull(skb, skb_len);
348                                 chunk -= skb_len;
349 
350                                 skb_walk_frags(skb, frag) {
351                                         if (chunk <= frag->len) {
352                                                 /* Pulling partial data */
353                                                 skb->len -= chunk;
354                                                 skb->data_len -= chunk;
355                                                 __skb_pull(frag, chunk);
356                                                 break;
357                                         } else if (frag->len) {
358                                                 /* Pulling all frag data */
359                                                 chunk -= frag->len;
360                                                 skb->len -= frag->len;
361                                                 skb->data_len -= frag->len;
362                                                 __skb_pull(frag, frag->len);
363                                         }
364                                 }
365                         }
366 
367                         if (skb->len) {
368                                 skb_queue_head(&sk->sk_receive_queue, skb);
369                                 break;
370                         }
371                         kfree_skb(skb);
372 
373                 } else {
374                         /* put message back and return */
375                         skb_queue_head(&sk->sk_receive_queue, skb);
376                         break;
377                 }
378         } while (size);
379 
380 out:
381         release_sock(sk);
382         return copied ? : err;
383 }
384 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
385 
386 static inline unsigned int bt_accept_poll(struct sock *parent)
387 {
388         struct list_head *p, *n;
389         struct sock *sk;
390 
391         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
392                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
393                 if (sk->sk_state == BT_CONNECTED ||
394                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
395                      sk->sk_state == BT_CONNECT2))
396                         return POLLIN | POLLRDNORM;
397         }
398 
399         return 0;
400 }
401 
402 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
403                           poll_table *wait)
404 {
405         struct sock *sk = sock->sk;
406         unsigned int mask = 0;
407 
408         BT_DBG("sock %p, sk %p", sock, sk);
409 
410         poll_wait(file, sk_sleep(sk), wait);
411 
412         if (sk->sk_state == BT_LISTEN)
413                 return bt_accept_poll(sk);
414 
415         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
416                 mask |= POLLERR |
417                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
418 
419         if (sk->sk_shutdown & RCV_SHUTDOWN)
420                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
421 
422         if (sk->sk_shutdown == SHUTDOWN_MASK)
423                 mask |= POLLHUP;
424 
425         if (!skb_queue_empty(&sk->sk_receive_queue))
426                 mask |= POLLIN | POLLRDNORM;
427 
428         if (sk->sk_state == BT_CLOSED)
429                 mask |= POLLHUP;
430 
431         if (sk->sk_state == BT_CONNECT ||
432                         sk->sk_state == BT_CONNECT2 ||
433                         sk->sk_state == BT_CONFIG)
434                 return mask;
435 
436         if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
437                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
438         else
439                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
440 
441         return mask;
442 }
443 EXPORT_SYMBOL(bt_sock_poll);
444 
445 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
446 {
447         struct sock *sk = sock->sk;
448         struct sk_buff *skb;
449         long amount;
450         int err;
451 
452         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
453 
454         switch (cmd) {
455         case TIOCOUTQ:
456                 if (sk->sk_state == BT_LISTEN)
457                         return -EINVAL;
458 
459                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
460                 if (amount < 0)
461                         amount = 0;
462                 err = put_user(amount, (int __user *) arg);
463                 break;
464 
465         case TIOCINQ:
466                 if (sk->sk_state == BT_LISTEN)
467                         return -EINVAL;
468 
469                 lock_sock(sk);
470                 skb = skb_peek(&sk->sk_receive_queue);
471                 amount = skb ? skb->len : 0;
472                 release_sock(sk);
473                 err = put_user(amount, (int __user *) arg);
474                 break;
475 
476         case SIOCGSTAMP:
477                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
478                 break;
479 
480         case SIOCGSTAMPNS:
481                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
482                 break;
483 
484         default:
485                 err = -ENOIOCTLCMD;
486                 break;
487         }
488 
489         return err;
490 }
491 EXPORT_SYMBOL(bt_sock_ioctl);
492 
493 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
494 {
495         DECLARE_WAITQUEUE(wait, current);
496         int err = 0;
497 
498         BT_DBG("sk %p", sk);
499 
500         add_wait_queue(sk_sleep(sk), &wait);
501         set_current_state(TASK_INTERRUPTIBLE);
502         while (sk->sk_state != state) {
503                 if (!timeo) {
504                         err = -EINPROGRESS;
505                         break;
506                 }
507 
508                 if (signal_pending(current)) {
509                         err = sock_intr_errno(timeo);
510                         break;
511                 }
512 
513                 release_sock(sk);
514                 timeo = schedule_timeout(timeo);
515                 lock_sock(sk);
516                 set_current_state(TASK_INTERRUPTIBLE);
517 
518                 err = sock_error(sk);
519                 if (err)
520                         break;
521         }
522         __set_current_state(TASK_RUNNING);
523         remove_wait_queue(sk_sleep(sk), &wait);
524         return err;
525 }
526 EXPORT_SYMBOL(bt_sock_wait_state);
527 
528 #ifdef CONFIG_PROC_FS
529 struct bt_seq_state {
530         struct bt_sock_list *l;
531 };
532 
533 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
534         __acquires(seq->private->l->lock)
535 {
536         struct bt_seq_state *s = seq->private;
537         struct bt_sock_list *l = s->l;
538 
539         read_lock(&l->lock);
540         return seq_hlist_start_head(&l->head, *pos);
541 }
542 
543 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
544 {
545         struct bt_seq_state *s = seq->private;
546         struct bt_sock_list *l = s->l;
547 
548         return seq_hlist_next(v, &l->head, pos);
549 }
550 
551 static void bt_seq_stop(struct seq_file *seq, void *v)
552         __releases(seq->private->l->lock)
553 {
554         struct bt_seq_state *s = seq->private;
555         struct bt_sock_list *l = s->l;
556 
557         read_unlock(&l->lock);
558 }
559 
560 static int bt_seq_show(struct seq_file *seq, void *v)
561 {
562         struct bt_seq_state *s = seq->private;
563         struct bt_sock_list *l = s->l;
564 
565         if (v == SEQ_START_TOKEN) {
566                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Src Dst Parent");
567 
568                 if (l->custom_seq_show) {
569                         seq_putc(seq, ' ');
570                         l->custom_seq_show(seq, v);
571                 }
572 
573                 seq_putc(seq, '\n');
574         } else {
575                 struct sock *sk = sk_entry(v);
576                 struct bt_sock *bt = bt_sk(sk);
577 
578                 seq_printf(seq,
579                            "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
580                            sk,
581                            atomic_read(&sk->sk_refcnt),
582                            sk_rmem_alloc_get(sk),
583                            sk_wmem_alloc_get(sk),
584                            from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
585                            sock_i_ino(sk),
586                            &bt->src,
587                            &bt->dst,
588                            bt->parent? sock_i_ino(bt->parent): 0LU);
589 
590                 if (l->custom_seq_show) {
591                         seq_putc(seq, ' ');
592                         l->custom_seq_show(seq, v);
593                 }
594 
595                 seq_putc(seq, '\n');
596         }
597         return 0;
598 }
599 
600 static struct seq_operations bt_seq_ops = {
601         .start = bt_seq_start,
602         .next  = bt_seq_next,
603         .stop  = bt_seq_stop,
604         .show  = bt_seq_show,
605 };
606 
607 static int bt_seq_open(struct inode *inode, struct file *file)
608 {
609         struct bt_sock_list *sk_list;
610         struct bt_seq_state *s;
611 
612         sk_list = PDE_DATA(inode);
613         s = __seq_open_private(file, &bt_seq_ops,
614                                sizeof(struct bt_seq_state));
615         if (!s)
616                 return -ENOMEM;
617 
618         s->l = sk_list;
619         return 0;
620 }
621 
622 static const struct file_operations bt_fops = {
623         .open = bt_seq_open,
624         .read = seq_read,
625         .llseek = seq_lseek,
626         .release = seq_release_private
627 };
628 
629 int bt_procfs_init(struct net *net, const char *name,
630                    struct bt_sock_list* sk_list,
631                    int (* seq_show)(struct seq_file *, void *))
632 {
633         sk_list->custom_seq_show = seq_show;
634 
635         if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
636                 return -ENOMEM;
637         return 0;
638 }
639 
640 void bt_procfs_cleanup(struct net *net, const char *name)
641 {
642         remove_proc_entry(name, net->proc_net);
643 }
644 #else
645 int bt_procfs_init(struct net *net, const char *name,
646                    struct bt_sock_list* sk_list,
647                    int (* seq_show)(struct seq_file *, void *))
648 {
649         return 0;
650 }
651 
652 void bt_procfs_cleanup(struct net *net, const char *name)
653 {
654 }
655 #endif
656 EXPORT_SYMBOL(bt_procfs_init);
657 EXPORT_SYMBOL(bt_procfs_cleanup);
658 
659 static struct net_proto_family bt_sock_family_ops = {
660         .owner  = THIS_MODULE,
661         .family = PF_BLUETOOTH,
662         .create = bt_sock_create,
663 };
664 
665 static int __init bt_init(void)
666 {
667         int err;
668 
669         BT_INFO("Core ver %s", VERSION);
670 
671         err = bt_sysfs_init();
672         if (err < 0)
673                 return err;
674 
675         err = sock_register(&bt_sock_family_ops);
676         if (err < 0) {
677                 bt_sysfs_cleanup();
678                 return err;
679         }
680 
681         BT_INFO("HCI device and connection manager initialized");
682 
683         err = hci_sock_init();
684         if (err < 0)
685                 goto error;
686 
687         err = l2cap_init();
688         if (err < 0)
689                 goto sock_err;
690 
691         err = sco_init();
692         if (err < 0) {
693                 l2cap_exit();
694                 goto sock_err;
695         }
696 
697         return 0;
698 
699 sock_err:
700         hci_sock_cleanup();
701 
702 error:
703         sock_unregister(PF_BLUETOOTH);
704         bt_sysfs_cleanup();
705 
706         return err;
707 }
708 
709 static void __exit bt_exit(void)
710 {
711 
712         sco_exit();
713 
714         l2cap_exit();
715 
716         hci_sock_cleanup();
717 
718         sock_unregister(PF_BLUETOOTH);
719 
720         bt_sysfs_cleanup();
721 }
722 
723 subsys_initcall(bt_init);
724 module_exit(bt_exit);
725 
726 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
727 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
728 MODULE_VERSION(VERSION);
729 MODULE_LICENSE("GPL");
730 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
731 

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