ia64/linux-2.6.18-xen.hg

view net/econet/af_econet.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /*
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 */
12 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/string.h>
18 #include <linux/mm.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
21 #include <linux/in.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <linux/if_ether.h>
25 #include <linux/netdevice.h>
26 #include <linux/inetdevice.h>
27 #include <linux/route.h>
28 #include <linux/inet.h>
29 #include <linux/etherdevice.h>
30 #include <linux/if_arp.h>
31 #include <linux/wireless.h>
32 #include <linux/skbuff.h>
33 #include <linux/udp.h>
34 #include <net/sock.h>
35 #include <net/inet_common.h>
36 #include <linux/stat.h>
37 #include <linux/init.h>
38 #include <linux/if_ec.h>
39 #include <net/udp.h>
40 #include <net/ip.h>
41 #include <linux/spinlock.h>
42 #include <linux/rcupdate.h>
43 #include <linux/bitops.h>
44 #include <linux/mutex.h>
46 #include <asm/uaccess.h>
47 #include <asm/system.h>
49 static const struct proto_ops econet_ops;
50 static struct hlist_head econet_sklist;
51 static DEFINE_RWLOCK(econet_lock);
52 static DEFINE_MUTEX(econet_mutex);
54 /* Since there are only 256 possible network numbers (or fewer, depends
55 how you count) it makes sense to use a simple lookup table. */
56 static struct net_device *net2dev_map[256];
58 #define EC_PORT_IP 0xd2
60 #ifdef CONFIG_ECONET_AUNUDP
61 static DEFINE_SPINLOCK(aun_queue_lock);
62 static struct socket *udpsock;
63 #define AUN_PORT 0x8000
66 struct aunhdr
67 {
68 unsigned char code; /* AUN magic protocol byte */
69 unsigned char port;
70 unsigned char cb;
71 unsigned char pad;
72 unsigned long handle;
73 };
75 static unsigned long aun_seq;
77 /* Queue of packets waiting to be transmitted. */
78 static struct sk_buff_head aun_queue;
79 static struct timer_list ab_cleanup_timer;
81 #endif /* CONFIG_ECONET_AUNUDP */
83 /* Per-packet information */
84 struct ec_cb
85 {
86 struct sockaddr_ec sec;
87 unsigned long cookie; /* Supplied by user. */
88 #ifdef CONFIG_ECONET_AUNUDP
89 int done;
90 unsigned long seq; /* Sequencing */
91 unsigned long timeout; /* Timeout */
92 unsigned long start; /* jiffies */
93 #endif
94 #ifdef CONFIG_ECONET_NATIVE
95 void (*sent)(struct sk_buff *, int result);
96 #endif
97 };
99 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
100 {
101 write_lock_bh(&econet_lock);
102 sk_del_node_init(sk);
103 write_unlock_bh(&econet_lock);
104 }
106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
107 {
108 write_lock_bh(&econet_lock);
109 sk_add_node(sk, list);
110 write_unlock_bh(&econet_lock);
111 }
113 /*
114 * Pull a packet from our receive queue and hand it to the user.
115 * If necessary we block.
116 */
118 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
119 struct msghdr *msg, size_t len, int flags)
120 {
121 struct sock *sk = sock->sk;
122 struct sk_buff *skb;
123 size_t copied;
124 int err;
126 msg->msg_namelen = sizeof(struct sockaddr_ec);
128 mutex_lock(&econet_mutex);
130 /*
131 * Call the generic datagram receiver. This handles all sorts
132 * of horrible races and re-entrancy so we can forget about it
133 * in the protocol layers.
134 *
135 * Now it will return ENETDOWN, if device have just gone down,
136 * but then it will block.
137 */
139 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
141 /*
142 * An error occurred so return it. Because skb_recv_datagram()
143 * handles the blocking we don't see and worry about blocking
144 * retries.
145 */
147 if(skb==NULL)
148 goto out;
150 /*
151 * You lose any data beyond the buffer you gave. If it worries a
152 * user program they can ask the device for its MTU anyway.
153 */
155 copied = skb->len;
156 if (copied > len)
157 {
158 copied=len;
159 msg->msg_flags|=MSG_TRUNC;
160 }
162 /* We can't use skb_copy_datagram here */
163 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
164 if (err)
165 goto out_free;
166 skb_get_timestamp(skb, &sk->sk_stamp);
168 if (msg->msg_name)
169 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
171 /*
172 * Free or return the buffer as appropriate. Again this
173 * hides all the races and re-entrancy issues from us.
174 */
175 err = copied;
177 out_free:
178 skb_free_datagram(sk, skb);
179 out:
180 mutex_unlock(&econet_mutex);
181 return err;
182 }
184 /*
185 * Bind an Econet socket.
186 */
188 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
189 {
190 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
191 struct sock *sk;
192 struct econet_sock *eo;
194 /*
195 * Check legality
196 */
198 if (addr_len < sizeof(struct sockaddr_ec) ||
199 sec->sec_family != AF_ECONET)
200 return -EINVAL;
202 mutex_lock(&econet_mutex);
204 sk = sock->sk;
205 eo = ec_sk(sk);
207 eo->cb = sec->cb;
208 eo->port = sec->port;
209 eo->station = sec->addr.station;
210 eo->net = sec->addr.net;
212 mutex_unlock(&econet_mutex);
214 return 0;
215 }
217 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
218 /*
219 * Queue a transmit result for the user to be told about.
220 */
222 static void tx_result(struct sock *sk, unsigned long cookie, int result)
223 {
224 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
225 struct ec_cb *eb;
226 struct sockaddr_ec *sec;
228 if (skb == NULL)
229 {
230 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
231 return;
232 }
234 eb = (struct ec_cb *)&skb->cb;
235 sec = (struct sockaddr_ec *)&eb->sec;
236 memset(sec, 0, sizeof(struct sockaddr_ec));
237 sec->cookie = cookie;
238 sec->type = ECTYPE_TRANSMIT_STATUS | result;
239 sec->sec_family = AF_ECONET;
241 if (sock_queue_rcv_skb(sk, skb) < 0)
242 kfree_skb(skb);
243 }
244 #endif
246 #ifdef CONFIG_ECONET_NATIVE
247 /*
248 * Called by the Econet hardware driver when a packet transmit
249 * has completed. Tell the user.
250 */
252 static void ec_tx_done(struct sk_buff *skb, int result)
253 {
254 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
255 tx_result(skb->sk, eb->cookie, result);
256 }
257 #endif
259 /*
260 * Send a packet. We have to work out which device it's going out on
261 * and hence whether to use real Econet or the UDP emulation.
262 */
264 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
265 struct msghdr *msg, size_t len)
266 {
267 struct sock *sk = sock->sk;
268 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
269 struct net_device *dev;
270 struct ec_addr addr;
271 int err;
272 unsigned char port, cb;
273 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
274 struct sk_buff *skb;
275 struct ec_cb *eb;
276 #endif
277 #ifdef CONFIG_ECONET_AUNUDP
278 struct msghdr udpmsg;
279 struct iovec iov[msg->msg_iovlen+1];
280 struct aunhdr ah;
281 struct sockaddr_in udpdest;
282 __kernel_size_t size;
283 int i;
284 mm_segment_t oldfs;
285 #endif
287 /*
288 * Check the flags.
289 */
291 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
292 return -EINVAL;
294 /*
295 * Get and verify the address.
296 */
298 mutex_lock(&econet_mutex);
300 if (saddr == NULL) {
301 struct econet_sock *eo = ec_sk(sk);
303 addr.station = eo->station;
304 addr.net = eo->net;
305 port = eo->port;
306 cb = eo->cb;
307 } else {
308 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
309 mutex_unlock(&econet_mutex);
310 return -EINVAL;
311 }
312 addr.station = saddr->addr.station;
313 addr.net = saddr->addr.net;
314 port = saddr->port;
315 cb = saddr->cb;
316 }
318 /* Look for a device with the right network number. */
319 dev = net2dev_map[addr.net];
321 /* If not directly reachable, use some default */
322 if (dev == NULL) {
323 dev = net2dev_map[0];
324 /* No interfaces at all? */
325 if (dev == NULL) {
326 mutex_unlock(&econet_mutex);
327 return -ENETDOWN;
328 }
329 }
331 if (len + 15 > dev->mtu) {
332 mutex_unlock(&econet_mutex);
333 return -EMSGSIZE;
334 }
336 if (dev->type == ARPHRD_ECONET) {
337 /* Real hardware Econet. We're not worthy etc. */
338 #ifdef CONFIG_ECONET_NATIVE
339 unsigned short proto = 0;
341 dev_hold(dev);
343 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
344 msg->msg_flags & MSG_DONTWAIT, &err);
345 if (skb==NULL)
346 goto out_unlock;
348 skb_reserve(skb, LL_RESERVED_SPACE(dev));
349 skb->nh.raw = skb->data;
351 eb = (struct ec_cb *)&skb->cb;
353 /* BUG: saddr may be NULL */
354 eb->cookie = saddr->cookie;
355 eb->sec = *saddr;
356 eb->sent = ec_tx_done;
358 if (dev->hard_header) {
359 int res;
360 struct ec_framehdr *fh;
361 err = -EINVAL;
362 res = dev->hard_header(skb, dev, ntohs(proto),
363 &addr, NULL, len);
364 /* 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) {
370 skb->tail = skb->data;
371 skb->len = 0;
372 } else if (res < 0)
373 goto out_free;
374 }
376 /* Copy the data. Returns -EFAULT on error */
377 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
378 skb->protocol = proto;
379 skb->dev = dev;
380 skb->priority = sk->sk_priority;
381 if (err)
382 goto out_free;
384 err = -ENETDOWN;
385 if (!(dev->flags & IFF_UP))
386 goto out_free;
388 /*
389 * Now send it
390 */
392 dev_queue_xmit(skb);
393 dev_put(dev);
394 mutex_unlock(&econet_mutex);
395 return(len);
397 out_free:
398 kfree_skb(skb);
399 out_unlock:
400 if (dev)
401 dev_put(dev);
402 #else
403 err = -EPROTOTYPE;
404 #endif
405 mutex_unlock(&econet_mutex);
407 return err;
408 }
410 #ifdef CONFIG_ECONET_AUNUDP
411 /* AUN virtual Econet. */
413 if (udpsock == NULL) {
414 mutex_unlock(&econet_mutex);
415 return -ENETDOWN; /* No socket - can't send */
416 }
418 /* Make up a UDP datagram and hand it off to some higher intellect. */
420 memset(&udpdest, 0, sizeof(udpdest));
421 udpdest.sin_family = AF_INET;
422 udpdest.sin_port = htons(AUN_PORT);
424 /* At the moment we use the stupid Acorn scheme of Econet address
425 y.x maps to IP a.b.c.x. This should be replaced with something
426 more flexible and more aware of subnet masks. */
427 {
428 struct in_device *idev;
429 unsigned long network = 0;
431 rcu_read_lock();
432 idev = __in_dev_get_rcu(dev);
433 if (idev) {
434 if (idev->ifa_list)
435 network = ntohl(idev->ifa_list->ifa_address) &
436 0xffffff00; /* !!! */
437 }
438 rcu_read_unlock();
439 udpdest.sin_addr.s_addr = htonl(network | addr.station);
440 }
442 ah.port = port;
443 ah.cb = cb & 0x7f;
444 ah.code = 2; /* magic */
445 ah.pad = 0;
447 /* tack our header on the front of the iovec */
448 size = sizeof(struct aunhdr);
449 /*
450 * XXX: that is b0rken. We can't mix userland and kernel pointers
451 * in iovec, since on a lot of platforms copy_from_user() will
452 * *not* work with the kernel and userland ones at the same time,
453 * regardless of what we do with set_fs(). And we are talking about
454 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
455 * apply. Any suggestions on fixing that code? -- AV
456 */
457 iov[0].iov_base = (void *)&ah;
458 iov[0].iov_len = size;
459 for (i = 0; i < msg->msg_iovlen; i++) {
460 void __user *base = msg->msg_iov[i].iov_base;
461 size_t len = msg->msg_iov[i].iov_len;
462 /* Check it now since we switch to KERNEL_DS later. */
463 if (!access_ok(VERIFY_READ, base, len)) {
464 mutex_unlock(&econet_mutex);
465 return -EFAULT;
466 }
467 iov[i+1].iov_base = base;
468 iov[i+1].iov_len = len;
469 size += len;
470 }
472 /* Get a skbuff (no data, just holds our cb information) */
473 if ((skb = sock_alloc_send_skb(sk, 0,
474 msg->msg_flags & MSG_DONTWAIT,
475 &err)) == NULL) {
476 mutex_unlock(&econet_mutex);
477 return err;
478 }
480 eb = (struct ec_cb *)&skb->cb;
482 eb->cookie = saddr->cookie;
483 eb->timeout = (5*HZ);
484 eb->start = jiffies;
485 ah.handle = aun_seq;
486 eb->seq = (aun_seq++);
487 eb->sec = *saddr;
489 skb_queue_tail(&aun_queue, skb);
491 udpmsg.msg_name = (void *)&udpdest;
492 udpmsg.msg_namelen = sizeof(udpdest);
493 udpmsg.msg_iov = &iov[0];
494 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
495 udpmsg.msg_control = NULL;
496 udpmsg.msg_controllen = 0;
497 udpmsg.msg_flags=0;
499 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
500 err = sock_sendmsg(udpsock, &udpmsg, size);
501 set_fs(oldfs);
502 #else
503 err = -EPROTOTYPE;
504 #endif
505 mutex_unlock(&econet_mutex);
507 return err;
508 }
510 /*
511 * Look up the address of a socket.
512 */
514 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
515 int *uaddr_len, int peer)
516 {
517 struct sock *sk;
518 struct econet_sock *eo;
519 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
521 if (peer)
522 return -EOPNOTSUPP;
524 mutex_lock(&econet_mutex);
526 sk = sock->sk;
527 eo = ec_sk(sk);
529 sec->sec_family = AF_ECONET;
530 sec->port = eo->port;
531 sec->addr.station = eo->station;
532 sec->addr.net = eo->net;
534 mutex_unlock(&econet_mutex);
536 *uaddr_len = sizeof(*sec);
537 return 0;
538 }
540 static void econet_destroy_timer(unsigned long data)
541 {
542 struct sock *sk=(struct sock *)data;
544 if (!atomic_read(&sk->sk_wmem_alloc) &&
545 !atomic_read(&sk->sk_rmem_alloc)) {
546 sk_free(sk);
547 return;
548 }
550 sk->sk_timer.expires = jiffies + 10 * HZ;
551 add_timer(&sk->sk_timer);
552 printk(KERN_DEBUG "econet socket destroy delayed\n");
553 }
555 /*
556 * Close an econet socket.
557 */
559 static int econet_release(struct socket *sock)
560 {
561 struct sock *sk;
563 mutex_lock(&econet_mutex);
565 sk = sock->sk;
566 if (!sk)
567 goto out_unlock;
569 econet_remove_socket(&econet_sklist, sk);
571 /*
572 * Now the socket is dead. No more input will appear.
573 */
575 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
577 sock->sk = NULL;
578 sk->sk_socket = NULL;
579 sock_set_flag(sk, SOCK_DEAD);
581 /* Purge queues */
583 skb_queue_purge(&sk->sk_receive_queue);
585 if (atomic_read(&sk->sk_rmem_alloc) ||
586 atomic_read(&sk->sk_wmem_alloc)) {
587 sk->sk_timer.data = (unsigned long)sk;
588 sk->sk_timer.expires = jiffies + HZ;
589 sk->sk_timer.function = econet_destroy_timer;
590 add_timer(&sk->sk_timer);
592 goto out_unlock;
593 }
595 sk_free(sk);
597 out_unlock:
598 mutex_unlock(&econet_mutex);
599 return 0;
600 }
602 static struct proto econet_proto = {
603 .name = "ECONET",
604 .owner = THIS_MODULE,
605 .obj_size = sizeof(struct econet_sock),
606 };
608 /*
609 * Create an Econet socket
610 */
612 static int econet_create(struct socket *sock, int protocol)
613 {
614 struct sock *sk;
615 struct econet_sock *eo;
616 int err;
618 /* Econet only provides datagram services. */
619 if (sock->type != SOCK_DGRAM)
620 return -ESOCKTNOSUPPORT;
622 sock->state = SS_UNCONNECTED;
624 err = -ENOBUFS;
625 sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
626 if (sk == NULL)
627 goto out;
629 sk->sk_reuse = 1;
630 sock->ops = &econet_ops;
631 sock_init_data(sock, sk);
633 eo = ec_sk(sk);
634 sock_reset_flag(sk, SOCK_ZAPPED);
635 sk->sk_family = PF_ECONET;
636 eo->num = protocol;
638 econet_insert_socket(&econet_sklist, sk);
639 return(0);
640 out:
641 return err;
642 }
644 /*
645 * Handle Econet specific ioctls
646 */
648 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
649 {
650 struct ifreq ifr;
651 struct ec_device *edev;
652 struct net_device *dev;
653 struct sockaddr_ec *sec;
654 int err;
656 /*
657 * Fetch the caller's info block into kernel space
658 */
660 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
661 return -EFAULT;
663 if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
664 return -ENODEV;
666 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
668 mutex_lock(&econet_mutex);
670 err = 0;
671 switch (cmd) {
672 case SIOCSIFADDR:
673 edev = dev->ec_ptr;
674 if (edev == NULL) {
675 /* Magic up a new one. */
676 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
677 if (edev == NULL) {
678 err = -ENOMEM;
679 break;
680 }
681 dev->ec_ptr = edev;
682 } else
683 net2dev_map[edev->net] = NULL;
684 edev->station = sec->addr.station;
685 edev->net = sec->addr.net;
686 net2dev_map[sec->addr.net] = dev;
687 if (!net2dev_map[0])
688 net2dev_map[0] = dev;
689 break;
691 case SIOCGIFADDR:
692 edev = dev->ec_ptr;
693 if (edev == NULL) {
694 err = -ENODEV;
695 break;
696 }
697 memset(sec, 0, sizeof(struct sockaddr_ec));
698 sec->addr.station = edev->station;
699 sec->addr.net = edev->net;
700 sec->sec_family = AF_ECONET;
701 dev_put(dev);
702 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
703 err = -EFAULT;
704 break;
706 default:
707 err = -EINVAL;
708 break;
709 }
711 mutex_unlock(&econet_mutex);
713 dev_put(dev);
715 return err;
716 }
718 /*
719 * Handle generic ioctls
720 */
722 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
723 {
724 struct sock *sk = sock->sk;
725 void __user *argp = (void __user *)arg;
727 switch(cmd) {
728 case SIOCGSTAMP:
729 return sock_get_timestamp(sk, argp);
731 case SIOCSIFADDR:
732 case SIOCGIFADDR:
733 return ec_dev_ioctl(sock, cmd, argp);
734 break;
736 default:
737 return -ENOIOCTLCMD;
738 }
739 /*NOTREACHED*/
740 return 0;
741 }
743 static struct net_proto_family econet_family_ops = {
744 .family = PF_ECONET,
745 .create = econet_create,
746 .owner = THIS_MODULE,
747 };
749 static const struct proto_ops econet_ops = {
750 .family = PF_ECONET,
751 .owner = THIS_MODULE,
752 .release = econet_release,
753 .bind = econet_bind,
754 .connect = sock_no_connect,
755 .socketpair = sock_no_socketpair,
756 .accept = sock_no_accept,
757 .getname = econet_getname,
758 .poll = datagram_poll,
759 .ioctl = econet_ioctl,
760 .listen = sock_no_listen,
761 .shutdown = sock_no_shutdown,
762 .setsockopt = sock_no_setsockopt,
763 .getsockopt = sock_no_getsockopt,
764 .sendmsg = econet_sendmsg,
765 .recvmsg = econet_recvmsg,
766 .mmap = sock_no_mmap,
767 .sendpage = sock_no_sendpage,
768 };
770 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
771 /*
772 * Find the listening socket, if any, for the given data.
773 */
775 static struct sock *ec_listening_socket(unsigned char port, unsigned char
776 station, unsigned char net)
777 {
778 struct sock *sk;
779 struct hlist_node *node;
781 sk_for_each(sk, node, &econet_sklist) {
782 struct econet_sock *opt = ec_sk(sk);
783 if ((opt->port == port || opt->port == 0) &&
784 (opt->station == station || opt->station == 0) &&
785 (opt->net == net || opt->net == 0))
786 goto found;
787 }
788 sk = NULL;
789 found:
790 return sk;
791 }
793 /*
794 * Queue a received packet for a socket.
795 */
797 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
798 unsigned char stn, unsigned char net,
799 unsigned char cb, unsigned char port)
800 {
801 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
802 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
804 memset(sec, 0, sizeof(struct sockaddr_ec));
805 sec->sec_family = AF_ECONET;
806 sec->type = ECTYPE_PACKET_RECEIVED;
807 sec->port = port;
808 sec->cb = cb;
809 sec->addr.net = net;
810 sec->addr.station = stn;
812 return sock_queue_rcv_skb(sk, skb);
813 }
814 #endif
816 #ifdef CONFIG_ECONET_AUNUDP
817 /*
818 * Send an AUN protocol response.
819 */
821 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
822 {
823 struct sockaddr_in sin = {
824 .sin_family = AF_INET,
825 .sin_port = htons(AUN_PORT),
826 .sin_addr = {.s_addr = addr}
827 };
828 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
829 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
830 struct msghdr udpmsg;
832 udpmsg.msg_name = (void *)&sin;
833 udpmsg.msg_namelen = sizeof(sin);
834 udpmsg.msg_control = NULL;
835 udpmsg.msg_controllen = 0;
836 udpmsg.msg_flags=0;
838 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
839 }
842 /*
843 * Handle incoming AUN packets. Work out if anybody wants them,
844 * and send positive or negative acknowledgements as appropriate.
845 */
847 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
848 {
849 struct iphdr *ip = skb->nh.iph;
850 unsigned char stn = ntohl(ip->saddr) & 0xff;
851 struct sock *sk;
852 struct sk_buff *newskb;
853 struct ec_device *edev = skb->dev->ec_ptr;
855 if (! edev)
856 goto bad;
858 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
859 goto bad; /* Nobody wants it */
861 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
862 GFP_ATOMIC);
863 if (newskb == NULL)
864 {
865 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
866 /* Send nack and hope sender tries again */
867 goto bad;
868 }
870 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
871 len - sizeof(struct aunhdr));
873 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
874 {
875 /* Socket is bankrupt. */
876 kfree_skb(newskb);
877 goto bad;
878 }
880 aun_send_response(ip->saddr, ah->handle, 3, 0);
881 return;
883 bad:
884 aun_send_response(ip->saddr, ah->handle, 4, 0);
885 }
887 /*
888 * Handle incoming AUN transmit acknowledgements. If the sequence
889 * number matches something in our backlog then kill it and tell
890 * the user. If the remote took too long to reply then we may have
891 * dropped the packet already.
892 */
894 static void aun_tx_ack(unsigned long seq, int result)
895 {
896 struct sk_buff *skb;
897 unsigned long flags;
898 struct ec_cb *eb;
900 spin_lock_irqsave(&aun_queue_lock, flags);
901 skb = skb_peek(&aun_queue);
902 while (skb && skb != (struct sk_buff *)&aun_queue)
903 {
904 struct sk_buff *newskb = skb->next;
905 eb = (struct ec_cb *)&skb->cb;
906 if (eb->seq == seq)
907 goto foundit;
909 skb = newskb;
910 }
911 spin_unlock_irqrestore(&aun_queue_lock, flags);
912 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
913 return;
915 foundit:
916 tx_result(skb->sk, eb->cookie, result);
917 skb_unlink(skb, &aun_queue);
918 spin_unlock_irqrestore(&aun_queue_lock, flags);
919 kfree_skb(skb);
920 }
922 /*
923 * Deal with received AUN frames - sort out what type of thing it is
924 * and hand it to the right function.
925 */
927 static void aun_data_available(struct sock *sk, int slen)
928 {
929 int err;
930 struct sk_buff *skb;
931 unsigned char *data;
932 struct aunhdr *ah;
933 struct iphdr *ip;
934 size_t len;
936 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
937 if (err == -EAGAIN) {
938 printk(KERN_ERR "AUN: no data available?!");
939 return;
940 }
941 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
942 }
944 data = skb->h.raw + sizeof(struct udphdr);
945 ah = (struct aunhdr *)data;
946 len = skb->len - sizeof(struct udphdr);
947 ip = skb->nh.iph;
949 switch (ah->code)
950 {
951 case 2:
952 aun_incoming(skb, ah, len);
953 break;
954 case 3:
955 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
956 break;
957 case 4:
958 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
959 break;
960 #if 0
961 /* This isn't quite right yet. */
962 case 5:
963 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
964 break;
965 #endif
966 default:
967 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
968 }
970 skb_free_datagram(sk, skb);
971 }
973 /*
974 * Called by the timer to manage the AUN transmit queue. If a packet
975 * was sent to a dead or nonexistent host then we will never get an
976 * acknowledgement back. After a few seconds we need to spot this and
977 * drop the packet.
978 */
980 static void ab_cleanup(unsigned long h)
981 {
982 struct sk_buff *skb;
983 unsigned long flags;
985 spin_lock_irqsave(&aun_queue_lock, flags);
986 skb = skb_peek(&aun_queue);
987 while (skb && skb != (struct sk_buff *)&aun_queue)
988 {
989 struct sk_buff *newskb = skb->next;
990 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
991 if ((jiffies - eb->start) > eb->timeout)
992 {
993 tx_result(skb->sk, eb->cookie,
994 ECTYPE_TRANSMIT_NOT_PRESENT);
995 skb_unlink(skb, &aun_queue);
996 kfree_skb(skb);
997 }
998 skb = newskb;
999 }
1000 spin_unlock_irqrestore(&aun_queue_lock, flags);
1002 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1005 static int __init aun_udp_initialise(void)
1007 int error;
1008 struct sockaddr_in sin;
1010 skb_queue_head_init(&aun_queue);
1011 spin_lock_init(&aun_queue_lock);
1012 init_timer(&ab_cleanup_timer);
1013 ab_cleanup_timer.expires = jiffies + (HZ*2);
1014 ab_cleanup_timer.function = ab_cleanup;
1015 add_timer(&ab_cleanup_timer);
1017 memset(&sin, 0, sizeof(sin));
1018 sin.sin_port = htons(AUN_PORT);
1020 /* We can count ourselves lucky Acorn machines are too dim to
1021 speak IPv6. :-) */
1022 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1024 printk("AUN: socket error %d\n", -error);
1025 return error;
1028 udpsock->sk->sk_reuse = 1;
1029 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1030 from interrupts */
1032 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1033 sizeof(sin));
1034 if (error < 0)
1036 printk("AUN: bind error %d\n", -error);
1037 goto release;
1040 udpsock->sk->sk_data_ready = aun_data_available;
1042 return 0;
1044 release:
1045 sock_release(udpsock);
1046 udpsock = NULL;
1047 return error;
1049 #endif
1051 #ifdef CONFIG_ECONET_NATIVE
1053 /*
1054 * Receive an Econet frame from a device.
1055 */
1057 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1059 struct ec_framehdr *hdr;
1060 struct sock *sk;
1061 struct ec_device *edev = dev->ec_ptr;
1063 if (skb->pkt_type == PACKET_OTHERHOST)
1064 goto drop;
1066 if (!edev)
1067 goto drop;
1069 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1070 return NET_RX_DROP;
1072 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1073 goto drop;
1075 hdr = (struct ec_framehdr *) skb->data;
1077 /* First check for encapsulated IP */
1078 if (hdr->port == EC_PORT_IP) {
1079 skb->protocol = htons(ETH_P_IP);
1080 skb_pull(skb, sizeof(struct ec_framehdr));
1081 netif_rx(skb);
1082 return 0;
1085 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1086 if (!sk)
1087 goto drop;
1089 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1090 hdr->port))
1091 goto drop;
1093 return 0;
1095 drop:
1096 kfree_skb(skb);
1097 return NET_RX_DROP;
1100 static struct packet_type econet_packet_type = {
1101 .type = __constant_htons(ETH_P_ECONET),
1102 .func = econet_rcv,
1103 };
1105 static void econet_hw_initialise(void)
1107 dev_add_pack(&econet_packet_type);
1110 #endif
1112 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1114 struct net_device *dev = (struct net_device *)data;
1115 struct ec_device *edev;
1117 switch (msg) {
1118 case NETDEV_UNREGISTER:
1119 /* A device has gone down - kill any data we hold for it. */
1120 edev = dev->ec_ptr;
1121 if (edev)
1123 if (net2dev_map[0] == dev)
1124 net2dev_map[0] = NULL;
1125 net2dev_map[edev->net] = NULL;
1126 kfree(edev);
1127 dev->ec_ptr = NULL;
1129 break;
1132 return NOTIFY_DONE;
1135 static struct notifier_block econet_netdev_notifier = {
1136 .notifier_call =econet_notifier,
1137 };
1139 static void __exit econet_proto_exit(void)
1141 #ifdef CONFIG_ECONET_AUNUDP
1142 del_timer(&ab_cleanup_timer);
1143 if (udpsock)
1144 sock_release(udpsock);
1145 #endif
1146 unregister_netdevice_notifier(&econet_netdev_notifier);
1147 sock_unregister(econet_family_ops.family);
1148 proto_unregister(&econet_proto);
1151 static int __init econet_proto_init(void)
1153 int err = proto_register(&econet_proto, 0);
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);
1166 out:
1167 return err;
1170 module_init(econet_proto_init);
1171 module_exit(econet_proto_exit);
1173 MODULE_LICENSE("GPL");
1174 MODULE_ALIAS_NETPROTO(PF_ECONET);