?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: oti6858: cleanup
[linux/fpc-iii.git] / net / iucv / af_iucv.c
blob2255e3c082ed68d6c493f481b87b136a9b53a943
1 /*
2 * linux/net/iucv/af_iucv.c
3 *
4 * IUCV protocol stack for Linux on zSeries
5 *
6 * Copyright 2006 IBM Corporation
7 *
8 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com>
9 */
10
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/list.h>
14 #include <linux/errno.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/skbuff.h>
19 #include <linux/init.h>
20 #include <linux/poll.h>
21 #include <net/sock.h>
22 #include <asm/ebcdic.h>
23 #include <asm/cpcmd.h>
24 #include <linux/kmod.h>
25
26 #include <net/iucv/iucv.h>
27 #include <net/iucv/af_iucv.h>
28
29 #define CONFIG_IUCV_SOCK_DEBUG 1
30
31 #define IPRMDATA 0x80
32 #define VERSION "1.0"
33
34 static char iucv_userid[80];
35
36 static struct proto_ops iucv_sock_ops;
37
38 static struct proto iucv_proto = {
39 .name = "AF_IUCV",
40 .owner = THIS_MODULE,
41 .obj_size = sizeof(struct iucv_sock),
42 };
43
44 static void iucv_sock_kill(struct sock *sk);
45 static void iucv_sock_close(struct sock *sk);
46
47 /* Call Back functions */
48 static void iucv_callback_rx(struct iucv_path *, struct iucv_message *);
49 static void iucv_callback_txdone(struct iucv_path *, struct iucv_message *);
50 static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
51 static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8],
52 u8 ipuser[16]);
53 static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
54
55 static struct iucv_sock_list iucv_sk_list = {
56 .lock = RW_LOCK_UNLOCKED,
57 .autobind_name = ATOMIC_INIT(0)
58 };
59
60 static struct iucv_handler af_iucv_handler = {
61 .path_pending = iucv_callback_connreq,
62 .path_complete = iucv_callback_connack,
63 .path_severed = iucv_callback_connrej,
64 .message_pending = iucv_callback_rx,
65 .message_complete = iucv_callback_txdone
66 };
67
68 static inline void high_nmcpy(unsigned char *dst, char *src)
69 {
70 memcpy(dst, src, 8);
71 }
72
73 static inline void low_nmcpy(unsigned char *dst, char *src)
74 {
75 memcpy(&dst[8], src, 8);
76 }
77
78 /* Timers */
79 static void iucv_sock_timeout(unsigned long arg)
80 {
81 struct sock *sk = (struct sock *)arg;
82
83 bh_lock_sock(sk);
84 sk->sk_err = ETIMEDOUT;
85 sk->sk_state_change(sk);
86 bh_unlock_sock(sk);
87
88 iucv_sock_kill(sk);
89 sock_put(sk);
90 }
91
92 static void iucv_sock_clear_timer(struct sock *sk)
93 {
94 sk_stop_timer(sk, &sk->sk_timer);
95 }
96
97 static struct sock *__iucv_get_sock_by_name(char *nm)
98 {
99 struct sock *sk;
100 struct hlist_node *node;
101
102 sk_for_each(sk, node, &iucv_sk_list.head)
103 if (!memcmp(&iucv_sk(sk)->src_name, nm, 8))
104 return sk;
105
106 return NULL;
107 }
108
109 static void iucv_sock_destruct(struct sock *sk)
110 {
111 skb_queue_purge(&sk->sk_receive_queue);
112 skb_queue_purge(&sk->sk_write_queue);
113 }
114
115 /* Cleanup Listen */
116 static void iucv_sock_cleanup_listen(struct sock *parent)
117 {
118 struct sock *sk;
119
120 /* Close non-accepted connections */
121 while ((sk = iucv_accept_dequeue(parent, NULL))) {
122 iucv_sock_close(sk);
123 iucv_sock_kill(sk);
124 }
125
126 parent->sk_state = IUCV_CLOSED;
127 sock_set_flag(parent, SOCK_ZAPPED);
128 }
129
130 /* Kill socket */
131 static void iucv_sock_kill(struct sock *sk)
132 {
133 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
134 return;
135
136 iucv_sock_unlink(&iucv_sk_list, sk);
137 sock_set_flag(sk, SOCK_DEAD);
138 sock_put(sk);
139 }
140
141 /* Close an IUCV socket */
142 static void iucv_sock_close(struct sock *sk)
143 {
144 unsigned char user_data[16];
145 struct iucv_sock *iucv = iucv_sk(sk);
146 int err;
147 unsigned long timeo;
148
149 iucv_sock_clear_timer(sk);
150 lock_sock(sk);
151
152 switch (sk->sk_state) {
153 case IUCV_LISTEN:
154 iucv_sock_cleanup_listen(sk);
155 break;
156
157 case IUCV_CONNECTED:
158 case IUCV_DISCONN:
159 err = 0;
160
161 sk->sk_state = IUCV_CLOSING;
162 sk->sk_state_change(sk);
163
164 if (!skb_queue_empty(&iucv->send_skb_q)) {
165 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
166 timeo = sk->sk_lingertime;
167 else
168 timeo = IUCV_DISCONN_TIMEOUT;
169 err = iucv_sock_wait_state(sk, IUCV_CLOSED, 0, timeo);
170 }
171
172 sk->sk_state = IUCV_CLOSED;
173 sk->sk_state_change(sk);
174
175 if (iucv->path) {
176 low_nmcpy(user_data, iucv->src_name);
177 high_nmcpy(user_data, iucv->dst_name);
178 ASCEBC(user_data, sizeof(user_data));
179 err = iucv_path_sever(iucv->path, user_data);
180 iucv_path_free(iucv->path);
181 iucv->path = NULL;
182 }
183
184 sk->sk_err = ECONNRESET;
185 sk->sk_state_change(sk);
186
187 skb_queue_purge(&iucv->send_skb_q);
188 skb_queue_purge(&iucv->backlog_skb_q);
189
190 sock_set_flag(sk, SOCK_ZAPPED);
191 break;
192
193 default:
194 sock_set_flag(sk, SOCK_ZAPPED);
195 break;
196 }
197
198 release_sock(sk);
199 iucv_sock_kill(sk);
200 }
201
202 static void iucv_sock_init(struct sock *sk, struct sock *parent)
203 {
204 if (parent)
205 sk->sk_type = parent->sk_type;
206 }
207
208 static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio)
209 {
210 struct sock *sk;
211
212 sk = sk_alloc(&init_net, PF_IUCV, prio, &iucv_proto);
213 if (!sk)
214 return NULL;
215
216 sock_init_data(sock, sk);
217 INIT_LIST_HEAD(&iucv_sk(sk)->accept_q);
218 spin_lock_init(&iucv_sk(sk)->accept_q_lock);
219 skb_queue_head_init(&iucv_sk(sk)->send_skb_q);
220 INIT_LIST_HEAD(&iucv_sk(sk)->message_q.list);
221 spin_lock_init(&iucv_sk(sk)->message_q.lock);
222 skb_queue_head_init(&iucv_sk(sk)->backlog_skb_q);
223 iucv_sk(sk)->send_tag = 0;
224
225 sk->sk_destruct = iucv_sock_destruct;
226 sk->sk_sndtimeo = IUCV_CONN_TIMEOUT;
227 sk->sk_allocation = GFP_DMA;
228
229 sock_reset_flag(sk, SOCK_ZAPPED);
230
231 sk->sk_protocol = proto;
232 sk->sk_state = IUCV_OPEN;
233
234 setup_timer(&sk->sk_timer, iucv_sock_timeout, (unsigned long)sk);
235
236 iucv_sock_link(&iucv_sk_list, sk);
237 return sk;
238 }
239
240 /* Create an IUCV socket */
241 static int iucv_sock_create(struct net *net, struct socket *sock, int protocol)
242 {
243 struct sock *sk;
244
245 if (sock->type != SOCK_STREAM)
246 return -ESOCKTNOSUPPORT;
247
248 sock->state = SS_UNCONNECTED;
249 sock->ops = &iucv_sock_ops;
250
251 sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
252 if (!sk)
253 return -ENOMEM;
254
255 iucv_sock_init(sk, NULL);
256
257 return 0;
258 }
259
260 void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk)
261 {
262 write_lock_bh(&l->lock);
263 sk_add_node(sk, &l->head);
264 write_unlock_bh(&l->lock);
265 }
266
267 void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk)
268 {
269 write_lock_bh(&l->lock);
270 sk_del_node_init(sk);
271 write_unlock_bh(&l->lock);
272 }
273
274 void iucv_accept_enqueue(struct sock *parent, struct sock *sk)
275 {
276 unsigned long flags;
277 struct iucv_sock *par = iucv_sk(parent);
278
279 sock_hold(sk);
280 spin_lock_irqsave(&par->accept_q_lock, flags);
281 list_add_tail(&iucv_sk(sk)->accept_q, &par->accept_q);
282 spin_unlock_irqrestore(&par->accept_q_lock, flags);
283 iucv_sk(sk)->parent = parent;
284 parent->sk_ack_backlog++;
285 }
286
287 void iucv_accept_unlink(struct sock *sk)
288 {
289 unsigned long flags;
290 struct iucv_sock *par = iucv_sk(iucv_sk(sk)->parent);
291
292 spin_lock_irqsave(&par->accept_q_lock, flags);
293 list_del_init(&iucv_sk(sk)->accept_q);
294 spin_unlock_irqrestore(&par->accept_q_lock, flags);
295 iucv_sk(sk)->parent->sk_ack_backlog--;
296 iucv_sk(sk)->parent = NULL;
297 sock_put(sk);
298 }
299
300 struct sock *iucv_accept_dequeue(struct sock *parent, struct socket *newsock)
301 {
302 struct iucv_sock *isk, *n;
303 struct sock *sk;
304
305 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
306 sk = (struct sock *) isk;
307 lock_sock(sk);
308
309 if (sk->sk_state == IUCV_CLOSED) {
310 iucv_accept_unlink(sk);
311 release_sock(sk);
312 continue;
313 }
314
315 if (sk->sk_state == IUCV_CONNECTED ||
316 sk->sk_state == IUCV_SEVERED ||
317 !newsock) {
318 iucv_accept_unlink(sk);
319 if (newsock)
320 sock_graft(sk, newsock);
321
322 if (sk->sk_state == IUCV_SEVERED)
323 sk->sk_state = IUCV_DISCONN;
324
325 release_sock(sk);
326 return sk;
327 }
328
329 release_sock(sk);
330 }
331 return NULL;
332 }
333
334 int iucv_sock_wait_state(struct sock *sk, int state, int state2,
335 unsigned long timeo)
336 {
337 DECLARE_WAITQUEUE(wait, current);
338 int err = 0;
339
340 add_wait_queue(sk->sk_sleep, &wait);
341 while (sk->sk_state != state && sk->sk_state != state2) {
342 set_current_state(TASK_INTERRUPTIBLE);
343
344 if (!timeo) {
345 err = -EAGAIN;
346 break;
347 }
348
349 if (signal_pending(current)) {
350 err = sock_intr_errno(timeo);
351 break;
352 }
353
354 release_sock(sk);
355 timeo = schedule_timeout(timeo);
356 lock_sock(sk);
357
358 err = sock_error(sk);
359 if (err)
360 break;
361 }
362 set_current_state(TASK_RUNNING);
363 remove_wait_queue(sk->sk_sleep, &wait);
364 return err;
365 }
366
367 /* Bind an unbound socket */
368 static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr,
369 int addr_len)
370 {
371 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
372 struct sock *sk = sock->sk;
373 struct iucv_sock *iucv;
374 int err;
375
376 /* Verify the input sockaddr */
377 if (!addr || addr->sa_family != AF_IUCV)
378 return -EINVAL;
379
380 lock_sock(sk);
381 if (sk->sk_state != IUCV_OPEN) {
382 err = -EBADFD;
383 goto done;
384 }
385
386 write_lock_bh(&iucv_sk_list.lock);
387
388 iucv = iucv_sk(sk);
389 if (__iucv_get_sock_by_name(sa->siucv_name)) {
390 err = -EADDRINUSE;
391 goto done_unlock;
392 }
393 if (iucv->path) {
394 err = 0;
395 goto done_unlock;
396 }
397
398 /* Bind the socket */
399 memcpy(iucv->src_name, sa->siucv_name, 8);
400
401 /* Copy the user id */
402 memcpy(iucv->src_user_id, iucv_userid, 8);
403 sk->sk_state = IUCV_BOUND;
404 err = 0;
405
406 done_unlock:
407 /* Release the socket list lock */
408 write_unlock_bh(&iucv_sk_list.lock);
409 done:
410 release_sock(sk);
411 return err;
412 }
413
414 /* Automatically bind an unbound socket */
415 static int iucv_sock_autobind(struct sock *sk)
416 {
417 struct iucv_sock *iucv = iucv_sk(sk);
418 char query_buffer[80];
419 char name[12];
420 int err = 0;
421
422 /* Set the userid and name */
423 cpcmd("QUERY USERID", query_buffer, sizeof(query_buffer), &err);
424 if (unlikely(err))
425 return -EPROTO;
426
427 memcpy(iucv->src_user_id, query_buffer, 8);
428
429 write_lock_bh(&iucv_sk_list.lock);
430
431 sprintf(name, "%08x", atomic_inc_return(&iucv_sk_list.autobind_name));
432 while (__iucv_get_sock_by_name(name)) {
433 sprintf(name, "%08x",
434 atomic_inc_return(&iucv_sk_list.autobind_name));
435 }
436
437 write_unlock_bh(&iucv_sk_list.lock);
438
439 memcpy(&iucv->src_name, name, 8);
440
441 return err;
442 }
443
444 /* Connect an unconnected socket */
445 static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
446 int alen, int flags)
447 {
448 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
449 struct sock *sk = sock->sk;
450 struct iucv_sock *iucv;
451 unsigned char user_data[16];
452 int err;
453
454 if (addr->sa_family != AF_IUCV || alen < sizeof(struct sockaddr_iucv))
455 return -EINVAL;
456
457 if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
458 return -EBADFD;
459
460 if (sk->sk_type != SOCK_STREAM)
461 return -EINVAL;
462
463 iucv = iucv_sk(sk);
464
465 if (sk->sk_state == IUCV_OPEN) {
466 err = iucv_sock_autobind(sk);
467 if (unlikely(err))
468 return err;
469 }
470
471 lock_sock(sk);
472
473 /* Set the destination information */
474 memcpy(iucv_sk(sk)->dst_user_id, sa->siucv_user_id, 8);
475 memcpy(iucv_sk(sk)->dst_name, sa->siucv_name, 8);
476
477 high_nmcpy(user_data, sa->siucv_name);
478 low_nmcpy(user_data, iucv_sk(sk)->src_name);
479 ASCEBC(user_data, sizeof(user_data));
480
481 iucv = iucv_sk(sk);
482 /* Create path. */
483 iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT,
484 IPRMDATA, GFP_KERNEL);
485 err = iucv_path_connect(iucv->path, &af_iucv_handler,
486 sa->siucv_user_id, NULL, user_data, sk);
487 if (err) {
488 iucv_path_free(iucv->path);
489 iucv->path = NULL;
490 err = -ECONNREFUSED;
491 goto done;
492 }
493
494 if (sk->sk_state != IUCV_CONNECTED) {
495 err = iucv_sock_wait_state(sk, IUCV_CONNECTED, IUCV_DISCONN,
496 sock_sndtimeo(sk, flags & O_NONBLOCK));
497 }
498
499 if (sk->sk_state == IUCV_DISCONN) {
500 release_sock(sk);
501 return -ECONNREFUSED;
502 }
503 done:
504 release_sock(sk);
505 return err;
506 }
507
508 /* Move a socket into listening state. */
509 static int iucv_sock_listen(struct socket *sock, int backlog)
510 {
511 struct sock *sk = sock->sk;
512 int err;
513
514 lock_sock(sk);
515
516 err = -EINVAL;
517 if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM)
518 goto done;
519
520 sk->sk_max_ack_backlog = backlog;
521 sk->sk_ack_backlog = 0;
522 sk->sk_state = IUCV_LISTEN;
523 err = 0;
524
525 done:
526 release_sock(sk);
527 return err;
528 }
529
530 /* Accept a pending connection */
531 static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
532 int flags)
533 {
534 DECLARE_WAITQUEUE(wait, current);
535 struct sock *sk = sock->sk, *nsk;
536 long timeo;
537 int err = 0;
538
539 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
540
541 if (sk->sk_state != IUCV_LISTEN) {
542 err = -EBADFD;
543 goto done;
544 }
545
546 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
547
548 /* Wait for an incoming connection */
549 add_wait_queue_exclusive(sk->sk_sleep, &wait);
550 while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
551 set_current_state(TASK_INTERRUPTIBLE);
552 if (!timeo) {
553 err = -EAGAIN;
554 break;
555 }
556
557 release_sock(sk);
558 timeo = schedule_timeout(timeo);
559 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
560
561 if (sk->sk_state != IUCV_LISTEN) {
562 err = -EBADFD;
563 break;
564 }
565
566 if (signal_pending(current)) {
567 err = sock_intr_errno(timeo);
568 break;
569 }
570 }
571
572 set_current_state(TASK_RUNNING);
573 remove_wait_queue(sk->sk_sleep, &wait);
574
575 if (err)
576 goto done;
577
578 newsock->state = SS_CONNECTED;
579
580 done:
581 release_sock(sk);
582 return err;
583 }
584
585 static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
586 int *len, int peer)
587 {
588 struct sockaddr_iucv *siucv = (struct sockaddr_iucv *) addr;
589 struct sock *sk = sock->sk;
590
591 addr->sa_family = AF_IUCV;
592 *len = sizeof(struct sockaddr_iucv);
593
594 if (peer) {
595 memcpy(siucv->siucv_user_id, iucv_sk(sk)->dst_user_id, 8);
596 memcpy(siucv->siucv_name, &iucv_sk(sk)->dst_name, 8);
597 } else {
598 memcpy(siucv->siucv_user_id, iucv_sk(sk)->src_user_id, 8);
599 memcpy(siucv->siucv_name, iucv_sk(sk)->src_name, 8);
600 }
601 memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port));
602 memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr));
603 memset(siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid));
604
605 return 0;
606 }
607
608 static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
609 struct msghdr *msg, size_t len)
610 {
611 struct sock *sk = sock->sk;
612 struct iucv_sock *iucv = iucv_sk(sk);
613 struct sk_buff *skb;
614 struct iucv_message txmsg;
615 int err;
616
617 err = sock_error(sk);
618 if (err)
619 return err;
620
621 if (msg->msg_flags & MSG_OOB)
622 return -EOPNOTSUPP;
623
624 lock_sock(sk);
625
626 if (sk->sk_shutdown & SEND_SHUTDOWN) {
627 err = -EPIPE;
628 goto out;
629 }
630
631 if (sk->sk_state == IUCV_CONNECTED) {
632 if (!(skb = sock_alloc_send_skb(sk, len,
633 msg->msg_flags & MSG_DONTWAIT,
634 &err)))
635 goto out;
636
637 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
638 err = -EFAULT;
639 goto fail;
640 }
641
642 txmsg.class = 0;
643 txmsg.tag = iucv->send_tag++;
644 memcpy(skb->cb, &txmsg.tag, 4);
645 skb_queue_tail(&iucv->send_skb_q, skb);
646 err = iucv_message_send(iucv->path, &txmsg, 0, 0,
647 (void *) skb->data, skb->len);
648 if (err) {
649 if (err == 3)
650 printk(KERN_ERR "AF_IUCV msg limit exceeded\n");
651 skb_unlink(skb, &iucv->send_skb_q);
652 err = -EPIPE;
653 goto fail;
654 }
655
656 } else {
657 err = -ENOTCONN;
658 goto out;
659 }
660
661 release_sock(sk);
662 return len;
663
664 fail:
665 kfree_skb(skb);
666 out:
667 release_sock(sk);
668 return err;
669 }
670
671 static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len)
672 {
673 int dataleft, size, copied = 0;
674 struct sk_buff *nskb;
675
676 dataleft = len;
677 while (dataleft) {
678 if (dataleft >= sk->sk_rcvbuf / 4)
679 size = sk->sk_rcvbuf / 4;
680 else
681 size = dataleft;
682
683 nskb = alloc_skb(size, GFP_ATOMIC | GFP_DMA);
684 if (!nskb)
685 return -ENOMEM;
686
687 memcpy(nskb->data, skb->data + copied, size);
688 copied += size;
689 dataleft -= size;
690
691 skb_reset_transport_header(nskb);
692 skb_reset_network_header(nskb);
693 nskb->len = size;
694
695 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, nskb);
696 }
697
698 return 0;
699 }
700
701 static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
702 struct iucv_path *path,
703 struct iucv_message *msg)
704 {
705 int rc;
706
707 if (msg->flags & IPRMDATA) {
708 skb->data = NULL;
709 skb->len = 0;
710 } else {
711 rc = iucv_message_receive(path, msg, 0, skb->data,
712 msg->length, NULL);
713 if (rc) {
714 kfree_skb(skb);
715 return;
716 }
717 if (skb->truesize >= sk->sk_rcvbuf / 4) {
718 rc = iucv_fragment_skb(sk, skb, msg->length);
719 kfree_skb(skb);
720 skb = NULL;
721 if (rc) {
722 iucv_path_sever(path, NULL);
723 return;
724 }
725 skb = skb_dequeue(&iucv_sk(sk)->backlog_skb_q);
726 } else {
727 skb_reset_transport_header(skb);
728 skb_reset_network_header(skb);
729 skb->len = msg->length;
730 }
731 }
732
733 if (sock_queue_rcv_skb(sk, skb))
734 skb_queue_head(&iucv_sk(sk)->backlog_skb_q, skb);
735 }
736
737 static void iucv_process_message_q(struct sock *sk)
738 {
739 struct iucv_sock *iucv = iucv_sk(sk);
740 struct sk_buff *skb;
741 struct sock_msg_q *p, *n;
742
743 list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
744 skb = alloc_skb(p->msg.length, GFP_ATOMIC | GFP_DMA);
745 if (!skb)
746 break;
747 iucv_process_message(sk, skb, p->path, &p->msg);
748 list_del(&p->list);
749 kfree(p);
750 if (!skb_queue_empty(&iucv->backlog_skb_q))
751 break;
752 }
753 }
754
755 static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
756 struct msghdr *msg, size_t len, int flags)
757 {
758 int noblock = flags & MSG_DONTWAIT;
759 struct sock *sk = sock->sk;
760 struct iucv_sock *iucv = iucv_sk(sk);
761 int target, copied = 0;
762 struct sk_buff *skb, *rskb, *cskb;
763 int err = 0;
764
765 if ((sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED) &&
766 skb_queue_empty(&iucv->backlog_skb_q) &&
767 skb_queue_empty(&sk->sk_receive_queue) &&
768 list_empty(&iucv->message_q.list))
769 return 0;
770
771 if (flags & (MSG_OOB))
772 return -EOPNOTSUPP;
773
774 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
775
776 skb = skb_recv_datagram(sk, flags, noblock, &err);
777 if (!skb) {
778 if (sk->sk_shutdown & RCV_SHUTDOWN)
779 return 0;
780 return err;
781 }
782
783 copied = min_t(unsigned int, skb->len, len);
784
785 cskb = skb;
786 if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
787 skb_queue_head(&sk->sk_receive_queue, skb);
788 if (copied == 0)
789 return -EFAULT;
790 goto done;
791 }
792
793 len -= copied;
794
795 /* Mark read part of skb as used */
796 if (!(flags & MSG_PEEK)) {
797 skb_pull(skb, copied);
798
799 if (skb->len) {
800 skb_queue_head(&sk->sk_receive_queue, skb);
801 goto done;
802 }
803
804 kfree_skb(skb);
805
806 /* Queue backlog skbs */
807 rskb = skb_dequeue(&iucv->backlog_skb_q);
808 while (rskb) {
809 if (sock_queue_rcv_skb(sk, rskb)) {
810 skb_queue_head(&iucv->backlog_skb_q,
811 rskb);
812 break;
813 } else {
814 rskb = skb_dequeue(&iucv->backlog_skb_q);
815 }
816 }
817 if (skb_queue_empty(&iucv->backlog_skb_q)) {
818 spin_lock_bh(&iucv->message_q.lock);
819 if (!list_empty(&iucv->message_q.list))
820 iucv_process_message_q(sk);
821 spin_unlock_bh(&iucv->message_q.lock);
822 }
823
824 } else
825 skb_queue_head(&sk->sk_receive_queue, skb);
826
827 done:
828 return err ? : copied;
829 }
830
831 static inline unsigned int iucv_accept_poll(struct sock *parent)
832 {
833 struct iucv_sock *isk, *n;
834 struct sock *sk;
835
836 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
837 sk = (struct sock *) isk;
838
839 if (sk->sk_state == IUCV_CONNECTED)
840 return POLLIN | POLLRDNORM;
841 }
842
843 return 0;
844 }
845
846 unsigned int iucv_sock_poll(struct file *file, struct socket *sock,
847 poll_table *wait)
848 {
849 struct sock *sk = sock->sk;
850 unsigned int mask = 0;
851
852 poll_wait(file, sk->sk_sleep, wait);
853
854 if (sk->sk_state == IUCV_LISTEN)
855 return iucv_accept_poll(sk);
856
857 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
858 mask |= POLLERR;
859
860 if (sk->sk_shutdown & RCV_SHUTDOWN)
861 mask |= POLLRDHUP;
862
863 if (sk->sk_shutdown == SHUTDOWN_MASK)
864 mask |= POLLHUP;
865
866 if (!skb_queue_empty(&sk->sk_receive_queue) ||
867 (sk->sk_shutdown & RCV_SHUTDOWN))
868 mask |= POLLIN | POLLRDNORM;
869
870 if (sk->sk_state == IUCV_CLOSED)
871 mask |= POLLHUP;
872
873 if (sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED)
874 mask |= POLLIN;
875
876 if (sock_writeable(sk))
877 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
878 else
879 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
880
881 return mask;
882 }
883
884 static int iucv_sock_shutdown(struct socket *sock, int how)
885 {
886 struct sock *sk = sock->sk;
887 struct iucv_sock *iucv = iucv_sk(sk);
888 struct iucv_message txmsg;
889 int err = 0;
890 u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
891
892 how++;
893
894 if ((how & ~SHUTDOWN_MASK) || !how)
895 return -EINVAL;
896
897 lock_sock(sk);
898 switch (sk->sk_state) {
899 case IUCV_CLOSED:
900 err = -ENOTCONN;
901 goto fail;
902
903 default:
904 sk->sk_shutdown |= how;
905 break;
906 }
907
908 if (how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) {
909 txmsg.class = 0;
910 txmsg.tag = 0;
911 err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0,
912 (void *) prmmsg, 8);
913 if (err) {
914 switch (err) {
915 case 1:
916 err = -ENOTCONN;
917 break;
918 case 2:
919 err = -ECONNRESET;
920 break;
921 default:
922 err = -ENOTCONN;
923 break;
924 }
925 }
926 }
927
928 if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) {
929 err = iucv_path_quiesce(iucv_sk(sk)->path, NULL);
930 if (err)
931 err = -ENOTCONN;
932
933 skb_queue_purge(&sk->sk_receive_queue);
934 }
935
936 /* Wake up anyone sleeping in poll */
937 sk->sk_state_change(sk);
938
939 fail:
940 release_sock(sk);
941 return err;
942 }
943
944 static int iucv_sock_release(struct socket *sock)
945 {
946 struct sock *sk = sock->sk;
947 int err = 0;
948
949 if (!sk)
950 return 0;
951
952 iucv_sock_close(sk);
953
954 /* Unregister with IUCV base support */
955 if (iucv_sk(sk)->path) {
956 iucv_path_sever(iucv_sk(sk)->path, NULL);
957 iucv_path_free(iucv_sk(sk)->path);
958 iucv_sk(sk)->path = NULL;
959 }
960
961 sock_orphan(sk);
962 iucv_sock_kill(sk);
963 return err;
964 }
965
966 /* Callback wrappers - called from iucv base support */
967 static int iucv_callback_connreq(struct iucv_path *path,
968 u8 ipvmid[8], u8 ipuser[16])
969 {
970 unsigned char user_data[16];
971 unsigned char nuser_data[16];
972 unsigned char src_name[8];
973 struct hlist_node *node;
974 struct sock *sk, *nsk;
975 struct iucv_sock *iucv, *niucv;
976 int err;
977
978 memcpy(src_name, ipuser, 8);
979 EBCASC(src_name, 8);
980 /* Find out if this path belongs to af_iucv. */
981 read_lock(&iucv_sk_list.lock);
982 iucv = NULL;
983 sk = NULL;
984 sk_for_each(sk, node, &iucv_sk_list.head)
985 if (sk->sk_state == IUCV_LISTEN &&
986 !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) {
987 /*
988 * Found a listening socket with
989 * src_name == ipuser[0-7].
990 */
991 iucv = iucv_sk(sk);
992 break;
993 }
994 read_unlock(&iucv_sk_list.lock);
995 if (!iucv)
996 /* No socket found, not one of our paths. */
997 return -EINVAL;
998
999 bh_lock_sock(sk);
1000
1001 /* Check if parent socket is listening */
1002 low_nmcpy(user_data, iucv->src_name);
1003 high_nmcpy(user_data, iucv->dst_name);
1004 ASCEBC(user_data, sizeof(user_data));
1005 if (sk->sk_state != IUCV_LISTEN) {
1006 err = iucv_path_sever(path, user_data);
1007 goto fail;
1008 }
1009
1010 /* Check for backlog size */
1011 if (sk_acceptq_is_full(sk)) {
1012 err = iucv_path_sever(path, user_data);
1013 goto fail;
1014 }
1015
1016 /* Create the new socket */
1017 nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC);
1018 if (!nsk) {
1019 err = iucv_path_sever(path, user_data);
1020 goto fail;
1021 }
1022
1023 niucv = iucv_sk(nsk);
1024 iucv_sock_init(nsk, sk);
1025
1026 /* Set the new iucv_sock */
1027 memcpy(niucv->dst_name, ipuser + 8, 8);
1028 EBCASC(niucv->dst_name, 8);
1029 memcpy(niucv->dst_user_id, ipvmid, 8);
1030 memcpy(niucv->src_name, iucv->src_name, 8);
1031 memcpy(niucv->src_user_id, iucv->src_user_id, 8);
1032 niucv->path = path;
1033
1034 /* Call iucv_accept */
1035 high_nmcpy(nuser_data, ipuser + 8);
1036 memcpy(nuser_data + 8, niucv->src_name, 8);
1037 ASCEBC(nuser_data + 8, 8);
1038
1039 path->msglim = IUCV_QUEUELEN_DEFAULT;
1040 err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk);
1041 if (err) {
1042 err = iucv_path_sever(path, user_data);
1043 goto fail;
1044 }
1045
1046 iucv_accept_enqueue(sk, nsk);
1047
1048 /* Wake up accept */
1049 nsk->sk_state = IUCV_CONNECTED;
1050 sk->sk_data_ready(sk, 1);
1051 err = 0;
1052 fail:
1053 bh_unlock_sock(sk);
1054 return 0;
1055 }
1056
1057 static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
1058 {
1059 struct sock *sk = path->private;
1060
1061 sk->sk_state = IUCV_CONNECTED;
1062 sk->sk_state_change(sk);
1063 }
1064
1065 static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
1066 {
1067 struct sock *sk = path->private;
1068 struct iucv_sock *iucv = iucv_sk(sk);
1069 struct sk_buff *skb;
1070 struct sock_msg_q *save_msg;
1071 int len;
1072
1073 if (sk->sk_shutdown & RCV_SHUTDOWN)
1074 return;
1075
1076 if (!list_empty(&iucv->message_q.list) ||
1077 !skb_queue_empty(&iucv->backlog_skb_q))
1078 goto save_message;
1079
1080 len = atomic_read(&sk->sk_rmem_alloc);
1081 len += msg->length + sizeof(struct sk_buff);
1082 if (len > sk->sk_rcvbuf)
1083 goto save_message;
1084
1085 skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA);
1086 if (!skb)
1087 goto save_message;
1088
1089 spin_lock(&iucv->message_q.lock);
1090 iucv_process_message(sk, skb, path, msg);
1091 spin_unlock(&iucv->message_q.lock);
1092
1093 return;
1094
1095 save_message:
1096 save_msg = kzalloc(sizeof(struct sock_msg_q), GFP_ATOMIC | GFP_DMA);
1097 save_msg->path = path;
1098 save_msg->msg = *msg;
1099
1100 spin_lock(&iucv->message_q.lock);
1101 list_add_tail(&save_msg->list, &iucv->message_q.list);
1102 spin_unlock(&iucv->message_q.lock);
1103 }
1104
1105 static void iucv_callback_txdone(struct iucv_path *path,
1106 struct iucv_message *msg)
1107 {
1108 struct sock *sk = path->private;
1109 struct sk_buff *this;
1110 struct sk_buff_head *list = &iucv_sk(sk)->send_skb_q;
1111 struct sk_buff *list_skb = list->next;
1112 unsigned long flags;
1113
1114 if (list_skb) {
1115 spin_lock_irqsave(&list->lock, flags);
1116
1117 do {
1118 this = list_skb;
1119 list_skb = list_skb->next;
1120 } while (memcmp(&msg->tag, this->cb, 4) && list_skb);
1121
1122 spin_unlock_irqrestore(&list->lock, flags);
1123
1124 skb_unlink(this, &iucv_sk(sk)->send_skb_q);
1125 kfree_skb(this);
1126 }
1127
1128 if (sk->sk_state == IUCV_CLOSING) {
1129 if (skb_queue_empty(&iucv_sk(sk)->send_skb_q)) {
1130 sk->sk_state = IUCV_CLOSED;
1131 sk->sk_state_change(sk);
1132 }
1133 }
1134
1135 }
1136
1137 static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
1138 {
1139 struct sock *sk = path->private;
1140
1141 if (!list_empty(&iucv_sk(sk)->accept_q))
1142 sk->sk_state = IUCV_SEVERED;
1143 else
1144 sk->sk_state = IUCV_DISCONN;
1145
1146 sk->sk_state_change(sk);
1147 }
1148
1149 static struct proto_ops iucv_sock_ops = {
1150 .family = PF_IUCV,
1151 .owner = THIS_MODULE,
1152 .release = iucv_sock_release,
1153 .bind = iucv_sock_bind,
1154 .connect = iucv_sock_connect,
1155 .listen = iucv_sock_listen,
1156 .accept = iucv_sock_accept,
1157 .getname = iucv_sock_getname,
1158 .sendmsg = iucv_sock_sendmsg,
1159 .recvmsg = iucv_sock_recvmsg,
1160 .poll = iucv_sock_poll,
1161 .ioctl = sock_no_ioctl,
1162 .mmap = sock_no_mmap,
1163 .socketpair = sock_no_socketpair,
1164 .shutdown = iucv_sock_shutdown,
1165 .setsockopt = sock_no_setsockopt,
1166 .getsockopt = sock_no_getsockopt
1167 };
1168
1169 static struct net_proto_family iucv_sock_family_ops = {
1170 .family = AF_IUCV,
1171 .owner = THIS_MODULE,
1172 .create = iucv_sock_create,
1173 };
1174
1175 static int __init afiucv_init(void)
1176 {
1177 int err;
1178
1179 if (!MACHINE_IS_VM) {
1180 printk(KERN_ERR "AF_IUCV connection needs VM as base\n");
1181 err = -EPROTONOSUPPORT;
1182 goto out;
1183 }
1184 cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err);
1185 if (unlikely(err)) {
1186 printk(KERN_ERR "AF_IUCV needs the VM userid\n");
1187 err = -EPROTONOSUPPORT;
1188 goto out;
1189 }
1190
1191 err = iucv_register(&af_iucv_handler, 0);
1192 if (err)
1193 goto out;
1194 err = proto_register(&iucv_proto, 0);
1195 if (err)
1196 goto out_iucv;
1197 err = sock_register(&iucv_sock_family_ops);
1198 if (err)
1199 goto out_proto;
1200 printk(KERN_INFO "AF_IUCV lowlevel driver initialized\n");
1201 return 0;
1202
1203 out_proto:
1204 proto_unregister(&iucv_proto);
1205 out_iucv:
1206 iucv_unregister(&af_iucv_handler, 0);
1207 out:
1208 return err;
1209 }
1210
1211 static void __exit afiucv_exit(void)
1212 {
1213 sock_unregister(PF_IUCV);
1214 proto_unregister(&iucv_proto);
1215 iucv_unregister(&af_iucv_handler, 0);
1216
1217 printk(KERN_INFO "AF_IUCV lowlevel driver unloaded\n");
1218 }
1219
1220 module_init(afiucv_init);
1221 module_exit(afiucv_exit);
1222
1223 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
1224 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION);
1225 MODULE_VERSION(VERSION);
1226 MODULE_LICENSE("GPL");
1227 MODULE_ALIAS_NETPROTO(PF_IUCV);
Linux with added FPC-III support