chnl_net.c 12.4 KB
Newer Older
1
2
3
4
5
6
7
/*
 * Copyright (C) ST-Ericsson AB 2010
 * Authors:	Sjur Brendeland/sjur.brandeland@stericsson.com
 *		Daniel Martensson / Daniel.Martensson@stericsson.com
 * License terms: GNU General Public License (GPL) version 2
 */

Joe Perches's avatar
Joe Perches committed
8
9
#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/if_ether.h>
#include <linux/moduleparam.h>
#include <linux/ip.h>
#include <linux/sched.h>
#include <linux/sockios.h>
#include <linux/caif/if_caif.h>
#include <net/rtnetlink.h>
#include <net/caif/caif_layer.h>
#include <net/caif/cfcnfg.h>
#include <net/caif/cfpkt.h>
#include <net/caif/caif_dev.h>

27
/* GPRS PDP connection has MTU to 1500 */
28
#define GPRS_PDP_MTU 1500
29
30
/* 5 sec. connect timeout */
#define CONNECT_TIMEOUT (5 * HZ)
31
32
33
34
35
36
37
38
#define CAIF_NET_DEFAULT_QUEUE_LEN 500

/*This list is protected by the rtnl lock. */
static LIST_HEAD(chnl_net_list);

MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK("caif");

39
40
41
42
43
44
45
enum caif_states {
	CAIF_CONNECTED		= 1,
	CAIF_CONNECTING,
	CAIF_DISCONNECTED,
	CAIF_SHUTDOWN
};

46
47
48
49
50
51
52
53
54
55
struct chnl_net {
	struct cflayer chnl;
	struct net_device_stats stats;
	struct caif_connect_request conn_req;
	struct list_head list_field;
	struct net_device *netdev;
	char name[256];
	wait_queue_head_t netmgmt_wq;
	/* Flow status to remember and control the transmission. */
	bool flowenabled;
56
	enum caif_states state;
57
58
59
60
61
62
63
64
65
66
};

static void robust_list_del(struct list_head *delete_node)
{
	struct list_head *list_node;
	struct list_head *n;
	ASSERT_RTNL();
	list_for_each_safe(list_node, n, &chnl_net_list) {
		if (list_node == delete_node) {
			list_del(list_node);
67
			return;
68
69
		}
	}
70
	WARN_ON(1);
71
72
73
74
75
}

static int chnl_recv_cb(struct cflayer *layr, struct cfpkt *pkt)
{
	struct sk_buff *skb;
76
	struct chnl_net *priv  = container_of(layr, struct chnl_net, chnl);
77
78
	int pktlen;
	int err = 0;
79
80
	const u8 *ip_version;
	u8 buf;
81
82
83
84
85
86
87
88
89
90
91
92
93
94

	priv = container_of(layr, struct chnl_net, chnl);

	if (!priv)
		return -EINVAL;

	/* Get length of CAIF packet. */
	pktlen = cfpkt_getlen(pkt);

	skb = (struct sk_buff *) cfpkt_tonative(pkt);
	/* Pass some minimum information and
	 * send the packet to the net stack.
	 */
	skb->dev = priv->netdev;
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

	/* check the version of IP */
	ip_version = skb_header_pointer(skb, 0, 1, &buf);
	if (!ip_version)
		return -EINVAL;
	switch (*ip_version >> 4) {
	case 4:
		skb->protocol = htons(ETH_P_IP);
		break;
	case 6:
		skb->protocol = htons(ETH_P_IPV6);
		break;
	default:
		return -EINVAL;
	}
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

	/* If we change the header in loop mode, the checksum is corrupted. */
	if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
		skb->ip_summed = CHECKSUM_UNNECESSARY;
	else
		skb->ip_summed = CHECKSUM_NONE;

	if (in_interrupt())
		netif_rx(skb);
	else
		netif_rx_ni(skb);

	/* Update statistics. */
	priv->netdev->stats.rx_packets++;
	priv->netdev->stats.rx_bytes += pktlen;

	return err;
}

static int delete_device(struct chnl_net *dev)
{
	ASSERT_RTNL();
	if (dev->netdev)
		unregister_netdevice(dev->netdev);
	return 0;
}

static void close_work(struct work_struct *work)
{
	struct chnl_net *dev = NULL;
	struct list_head *list_node;
	struct list_head *_tmp;
142
143
144
145
	/* May be called with or without RTNL lock held */
	int islocked = rtnl_is_locked();
	if (!islocked)
		rtnl_lock();
146
147
	list_for_each_safe(list_node, _tmp, &chnl_net_list) {
		dev = list_entry(list_node, struct chnl_net, list_field);
148
149
		if (dev->state == CAIF_SHUTDOWN)
			dev_close(dev->netdev);
150
	}
151
152
	if (!islocked)
		rtnl_unlock();
153
154
155
156
157
158
}
static DECLARE_WORK(close_worker, close_work);

