Merge branch 'master' of git://gitorious.org/linux-can/linux-can-next

Marc Kleine-Budde says:

====================
here is our second pull request for net-next. In this series Federico
Vaga adds a pci driver for c_can/d_can hardware using the existing
generic c_can driver. The remaining 6 patches are by Oliver Hartkopp.
He adds CANFD support to the CAN stack while keeping binary
compatibility for existing applications. CANFD is an extension to the
existing CAN standard, it allows longer CAN frames and/or higher data
rates. There's no real hardware available yet, but this series adds
CANFD support to the vcan driver.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 135 insertions, 31 deletions

diff --git a/net/can/af_can.c b/net/can/af_can.c
index 6efcd37b4bd..821022a7214 100644
--- a/net/can/af_can.c
+++ b/net/can/af_can.c
@@ -41,6 +41,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/stddef.h>
 #include <linux/init.h>
 #include <linux/kmod.h>
 #include <linux/slab.h>
@@ -220,30 +221,46 @@ static int can_create(struct net *net, struct socket *sock, int protocol,
  *  -ENOBUFS on full driver queue (see net_xmit_errno())
  *  -ENOMEM when local loopback failed at calling skb_clone()
  *  -EPERM when trying to send on a non-CAN interface
+ *  -EMSGSIZE CAN frame size is bigger than CAN interface MTU
  *  -EINVAL when the skb->data does not contain a valid CAN frame
  */
 int can_send(struct sk_buff *skb, int loop)
 {
         struct sk_buff *newskb = NULL;
-        struct can_frame *cf = (struct can_frame *)skb->data;
-        int err;
+        struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
+        int err = -EINVAL;
+
+        if (skb->len == CAN_MTU) {
+                skb->protocol = htons(ETH_P_CAN);
+                if (unlikely(cfd->len > CAN_MAX_DLEN))
+                        goto inval_skb;
+        } else if (skb->len == CANFD_MTU) {
+                skb->protocol = htons(ETH_P_CANFD);
+                if (unlikely(cfd->len > CANFD_MAX_DLEN))
+                        goto inval_skb;
+        } else
+                goto inval_skb;
 
-        if (skb->len != sizeof(struct can_frame) || cf->can_dlc > 8) {
-                kfree_skb(skb);
-                return -EINVAL;
+        /*
+         * Make sure the CAN frame can pass the selected CAN netdevice.
+         * As structs can_frame and canfd_frame are similar, we can provide
+         * CAN FD frames to legacy CAN drivers as long as the length is <= 8
+         */
+        if (unlikely(skb->len > skb->dev->mtu && cfd->len > CAN_MAX_DLEN)) {
+                err = -EMSGSIZE;
+                goto inval_skb;
         }
 
-        if (skb->dev->type != ARPHRD_CAN) {
-                kfree_skb(skb);
-                return -EPERM;
+        if (unlikely(skb->dev->type != ARPHRD_CAN)) {
+                err = -EPERM;
+                goto inval_skb;
         }
 
-        if (!(skb->dev->flags & IFF_UP)) {
-                kfree_skb(skb);
-                return -ENETDOWN;
+        if (unlikely(!(skb->dev->flags & IFF_UP))) {
+                err = -ENETDOWN;
+                goto inval_skb;
         }
 
-        skb->protocol = htons(ETH_P_CAN);
         skb_reset_network_header(skb);
         skb_reset_transport_header(skb);
 
@@ -300,6 +317,10 @@ int can_send(struct sk_buff *skb, int loop)
         can_stats.tx_frames_delta++;
 
         return 0;
+
+inval_skb:
+        kfree_skb(skb);
+        return err;
 }
 EXPORT_SYMBOL(can_send);
 
@@ -632,24 +653,11 @@ static int can_rcv_filter(struct dev_rcv_lists *d, struct sk_buff *skb)
         return matches;
 }
 
-static int can_rcv(struct sk_buff *skb, struct net_device *dev,
-                   struct packet_type *pt, struct net_device *orig_dev)
+static void can_receive(struct sk_buff *skb, struct net_device *dev)
 {
         struct dev_rcv_lists *d;
-        struct can_frame *cf = (struct can_frame *)skb->data;
         int matches;
 
-        if (!net_eq(dev_net(dev), &init_net))
-                goto drop;
-
-        if (WARN_ONCE(dev->type != ARPHRD_CAN ||
-                      skb->len != sizeof(struct can_frame) ||
-                      cf->can_dlc > 8,
-                      "PF_CAN: dropped non conform skbuf: "
-                      "dev type %d, len %d, can_dlc %d\n",
-                      dev->type, skb->len, cf->can_dlc))
-                goto drop;
-
         /* update statistics */
         can_stats.rx_frames++;
         can_stats.rx_frames_delta++;
@@ -673,7 +681,49 @@ static int can_rcv(struct sk_buff *skb, struct net_device *dev,
                 can_stats.matches++;
                 can_stats.matches_delta++;
         }
+}
 
+static int can_rcv(struct sk_buff *skb, struct net_device *dev,
+                   struct packet_type *pt, struct net_device *orig_dev)
+{
+        struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
+
+        if (unlikely(!net_eq(dev_net(dev), &init_net)))
+                goto drop;
+
+        if (WARN_ONCE(dev->type != ARPHRD_CAN ||
+                      skb->len != CAN_MTU ||
+                      cfd->len > CAN_MAX_DLEN,
+                      "PF_CAN: dropped non conform CAN skbuf: "
+                      "dev type %d, len %d, datalen %d\n",
+                      dev->type, skb->len, cfd->len))
+                goto drop;
+
+        can_receive(skb, dev);
+        return NET_RX_SUCCESS;
+
+drop:
+        kfree_skb(skb);
+        return NET_RX_DROP;
+}
+
+static int canfd_rcv(struct sk_buff *skb, struct net_device *dev,
+                   struct packet_type *pt, struct net_device *orig_dev)
+{
+        struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
+
+        if (unlikely(!net_eq(dev_net(dev), &init_net)))
+                goto drop;
+
+        if (WARN_ONCE(dev->type != ARPHRD_CAN ||
+                      skb->len != CANFD_MTU ||
+                      cfd->len > CANFD_MAX_DLEN,
+                      "PF_CAN: dropped non conform CAN FD skbuf: "
+                      "dev type %d, len %d, datalen %d\n",
+                      dev->type, skb->len, cfd->len))
+                goto drop;
+
+        can_receive(skb, dev);
         return NET_RX_SUCCESS;
 
 drop:
@@ -807,10 +857,14 @@ static int can_notifier(struct notifier_block *nb, unsigned long msg,
 
 static struct packet_type can_packet __read_mostly = {
         .type = cpu_to_be16(ETH_P_CAN),
-        .dev  = NULL,
         .func = can_rcv,
 };
 
+static struct packet_type canfd_packet __read_mostly = {
+        .type = cpu_to_be16(ETH_P_CANFD),
+        .func = canfd_rcv,
+};
+
 static const struct net_proto_family can_family_ops = {
         .family = PF_CAN,
         .create = can_create,
@@ -824,6 +878,12 @@ static struct notifier_block can_netdev_notifier __read_mostly = {
 
 static __init int can_init(void)
 {
+        /* check for correct padding to be able to use the structs similarly */
+        BUILD_BUG_ON(offsetof(struct can_frame, can_dlc) !=
+                     offsetof(struct canfd_frame, len) ||
+                     offsetof(struct can_frame, data) !=
+                     offsetof(struct canfd_frame, data));
+
         printk(banner);
 
         memset(&can_rx_alldev_list, 0, sizeof(can_rx_alldev_list));
@@ -846,6 +906,7 @@ static __init int can_init(void)
         sock_register(&can_family_ops);
         register_netdevice_notifier(&can_netdev_notifier);
         dev_add_pack(&can_packet);
+        dev_add_pack(&canfd_packet);
 
         return 0;
 }
@@ -860,6 +921,7 @@ static __exit void can_exit(void)
         can_remove_proc();
 
         /* protocol unregister */
+        dev_remove_pack(&canfd_packet);
         dev_remove_pack(&can_packet);
         unregister_netdevice_notifier(&can_netdev_notifier);
         sock_unregister(PF_CAN);
diff --git a/net/can/raw.c b/net/can/raw.c
index 46cca3a91d1..3e9c89356a9 100644
--- a/net/can/raw.c
+++ b/net/can/raw.c
@@ -82,6 +82,7 @@ struct raw_sock {
         struct notifier_block notifier;
         int loopback;
         int recv_own_msgs;
+        int fd_frames;
         int count;                 /* number of active filters */
         struct can_filter dfilter; /* default/single filter */
         struct can_filter *filter; /* pointer to filter(s) */
@@ -119,6 +120,14 @@ static void raw_rcv(struct sk_buff *oskb, void *data)
         if (!ro->recv_own_msgs && oskb->sk == sk)
                 return;
 
+        /* do not pass frames with DLC > 8 to a legacy socket */
+        if (!ro->fd_frames) {
+                struct canfd_frame *cfd = (struct canfd_frame *)oskb->data;
+
+                if (unlikely(cfd->len > CAN_MAX_DLEN))
+                        return;
+        }
+
         /* clone the given skb to be able to enqueue it into the rcv queue */
         skb = skb_clone(oskb, GFP_ATOMIC);
         if (!skb)
@@ -291,6 +300,7 @@ static int raw_init(struct sock *sk)
         /* set default loopback behaviour */
         ro->loopback         = 1;
         ro->recv_own_msgs    = 0;
+        ro->fd_frames        = 0;
 
         /* set notifier */
         ro->notifier.notifier_call = raw_notifier;
@@ -569,6 +579,15 @@ static int raw_setsockopt(struct socket *sock, int level, int optname,
 
                 break;
 
+        case CAN_RAW_FD_FRAMES:
+                if (optlen != sizeof(ro->fd_frames))
+                        return -EINVAL;
+
+                if (copy_from_user(&ro->fd_frames, optval, optlen))
+                        return -EFAULT;
+
+                break;
+
         default:
                 return -ENOPROTOOPT;
         }
@@ -627,6 +646,12 @@ static int raw_getsockopt(struct socket *sock, int level, int optname,
                 val = &ro->recv_own_msgs;
                 break;
 
+        case CAN_RAW_FD_FRAMES:
+                if (len > sizeof(int))
+                        len = sizeof(int);
+                val = &ro->fd_frames;
+                break;
+
         default:
                 return -ENOPROTOOPT;
         }
@@ -662,8 +687,13 @@ static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
         } else
                 ifindex = ro->ifindex;
 
-        if (size != sizeof(struct can_frame))
-                return -EINVAL;
+        if (ro->fd_frames) {
+                if (unlikely(size != CANFD_MTU && size != CAN_MTU))
+                        return -EINVAL;
+        } else {
+                if (unlikely(size != CAN_MTU))
+                        return -EINVAL;
+        }
 
         dev = dev_get_by_index(&init_net, ifindex);
         if (!dev)
@@ -705,7 +735,9 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
                        struct msghdr *msg, size_t size, int flags)
 {
         struct sock *sk = sock->sk;
+        struct raw_sock *ro = raw_sk(sk);
         struct sk_buff *skb;
+        int rxmtu;
         int err = 0;
         int noblock;
 
@@ -716,10 +748,20 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
         if (!skb)
                 return err;
 
-        if (size < skb->len)
+        /*
+         * when serving a legacy socket the DLC <= 8 is already checked inside
+         * raw_rcv(). Now check if we need to pass a canfd_frame to a legacy
+         * socket and cut the possible CANFD_MTU/CAN_MTU length to CAN_MTU
+         */
+        if (!ro->fd_frames)
+                rxmtu = CAN_MTU;
+        else
+                rxmtu = skb->len;
+
+        if (size < rxmtu)
                 msg->msg_flags |= MSG_TRUNC;
         else
-                size = skb->len;
+                size = rxmtu;
 
         err = memcpy_toiovec(msg->msg_iov, skb->data, size);
         if (err < 0) {