can: fix NOHZ local_softirq_pending 08 warning
[linux-2.6.git] / net / can / raw.c
1 /*
2  * raw.c - Raw sockets for protocol family CAN
3  *
4  * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
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
9  * are met:
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 name of Volkswagen nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * Alternatively, provided that this notice is retained in full, this
20  * software may be distributed under the terms of the GNU General
21  * Public License ("GPL") version 2, in which case the provisions of the
22  * GPL apply INSTEAD OF those given above.
23  *
24  * The provided data structures and external interfaces from this code
25  * are not restricted to be used by modules with a GPL compatible license.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38  * DAMAGE.
39  *
40  * Send feedback to <socketcan-users@lists.berlios.de>
41  *
42  */
43
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/uio.h>
47 #include <linux/net.h>
48 #include <linux/netdevice.h>
49 #include <linux/socket.h>
50 #include <linux/if_arp.h>
51 #include <linux/skbuff.h>
52 #include <linux/can.h>
53 #include <linux/can/core.h>
54 #include <linux/can/raw.h>
55 #include <net/sock.h>
56 #include <net/net_namespace.h>
57
58 #define CAN_RAW_VERSION CAN_VERSION
59 static __initdata const char banner[] =
60         KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
61
62 MODULE_DESCRIPTION("PF_CAN raw protocol");
63 MODULE_LICENSE("Dual BSD/GPL");
64 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
65 MODULE_ALIAS("can-proto-1");
66
67 #define MASK_ALL 0
68
69 /*
70  * A raw socket has a list of can_filters attached to it, each receiving
71  * the CAN frames matching that filter.  If the filter list is empty,
72  * no CAN frames will be received by the socket.  The default after
73  * opening the socket, is to have one filter which receives all frames.
74  * The filter list is allocated dynamically with the exception of the
75  * list containing only one item.  This common case is optimized by
76  * storing the single filter in dfilter, to avoid using dynamic memory.
77  */
78
79 struct raw_sock {
80         struct sock sk;
81         int bound;
82         int ifindex;
83         struct notifier_block notifier;
84         int loopback;
85         int recv_own_msgs;
86         int count;                 /* number of active filters */
87         struct can_filter dfilter; /* default/single filter */
88         struct can_filter *filter; /* pointer to filter(s) */
89         can_err_mask_t err_mask;
90 };
91
92 static inline struct raw_sock *raw_sk(const struct sock *sk)
93 {
94         return (struct raw_sock *)sk;
95 }
96
97 static void raw_rcv(struct sk_buff *skb, void *data)
98 {
99         struct sock *sk = (struct sock *)data;
100         struct raw_sock *ro = raw_sk(sk);
101         struct sockaddr_can *addr;
102
103         /* check the received tx sock reference */
104         if (!ro->recv_own_msgs && skb->sk == sk)
105                 return;
106
107         /* clone the given skb to be able to enqueue it into the rcv queue */
108         skb = skb_clone(skb, GFP_ATOMIC);
109         if (!skb)
110                 return;
111
112         /*
113          *  Put the datagram to the queue so that raw_recvmsg() can
114          *  get it from there.  We need to pass the interface index to
115          *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
116          *  containing the interface index.
117          */
118
119         BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
120         addr = (struct sockaddr_can *)skb->cb;
121         memset(addr, 0, sizeof(*addr));
122         addr->can_family  = AF_CAN;
123         addr->can_ifindex = skb->dev->ifindex;
124
125         if (sock_queue_rcv_skb(sk, skb) < 0)
126                 kfree_skb(skb);
127 }
128
129 static int raw_enable_filters(struct net_device *dev, struct sock *sk,
130                               struct can_filter *filter, int count)
131 {
132         int err = 0;
133         int i;
134
135         for (i = 0; i < count; i++) {
136                 err = can_rx_register(dev, filter[i].can_id,
137                                       filter[i].can_mask,
138                                       raw_rcv, sk, "raw");
139                 if (err) {
140                         /* clean up successfully registered filters */
141                         while (--i >= 0)
142                                 can_rx_unregister(dev, filter[i].can_id,
143                                                   filter[i].can_mask,
144                                                   raw_rcv, sk);
145                         break;
146                 }
147         }
148
149         return err;
150 }
151
152 static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
153                                 can_err_mask_t err_mask)
154 {
155         int err = 0;
156
157         if (err_mask)
158                 err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
159                                       raw_rcv, sk, "raw");
160
161         return err;
162 }
163
164 static void raw_disable_filters(struct net_device *dev, struct sock *sk,
165                               struct can_filter *filter, int count)
166 {
167         int i;
168
169         for (i = 0; i < count; i++)
170                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
171                                   raw_rcv, sk);
172 }
173
174 static inline void raw_disable_errfilter(struct net_device *dev,
175                                          struct sock *sk,
176                                          can_err_mask_t err_mask)
177
178 {
179         if (err_mask)
180                 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
181                                   raw_rcv, sk);
182 }
183
184 static inline void raw_disable_allfilters(struct net_device *dev,
185                                           struct sock *sk)
186 {
187         struct raw_sock *ro = raw_sk(sk);
188
189         raw_disable_filters(dev, sk, ro->filter, ro->count);
190         raw_disable_errfilter(dev, sk, ro->err_mask);
191 }
192
193 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
194 {
195         struct raw_sock *ro = raw_sk(sk);
196         int err;
197
198         err = raw_enable_filters(dev, sk, ro->filter, ro->count);
199         if (!err) {
200                 err = raw_enable_errfilter(dev, sk, ro->err_mask);
201                 if (err)
202                         raw_disable_filters(dev, sk, ro->filter, ro->count);
203         }
204
205         return err;
206 }
207
208 static int raw_notifier(struct notifier_block *nb,
209                         unsigned long msg, void *data)
210 {
211         struct net_device *dev = (struct net_device *)data;
212         struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
213         struct sock *sk = &ro->sk;
214
215         if (!net_eq(dev_net(dev), &init_net))
216                 return NOTIFY_DONE;
217
218         if (dev->type != ARPHRD_CAN)
219                 return NOTIFY_DONE;
220
221         if (ro->ifindex != dev->ifindex)
222                 return NOTIFY_DONE;
223
224         switch (msg) {
225
226         case NETDEV_UNREGISTER:
227                 lock_sock(sk);
228                 /* remove current filters & unregister */
229                 if (ro->bound)
230                         raw_disable_allfilters(dev, sk);
231
232                 if (ro->count > 1)
233                         kfree(ro->filter);
234
235                 ro->ifindex = 0;
236                 ro->bound   = 0;
237                 ro->count   = 0;
238                 release_sock(sk);
239
240                 sk->sk_err = ENODEV;
241                 if (!sock_flag(sk, SOCK_DEAD))
242                         sk->sk_error_report(sk);
243                 break;
244
245         case NETDEV_DOWN:
246                 sk->sk_err = ENETDOWN;
247                 if (!sock_flag(sk, SOCK_DEAD))
248                         sk->sk_error_report(sk);
249                 break;
250         }
251
252         return NOTIFY_DONE;
253 }
254
255 static int raw_init(struct sock *sk)
256 {
257         struct raw_sock *ro = raw_sk(sk);
258
259         ro->bound            = 0;
260         ro->ifindex          = 0;
261
262         /* set default filter to single entry dfilter */
263         ro->dfilter.can_id   = 0;
264         ro->dfilter.can_mask = MASK_ALL;
265         ro->filter           = &ro->dfilter;
266         ro->count            = 1;
267
268         /* set default loopback behaviour */
269         ro->loopback         = 1;
270         ro->recv_own_msgs    = 0;
271
272         /* set notifier */
273         ro->notifier.notifier_call = raw_notifier;
274
275         register_netdevice_notifier(&ro->notifier);
276
277         return 0;
278 }
279
280 static int raw_release(struct socket *sock)
281 {
282         struct sock *sk = sock->sk;
283         struct raw_sock *ro = raw_sk(sk);
284
285         unregister_netdevice_notifier(&ro->notifier);
286
287         lock_sock(sk);
288
289         /* remove current filters & unregister */
290         if (ro->bound) {
291                 if (ro->ifindex) {
292                         struct net_device *dev;
293
294                         dev = dev_get_by_index(&init_net, ro->ifindex);
295                         if (dev) {
296                                 raw_disable_allfilters(dev, sk);
297                                 dev_put(dev);
298                         }
299                 } else
300                         raw_disable_allfilters(NULL, sk);
301         }
302
303         if (ro->count > 1)
304                 kfree(ro->filter);
305
306         ro->ifindex = 0;
307         ro->bound   = 0;
308         ro->count   = 0;
309
310         sock_orphan(sk);
311         sock->sk = NULL;
312
313         release_sock(sk);
314         sock_put(sk);
315
316         return 0;
317 }
318
319 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
320 {
321         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
322         struct sock *sk = sock->sk;
323         struct raw_sock *ro = raw_sk(sk);
324         int ifindex;
325         int err = 0;
326         int notify_enetdown = 0;
327
328         if (len < sizeof(*addr))
329                 return -EINVAL;
330
331         lock_sock(sk);
332
333         if (ro->bound && addr->can_ifindex == ro->ifindex)
334                 goto out;
335
336         if (addr->can_ifindex) {
337                 struct net_device *dev;
338
339                 dev = dev_get_by_index(&init_net, addr->can_ifindex);
340                 if (!dev) {
341                         err = -ENODEV;
342                         goto out;
343                 }
344                 if (dev->type != ARPHRD_CAN) {
345                         dev_put(dev);
346                         err = -ENODEV;
347                         goto out;
348                 }
349                 if (!(dev->flags & IFF_UP))
350                         notify_enetdown = 1;
351
352                 ifindex = dev->ifindex;
353
354                 /* filters set by default/setsockopt */
355                 err = raw_enable_allfilters(dev, sk);
356                 dev_put(dev);
357         } else {
358                 ifindex = 0;
359
360                 /* filters set by default/setsockopt */
361                 err = raw_enable_allfilters(NULL, sk);
362         }
363
364         if (!err) {
365                 if (ro->bound) {
366                         /* unregister old filters */
367                         if (ro->ifindex) {
368                                 struct net_device *dev;
369
370                                 dev = dev_get_by_index(&init_net, ro->ifindex);
371                                 if (dev) {
372                                         raw_disable_allfilters(dev, sk);
373                                         dev_put(dev);
374                                 }
375                         } else
376                                 raw_disable_allfilters(NULL, sk);
377                 }
378                 ro->ifindex = ifindex;
379                 ro->bound = 1;
380         }
381
382  out:
383         release_sock(sk);
384
385         if (notify_enetdown) {
386                 sk->sk_err = ENETDOWN;
387                 if (!sock_flag(sk, SOCK_DEAD))
388                         sk->sk_error_report(sk);
389         }
390
391         return err;
392 }
393
394 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
395                        int *len, int peer)
396 {
397         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
398         struct sock *sk = sock->sk;
399         struct raw_sock *ro = raw_sk(sk);
400
401         if (peer)
402                 return -EOPNOTSUPP;
403
404         memset(addr, 0, sizeof(*addr));
405         addr->can_family  = AF_CAN;
406         addr->can_ifindex = ro->ifindex;
407
408         *len = sizeof(*addr);
409
410         return 0;
411 }
412
413 static int raw_setsockopt(struct socket *sock, int level, int optname,
414                           char __user *optval, int optlen)
415 {
416         struct sock *sk = sock->sk;
417         struct raw_sock *ro = raw_sk(sk);
418         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
419         struct can_filter sfilter;         /* single filter */
420         struct net_device *dev = NULL;
421         can_err_mask_t err_mask = 0;
422         int count = 0;
423         int err = 0;
424
425         if (level != SOL_CAN_RAW)
426                 return -EINVAL;
427         if (optlen < 0)
428                 return -EINVAL;
429
430         switch (optname) {
431
432         case CAN_RAW_FILTER:
433                 if (optlen % sizeof(struct can_filter) != 0)
434                         return -EINVAL;
435
436                 count = optlen / sizeof(struct can_filter);
437
438                 if (count > 1) {
439                         /* filter does not fit into dfilter => alloc space */
440                         filter = kmalloc(optlen, GFP_KERNEL);
441                         if (!filter)
442                                 return -ENOMEM;
443
444                         if (copy_from_user(filter, optval, optlen)) {
445                                 kfree(filter);
446                                 return -EFAULT;
447                         }
448                 } else if (count == 1) {
449                         if (copy_from_user(&sfilter, optval, optlen))
450                                 return -EFAULT;
451                 }
452
453                 lock_sock(sk);
454
455                 if (ro->bound && ro->ifindex)
456                         dev = dev_get_by_index(&init_net, ro->ifindex);
457
458                 if (ro->bound) {
459                         /* (try to) register the new filters */
460                         if (count == 1)
461                                 err = raw_enable_filters(dev, sk, &sfilter, 1);
462                         else
463                                 err = raw_enable_filters(dev, sk, filter,
464                                                          count);
465                         if (err) {
466                                 if (count > 1)
467                                         kfree(filter);
468                                 goto out_fil;
469                         }
470
471                         /* remove old filter registrations */
472                         raw_disable_filters(dev, sk, ro->filter, ro->count);
473                 }
474
475                 /* remove old filter space */
476                 if (ro->count > 1)
477                         kfree(ro->filter);
478
479                 /* link new filters to the socket */
480                 if (count == 1) {
481                         /* copy filter data for single filter */
482                         ro->dfilter = sfilter;
483                         filter = &ro->dfilter;
484                 }
485                 ro->filter = filter;
486                 ro->count  = count;
487
488  out_fil:
489                 if (dev)
490                         dev_put(dev);
491
492                 release_sock(sk);
493
494                 break;
495
496         case CAN_RAW_ERR_FILTER:
497                 if (optlen != sizeof(err_mask))
498                         return -EINVAL;
499
500                 if (copy_from_user(&err_mask, optval, optlen))
501                         return -EFAULT;
502
503                 err_mask &= CAN_ERR_MASK;
504
505                 lock_sock(sk);
506
507                 if (ro->bound && ro->ifindex)
508                         dev = dev_get_by_index(&init_net, ro->ifindex);
509
510                 /* remove current error mask */
511                 if (ro->bound) {
512                         /* (try to) register the new err_mask */
513                         err = raw_enable_errfilter(dev, sk, err_mask);
514
515                         if (err)
516                                 goto out_err;
517
518                         /* remove old err_mask registration */
519                         raw_disable_errfilter(dev, sk, ro->err_mask);
520                 }
521
522                 /* link new err_mask to the socket */
523                 ro->err_mask = err_mask;
524
525  out_err:
526                 if (dev)
527                         dev_put(dev);
528
529                 release_sock(sk);
530
531                 break;
532
533         case CAN_RAW_LOOPBACK:
534                 if (optlen != sizeof(ro->loopback))
535                         return -EINVAL;
536
537                 if (copy_from_user(&ro->loopback, optval, optlen))
538                         return -EFAULT;
539
540                 break;
541
542         case CAN_RAW_RECV_OWN_MSGS:
543                 if (optlen != sizeof(ro->recv_own_msgs))
544                         return -EINVAL;
545
546                 if (copy_from_user(&ro->recv_own_msgs, optval, optlen))
547                         return -EFAULT;
548
549                 break;
550
551         default:
552                 return -ENOPROTOOPT;
553         }
554         return err;
555 }
556
557 static int raw_getsockopt(struct socket *sock, int level, int optname,
558                           char __user *optval, int __user *optlen)
559 {
560         struct sock *sk = sock->sk;
561         struct raw_sock *ro = raw_sk(sk);
562         int len;
563         void *val;
564         int err = 0;
565
566         if (level != SOL_CAN_RAW)
567                 return -EINVAL;
568         if (get_user(len, optlen))
569                 return -EFAULT;
570         if (len < 0)
571                 return -EINVAL;
572
573         switch (optname) {
574
575         case CAN_RAW_FILTER:
576                 lock_sock(sk);
577                 if (ro->count > 0) {
578                         int fsize = ro->count * sizeof(struct can_filter);
579                         if (len > fsize)
580                                 len = fsize;
581                         if (copy_to_user(optval, ro->filter, len))
582                                 err = -EFAULT;
583                 } else
584                         len = 0;
585                 release_sock(sk);
586
587                 if (!err)
588                         err = put_user(len, optlen);
589                 return err;
590
591         case CAN_RAW_ERR_FILTER:
592                 if (len > sizeof(can_err_mask_t))
593                         len = sizeof(can_err_mask_t);
594                 val = &ro->err_mask;
595                 break;
596
597         case CAN_RAW_LOOPBACK:
598                 if (len > sizeof(int))
599                         len = sizeof(int);
600                 val = &ro->loopback;
601                 break;
602
603         case CAN_RAW_RECV_OWN_MSGS:
604                 if (len > sizeof(int))
605                         len = sizeof(int);
606                 val = &ro->recv_own_msgs;
607                 break;
608
609         default:
610                 return -ENOPROTOOPT;
611         }
612
613         if (put_user(len, optlen))
614                 return -EFAULT;
615         if (copy_to_user(optval, val, len))
616                 return -EFAULT;
617         return 0;
618 }
619
620 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
621                        struct msghdr *msg, size_t size)
622 {
623         struct sock *sk = sock->sk;
624         struct raw_sock *ro = raw_sk(sk);
625         struct sk_buff *skb;
626         struct net_device *dev;
627         int ifindex;
628         int err;
629
630         if (msg->msg_name) {
631                 struct sockaddr_can *addr =
632                         (struct sockaddr_can *)msg->msg_name;
633
634                 if (addr->can_family != AF_CAN)
635                         return -EINVAL;
636
637                 ifindex = addr->can_ifindex;
638         } else
639                 ifindex = ro->ifindex;
640
641         if (size != sizeof(struct can_frame))
642                 return -EINVAL;
643
644         dev = dev_get_by_index(&init_net, ifindex);
645         if (!dev)
646                 return -ENXIO;
647
648         skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
649                                   &err);
650         if (!skb)
651                 goto put_dev;
652
653         err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
654         if (err < 0)
655                 goto free_skb;
656         err = sock_tx_timestamp(msg, sk, skb_tx(skb));
657         if (err < 0)
658                 goto free_skb;
659         skb->dev = dev;
660         skb->sk  = sk;
661
662         err = can_send(skb, ro->loopback);
663
664         dev_put(dev);
665
666         if (err)
667                 goto send_failed;
668
669         return size;
670
671 free_skb:
672         kfree_skb(skb);
673 put_dev:
674         dev_put(dev);
675 send_failed:
676         return err;
677 }
678
679 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
680                        struct msghdr *msg, size_t size, int flags)
681 {
682         struct sock *sk = sock->sk;
683         struct sk_buff *skb;
684         int err = 0;
685         int noblock;
686
687         noblock =  flags & MSG_DONTWAIT;
688         flags   &= ~MSG_DONTWAIT;
689
690         skb = skb_recv_datagram(sk, flags, noblock, &err);
691         if (!skb)
692                 return err;
693
694         if (size < skb->len)
695                 msg->msg_flags |= MSG_TRUNC;
696         else
697                 size = skb->len;
698
699         err = memcpy_toiovec(msg->msg_iov, skb->data, size);
700         if (err < 0) {
701                 skb_free_datagram(sk, skb);
702                 return err;
703         }
704
705         sock_recv_timestamp(msg, sk, skb);
706
707         if (msg->msg_name) {
708                 msg->msg_namelen = sizeof(struct sockaddr_can);
709                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
710         }
711
712         skb_free_datagram(sk, skb);
713
714         return size;
715 }
716
717 static struct proto_ops raw_ops __read_mostly = {
718         .family        = PF_CAN,
719         .release       = raw_release,
720         .bind          = raw_bind,
721         .connect       = sock_no_connect,
722         .socketpair    = sock_no_socketpair,
723         .accept        = sock_no_accept,
724         .getname       = raw_getname,
725         .poll          = datagram_poll,
726         .ioctl         = NULL,          /* use can_ioctl() from af_can.c */
727         .listen        = sock_no_listen,
728         .shutdown      = sock_no_shutdown,
729         .setsockopt    = raw_setsockopt,
730         .getsockopt    = raw_getsockopt,
731         .sendmsg       = raw_sendmsg,
732         .recvmsg       = raw_recvmsg,
733         .mmap          = sock_no_mmap,
734         .sendpage      = sock_no_sendpage,
735 };
736
737 static struct proto raw_proto __read_mostly = {
738         .name       = "CAN_RAW",
739         .owner      = THIS_MODULE,
740         .obj_size   = sizeof(struct raw_sock),
741         .init       = raw_init,
742 };
743
744 static struct can_proto raw_can_proto __read_mostly = {
745         .type       = SOCK_RAW,
746         .protocol   = CAN_RAW,
747         .capability = -1,
748         .ops        = &raw_ops,
749         .prot       = &raw_proto,
750 };
751
752 static __init int raw_module_init(void)
753 {
754         int err;
755
756         printk(banner);
757
758         err = can_proto_register(&raw_can_proto);
759         if (err < 0)
760                 printk(KERN_ERR "can: registration of raw protocol failed\n");
761
762         return err;
763 }
764
765 static __exit void raw_module_exit(void)
766 {
767         can_proto_unregister(&raw_can_proto);
768 }
769
770 module_init(raw_module_init);
771 module_exit(raw_module_exit);