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