net/phonet/pep-gprs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * File: pep-gprs.c
   4  *
   5  * GPRS over Phonet pipe end point socket
   6  *
   7  * Copyright (C) 2008 Nokia Corporation.
   8  *
   9  * Author: Rémi Denis-Courmont
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/if_ether.h>
  15 #include <linux/if_arp.h>
  16 #include <net/sock.h>
  17
  18 #include <linux/if_phonet.h>
  19 #include <net/tcp_states.h>
  20 #include <net/phonet/gprs.h>
  21
  22 #include <trace/events/sock.h>
  23
  24 #define GPRS_DEFAULT_MTU 1400
  25
  26 struct gprs_dev {
  27         struct sock             *sk;
  28         void                    (*old_state_change)(struct sock *);
  29         void                    (*old_data_ready)(struct sock *);
  30         void                    (*old_write_space)(struct sock *);
  31
  32         struct net_device       *dev;
  33 };
  34
  35 static __be16 gprs_type_trans(struct sk_buff *skb)
  36 {
  37         const u8 *pvfc;
  38         u8 buf;
  39
  40         pvfc = skb_header_pointer(skb, 0, 1, &buf);
  41         if (!pvfc)
  42                 return htons(0);
  43         /* Look at IP version field */
  44         switch (*pvfc >> 4) {
  45         case 4:
  46                 return htons(ETH_P_IP);
  47         case 6:
  48                 return htons(ETH_P_IPV6);
  49         }
  50         return htons(0);
  51 }
  52
  53 static void gprs_writeable(struct gprs_dev *gp)
  54 {
  55         struct net_device *dev = gp->dev;
  56
  57         if (pep_writeable(gp->sk))
  58                 netif_wake_queue(dev);
  59 }
  60
  61 /*
  62  * Socket callbacks
  63  */
  64
  65 static void gprs_state_change(struct sock *sk)
  66 {
  67         struct gprs_dev *gp = sk->sk_user_data;
  68
  69         if (sk->sk_state == TCP_CLOSE_WAIT) {
  70                 struct net_device *dev = gp->dev;
  71
  72                 netif_stop_queue(dev);
  73                 netif_carrier_off(dev);
  74         }
  75 }
  76
  77 static int gprs_recv(struct gprs_dev *gp, struct sk_buff *skb)
  78 {
  79         struct net_device *dev = gp->dev;
  80         int err = 0;
  81         __be16 protocol = gprs_type_trans(skb);
  82
  83         if (!protocol) {
  84                 err = -EINVAL;
  85                 goto drop;
  86         }
  87
  88         if (skb_headroom(skb) & 3) {
  89                 struct sk_buff *rskb, *fs;
  90                 int flen = 0;
  91
  92                 /* Phonet Pipe data header may be misaligned (3 bytes),
  93                  * so wrap the IP packet as a single fragment of an head-less
  94                  * socket buffer. The network stack will pull what it needs,
  95                  * but at least, the whole IP payload is not memcpy'd. */
  96                 rskb = netdev_alloc_skb(dev, 0);
  97                 if (!rskb) {
  98                         err = -ENOBUFS;
  99                         goto drop;
 100                 }
 101                 skb_shinfo(rskb)->frag_list = skb;
 102                 rskb->len += skb->len;
 103                 rskb->data_len += rskb->len;
 104                 rskb->truesize += rskb->len;
 105
 106                 /* Avoid nested fragments */
 107                 skb_walk_frags(skb, fs)
 108                         flen += fs->len;
 109                 skb->next = skb_shinfo(skb)->frag_list;
 110                 skb_frag_list_init(skb);
 111                 skb->len -= flen;
 112                 skb->data_len -= flen;
 113                 skb->truesize -= flen;
 114
 115                 skb = rskb;
 116         }
 117
 118         skb->protocol = protocol;
 119         skb_reset_mac_header(skb);
 120         skb->dev = dev;
 121
 122         if (likely(dev->flags & IFF_UP)) {
 123                 dev->stats.rx_packets++;
 124                 dev->stats.rx_bytes += skb->len;
 125                 netif_rx(skb);
 126                 skb = NULL;
 127         } else
 128                 err = -ENODEV;
 129
 130 drop:
 131         if (skb) {
 132                 dev_kfree_skb(skb);
 133                 dev->stats.rx_dropped++;
 134         }
 135         return err;
 136 }
 137
 138 static void gprs_data_ready(struct sock *sk)
 139 {
 140         struct gprs_dev *gp = sk->sk_user_data;
 141         struct sk_buff *skb;
 142
 143         trace_sk_data_ready(sk);
 144
 145         while ((skb = pep_read(sk)) != NULL) {
 146                 skb_orphan(skb);
 147                 gprs_recv(gp, skb);
 148         }
 149 }
 150
 151 static void gprs_write_space(struct sock *sk)
 152 {
 153         struct gprs_dev *gp = sk->sk_user_data;
 154
 155         if (netif_running(gp->dev))
 156                 gprs_writeable(gp);
 157 }
 158
 159 /*
 160  * Network device callbacks
 161  */
 162
 163 static int gprs_open(struct net_device *dev)
 164 {
 165         struct gprs_dev *gp = netdev_priv(dev);
 166
 167         gprs_writeable(gp);
 168         return 0;
 169 }
 170
 171 static int gprs_close(struct net_device *dev)
 172 {
 173         netif_stop_queue(dev);
 174         return 0;
 175 }
 176
 177 static netdev_tx_t gprs_xmit(struct sk_buff *skb, struct net_device *dev)
 178 {
 179         struct gprs_dev *gp = netdev_priv(dev);
 180         struct sock *sk = gp->sk;
 181         int len, err;
 182
 183         switch (skb->protocol) {
 184         case  htons(ETH_P_IP):
 185         case  htons(ETH_P_IPV6):
 186                 break;
 187         default:
 188                 dev_kfree_skb(skb);
 189                 return NETDEV_TX_OK;
 190         }
 191
 192         skb_orphan(skb);
 193         skb_set_owner_w(skb, sk);
 194         len = skb->len;
 195         err = pep_write(sk, skb);
 196         if (err) {
 197                 net_dbg_ratelimited("%s: TX error (%d)\n", dev->name, err);
 198                 dev->stats.tx_aborted_errors++;
 199                 dev->stats.tx_errors++;
 200         } else {
 201                 dev->stats.tx_packets++;
 202                 dev->stats.tx_bytes += len;
 203         }
 204
 205         netif_stop_queue(dev);
 206         if (pep_writeable(sk))
 207                 netif_wake_queue(dev);
 208         return NETDEV_TX_OK;
 209 }
 210
 211 static const struct net_device_ops gprs_netdev_ops = {
 212         .ndo_open       = gprs_open,
 213         .ndo_stop       = gprs_close,
 214         .ndo_start_xmit = gprs_xmit,
 215 };
 216
 217 static void gprs_setup(struct net_device *dev)
 218 {
 219         dev->features           = NETIF_F_FRAGLIST;
 220         dev->type               = ARPHRD_PHONET_PIPE;
 221         dev->flags              = IFF_POINTOPOINT | IFF_NOARP;
 222         dev->mtu                = GPRS_DEFAULT_MTU;
 223         dev->min_mtu            = 576;
 224         dev->max_mtu            = (PHONET_MAX_MTU - 11);
 225         dev->hard_header_len    = 0;
 226         dev->addr_len           = 0;
 227         dev->tx_queue_len       = 10;
 228
 229         dev->netdev_ops         = &gprs_netdev_ops;
 230         dev->needs_free_netdev  = true;
 231 }
 232
 233 /*
 234  * External interface
 235  */
 236
 237 /*
 238  * Attach a GPRS interface to a datagram socket.
 239  * Returns the interface index on success, negative error code on error.
 240  */
 241 int gprs_attach(struct sock *sk)
 242 {
 243         static const char ifname[] = "gprs%d";
 244         struct gprs_dev *gp;
 245         struct net_device *dev;
 246         int err;
 247
 248         if (unlikely(sk->sk_type == SOCK_STREAM))
 249                 return -EINVAL; /* need packet boundaries */
 250
 251         /* Create net device */
 252         dev = alloc_netdev(sizeof(*gp), ifname, NET_NAME_UNKNOWN, gprs_setup);
 253         if (!dev)
 254                 return -ENOMEM;
 255         gp = netdev_priv(dev);
 256         gp->sk = sk;
 257         gp->dev = dev;
 258
 259         netif_stop_queue(dev);
 260         err = register_netdev(dev);
 261         if (err) {
 262                 free_netdev(dev);
 263                 return err;
 264         }
 265
 266         lock_sock(sk);
 267         if (unlikely(sk->sk_user_data)) {
 268                 err = -EBUSY;
 269                 goto out_rel;
 270         }
 271         if (unlikely((1 << sk->sk_state & (TCPF_CLOSE|TCPF_LISTEN)) ||
 272                         sock_flag(sk, SOCK_DEAD))) {
 273                 err = -EINVAL;
 274                 goto out_rel;
 275         }
 276         sk->sk_user_data        = gp;
 277         gp->old_state_change    = sk->sk_state_change;
 278         gp->old_data_ready      = sk->sk_data_ready;
 279         gp->old_write_space     = sk->sk_write_space;
 280         sk->sk_state_change     = gprs_state_change;
 281         sk->sk_data_ready       = gprs_data_ready;
 282         sk->sk_write_space      = gprs_write_space;
 283         release_sock(sk);
 284         sock_hold(sk);
 285
 286         printk(KERN_DEBUG"%s: attached\n", dev->name);
 287         return dev->ifindex;
 288
 289 out_rel:
 290         release_sock(sk);
 291         unregister_netdev(dev);
 292         return err;
 293 }
 294
 295 void gprs_detach(struct sock *sk)
 296 {
 297         struct gprs_dev *gp = sk->sk_user_data;
 298         struct net_device *dev = gp->dev;
 299
 300         lock_sock(sk);
 301         sk->sk_user_data        = NULL;
 302         sk->sk_state_change     = gp->old_state_change;
 303         sk->sk_data_ready       = gp->old_data_ready;
 304         sk->sk_write_space      = gp->old_write_space;
 305         release_sock(sk);
 306
 307         printk(KERN_DEBUG"%s: detached\n", dev->name);
 308         unregister_netdev(dev);
 309         sock_put(sk);
 310 }