blob: 0e0254fd767de359769b080ff4bacdcb12c52eb4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * An implementation of the Acorn Econet and AUN protocols.
3 * Philip Blundell <philb@gnu.org>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
9 *
10 */
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/module.h>
13
14#include <linux/types.h>
15#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/string.h>
17#include <linux/mm.h>
18#include <linux/socket.h>
19#include <linux/sockios.h>
20#include <linux/in.h>
21#include <linux/errno.h>
22#include <linux/interrupt.h>
23#include <linux/if_ether.h>
24#include <linux/netdevice.h>
25#include <linux/inetdevice.h>
26#include <linux/route.h>
27#include <linux/inet.h>
28#include <linux/etherdevice.h>
29#include <linux/if_arp.h>
30#include <linux/wireless.h>
31#include <linux/skbuff.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020032#include <linux/udp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <net/sock.h>
34#include <net/inet_common.h>
35#include <linux/stat.h>
36#include <linux/init.h>
37#include <linux/if_ec.h>
38#include <net/udp.h>
39#include <net/ip.h>
40#include <linux/spinlock.h>
41#include <linux/rcupdate.h>
42#include <linux/bitops.h>
David S. Miller1d181832006-03-28 00:01:55 -080043#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#include <asm/uaccess.h>
46#include <asm/system.h>
47
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080048static const struct proto_ops econet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049static struct hlist_head econet_sklist;
50static DEFINE_RWLOCK(econet_lock);
David S. Miller1d181832006-03-28 00:01:55 -080051static DEFINE_MUTEX(econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53/* Since there are only 256 possible network numbers (or fewer, depends
54 how you count) it makes sense to use a simple lookup table. */
55static struct net_device *net2dev_map[256];
56
57#define EC_PORT_IP 0xd2
58
59#ifdef CONFIG_ECONET_AUNUDP
YOSHIFUJI Hideakica403302006-01-04 13:56:08 -080060static DEFINE_SPINLOCK(aun_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static struct socket *udpsock;
62#define AUN_PORT 0x8000
63
64
65struct aunhdr
66{
67 unsigned char code; /* AUN magic protocol byte */
68 unsigned char port;
69 unsigned char cb;
70 unsigned char pad;
71 unsigned long handle;
72};
73
74static unsigned long aun_seq;
75
76/* Queue of packets waiting to be transmitted. */
77static struct sk_buff_head aun_queue;
78static struct timer_list ab_cleanup_timer;
79
80#endif /* CONFIG_ECONET_AUNUDP */
81
82/* Per-packet information */
83struct ec_cb
84{
85 struct sockaddr_ec sec;
86 unsigned long cookie; /* Supplied by user. */
87#ifdef CONFIG_ECONET_AUNUDP
88 int done;
89 unsigned long seq; /* Sequencing */
90 unsigned long timeout; /* Timeout */
91 unsigned long start; /* jiffies */
92#endif
93#ifdef CONFIG_ECONET_NATIVE
94 void (*sent)(struct sk_buff *, int result);
95#endif
96};
97
98static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
99{
100 write_lock_bh(&econet_lock);
101 sk_del_node_init(sk);
102 write_unlock_bh(&econet_lock);
103}
104
105static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
106{
107 write_lock_bh(&econet_lock);
108 sk_add_node(sk, list);
109 write_unlock_bh(&econet_lock);
110}
111
112/*
113 * Pull a packet from our receive queue and hand it to the user.
114 * If necessary we block.
115 */
116
117static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
118 struct msghdr *msg, size_t len, int flags)
119{
120 struct sock *sk = sock->sk;
121 struct sk_buff *skb;
122 size_t copied;
123 int err;
124
125 msg->msg_namelen = sizeof(struct sockaddr_ec);
126
David S. Miller1d181832006-03-28 00:01:55 -0800127 mutex_lock(&econet_mutex);
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 /*
130 * Call the generic datagram receiver. This handles all sorts
131 * of horrible races and re-entrancy so we can forget about it
132 * in the protocol layers.
133 *
134 * Now it will return ENETDOWN, if device have just gone down,
135 * but then it will block.
136 */
137
138 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
139
140 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900141 * An error occurred so return it. Because skb_recv_datagram()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 * handles the blocking we don't see and worry about blocking
143 * retries.
144 */
145
146 if(skb==NULL)
147 goto out;
148
149 /*
150 * You lose any data beyond the buffer you gave. If it worries a
151 * user program they can ask the device for its MTU anyway.
152 */
153
154 copied = skb->len;
155 if (copied > len)
156 {
157 copied=len;
158 msg->msg_flags|=MSG_TRUNC;
159 }
160
161 /* We can't use skb_copy_datagram here */
162 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
163 if (err)
164 goto out_free;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700165 sk->sk_stamp = skb->tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
167 if (msg->msg_name)
168 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
169
170 /*
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
173 */
174 err = copied;
175
176out_free:
177 skb_free_datagram(sk, skb);
178out:
David S. Miller1d181832006-03-28 00:01:55 -0800179 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return err;
181}
182
183/*
184 * Bind an Econet socket.
185 */
186
187static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
188{
189 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
David S. Miller1d181832006-03-28 00:01:55 -0800190 struct sock *sk;
191 struct econet_sock *eo;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 /*
194 * Check legality
195 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (addr_len < sizeof(struct sockaddr_ec) ||
198 sec->sec_family != AF_ECONET)
199 return -EINVAL;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900200
David S. Miller1d181832006-03-28 00:01:55 -0800201 mutex_lock(&econet_mutex);
202
203 sk = sock->sk;
204 eo = ec_sk(sk);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 eo->cb = sec->cb;
207 eo->port = sec->port;
208 eo->station = sec->addr.station;
209 eo->net = sec->addr.net;
210
David S. Miller1d181832006-03-28 00:01:55 -0800211 mutex_unlock(&econet_mutex);
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return 0;
214}
215
216#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
217/*
218 * Queue a transmit result for the user to be told about.
219 */
220
221static void tx_result(struct sock *sk, unsigned long cookie, int result)
222{
223 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
224 struct ec_cb *eb;
225 struct sockaddr_ec *sec;
226
227 if (skb == NULL)
228 {
229 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
230 return;
231 }
232
233 eb = (struct ec_cb *)&skb->cb;
234 sec = (struct sockaddr_ec *)&eb->sec;
235 memset(sec, 0, sizeof(struct sockaddr_ec));
236 sec->cookie = cookie;
237 sec->type = ECTYPE_TRANSMIT_STATUS | result;
238 sec->sec_family = AF_ECONET;
239
240 if (sock_queue_rcv_skb(sk, skb) < 0)
241 kfree_skb(skb);
242}
243#endif
244
245#ifdef CONFIG_ECONET_NATIVE
246/*
247 * Called by the Econet hardware driver when a packet transmit
248 * has completed. Tell the user.
249 */
250
251static void ec_tx_done(struct sk_buff *skb, int result)
252{
253 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
254 tx_result(skb->sk, eb->cookie, result);
255}
256#endif
257
258/*
259 * Send a packet. We have to work out which device it's going out on
260 * and hence whether to use real Econet or the UDP emulation.
261 */
262
263static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
264 struct msghdr *msg, size_t len)
265{
266 struct sock *sk = sock->sk;
267 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
268 struct net_device *dev;
269 struct ec_addr addr;
270 int err;
271 unsigned char port, cb;
272#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
273 struct sk_buff *skb;
274 struct ec_cb *eb;
275#endif
276#ifdef CONFIG_ECONET_AUNUDP
277 struct msghdr udpmsg;
278 struct iovec iov[msg->msg_iovlen+1];
279 struct aunhdr ah;
280 struct sockaddr_in udpdest;
281 __kernel_size_t size;
282 int i;
283 mm_segment_t oldfs;
284#endif
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900287 * Check the flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 */
289
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900290 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return -EINVAL;
292
293 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900294 * Get and verify the address.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900296
David S. Miller1d181832006-03-28 00:01:55 -0800297 mutex_lock(&econet_mutex);
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 if (saddr == NULL) {
300 struct econet_sock *eo = ec_sk(sk);
301
302 addr.station = eo->station;
303 addr.net = eo->net;
304 port = eo->port;
305 cb = eo->cb;
306 } else {
David S. Miller1d181832006-03-28 00:01:55 -0800307 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
308 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return -EINVAL;
David S. Miller1d181832006-03-28 00:01:55 -0800310 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 addr.station = saddr->addr.station;
312 addr.net = saddr->addr.net;
313 port = saddr->port;
314 cb = saddr->cb;
315 }
316
317 /* Look for a device with the right network number. */
318 dev = net2dev_map[addr.net];
319
320 /* If not directly reachable, use some default */
David S. Miller1d181832006-03-28 00:01:55 -0800321 if (dev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 dev = net2dev_map[0];
323 /* No interfaces at all? */
David S. Miller1d181832006-03-28 00:01:55 -0800324 if (dev == NULL) {
325 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 return -ENETDOWN;
David S. Miller1d181832006-03-28 00:01:55 -0800327 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 }
329
David S. Miller1d181832006-03-28 00:01:55 -0800330 if (len + 15 > dev->mtu) {
331 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 return -EMSGSIZE;
David S. Miller1d181832006-03-28 00:01:55 -0800333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
David S. Miller1d181832006-03-28 00:01:55 -0800335 if (dev->type == ARPHRD_ECONET) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 /* Real hardware Econet. We're not worthy etc. */
337#ifdef CONFIG_ECONET_NATIVE
338 unsigned short proto = 0;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700339 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 dev_hold(dev);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900342
Johannes Bergf5184d22008-05-12 20:48:31 -0700343 skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 msg->msg_flags & MSG_DONTWAIT, &err);
345 if (skb==NULL)
346 goto out_unlock;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 skb_reserve(skb, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700349 skb_reset_network_header(skb);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 eb = (struct ec_cb *)&skb->cb;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 /* BUG: saddr may be NULL */
354 eb->cookie = saddr->cookie;
355 eb->sec = *saddr;
356 eb->sent = ec_tx_done;
357
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700358 err = -EINVAL;
359 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
360 if (res < 0)
361 goto out_free;
362 if (res > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 struct ec_framehdr *fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 /* Poke in our control byte and
365 port number. Hack, hack. */
366 fh = (struct ec_framehdr *)(skb->data);
367 fh->cb = cb;
368 fh->port = port;
369 if (sock->type != SOCK_DGRAM) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700370 skb_reset_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 skb->len = 0;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700372 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* Copy the data. Returns -EFAULT on error */
376 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
377 skb->protocol = proto;
378 skb->dev = dev;
379 skb->priority = sk->sk_priority;
380 if (err)
381 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 err = -ENETDOWN;
384 if (!(dev->flags & IFF_UP))
385 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 /*
388 * Now send it
389 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 dev_queue_xmit(skb);
392 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800393 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return(len);
395
396 out_free:
397 kfree_skb(skb);
398 out_unlock:
399 if (dev)
400 dev_put(dev);
401#else
402 err = -EPROTOTYPE;
403#endif
David S. Miller1d181832006-03-28 00:01:55 -0800404 mutex_unlock(&econet_mutex);
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return err;
407 }
408
409#ifdef CONFIG_ECONET_AUNUDP
410 /* AUN virtual Econet. */
411
David S. Miller1d181832006-03-28 00:01:55 -0800412 if (udpsock == NULL) {
413 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return -ENETDOWN; /* No socket - can't send */
David S. Miller1d181832006-03-28 00:01:55 -0800415 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 /* Make up a UDP datagram and hand it off to some higher intellect. */
418
419 memset(&udpdest, 0, sizeof(udpdest));
420 udpdest.sin_family = AF_INET;
421 udpdest.sin_port = htons(AUN_PORT);
422
423 /* At the moment we use the stupid Acorn scheme of Econet address
424 y.x maps to IP a.b.c.x. This should be replaced with something
425 more flexible and more aware of subnet masks. */
426 {
427 struct in_device *idev;
428 unsigned long network = 0;
429
430 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700431 idev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (idev) {
433 if (idev->ifa_list)
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900434 network = ntohl(idev->ifa_list->ifa_address) &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 0xffffff00; /* !!! */
436 }
437 rcu_read_unlock();
438 udpdest.sin_addr.s_addr = htonl(network | addr.station);
439 }
440
441 ah.port = port;
442 ah.cb = cb & 0x7f;
443 ah.code = 2; /* magic */
444 ah.pad = 0;
445
446 /* tack our header on the front of the iovec */
447 size = sizeof(struct aunhdr);
448 /*
449 * XXX: that is b0rken. We can't mix userland and kernel pointers
450 * in iovec, since on a lot of platforms copy_from_user() will
451 * *not* work with the kernel and userland ones at the same time,
452 * regardless of what we do with set_fs(). And we are talking about
453 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
454 * apply. Any suggestions on fixing that code? -- AV
455 */
456 iov[0].iov_base = (void *)&ah;
457 iov[0].iov_len = size;
458 for (i = 0; i < msg->msg_iovlen; i++) {
459 void __user *base = msg->msg_iov[i].iov_base;
460 size_t len = msg->msg_iov[i].iov_len;
461 /* Check it now since we switch to KERNEL_DS later. */
David S. Miller1d181832006-03-28 00:01:55 -0800462 if (!access_ok(VERIFY_READ, base, len)) {
463 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return -EFAULT;
David S. Miller1d181832006-03-28 00:01:55 -0800465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 iov[i+1].iov_base = base;
467 iov[i+1].iov_len = len;
468 size += len;
469 }
470
471 /* Get a skbuff (no data, just holds our cb information) */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900472 if ((skb = sock_alloc_send_skb(sk, 0,
David S. Miller1d181832006-03-28 00:01:55 -0800473 msg->msg_flags & MSG_DONTWAIT,
474 &err)) == NULL) {
475 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return err;
David S. Miller1d181832006-03-28 00:01:55 -0800477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 eb = (struct ec_cb *)&skb->cb;
480
481 eb->cookie = saddr->cookie;
482 eb->timeout = (5*HZ);
483 eb->start = jiffies;
484 ah.handle = aun_seq;
485 eb->seq = (aun_seq++);
486 eb->sec = *saddr;
487
488 skb_queue_tail(&aun_queue, skb);
489
490 udpmsg.msg_name = (void *)&udpdest;
491 udpmsg.msg_namelen = sizeof(udpdest);
492 udpmsg.msg_iov = &iov[0];
493 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
494 udpmsg.msg_control = NULL;
495 udpmsg.msg_controllen = 0;
496 udpmsg.msg_flags=0;
497
498 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
499 err = sock_sendmsg(udpsock, &udpmsg, size);
500 set_fs(oldfs);
501#else
502 err = -EPROTOTYPE;
503#endif
David S. Miller1d181832006-03-28 00:01:55 -0800504 mutex_unlock(&econet_mutex);
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return err;
507}
508
509/*
510 * Look up the address of a socket.
511 */
512
513static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
514 int *uaddr_len, int peer)
515{
David S. Miller1d181832006-03-28 00:01:55 -0800516 struct sock *sk;
517 struct econet_sock *eo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
519
520 if (peer)
521 return -EOPNOTSUPP;
522
Eric Dumazet80922bb2009-08-06 03:48:36 +0000523 memset(sec, 0, sizeof(*sec));
David S. Miller1d181832006-03-28 00:01:55 -0800524 mutex_lock(&econet_mutex);
525
526 sk = sock->sk;
527 eo = ec_sk(sk);
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 sec->sec_family = AF_ECONET;
530 sec->port = eo->port;
531 sec->addr.station = eo->station;
532 sec->addr.net = eo->net;
533
David S. Miller1d181832006-03-28 00:01:55 -0800534 mutex_unlock(&econet_mutex);
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 *uaddr_len = sizeof(*sec);
537 return 0;
538}
539
540static void econet_destroy_timer(unsigned long data)
541{
542 struct sock *sk=(struct sock *)data;
543
Eric Dumazetc5640392009-06-16 10:12:03 +0000544 if (!sk_has_allocations(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 sk_free(sk);
546 return;
547 }
548
549 sk->sk_timer.expires = jiffies + 10 * HZ;
550 add_timer(&sk->sk_timer);
551 printk(KERN_DEBUG "econet socket destroy delayed\n");
552}
553
554/*
555 * Close an econet socket.
556 */
557
558static int econet_release(struct socket *sock)
559{
David S. Miller1d181832006-03-28 00:01:55 -0800560 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
David S. Miller1d181832006-03-28 00:01:55 -0800562 mutex_lock(&econet_mutex);
563
564 sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 if (!sk)
David S. Miller1d181832006-03-28 00:01:55 -0800566 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 econet_remove_socket(&econet_sklist, sk);
569
570 /*
571 * Now the socket is dead. No more input will appear.
572 */
573
574 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
575
David S. Miller0efffaf2008-06-17 03:01:47 -0700576 sock_orphan(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 /* Purge queues */
579
580 skb_queue_purge(&sk->sk_receive_queue);
581
Eric Dumazetc5640392009-06-16 10:12:03 +0000582 if (sk_has_allocations(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 sk->sk_timer.data = (unsigned long)sk;
584 sk->sk_timer.expires = jiffies + HZ;
585 sk->sk_timer.function = econet_destroy_timer;
586 add_timer(&sk->sk_timer);
David S. Miller1d181832006-03-28 00:01:55 -0800587
588 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 }
590
591 sk_free(sk);
David S. Miller1d181832006-03-28 00:01:55 -0800592
593out_unlock:
594 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 return 0;
596}
597
598static struct proto econet_proto = {
599 .name = "ECONET",
600 .owner = THIS_MODULE,
601 .obj_size = sizeof(struct econet_sock),
602};
603
604/*
605 * Create an Econet socket
606 */
607
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700608static int econet_create(struct net *net, struct socket *sock, int protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
610 struct sock *sk;
611 struct econet_sock *eo;
612 int err;
613
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700614 if (net != &init_net)
615 return -EAFNOSUPPORT;
616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /* Econet only provides datagram services. */
618 if (sock->type != SOCK_DGRAM)
619 return -ESOCKTNOSUPPORT;
620
621 sock->state = SS_UNCONNECTED;
622
623 err = -ENOBUFS;
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700624 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 if (sk == NULL)
626 goto out;
627
628 sk->sk_reuse = 1;
629 sock->ops = &econet_ops;
630 sock_init_data(sock, sk);
631
632 eo = ec_sk(sk);
633 sock_reset_flag(sk, SOCK_ZAPPED);
634 sk->sk_family = PF_ECONET;
635 eo->num = protocol;
636
637 econet_insert_socket(&econet_sklist, sk);
638 return(0);
639out:
640 return err;
641}
642
643/*
644 * Handle Econet specific ioctls
645 */
646
647static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
648{
649 struct ifreq ifr;
650 struct ec_device *edev;
651 struct net_device *dev;
652 struct sockaddr_ec *sec;
David S. Miller1d181832006-03-28 00:01:55 -0800653 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 /*
656 * Fetch the caller's info block into kernel space
657 */
658
659 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
660 return -EFAULT;
661
Eric W. Biederman881d9662007-09-17 11:56:21 -0700662 if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 return -ENODEV;
664
665 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
666
David S. Miller1d181832006-03-28 00:01:55 -0800667 mutex_lock(&econet_mutex);
668
669 err = 0;
670 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 case SIOCSIFADDR:
672 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800673 if (edev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 /* Magic up a new one. */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700675 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 if (edev == NULL) {
David S. Miller1d181832006-03-28 00:01:55 -0800677 err = -ENOMEM;
678 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 dev->ec_ptr = edev;
David S. Miller1d181832006-03-28 00:01:55 -0800681 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 net2dev_map[edev->net] = NULL;
683 edev->station = sec->addr.station;
684 edev->net = sec->addr.net;
685 net2dev_map[sec->addr.net] = dev;
686 if (!net2dev_map[0])
687 net2dev_map[0] = dev;
David S. Miller1d181832006-03-28 00:01:55 -0800688 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 case SIOCGIFADDR:
691 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800692 if (edev == NULL) {
693 err = -ENODEV;
694 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
696 memset(sec, 0, sizeof(struct sockaddr_ec));
697 sec->addr.station = edev->station;
698 sec->addr.net = edev->net;
699 sec->sec_family = AF_ECONET;
700 dev_put(dev);
701 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
David S. Miller1d181832006-03-28 00:01:55 -0800702 err = -EFAULT;
703 break;
704
705 default:
706 err = -EINVAL;
707 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 }
709
David S. Miller1d181832006-03-28 00:01:55 -0800710 mutex_unlock(&econet_mutex);
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800713
714 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715}
716
717/*
718 * Handle generic ioctls
719 */
720
721static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
722{
723 struct sock *sk = sock->sk;
724 void __user *argp = (void __user *)arg;
725
726 switch(cmd) {
727 case SIOCGSTAMP:
728 return sock_get_timestamp(sk, argp);
729
Eric Dumazetae40eb12007-03-18 17:33:16 -0700730 case SIOCGSTAMPNS:
731 return sock_get_timestampns(sk, argp);
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 case SIOCSIFADDR:
734 case SIOCGIFADDR:
735 return ec_dev_ioctl(sock, cmd, argp);
736 break;
737
738 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -0800739 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
741 /*NOTREACHED*/
742 return 0;
743}
744
745static struct net_proto_family econet_family_ops = {
746 .family = PF_ECONET,
747 .create = econet_create,
748 .owner = THIS_MODULE,
749};
750
David S. Miller1d181832006-03-28 00:01:55 -0800751static const struct proto_ops econet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 .family = PF_ECONET,
753 .owner = THIS_MODULE,
754 .release = econet_release,
755 .bind = econet_bind,
756 .connect = sock_no_connect,
757 .socketpair = sock_no_socketpair,
758 .accept = sock_no_accept,
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900759 .getname = econet_getname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 .poll = datagram_poll,
761 .ioctl = econet_ioctl,
762 .listen = sock_no_listen,
763 .shutdown = sock_no_shutdown,
764 .setsockopt = sock_no_setsockopt,
765 .getsockopt = sock_no_getsockopt,
766 .sendmsg = econet_sendmsg,
767 .recvmsg = econet_recvmsg,
768 .mmap = sock_no_mmap,
769 .sendpage = sock_no_sendpage,
770};
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
773/*
774 * Find the listening socket, if any, for the given data.
775 */
776
777static struct sock *ec_listening_socket(unsigned char port, unsigned char
778 station, unsigned char net)
779{
780 struct sock *sk;
781 struct hlist_node *node;
782
783 sk_for_each(sk, node, &econet_sklist) {
784 struct econet_sock *opt = ec_sk(sk);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900785 if ((opt->port == port || opt->port == 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 (opt->station == station || opt->station == 0) &&
787 (opt->net == net || opt->net == 0))
788 goto found;
789 }
790 sk = NULL;
791found:
792 return sk;
793}
794
795/*
796 * Queue a received packet for a socket.
797 */
798
799static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
800 unsigned char stn, unsigned char net,
801 unsigned char cb, unsigned char port)
802{
803 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
804 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
805
806 memset(sec, 0, sizeof(struct sockaddr_ec));
807 sec->sec_family = AF_ECONET;
808 sec->type = ECTYPE_PACKET_RECEIVED;
809 sec->port = port;
810 sec->cb = cb;
811 sec->addr.net = net;
812 sec->addr.station = stn;
813
814 return sock_queue_rcv_skb(sk, skb);
815}
816#endif
817
818#ifdef CONFIG_ECONET_AUNUDP
819/*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900820 * Send an AUN protocol response.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 */
822
823static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
824{
825 struct sockaddr_in sin = {
826 .sin_family = AF_INET,
827 .sin_port = htons(AUN_PORT),
828 .sin_addr = {.s_addr = addr}
829 };
830 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
831 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
832 struct msghdr udpmsg;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 udpmsg.msg_name = (void *)&sin;
835 udpmsg.msg_namelen = sizeof(sin);
836 udpmsg.msg_control = NULL;
837 udpmsg.msg_controllen = 0;
838 udpmsg.msg_flags=0;
839
840 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
841}
842
843
844/*
845 * Handle incoming AUN packets. Work out if anybody wants them,
846 * and send positive or negative acknowledgements as appropriate.
847 */
848
849static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
850{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700851 struct iphdr *ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 unsigned char stn = ntohl(ip->saddr) & 0xff;
853 struct sock *sk;
854 struct sk_buff *newskb;
855 struct ec_device *edev = skb->dev->ec_ptr;
856
857 if (! edev)
858 goto bad;
859
860 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
861 goto bad; /* Nobody wants it */
862
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900863 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 GFP_ATOMIC);
865 if (newskb == NULL)
866 {
867 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
868 /* Send nack and hope sender tries again */
869 goto bad;
870 }
871
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900872 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 len - sizeof(struct aunhdr));
874
875 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
876 {
877 /* Socket is bankrupt. */
878 kfree_skb(newskb);
879 goto bad;
880 }
881
882 aun_send_response(ip->saddr, ah->handle, 3, 0);
883 return;
884
885bad:
886 aun_send_response(ip->saddr, ah->handle, 4, 0);
887}
888
889/*
890 * Handle incoming AUN transmit acknowledgements. If the sequence
891 * number matches something in our backlog then kill it and tell
892 * the user. If the remote took too long to reply then we may have
893 * dropped the packet already.
894 */
895
896static void aun_tx_ack(unsigned long seq, int result)
897{
898 struct sk_buff *skb;
899 unsigned long flags;
900 struct ec_cb *eb;
901
902 spin_lock_irqsave(&aun_queue_lock, flags);
David S. Millerde103342009-05-28 16:46:29 -0700903 skb_queue_walk(&aun_queue, skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 eb = (struct ec_cb *)&skb->cb;
905 if (eb->seq == seq)
906 goto foundit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
908 spin_unlock_irqrestore(&aun_queue_lock, flags);
909 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
910 return;
911
912foundit:
913 tx_result(skb->sk, eb->cookie, result);
David S. Miller8728b832005-08-09 19:25:21 -0700914 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 spin_unlock_irqrestore(&aun_queue_lock, flags);
916 kfree_skb(skb);
917}
918
919/*
920 * Deal with received AUN frames - sort out what type of thing it is
921 * and hand it to the right function.
922 */
923
924static void aun_data_available(struct sock *sk, int slen)
925{
926 int err;
927 struct sk_buff *skb;
928 unsigned char *data;
929 struct aunhdr *ah;
930 struct iphdr *ip;
931 size_t len;
932
933 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
934 if (err == -EAGAIN) {
935 printk(KERN_ERR "AUN: no data available?!");
936 return;
937 }
938 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
939 }
940
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700941 data = skb_transport_header(skb) + sizeof(struct udphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 ah = (struct aunhdr *)data;
943 len = skb->len - sizeof(struct udphdr);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700944 ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 switch (ah->code)
947 {
948 case 2:
949 aun_incoming(skb, ah, len);
950 break;
951 case 3:
952 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
953 break;
954 case 4:
955 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
956 break;
957#if 0
958 /* This isn't quite right yet. */
959 case 5:
960 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
961 break;
962#endif
963 default:
964 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
965 }
966
967 skb_free_datagram(sk, skb);
968}
969
970/*
971 * Called by the timer to manage the AUN transmit queue. If a packet
972 * was sent to a dead or nonexistent host then we will never get an
973 * acknowledgement back. After a few seconds we need to spot this and
974 * drop the packet.
975 */
976
977static void ab_cleanup(unsigned long h)
978{
David S. Millerde103342009-05-28 16:46:29 -0700979 struct sk_buff *skb, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 unsigned long flags;
981
982 spin_lock_irqsave(&aun_queue_lock, flags);
David S. Millerde103342009-05-28 16:46:29 -0700983 skb_queue_walk_safe(&aun_queue, skb, n) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
David S. Millerde103342009-05-28 16:46:29 -0700985 if ((jiffies - eb->start) > eb->timeout) {
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900986 tx_result(skb->sk, eb->cookie,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 ECTYPE_TRANSMIT_NOT_PRESENT);
David S. Miller8728b832005-08-09 19:25:21 -0700988 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 kfree_skb(skb);
990 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 }
992 spin_unlock_irqrestore(&aun_queue_lock, flags);
993
994 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
995}
996
997static int __init aun_udp_initialise(void)
998{
999 int error;
1000 struct sockaddr_in sin;
1001
1002 skb_queue_head_init(&aun_queue);
1003 spin_lock_init(&aun_queue_lock);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001004 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 ab_cleanup_timer.expires = jiffies + (HZ*2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 add_timer(&ab_cleanup_timer);
1007
1008 memset(&sin, 0, sizeof(sin));
1009 sin.sin_port = htons(AUN_PORT);
1010
1011 /* We can count ourselves lucky Acorn machines are too dim to
1012 speak IPv6. :-) */
1013 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1014 {
1015 printk("AUN: socket error %d\n", -error);
1016 return error;
1017 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 udpsock->sk->sk_reuse = 1;
1020 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1021 from interrupts */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001022
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1024 sizeof(sin));
1025 if (error < 0)
1026 {
1027 printk("AUN: bind error %d\n", -error);
1028 goto release;
1029 }
1030
1031 udpsock->sk->sk_data_ready = aun_data_available;
1032
1033 return 0;
1034
1035release:
1036 sock_release(udpsock);
1037 udpsock = NULL;
1038 return error;
1039}
1040#endif
1041
1042#ifdef CONFIG_ECONET_NATIVE
1043
1044/*
1045 * Receive an Econet frame from a device.
1046 */
1047
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001048static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049{
1050 struct ec_framehdr *hdr;
1051 struct sock *sk;
1052 struct ec_device *edev = dev->ec_ptr;
1053
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -07001054 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane730c152007-09-17 11:53:39 -07001055 goto drop;
1056
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 if (skb->pkt_type == PACKET_OTHERHOST)
1058 goto drop;
1059
1060 if (!edev)
1061 goto drop;
1062
1063 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1064 return NET_RX_DROP;
1065
1066 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1067 goto drop;
1068
1069 hdr = (struct ec_framehdr *) skb->data;
1070
1071 /* First check for encapsulated IP */
1072 if (hdr->port == EC_PORT_IP) {
1073 skb->protocol = htons(ETH_P_IP);
1074 skb_pull(skb, sizeof(struct ec_framehdr));
1075 netif_rx(skb);
Mark Smith482d8042009-07-06 11:05:58 +00001076 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 }
1078
1079 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1080 if (!sk)
1081 goto drop;
1082
1083 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1084 hdr->port))
1085 goto drop;
1086
Mark Smith482d8042009-07-06 11:05:58 +00001087 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
1089drop:
1090 kfree_skb(skb);
1091 return NET_RX_DROP;
1092}
1093
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001094static struct packet_type econet_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001095 .type = cpu_to_be16(ETH_P_ECONET),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 .func = econet_rcv,
1097};
1098
1099static void econet_hw_initialise(void)
1100{
1101 dev_add_pack(&econet_packet_type);
1102}
1103
1104#endif
1105
1106static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1107{
1108 struct net_device *dev = (struct net_device *)data;
1109 struct ec_device *edev;
1110
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -07001111 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001112 return NOTIFY_DONE;
1113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 switch (msg) {
1115 case NETDEV_UNREGISTER:
1116 /* A device has gone down - kill any data we hold for it. */
1117 edev = dev->ec_ptr;
1118 if (edev)
1119 {
1120 if (net2dev_map[0] == dev)
1121 net2dev_map[0] = NULL;
1122 net2dev_map[edev->net] = NULL;
1123 kfree(edev);
1124 dev->ec_ptr = NULL;
1125 }
1126 break;
1127 }
1128
1129 return NOTIFY_DONE;
1130}
1131
1132static struct notifier_block econet_netdev_notifier = {
1133 .notifier_call =econet_notifier,
1134};
1135
1136static void __exit econet_proto_exit(void)
1137{
1138#ifdef CONFIG_ECONET_AUNUDP
1139 del_timer(&ab_cleanup_timer);
1140 if (udpsock)
1141 sock_release(udpsock);
1142#endif
1143 unregister_netdevice_notifier(&econet_netdev_notifier);
Alexey Dobriyan9c29a372007-08-14 17:25:20 -07001144#ifdef CONFIG_ECONET_NATIVE
1145 dev_remove_pack(&econet_packet_type);
1146#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 sock_unregister(econet_family_ops.family);
1148 proto_unregister(&econet_proto);
1149}
1150
1151static int __init econet_proto_init(void)
1152{
1153 int err = proto_register(&econet_proto, 0);
1154
1155 if (err != 0)
1156 goto out;
1157 sock_register(&econet_family_ops);
1158#ifdef CONFIG_ECONET_AUNUDP
1159 spin_lock_init(&aun_queue_lock);
1160 aun_udp_initialise();
1161#endif
1162#ifdef CONFIG_ECONET_NATIVE
1163 econet_hw_initialise();
1164#endif
1165 register_netdevice_notifier(&econet_netdev_notifier);
1166out:
1167 return err;
1168}
1169
1170module_init(econet_proto_init);
1171module_exit(econet_proto_exit);
1172
1173MODULE_LICENSE("GPL");
1174MODULE_ALIAS_NETPROTO(PF_ECONET);