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

TOMOYO Linux Cross Reference
Linux/net/phonet/pep-gprs.c

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

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