static void chnl_flowctrl_cb(struct cflayer *layr, enum caif_ctrlcmd flow,
				int phyid)
{
159
	struct chnl_net *priv = container_of(layr, struct chnl_net, chnl);
Joe Perches's avatar
Joe Perches committed
160
	pr_debug("NET flowctrl func called flow: %s\n",
161
162
163
164
165
166
167
168
		flow == CAIF_CTRLCMD_FLOW_ON_IND ? "ON" :
		flow == CAIF_CTRLCMD_INIT_RSP ? "INIT" :
		flow == CAIF_CTRLCMD_FLOW_OFF_IND ? "OFF" :
		flow == CAIF_CTRLCMD_DEINIT_RSP ? "CLOSE/DEINIT" :
		flow == CAIF_CTRLCMD_INIT_FAIL_RSP ? "OPEN_FAIL" :
		flow == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ?
		 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND");

169

170
171
172

	switch (flow) {
	case CAIF_CTRLCMD_FLOW_OFF_IND:
173
174
175
		priv->flowenabled = false;
		netif_stop_queue(priv->netdev);
		break;
176
	case CAIF_CTRLCMD_DEINIT_RSP:
177
178
		priv->state = CAIF_DISCONNECTED;
		break;
179
	case CAIF_CTRLCMD_INIT_FAIL_RSP:
180
181
182
		priv->state = CAIF_DISCONNECTED;
		wake_up_interruptible(&priv->netmgmt_wq);
		break;
183
	case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
184
		priv->state = CAIF_SHUTDOWN;
185
186
187
188
		netif_tx_disable(priv->netdev);
		schedule_work(&close_worker);
		break;
	case CAIF_CTRLCMD_FLOW_ON_IND:
189
190
191
		priv->flowenabled = true;
		netif_wake_queue(priv->netdev);
		break;
192
	case CAIF_CTRLCMD_INIT_RSP:
193
		priv->state = CAIF_CONNECTED;
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
		priv->flowenabled = true;
		netif_wake_queue(priv->netdev);
		wake_up_interruptible(&priv->netmgmt_wq);
		break;
	default:
		break;
	}
}

static int chnl_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct chnl_net *priv;
	struct cfpkt *pkt = NULL;
	int len;
	int result = -1;
	/* Get our private data. */
	priv = netdev_priv(dev);

	if (skb->len > priv->netdev->mtu) {
Joe Perches's avatar
Joe Perches committed
213
		pr_warn("Size of skb exceeded MTU\n");
214
215
216
217
		return -ENOSPC;
	}

	if (!priv->flowenabled) {
Joe Perches's avatar
Joe Perches committed
218
		pr_debug("dropping packets flow off\n");
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
		return NETDEV_TX_BUSY;
	}

	if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
		swap(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);

	/* Store original SKB length. */
	len = skb->len;

	pkt = cfpkt_fromnative(CAIF_DIR_OUT, (void *) skb);

	/* Send the packet down the stack. */
	result = priv->chnl.dn->transmit(priv->chnl.dn, pkt);
	if (result) {
		if (result == -EAGAIN)
			result = NETDEV_TX_BUSY;
		return result;
	}

	/* Update statistics. */
	dev->stats.tx_packets++;
	dev->stats.tx_bytes += len;

	return NETDEV_TX_OK;
}

