xref: /openbmc/linux/net/iucv/af_iucv.c (revision c21b37f6)
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);
1193