blob: bc0f6252613f1adc43aa72258831a39989b4c39e [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
343 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_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
David S. Miller1d181832006-03-28 00:01:55 -0800523 mutex_lock(&econet_mutex);
524
525 sk = sock->sk;
526 eo = ec_sk(sk);
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 sec->sec_family = AF_ECONET;
529 sec->port = eo->port;
530 sec->addr.station = eo->station;
531 sec->addr.net = eo->net;
532
David S. Miller1d181832006-03-28 00:01:55 -0800533 mutex_unlock(&econet_mutex);
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 *uaddr_len = sizeof(*sec);
536 return 0;
537}
538
539static void econet_destroy_timer(unsigned long data)
540{
541 struct sock *sk=(struct sock *)data;
542
543 if (!atomic_read(&sk->sk_wmem_alloc) &&
544 !atomic_read(&sk->sk_rmem_alloc)) {
545 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
576 sock->sk = NULL;
577 sk->sk_socket = NULL;
578 sock_set_flag(sk, SOCK_DEAD);
579
580 /* Purge queues */
581
582 skb_queue_purge(&sk->sk_receive_queue);
583
584 if (atomic_read(&sk->sk_rmem_alloc) ||
585 atomic_read(&sk->sk_wmem_alloc)) {
586 sk->sk_timer.data = (unsigned long)sk;
587 sk->sk_timer.expires = jiffies + HZ;
588 sk->sk_timer.function = econet_destroy_timer;
589 add_timer(&sk->sk_timer);
David S. Miller1d181832006-03-28 00:01:55 -0800590
591 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
593
594 sk_free(sk);
David S. Miller1d181832006-03-28 00:01:55 -0800595
596out_unlock:
597 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 return 0;
599}
600
601static struct proto econet_proto = {
602 .name = "ECONET",
603 .owner = THIS_MODULE,
604 .obj_size = sizeof(struct econet_sock),
605};
606
607/*
608 * Create an Econet socket
609 */
610
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700611static int econet_create(struct net *net, struct socket *sock, int protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
613 struct sock *sk;
614 struct econet_sock *eo;
615 int err;
616
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700617 if (net != &init_net)
618 return -EAFNOSUPPORT;
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 /* Econet only provides datagram services. */
621 if (sock->type != SOCK_DGRAM)
622 return -ESOCKTNOSUPPORT;
623
624 sock->state = SS_UNCONNECTED;
625
626 err = -ENOBUFS;
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700627 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 if (sk == NULL)
629 goto out;
630
631 sk->sk_reuse = 1;
632 sock->ops = &econet_ops;
633 sock_init_data(sock, sk);
634
635 eo = ec_sk(sk);
636 sock_reset_flag(sk, SOCK_ZAPPED);
637 sk->sk_family = PF_ECONET;
638 eo->num = protocol;
639
640 econet_insert_socket(&econet_sklist, sk);
641 return(0);
642out:
643 return err;
644}
645
646/*
647 * Handle Econet specific ioctls
648 */
649
650static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
651{
652 struct ifreq ifr;
653 struct ec_device *edev;
654 struct net_device *dev;
655 struct sockaddr_ec *sec;
David S. Miller1d181832006-03-28 00:01:55 -0800656 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 /*
659 * Fetch the caller's info block into kernel space
660 */
661
662 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
663 return -EFAULT;
664
Eric W. Biederman881d9662007-09-17 11:56:21 -0700665 if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 return -ENODEV;
667
668 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
669
David S. Miller1d181832006-03-28 00:01:55 -0800670 mutex_lock(&econet_mutex);
671
672 err = 0;
673 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 case SIOCSIFADDR:
675 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800676 if (edev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /* Magic up a new one. */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700678 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 if (edev == NULL) {
David S. Miller1d181832006-03-28 00:01:55 -0800680 err = -ENOMEM;
681 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 dev->ec_ptr = edev;
David S. Miller1d181832006-03-28 00:01:55 -0800684 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 net2dev_map[edev->net] = NULL;
686 edev->station = sec->addr.station;
687 edev->net = sec->addr.net;
688 net2dev_map[sec->addr.net] = dev;
689 if (!net2dev_map[0])
690 net2dev_map[0] = dev;
David S. Miller1d181832006-03-28 00:01:55 -0800691 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 case SIOCGIFADDR:
694 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800695 if (edev == NULL) {
696 err = -ENODEV;
697 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 }
699 memset(sec, 0, sizeof(struct sockaddr_ec));
700 sec->addr.station = edev->station;
701 sec->addr.net = edev->net;
702 sec->sec_family = AF_ECONET;
703 dev_put(dev);
704 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
David S. Miller1d181832006-03-28 00:01:55 -0800705 err = -EFAULT;
706 break;
707
708 default:
709 err = -EINVAL;
710 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 }
712
David S. Miller1d181832006-03-28 00:01:55 -0800713 mutex_unlock(&econet_mutex);
714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800716
717 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720/*
721 * Handle generic ioctls
722 */
723
724static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
725{
726 struct sock *sk = sock->sk;
727 void __user *argp = (void __user *)arg;
728
729 switch(cmd) {
730 case SIOCGSTAMP:
731 return sock_get_timestamp(sk, argp);
732
Eric Dumazetae40eb12007-03-18 17:33:16 -0700733 case SIOCGSTAMPNS:
734 return sock_get_timestampns(sk, argp);
735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 case SIOCSIFADDR:
737 case SIOCGIFADDR:
738 return ec_dev_ioctl(sock, cmd, argp);
739 break;
740
741 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -0800742 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
744 /*NOTREACHED*/
745 return 0;
746}
747
748static struct net_proto_family econet_family_ops = {
749 .family = PF_ECONET,
750 .create = econet_create,
751 .owner = THIS_MODULE,
752};
753
David S. Miller1d181832006-03-28 00:01:55 -0800754static const struct proto_ops econet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 .family = PF_ECONET,
756 .owner = THIS_MODULE,
757 .release = econet_release,
758 .bind = econet_bind,
759 .connect = sock_no_connect,
760 .socketpair = sock_no_socketpair,
761 .accept = sock_no_accept,
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900762 .getname = econet_getname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 .poll = datagram_poll,
764 .ioctl = econet_ioctl,
765 .listen = sock_no_listen,
766 .shutdown = sock_no_shutdown,
767 .setsockopt = sock_no_setsockopt,
768 .getsockopt = sock_no_getsockopt,
769 .sendmsg = econet_sendmsg,
770 .recvmsg = econet_recvmsg,
771 .mmap = sock_no_mmap,
772 .sendpage = sock_no_sendpage,
773};
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
776/*
777 * Find the listening socket, if any, for the given data.
778 */
779
780static struct sock *ec_listening_socket(unsigned char port, unsigned char
781 station, unsigned char net)
782{
783 struct sock *sk;
784 struct hlist_node *node;
785
786 sk_for_each(sk, node, &econet_sklist) {
787 struct econet_sock *opt = ec_sk(sk);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900788 if ((opt->port == port || opt->port == 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 (opt->station == station || opt->station == 0) &&
790 (opt->net == net || opt->net == 0))
791 goto found;
792 }
793 sk = NULL;
794found:
795 return sk;
796}
797
798/*
799 * Queue a received packet for a socket.
800 */
801
802static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
803 unsigned char stn, unsigned char net,
804 unsigned char cb, unsigned char port)
805{
806 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
807 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
808
809 memset(sec, 0, sizeof(struct sockaddr_ec));
810 sec->sec_family = AF_ECONET;
811 sec->type = ECTYPE_PACKET_RECEIVED;
812 sec->port = port;
813 sec->cb = cb;
814 sec->addr.net = net;
815 sec->addr.station = stn;
816
817 return sock_queue_rcv_skb(sk, skb);
818}
819#endif
820
821#ifdef CONFIG_ECONET_AUNUDP
822/*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900823 * Send an AUN protocol response.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 */
825
826static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
827{
828 struct sockaddr_in sin = {
829 .sin_family = AF_INET,
830 .sin_port = htons(AUN_PORT),
831 .sin_addr = {.s_addr = addr}
832 };
833 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
834 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
835 struct msghdr udpmsg;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 udpmsg.msg_name = (void *)&sin;
838 udpmsg.msg_namelen = sizeof(sin);
839 udpmsg.msg_control = NULL;
840 udpmsg.msg_controllen = 0;
841 udpmsg.msg_flags=0;
842
843 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
844}
845
846
847/*
848 * Handle incoming AUN packets. Work out if anybody wants them,
849 * and send positive or negative acknowledgements as appropriate.
850 */
851
852static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
853{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700854 struct iphdr *ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 unsigned char stn = ntohl(ip->saddr) & 0xff;
856 struct sock *sk;
857 struct sk_buff *newskb;
858 struct ec_device *edev = skb->dev->ec_ptr;
859
860 if (! edev)
861 goto bad;
862
863 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
864 goto bad; /* Nobody wants it */
865
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900866 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 GFP_ATOMIC);
868 if (newskb == NULL)
869 {
870 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
871 /* Send nack and hope sender tries again */
872 goto bad;
873 }
874
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900875 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 len - sizeof(struct aunhdr));
877
878 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
879 {
880 /* Socket is bankrupt. */
881 kfree_skb(newskb);
882 goto bad;
883 }
884
885 aun_send_response(ip->saddr, ah->handle, 3, 0);
886 return;
887
888bad:
889 aun_send_response(ip->saddr, ah->handle, 4, 0);
890}
891
892/*
893 * Handle incoming AUN transmit acknowledgements. If the sequence
894 * number matches something in our backlog then kill it and tell
895 * the user. If the remote took too long to reply then we may have
896 * dropped the packet already.
897 */
898
899static void aun_tx_ack(unsigned long seq, int result)
900{
901 struct sk_buff *skb;
902 unsigned long flags;
903 struct ec_cb *eb;
904
905 spin_lock_irqsave(&aun_queue_lock, flags);
906 skb = skb_peek(&aun_queue);
907 while (skb && skb != (struct sk_buff *)&aun_queue)
908 {
909 struct sk_buff *newskb = skb->next;
910 eb = (struct ec_cb *)&skb->cb;
911 if (eb->seq == seq)
912 goto foundit;
913
914 skb = newskb;
915 }
916 spin_unlock_irqrestore(&aun_queue_lock, flags);
917 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
918 return;
919
920foundit:
921 tx_result(skb->sk, eb->cookie, result);
David S. Miller8728b832005-08-09 19:25:21 -0700922 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 spin_unlock_irqrestore(&aun_queue_lock, flags);
924 kfree_skb(skb);
925}
926
927/*
928 * Deal with received AUN frames - sort out what type of thing it is
929 * and hand it to the right function.
930 */
931
932static void aun_data_available(struct sock *sk, int slen)
933{
934 int err;
935 struct sk_buff *skb;
936 unsigned char *data;
937 struct aunhdr *ah;
938 struct iphdr *ip;
939 size_t len;
940
941 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
942 if (err == -EAGAIN) {
943 printk(KERN_ERR "AUN: no data available?!");
944 return;
945 }
946 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
947 }
948
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700949 data = skb_transport_header(skb) + sizeof(struct udphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 ah = (struct aunhdr *)data;
951 len = skb->len - sizeof(struct udphdr);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700952 ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954 switch (ah->code)
955 {
956 case 2:
957 aun_incoming(skb, ah, len);
958 break;
959 case 3:
960 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
961 break;
962 case 4:
963 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
964 break;
965#if 0
966 /* This isn't quite right yet. */
967 case 5:
968 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
969 break;
970#endif
971 default:
972 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
973 }
974
975 skb_free_datagram(sk, skb);
976}
977
978/*
979 * Called by the timer to manage the AUN transmit queue. If a packet
980 * was sent to a dead or nonexistent host then we will never get an
981 * acknowledgement back. After a few seconds we need to spot this and
982 * drop the packet.
983 */
984
985static void ab_cleanup(unsigned long h)
986{
987 struct sk_buff *skb;
988 unsigned long flags;
989
990 spin_lock_irqsave(&aun_queue_lock, flags);
991 skb = skb_peek(&aun_queue);
992 while (skb && skb != (struct sk_buff *)&aun_queue)
993 {
994 struct sk_buff *newskb = skb->next;
995 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
996 if ((jiffies - eb->start) > eb->timeout)
997 {
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900998 tx_result(skb->sk, eb->cookie,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 ECTYPE_TRANSMIT_NOT_PRESENT);
David S. Miller8728b832005-08-09 19:25:21 -07001000 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 kfree_skb(skb);
1002 }
1003 skb = newskb;
1004 }
1005 spin_unlock_irqrestore(&aun_queue_lock, flags);
1006
1007 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1008}
1009
1010static int __init aun_udp_initialise(void)
1011{
1012 int error;
1013 struct sockaddr_in sin;
1014
1015 skb_queue_head_init(&aun_queue);
1016 spin_lock_init(&aun_queue_lock);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001017 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 ab_cleanup_timer.expires = jiffies + (HZ*2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 add_timer(&ab_cleanup_timer);
1020
1021 memset(&sin, 0, sizeof(sin));
1022 sin.sin_port = htons(AUN_PORT);
1023
1024 /* We can count ourselves lucky Acorn machines are too dim to
1025 speak IPv6. :-) */
1026 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1027 {
1028 printk("AUN: socket error %d\n", -error);
1029 return error;
1030 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 udpsock->sk->sk_reuse = 1;
1033 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1034 from interrupts */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1037 sizeof(sin));
1038 if (error < 0)
1039 {
1040 printk("AUN: bind error %d\n", -error);
1041 goto release;
1042 }
1043
1044 udpsock->sk->sk_data_ready = aun_data_available;
1045
1046 return 0;
1047
1048release:
1049 sock_release(udpsock);
1050 udpsock = NULL;
1051 return error;
1052}
1053#endif
1054
1055#ifdef CONFIG_ECONET_NATIVE
1056
1057/*
1058 * Receive an Econet frame from a device.
1059 */
1060
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001061static 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 -07001062{
1063 struct ec_framehdr *hdr;
1064 struct sock *sk;
1065 struct ec_device *edev = dev->ec_ptr;
1066
Eric W. Biedermane730c152007-09-17 11:53:39 -07001067 if (dev->nd_net != &init_net)
1068 goto drop;
1069
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (skb->pkt_type == PACKET_OTHERHOST)
1071 goto drop;
1072
1073 if (!edev)
1074 goto drop;
1075
1076 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1077 return NET_RX_DROP;
1078
1079 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1080 goto drop;
1081
1082 hdr = (struct ec_framehdr *) skb->data;
1083
1084 /* First check for encapsulated IP */
1085 if (hdr->port == EC_PORT_IP) {
1086 skb->protocol = htons(ETH_P_IP);
1087 skb_pull(skb, sizeof(struct ec_framehdr));
1088 netif_rx(skb);
1089 return 0;
1090 }
1091
1092 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1093 if (!sk)
1094 goto drop;
1095
1096 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1097 hdr->port))
1098 goto drop;
1099
1100 return 0;
1101
1102drop:
1103 kfree_skb(skb);
1104 return NET_RX_DROP;
1105}
1106
1107static struct packet_type econet_packet_type = {
1108 .type = __constant_htons(ETH_P_ECONET),
1109 .func = econet_rcv,
1110};
1111
1112static void econet_hw_initialise(void)
1113{
1114 dev_add_pack(&econet_packet_type);
1115}
1116
1117#endif
1118
1119static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1120{
1121 struct net_device *dev = (struct net_device *)data;
1122 struct ec_device *edev;
1123
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001124 if (dev->nd_net != &init_net)
1125 return NOTIFY_DONE;
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 switch (msg) {
1128 case NETDEV_UNREGISTER:
1129 /* A device has gone down - kill any data we hold for it. */
1130 edev = dev->ec_ptr;
1131 if (edev)
1132 {
1133 if (net2dev_map[0] == dev)
1134 net2dev_map[0] = NULL;
1135 net2dev_map[edev->net] = NULL;
1136 kfree(edev);
1137 dev->ec_ptr = NULL;
1138 }
1139 break;
1140 }
1141
1142 return NOTIFY_DONE;
1143}
1144
1145static struct notifier_block econet_netdev_notifier = {
1146 .notifier_call =econet_notifier,
1147};
1148
1149static void __exit econet_proto_exit(void)
1150{
1151#ifdef CONFIG_ECONET_AUNUDP
1152 del_timer(&ab_cleanup_timer);
1153 if (udpsock)
1154 sock_release(udpsock);
1155#endif
1156 unregister_netdevice_notifier(&econet_netdev_notifier);
Alexey Dobriyan9c29a372007-08-14 17:25:20 -07001157#ifdef CONFIG_ECONET_NATIVE
1158 dev_remove_pack(&econet_packet_type);
1159#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 sock_unregister(econet_family_ops.family);
1161 proto_unregister(&econet_proto);
1162}
1163
1164static int __init econet_proto_init(void)
1165{
1166 int err = proto_register(&econet_proto, 0);
1167
1168 if (err != 0)
1169 goto out;
1170 sock_register(&econet_family_ops);
1171#ifdef CONFIG_ECONET_AUNUDP
1172 spin_lock_init(&aun_queue_lock);
1173 aun_udp_initialise();
1174#endif
1175#ifdef CONFIG_ECONET_NATIVE
1176 econet_hw_initialise();
1177#endif
1178 register_netdevice_notifier(&econet_netdev_notifier);
1179out:
1180 return err;
1181}
1182
1183module_init(econet_proto_init);
1184module_exit(econet_proto_exit);
1185
1186MODULE_LICENSE("GPL");
1187MODULE_ALIAS_NETPROTO(PF_ECONET);