static int chnl_net_open(struct net_device *dev)
{
	struct chnl_net *priv = NULL;
	int result = -1;
249
250
	int llifindex, headroom, tailroom, mtu;
	struct net_device *lldev;
251
252
253
	ASSERT_RTNL();
	priv = netdev_priv(dev);
	if (!priv) {
Joe Perches's avatar
Joe Perches committed
254
		pr_debug("chnl_net_open: no priv\n");
255
256
		return -ENODEV;
	}
257
258
259

	if (priv->state != CAIF_CONNECTING) {
		priv->state = CAIF_CONNECTING;
260
261
		result = caif_connect_client(&priv->conn_req, &priv->chnl,
					&llifindex, &headroom, &tailroom);
262
		if (result != 0) {
Joe Perches's avatar
Joe Perches committed
263
264
265
266
				pr_debug("err: "
					 "Unable to register and open device,"
					 " Err:%d\n",
					 result);
267
268
269
270
271
272
				goto error;
		}

		lldev = dev_get_by_index(dev_net(dev), llifindex);

		if (lldev == NULL) {
Joe Perches's avatar
Joe Perches committed
273
			pr_debug("no interface?\n");
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
			result = -ENODEV;
			goto error;
		}

		dev->needed_tailroom = tailroom + lldev->needed_tailroom;
		dev->hard_header_len = headroom + lldev->hard_header_len +
			lldev->needed_tailroom;

		/*
		 * MTU, head-room etc is not know before we have a
		 * CAIF link layer device available. MTU calculation may
		 * override initial RTNL configuration.
		 * MTU is minimum of current mtu, link layer mtu pluss
		 * CAIF head and tail, and PDP GPRS contexts max MTU.
		 */
		mtu = min_t(int, dev->mtu, lldev->mtu - (headroom + tailroom));
		mtu = min_t(int, GPRS_PDP_MTU, mtu);
		dev_set_mtu(dev, mtu);
		dev_put(lldev);

		if (mtu < 100) {
Joe Perches's avatar
Joe Perches committed
295
			pr_warn("CAIF Interface MTU too small (%d)\n", mtu);
296
297
			result = -ENODEV;
			goto error;
298
		}
299
	}
300

301
302
	rtnl_unlock();  /* Release RTNL lock during connect wait */

303
304
305
	result = wait_event_interruptible_timeout(priv->netmgmt_wq,
						priv->state != CAIF_CONNECTING,
						CONNECT_TIMEOUT);
306

307
308
	rtnl_lock();

309
	if (result == -ERESTARTSYS) {
Joe Perches's avatar
Joe Perches committed
310
		pr_debug("wait_event_interruptible woken by a signal\n");
311
312
		result = -ERESTARTSYS;
		goto error;
313
	}
314

315
	if (result == 0) {
Joe Perches's avatar
Joe Perches committed
316
		pr_debug("connect timeout\n");
317
318
		caif_disconnect_client(&priv->chnl);
		priv->state = CAIF_DISCONNECTED;
Joe Perches's avatar
Joe Perches committed
319
		pr_debug("state disconnected\n");
320
321
		result = -ETIMEDOUT;
		goto error;
322
	}
323

324
	if (priv->state != CAIF_CONNECTED) {
Joe Perches's avatar
Joe Perches committed
325
		pr_debug("connect failed\n");
326
327
		result = -ECONNREFUSED;
		goto error;
328
	}
Joe Perches's avatar
Joe Perches committed
329
	pr_debug("CAIF Netdevice connected\n");
330
	return 0;
331
332
333
334

error:
	caif_disconnect_client(&priv->chnl);
	priv->state = CAIF_DISCONNECTED;
Joe Perches's avatar
Joe Perches committed
335
	pr_debug("state disconnected\n");
336
337
	return result;

338
339
340
341
342
}

static int chnl_net_stop(struct net_device *dev)
{
	struct chnl_net *priv;
343

344
345
	ASSERT_RTNL();
	priv = netdev_priv(dev);
346
347
	priv->state = CAIF_DISCONNECTED;
	caif_disconnect_client(&priv->chnl);
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
	return 0;
}

static int chnl_net_init(struct net_device *dev)
{
	struct chnl_net *priv;
	ASSERT_RTNL();
	priv = netdev_priv(dev);
	strncpy(priv->name, dev->name, sizeof(priv->name));
	return 0;
}

static void chnl_net_uninit(struct net_device *dev)
{
	struct chnl_net *priv;
	ASSERT_RTNL();
	priv = netdev_priv(dev);
	robust_list_del(&priv->list_field);
}

static const struct net_device_ops netdev_ops = {
	.ndo_open = chnl_net_open,
	.ndo_stop = chnl_net_stop,
	.ndo_init = chnl_net_init,
	.ndo_uninit = chnl_net_uninit,
	.ndo_start_xmit = chnl_net_start_xmit,
};

static void ipcaif_net_setup(struct net_device *dev)
{
	struct chnl_net *priv;
	dev->netdev_ops = &netdev_ops;
	dev->destructor = free_netdev;
	dev->flags |= IFF_NOARP;
	dev->flags |= IFF_POINTOPOINT;
383
	dev->mtu = GPRS_PDP_MTU;
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
	dev->tx_queue_len = CAIF_NET_DEFAULT_QUEUE_LEN;

	priv = netdev_priv(dev);
	priv->chnl.receive = chnl_recv_cb;
	priv->chnl.ctrlcmd = chnl_flowctrl_cb;
	priv->netdev = dev;
	priv->conn_req.protocol = CAIFPROTO_DATAGRAM;
	priv->conn_req.link_selector = CAIF_LINK_HIGH_BANDW;
	priv->conn_req.priority = CAIF_PRIO_LOW;
	/* Insert illegal value */
	priv->conn_req.sockaddr.u.dgm.connection_id = -1;
	priv->flowenabled = false;

	ASSERT_RTNL();
	init_waitqueue_head(&priv->netmgmt_wq);
	list_add(&priv->list_field, &chnl_net_list);
}


static int ipcaif_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	struct chnl_net *priv;
	u8 loop;
	priv = netdev_priv(dev);
	NLA_PUT_U32(skb, IFLA_CAIF_IPV4_CONNID,
		    priv->conn_req.sockaddr.u.dgm.connection_id);
	NLA_PUT_U32(skb, IFLA_CAIF_IPV6_CONNID,
		    priv->conn_req.sockaddr.u.dgm.connection_id);
	loop = priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP;
	NLA_PUT_U8(skb, IFLA_CAIF_LOOPBACK, loop);


	return 0;
nla_put_failure:
	return -EMSGSIZE;

}

static void caif_netlink_parms(struct nlattr *data[],
				struct caif_connect_request *conn_req)
{
	if (!data) {
Joe Perches's avatar
Joe Perches committed
426
		pr_warn("no params data found\n");
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
		return;
	}
	if (data[IFLA_CAIF_IPV4_CONNID])
		conn_req->sockaddr.u.dgm.connection_id =
			nla_get_u32(data[IFLA_CAIF_IPV4_CONNID]);
	if (data[IFLA_CAIF_IPV6_CONNID])
		conn_req->sockaddr.u.dgm.connection_id =
			nla_get_u32(data[IFLA_CAIF_IPV6_CONNID]);
	if (data[IFLA_CAIF_LOOPBACK]) {
		if (nla_get_u8(data[IFLA_CAIF_LOOPBACK]))
			conn_req->protocol = CAIFPROTO_DATAGRAM_LOOP;
		else
			conn_req->protocol = CAIFPROTO_DATAGRAM;
	}
}

static int ipcaif_newlink(struct net *src_net, struct net_device *dev,
			  struct nlattr *tb[], struct nlattr *data[])
{
	int ret;
	struct chnl_net *caifdev;
	ASSERT_RTNL();
	caifdev = netdev_priv(dev);
	caif_netlink_parms(data, &caifdev->conn_req);
451
452
	dev_net_set(caifdev->netdev, src_net);

453
454
	ret = register_netdevice(dev);
	if (ret)
Joe Perches's avatar
Joe Perches committed
455
		pr_warn("device rtml registration failed\n");
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
	return ret;
}

static int ipcaif_changelink(struct net_device *dev, struct nlattr *tb[],
				struct nlattr *data[])
{
	struct chnl_net *caifdev;
	ASSERT_RTNL();
	caifdev = netdev_priv(dev);
	caif_netlink_parms(data, &caifdev->conn_req);
	netdev_state_change(dev);
	return 0;
}

static size_t ipcaif_get_size(const struct net_device *dev)
{
	return
		/* IFLA_CAIF_IPV4_CONNID */
		nla_total_size(4) +
		/* IFLA_CAIF_IPV6_CONNID */
		nla_total_size(4) +
		/* IFLA_CAIF_LOOPBACK */
		nla_total_size(2) +
		0;
}

static const struct nla_policy ipcaif_policy[IFLA_CAIF_MAX + 1] = {
	[IFLA_CAIF_IPV4_CONNID]	      = { .type = NLA_U32 },
	[IFLA_CAIF_IPV6_CONNID]	      = { .type = NLA_U32 },
	[IFLA_CAIF_LOOPBACK]	      = { .type = NLA_U8 }
};


static struct rtnl_link_ops ipcaif_link_ops __read_mostly = {
	.kind		= "caif",
	.priv_size	= sizeof(struct chnl_net),
	.setup		= ipcaif_net_setup,
	.maxtype	= IFLA_CAIF_MAX,
	.policy		= ipcaif_policy,
	.newlink	= ipcaif_newlink,
	.changelink	= ipcaif_changelink,
	.get_size	= ipcaif_get_size,
	.fill_info	= ipcaif_fill_info,

};

static int __init chnl_init_module(void)
{
	return rtnl_link_register(&ipcaif_link_ops);
}

static void __exit chnl_exit_module(void)
{
	struct chnl_net *dev = NULL;
	struct list_head *list_node;
	struct list_head *_tmp;
	rtnl_link_unregister(&ipcaif_link_ops);
	rtnl_lock();
	list_for_each_safe(list_node, _tmp, &chnl_net_list) {
		dev = list_entry(list_node, struct chnl_net, list_field);
		list_del(list_node);
		delete_device(dev);
	}
	rtnl_unlock();
}

module_init(chnl_init_module);
module_exit(chnl_exit_module);