2 * linux/net/iucv/af_iucv.c
4 * IUCV protocol stack for Linux on zSeries
6 * Copyright 2006 IBM Corporation
8 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com>
11 #define KMSG_COMPONENT "af_iucv"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/list.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/skbuff.h>
22 #include <linux/init.h>
23 #include <linux/poll.h>
25 #include <asm/ebcdic.h>
26 #include <asm/cpcmd.h>
27 #include <linux/kmod.h>
29 #include <net/iucv/iucv.h>
30 #include <net/iucv/af_iucv.h>
32 #define CONFIG_IUCV_SOCK_DEBUG 1
37 static char iucv_userid
[80];
39 static struct proto_ops iucv_sock_ops
;
41 static struct proto iucv_proto
= {
44 .obj_size
= sizeof(struct iucv_sock
),
47 static void iucv_sock_kill(struct sock
*sk
);
48 static void iucv_sock_close(struct sock
*sk
);
50 /* Call Back functions */
51 static void iucv_callback_rx(struct iucv_path
*, struct iucv_message
*);
52 static void iucv_callback_txdone(struct iucv_path
*, struct iucv_message
*);
53 static void iucv_callback_connack(struct iucv_path
*, u8 ipuser
[16]);
54 static int iucv_callback_connreq(struct iucv_path
*, u8 ipvmid
[8],
56 static void iucv_callback_connrej(struct iucv_path
*, u8 ipuser
[16]);
58 static struct iucv_sock_list iucv_sk_list
= {
59 .lock
= __RW_LOCK_UNLOCKED(iucv_sk_list
.lock
),
60 .autobind_name
= ATOMIC_INIT(0)
63 static struct iucv_handler af_iucv_handler
= {
64 .path_pending
= iucv_callback_connreq
,
65 .path_complete
= iucv_callback_connack
,
66 .path_severed
= iucv_callback_connrej
,
67 .message_pending
= iucv_callback_rx
,
68 .message_complete
= iucv_callback_txdone
71 static inline void high_nmcpy(unsigned char *dst
, char *src
)
76 static inline void low_nmcpy(unsigned char *dst
, char *src
)
78 memcpy(&dst
[8], src
, 8);
82 static void iucv_sock_timeout(unsigned long arg
)
84 struct sock
*sk
= (struct sock
*)arg
;
87 sk
->sk_err
= ETIMEDOUT
;
88 sk
->sk_state_change(sk
);
95 static void iucv_sock_clear_timer(struct sock
*sk
)
97 sk_stop_timer(sk
, &sk
->sk_timer
);
100 static struct sock
*__iucv_get_sock_by_name(char *nm
)
103 struct hlist_node
*node
;
105 sk_for_each(sk
, node
, &iucv_sk_list
.head
)
106 if (!memcmp(&iucv_sk(sk
)->src_name
, nm
, 8))
112 static void iucv_sock_destruct(struct sock
*sk
)
114 skb_queue_purge(&sk
->sk_receive_queue
);
115 skb_queue_purge(&sk
->sk_write_queue
);
119 static void iucv_sock_cleanup_listen(struct sock
*parent
)
123 /* Close non-accepted connections */
124 while ((sk
= iucv_accept_dequeue(parent
, NULL
))) {
129 parent
->sk_state
= IUCV_CLOSED
;
130 sock_set_flag(parent
, SOCK_ZAPPED
);
134 static void iucv_sock_kill(struct sock
*sk
)
136 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
139 iucv_sock_unlink(&iucv_sk_list
, sk
);
140 sock_set_flag(sk
, SOCK_DEAD
);
144 /* Close an IUCV socket */
145 static void iucv_sock_close(struct sock
*sk
)
147 unsigned char user_data
[16];
148 struct iucv_sock
*iucv
= iucv_sk(sk
);
152 iucv_sock_clear_timer(sk
);
155 switch (sk
->sk_state
) {
157 iucv_sock_cleanup_listen(sk
);
164 sk
->sk_state
= IUCV_CLOSING
;
165 sk
->sk_state_change(sk
);
167 if (!skb_queue_empty(&iucv
->send_skb_q
)) {
168 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
169 timeo
= sk
->sk_lingertime
;
171 timeo
= IUCV_DISCONN_TIMEOUT
;
172 err
= iucv_sock_wait_state(sk
, IUCV_CLOSED
, 0, timeo
);
175 sk
->sk_state
= IUCV_CLOSED
;
176 sk
->sk_state_change(sk
);
179 low_nmcpy(user_data
, iucv
->src_name
);
180 high_nmcpy(user_data
, iucv
->dst_name
);
181 ASCEBC(user_data
, sizeof(user_data
));
182 err
= iucv_path_sever(iucv
->path
, user_data
);
183 iucv_path_free(iucv
->path
);
187 sk
->sk_err
= ECONNRESET
;
188 sk
->sk_state_change(sk
);
190 skb_queue_purge(&iucv
->send_skb_q
);
191 skb_queue_purge(&iucv
->backlog_skb_q
);
193 sock_set_flag(sk
, SOCK_ZAPPED
);
197 sock_set_flag(sk
, SOCK_ZAPPED
);
205 static void iucv_sock_init(struct sock
*sk
, struct sock
*parent
)
208 sk
->sk_type
= parent
->sk_type
;
211 static struct sock
*iucv_sock_alloc(struct socket
*sock
, int proto
, gfp_t prio
)
215 sk
= sk_alloc(&init_net
, PF_IUCV
, prio
, &iucv_proto
);
219 sock_init_data(sock
, sk
);
220 INIT_LIST_HEAD(&iucv_sk(sk
)->accept_q
);
221 spin_lock_init(&iucv_sk(sk
)->accept_q_lock
);
222 skb_queue_head_init(&iucv_sk(sk
)->send_skb_q
);
223 INIT_LIST_HEAD(&iucv_sk(sk
)->message_q
.list
);
224 spin_lock_init(&iucv_sk(sk
)->message_q
.lock
);
225 skb_queue_head_init(&iucv_sk(sk
)->backlog_skb_q
);
226 iucv_sk(sk
)->send_tag
= 0;
228 sk
->sk_destruct
= iucv_sock_destruct
;
229 sk
->sk_sndtimeo
= IUCV_CONN_TIMEOUT
;
230 sk
->sk_allocation
= GFP_DMA
;
232 sock_reset_flag(sk
, SOCK_ZAPPED
);
234 sk
->sk_protocol
= proto
;
235 sk
->sk_state
= IUCV_OPEN
;
237 setup_timer(&sk
->sk_timer
, iucv_sock_timeout
, (unsigned long)sk
);
239 iucv_sock_link(&iucv_sk_list
, sk
);
243 /* Create an IUCV socket */
244 static int iucv_sock_create(struct net
*net
, struct socket
*sock
, int protocol
)
248 if (sock
->type
!= SOCK_STREAM
)
249 return -ESOCKTNOSUPPORT
;
251 sock
->state
= SS_UNCONNECTED
;
252 sock
->ops
= &iucv_sock_ops
;
254 sk
= iucv_sock_alloc(sock
, protocol
, GFP_KERNEL
);
258 iucv_sock_init(sk
, NULL
);
263 void iucv_sock_link(struct iucv_sock_list
*l
, struct sock
*sk
)
265 write_lock_bh(&l
->lock
);
266 sk_add_node(sk
, &l
->head
);
267 write_unlock_bh(&l
->lock
);
270 void iucv_sock_unlink(struct iucv_sock_list
*l
, struct sock
*sk
)
272 write_lock_bh(&l
->lock
);
273 sk_del_node_init(sk
);
274 write_unlock_bh(&l
->lock
);
277 void iucv_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
280 struct iucv_sock
*par
= iucv_sk(parent
);
283 spin_lock_irqsave(&par
->accept_q_lock
, flags
);
284 list_add_tail(&iucv_sk(sk
)->accept_q
, &par
->accept_q
);
285 spin_unlock_irqrestore(&par
->accept_q_lock
, flags
);
286 iucv_sk(sk
)->parent
= parent
;
287 parent
->sk_ack_backlog
++;
290 void iucv_accept_unlink(struct sock
*sk
)
293 struct iucv_sock
*par
= iucv_sk(iucv_sk(sk
)->parent
);
295 spin_lock_irqsave(&par
->accept_q_lock
, flags
);
296 list_del_init(&iucv_sk(sk
)->accept_q
);
297 spin_unlock_irqrestore(&par
->accept_q_lock
, flags
);
298 iucv_sk(sk
)->parent
->sk_ack_backlog
--;
299 iucv_sk(sk
)->parent
= NULL
;
303 struct sock
*iucv_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
305 struct iucv_sock
*isk
, *n
;
308 list_for_each_entry_safe(isk
, n
, &iucv_sk(parent
)->accept_q
, accept_q
) {
309 sk
= (struct sock
*) isk
;
312 if (sk
->sk_state
== IUCV_CLOSED
) {
313 iucv_accept_unlink(sk
);
318 if (sk
->sk_state
== IUCV_CONNECTED
||
319 sk
->sk_state
== IUCV_SEVERED
||
321 iucv_accept_unlink(sk
);
323 sock_graft(sk
, newsock
);
325 if (sk
->sk_state
== IUCV_SEVERED
)
326 sk
->sk_state
= IUCV_DISCONN
;
337 int iucv_sock_wait_state(struct sock
*sk
, int state
, int state2
,
340 DECLARE_WAITQUEUE(wait
, current
);
343 add_wait_queue(sk
->sk_sleep
, &wait
);
344 while (sk
->sk_state
!= state
&& sk
->sk_state
!= state2
) {
345 set_current_state(TASK_INTERRUPTIBLE
);
352 if (signal_pending(current
)) {
353 err
= sock_intr_errno(timeo
);
358 timeo
= schedule_timeout(timeo
);
361 err
= sock_error(sk
);
365 set_current_state(TASK_RUNNING
);
366 remove_wait_queue(sk
->sk_sleep
, &wait
);
370 /* Bind an unbound socket */
371 static int iucv_sock_bind(struct socket
*sock
, struct sockaddr
*addr
,
374 struct sockaddr_iucv
*sa
= (struct sockaddr_iucv
*) addr
;
375 struct sock
*sk
= sock
->sk
;
376 struct iucv_sock
*iucv
;
379 /* Verify the input sockaddr */
380 if (!addr
|| addr
->sa_family
!= AF_IUCV
)
384 if (sk
->sk_state
!= IUCV_OPEN
) {
389 write_lock_bh(&iucv_sk_list
.lock
);
392 if (__iucv_get_sock_by_name(sa
->siucv_name
)) {
401 /* Bind the socket */
402 memcpy(iucv
->src_name
, sa
->siucv_name
, 8);
404 /* Copy the user id */
405 memcpy(iucv
->src_user_id
, iucv_userid
, 8);
406 sk
->sk_state
= IUCV_BOUND
;
410 /* Release the socket list lock */
411 write_unlock_bh(&iucv_sk_list
.lock
);
417 /* Automatically bind an unbound socket */
418 static int iucv_sock_autobind(struct sock
*sk
)
420 struct iucv_sock
*iucv
= iucv_sk(sk
);
421 char query_buffer
[80];
425 /* Set the userid and name */
426 cpcmd("QUERY USERID", query_buffer
, sizeof(query_buffer
), &err
);
430 memcpy(iucv
->src_user_id
, query_buffer
, 8);
432 write_lock_bh(&iucv_sk_list
.lock
);
434 sprintf(name
, "%08x", atomic_inc_return(&iucv_sk_list
.autobind_name
));
435 while (__iucv_get_sock_by_name(name
)) {
436 sprintf(name
, "%08x",
437 atomic_inc_return(&iucv_sk_list
.autobind_name
));
440 write_unlock_bh(&iucv_sk_list
.lock
);
442 memcpy(&iucv
->src_name
, name
, 8);
447 /* Connect an unconnected socket */
448 static int iucv_sock_connect(struct socket
*sock
, struct sockaddr
*addr
,
451 struct sockaddr_iucv
*sa
= (struct sockaddr_iucv
*) addr
;
452 struct sock
*sk
= sock
->sk
;
453 struct iucv_sock
*iucv
;
454 unsigned char user_data
[16];
457 if (addr
->sa_family
!= AF_IUCV
|| alen
< sizeof(struct sockaddr_iucv
))
460 if (sk
->sk_state
!= IUCV_OPEN
&& sk
->sk_state
!= IUCV_BOUND
)
463 if (sk
->sk_type
!= SOCK_STREAM
)
468 if (sk
->sk_state
== IUCV_OPEN
) {
469 err
= iucv_sock_autobind(sk
);
476 /* Set the destination information */
477 memcpy(iucv_sk(sk
)->dst_user_id
, sa
->siucv_user_id
, 8);
478 memcpy(iucv_sk(sk
)->dst_name
, sa
->siucv_name
, 8);
480 high_nmcpy(user_data
, sa
->siucv_name
);
481 low_nmcpy(user_data
, iucv_sk(sk
)->src_name
);
482 ASCEBC(user_data
, sizeof(user_data
));
486 iucv
->path
= iucv_path_alloc(IUCV_QUEUELEN_DEFAULT
,
487 IPRMDATA
, GFP_KERNEL
);
492 err
= iucv_path_connect(iucv
->path
, &af_iucv_handler
,
493 sa
->siucv_user_id
, NULL
, user_data
, sk
);
495 iucv_path_free(iucv
->path
);
498 case 0x0b: /* Target communicator is not logged on */
501 case 0x0d: /* Max connections for this guest exceeded */
502 case 0x0e: /* Max connections for target guest exceeded */
505 case 0x0f: /* Missing IUCV authorization */
515 if (sk
->sk_state
!= IUCV_CONNECTED
) {
516 err
= iucv_sock_wait_state(sk
, IUCV_CONNECTED
, IUCV_DISCONN
,
517 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
520 if (sk
->sk_state
== IUCV_DISCONN
) {
522 return -ECONNREFUSED
;
529 /* Move a socket into listening state. */
530 static int iucv_sock_listen(struct socket
*sock
, int backlog
)
532 struct sock
*sk
= sock
->sk
;
538 if (sk
->sk_state
!= IUCV_BOUND
|| sock
->type
!= SOCK_STREAM
)
541 sk
->sk_max_ack_backlog
= backlog
;
542 sk
->sk_ack_backlog
= 0;
543 sk
->sk_state
= IUCV_LISTEN
;
551 /* Accept a pending connection */
552 static int iucv_sock_accept(struct socket
*sock
, struct socket
*newsock
,
555 DECLARE_WAITQUEUE(wait
, current
);
556 struct sock
*sk
= sock
->sk
, *nsk
;
560 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
562 if (sk
->sk_state
!= IUCV_LISTEN
) {
567 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
569 /* Wait for an incoming connection */
570 add_wait_queue_exclusive(sk
->sk_sleep
, &wait
);
571 while (!(nsk
= iucv_accept_dequeue(sk
, newsock
))) {
572 set_current_state(TASK_INTERRUPTIBLE
);
579 timeo
= schedule_timeout(timeo
);
580 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
582 if (sk
->sk_state
!= IUCV_LISTEN
) {
587 if (signal_pending(current
)) {
588 err
= sock_intr_errno(timeo
);
593 set_current_state(TASK_RUNNING
);
594 remove_wait_queue(sk
->sk_sleep
, &wait
);
599 newsock
->state
= SS_CONNECTED
;
606 static int iucv_sock_getname(struct socket
*sock
, struct sockaddr
*addr
,
609 struct sockaddr_iucv
*siucv
= (struct sockaddr_iucv
*) addr
;
610 struct sock
*sk
= sock
->sk
;
612 addr
->sa_family
= AF_IUCV
;
613 *len
= sizeof(struct sockaddr_iucv
);
616 memcpy(siucv
->siucv_user_id
, iucv_sk(sk
)->dst_user_id
, 8);
617 memcpy(siucv
->siucv_name
, &iucv_sk(sk
)->dst_name
, 8);
619 memcpy(siucv
->siucv_user_id
, iucv_sk(sk
)->src_user_id
, 8);
620 memcpy(siucv
->siucv_name
, iucv_sk(sk
)->src_name
, 8);
622 memset(&siucv
->siucv_port
, 0, sizeof(siucv
->siucv_port
));
623 memset(&siucv
->siucv_addr
, 0, sizeof(siucv
->siucv_addr
));
624 memset(siucv
->siucv_nodeid
, 0, sizeof(siucv
->siucv_nodeid
));
629 static int iucv_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
630 struct msghdr
*msg
, size_t len
)
632 struct sock
*sk
= sock
->sk
;
633 struct iucv_sock
*iucv
= iucv_sk(sk
);
635 struct iucv_message txmsg
;
640 err
= sock_error(sk
);
644 if (msg
->msg_flags
& MSG_OOB
)
649 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
654 if (sk
->sk_state
== IUCV_CONNECTED
) {
655 if (!(skb
= sock_alloc_send_skb(sk
, len
,
656 msg
->msg_flags
& MSG_DONTWAIT
,
660 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
666 memcpy(&txmsg
.class, skb
->data
, skb
->len
>= 4 ? 4 : skb
->len
);
667 txmsg
.tag
= iucv
->send_tag
++;
668 memcpy(skb
->cb
, &txmsg
.tag
, 4);
669 skb_queue_tail(&iucv
->send_skb_q
, skb
);
670 err
= iucv_message_send(iucv
->path
, &txmsg
, 0, 0,
671 (void *) skb
->data
, skb
->len
);
675 memcpy(user_id
, iucv
->dst_user_id
, 8);
677 memcpy(appl_id
, iucv
->dst_name
, 8);
678 pr_err("Application %s on z/VM guest %s"
679 " exceeds message limit\n",
682 skb_unlink(skb
, &iucv
->send_skb_q
);
702 static int iucv_fragment_skb(struct sock
*sk
, struct sk_buff
*skb
, int len
)
704 int dataleft
, size
, copied
= 0;
705 struct sk_buff
*nskb
;
709 if (dataleft
>= sk
->sk_rcvbuf
/ 4)
710 size
= sk
->sk_rcvbuf
/ 4;
714 nskb
= alloc_skb(size
, GFP_ATOMIC
| GFP_DMA
);
718 memcpy(nskb
->data
, skb
->data
+ copied
, size
);
722 skb_reset_transport_header(nskb
);
723 skb_reset_network_header(nskb
);
726 skb_queue_tail(&iucv_sk(sk
)->backlog_skb_q
, nskb
);
732 static void iucv_process_message(struct sock
*sk
, struct sk_buff
*skb
,
733 struct iucv_path
*path
,
734 struct iucv_message
*msg
)
738 if (msg
->flags
& IPRMDATA
) {
742 rc
= iucv_message_receive(path
, msg
, 0, skb
->data
,
748 if (skb
->truesize
>= sk
->sk_rcvbuf
/ 4) {
749 rc
= iucv_fragment_skb(sk
, skb
, msg
->length
);
753 iucv_path_sever(path
, NULL
);
756 skb
= skb_dequeue(&iucv_sk(sk
)->backlog_skb_q
);
758 skb_reset_transport_header(skb
);
759 skb_reset_network_header(skb
);
760 skb
->len
= msg
->length
;
764 if (sock_queue_rcv_skb(sk
, skb
))
765 skb_queue_head(&iucv_sk(sk
)->backlog_skb_q
, skb
);
768 static void iucv_process_message_q(struct sock
*sk
)
770 struct iucv_sock
*iucv
= iucv_sk(sk
);
772 struct sock_msg_q
*p
, *n
;
774 list_for_each_entry_safe(p
, n
, &iucv
->message_q
.list
, list
) {
775 skb
= alloc_skb(p
->msg
.length
, GFP_ATOMIC
| GFP_DMA
);
778 iucv_process_message(sk
, skb
, p
->path
, &p
->msg
);
781 if (!skb_queue_empty(&iucv
->backlog_skb_q
))
786 static int iucv_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
787 struct msghdr
*msg
, size_t len
, int flags
)
789 int noblock
= flags
& MSG_DONTWAIT
;
790 struct sock
*sk
= sock
->sk
;
791 struct iucv_sock
*iucv
= iucv_sk(sk
);
792 int target
, copied
= 0;
793 struct sk_buff
*skb
, *rskb
, *cskb
;
796 if ((sk
->sk_state
== IUCV_DISCONN
|| sk
->sk_state
== IUCV_SEVERED
) &&
797 skb_queue_empty(&iucv
->backlog_skb_q
) &&
798 skb_queue_empty(&sk
->sk_receive_queue
) &&
799 list_empty(&iucv
->message_q
.list
))
802 if (flags
& (MSG_OOB
))
805 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, len
);
807 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
809 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
814 copied
= min_t(unsigned int, skb
->len
, len
);
817 if (memcpy_toiovec(msg
->msg_iov
, cskb
->data
, copied
)) {
818 skb_queue_head(&sk
->sk_receive_queue
, skb
);
826 /* Mark read part of skb as used */
827 if (!(flags
& MSG_PEEK
)) {
828 skb_pull(skb
, copied
);
831 skb_queue_head(&sk
->sk_receive_queue
, skb
);
837 /* Queue backlog skbs */
838 rskb
= skb_dequeue(&iucv
->backlog_skb_q
);
840 if (sock_queue_rcv_skb(sk
, rskb
)) {
841 skb_queue_head(&iucv
->backlog_skb_q
,
845 rskb
= skb_dequeue(&iucv
->backlog_skb_q
);
848 if (skb_queue_empty(&iucv
->backlog_skb_q
)) {
849 spin_lock_bh(&iucv
->message_q
.lock
);
850 if (!list_empty(&iucv
->message_q
.list
))
851 iucv_process_message_q(sk
);
852 spin_unlock_bh(&iucv
->message_q
.lock
);
856 skb_queue_head(&sk
->sk_receive_queue
, skb
);
859 return err
? : copied
;
862 static inline unsigned int iucv_accept_poll(struct sock
*parent
)
864 struct iucv_sock
*isk
, *n
;
867 list_for_each_entry_safe(isk
, n
, &iucv_sk(parent
)->accept_q
, accept_q
) {
868 sk
= (struct sock
*) isk
;
870 if (sk
->sk_state
== IUCV_CONNECTED
)
871 return POLLIN
| POLLRDNORM
;
877 unsigned int iucv_sock_poll(struct file
*file
, struct socket
*sock
,
880 struct sock
*sk
= sock
->sk
;
881 unsigned int mask
= 0;
883 poll_wait(file
, sk
->sk_sleep
, wait
);
885 if (sk
->sk_state
== IUCV_LISTEN
)
886 return iucv_accept_poll(sk
);
888 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
891 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
894 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
897 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
898 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
899 mask
|= POLLIN
| POLLRDNORM
;
901 if (sk
->sk_state
== IUCV_CLOSED
)
904 if (sk
->sk_state
== IUCV_DISCONN
|| sk
->sk_state
== IUCV_SEVERED
)
907 if (sock_writeable(sk
))
908 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
910 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
915 static int iucv_sock_shutdown(struct socket
*sock
, int how
)
917 struct sock
*sk
= sock
->sk
;
918 struct iucv_sock
*iucv
= iucv_sk(sk
);
919 struct iucv_message txmsg
;
921 u8 prmmsg
[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
925 if ((how
& ~SHUTDOWN_MASK
) || !how
)
929 switch (sk
->sk_state
) {
935 sk
->sk_shutdown
|= how
;
939 if (how
== SEND_SHUTDOWN
|| how
== SHUTDOWN_MASK
) {
942 err
= iucv_message_send(iucv
->path
, &txmsg
, IUCV_IPRMDATA
, 0,
959 if (how
== RCV_SHUTDOWN
|| how
== SHUTDOWN_MASK
) {
960 err
= iucv_path_quiesce(iucv_sk(sk
)->path
, NULL
);
964 skb_queue_purge(&sk
->sk_receive_queue
);
967 /* Wake up anyone sleeping in poll */
968 sk
->sk_state_change(sk
);
975 static int iucv_sock_release(struct socket
*sock
)
977 struct sock
*sk
= sock
->sk
;
985 /* Unregister with IUCV base support */
986 if (iucv_sk(sk
)->path
) {
987 iucv_path_sever(iucv_sk(sk
)->path
, NULL
);
988 iucv_path_free(iucv_sk(sk
)->path
);
989 iucv_sk(sk
)->path
= NULL
;
997 /* Callback wrappers - called from iucv base support */
998 static int iucv_callback_connreq(struct iucv_path
*path
,
999 u8 ipvmid
[8], u8 ipuser
[16])
1001 unsigned char user_data
[16];
1002 unsigned char nuser_data
[16];
1003 unsigned char src_name
[8];
1004 struct hlist_node
*node
;
1005 struct sock
*sk
, *nsk
;
1006 struct iucv_sock
*iucv
, *niucv
;
1009 memcpy(src_name
, ipuser
, 8);
1010 EBCASC(src_name
, 8);
1011 /* Find out if this path belongs to af_iucv. */
1012 read_lock(&iucv_sk_list
.lock
);
1015 sk_for_each(sk
, node
, &iucv_sk_list
.head
)
1016 if (sk
->sk_state
== IUCV_LISTEN
&&
1017 !memcmp(&iucv_sk(sk
)->src_name
, src_name
, 8)) {
1019 * Found a listening socket with
1020 * src_name == ipuser[0-7].
1025 read_unlock(&iucv_sk_list
.lock
);
1027 /* No socket found, not one of our paths. */
1032 /* Check if parent socket is listening */
1033 low_nmcpy(user_data
, iucv
->src_name
);
1034 high_nmcpy(user_data
, iucv
->dst_name
);
1035 ASCEBC(user_data
, sizeof(user_data
));
1036 if (sk
->sk_state
!= IUCV_LISTEN
) {
1037 err
= iucv_path_sever(path
, user_data
);
1041 /* Check for backlog size */
1042 if (sk_acceptq_is_full(sk
)) {
1043 err
= iucv_path_sever(path
, user_data
);
1047 /* Create the new socket */
1048 nsk
= iucv_sock_alloc(NULL
, SOCK_STREAM
, GFP_ATOMIC
);
1050 err
= iucv_path_sever(path
, user_data
);
1054 niucv
= iucv_sk(nsk
);
1055 iucv_sock_init(nsk
, sk
);
1057 /* Set the new iucv_sock */
1058 memcpy(niucv
->dst_name
, ipuser
+ 8, 8);
1059 EBCASC(niucv
->dst_name
, 8);
1060 memcpy(niucv
->dst_user_id
, ipvmid
, 8);
1061 memcpy(niucv
->src_name
, iucv
->src_name
, 8);
1062 memcpy(niucv
->src_user_id
, iucv
->src_user_id
, 8);
1065 /* Call iucv_accept */
1066 high_nmcpy(nuser_data
, ipuser
+ 8);
1067 memcpy(nuser_data
+ 8, niucv
->src_name
, 8);
1068 ASCEBC(nuser_data
+ 8, 8);
1070 path
->msglim
= IUCV_QUEUELEN_DEFAULT
;
1071 err
= iucv_path_accept(path
, &af_iucv_handler
, nuser_data
, nsk
);
1073 err
= iucv_path_sever(path
, user_data
);
1077 iucv_accept_enqueue(sk
, nsk
);
1079 /* Wake up accept */
1080 nsk
->sk_state
= IUCV_CONNECTED
;
1081 sk
->sk_data_ready(sk
, 1);
1088 static void iucv_callback_connack(struct iucv_path
*path
, u8 ipuser
[16])
1090 struct sock
*sk
= path
->private;
1092 sk
->sk_state
= IUCV_CONNECTED
;
1093 sk
->sk_state_change(sk
);
1096 static void iucv_callback_rx(struct iucv_path
*path
, struct iucv_message
*msg
)
1098 struct sock
*sk
= path
->private;
1099 struct iucv_sock
*iucv
= iucv_sk(sk
);
1100 struct sk_buff
*skb
;
1101 struct sock_msg_q
*save_msg
;
1104 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1107 if (!list_empty(&iucv
->message_q
.list
) ||
1108 !skb_queue_empty(&iucv
->backlog_skb_q
))
1111 len
= atomic_read(&sk
->sk_rmem_alloc
);
1112 len
+= msg
->length
+ sizeof(struct sk_buff
);
1113 if (len
> sk
->sk_rcvbuf
)
1116 skb
= alloc_skb(msg
->length
, GFP_ATOMIC
| GFP_DMA
);
1120 spin_lock(&iucv
->message_q
.lock
);
1121 iucv_process_message(sk
, skb
, path
, msg
);
1122 spin_unlock(&iucv
->message_q
.lock
);
1127 save_msg
= kzalloc(sizeof(struct sock_msg_q
), GFP_ATOMIC
| GFP_DMA
);
1130 save_msg
->path
= path
;
1131 save_msg
->msg
= *msg
;
1133 spin_lock(&iucv
->message_q
.lock
);
1134 list_add_tail(&save_msg
->list
, &iucv
->message_q
.list
);
1135 spin_unlock(&iucv
->message_q
.lock
);
1138 static void iucv_callback_txdone(struct iucv_path
*path
,
1139 struct iucv_message
*msg
)
1141 struct sock
*sk
= path
->private;
1142 struct sk_buff
*this = NULL
;
1143 struct sk_buff_head
*list
= &iucv_sk(sk
)->send_skb_q
;
1144 struct sk_buff
*list_skb
= list
->next
;
1145 unsigned long flags
;
1147 if (!skb_queue_empty(list
)) {
1148 spin_lock_irqsave(&list
->lock
, flags
);
1150 while (list_skb
!= (struct sk_buff
*)list
) {
1151 if (!memcmp(&msg
->tag
, list_skb
->cb
, 4)) {
1155 list_skb
= list_skb
->next
;
1158 __skb_unlink(this, list
);
1160 spin_unlock_irqrestore(&list
->lock
, flags
);
1167 if (sk
->sk_state
== IUCV_CLOSING
) {
1168 if (skb_queue_empty(&iucv_sk(sk
)->send_skb_q
)) {
1169 sk
->sk_state
= IUCV_CLOSED
;
1170 sk
->sk_state_change(sk
);
1176 static void iucv_callback_connrej(struct iucv_path
*path
, u8 ipuser
[16])
1178 struct sock
*sk
= path
->private;
1180 if (!list_empty(&iucv_sk(sk
)->accept_q
))
1181 sk
->sk_state
= IUCV_SEVERED
;
1183 sk
->sk_state
= IUCV_DISCONN
;
1185 sk
->sk_state_change(sk
);
1188 static struct proto_ops iucv_sock_ops
= {
1190 .owner
= THIS_MODULE
,
1191 .release
= iucv_sock_release
,
1192 .bind
= iucv_sock_bind
,
1193 .connect
= iucv_sock_connect
,
1194 .listen
= iucv_sock_listen
,
1195 .accept
= iucv_sock_accept
,
1196 .getname
= iucv_sock_getname
,
1197 .sendmsg
= iucv_sock_sendmsg
,
1198 .recvmsg
= iucv_sock_recvmsg
,
1199 .poll
= iucv_sock_poll
,
1200 .ioctl
= sock_no_ioctl
,
1201 .mmap
= sock_no_mmap
,
1202 .socketpair
= sock_no_socketpair
,
1203 .shutdown
= iucv_sock_shutdown
,
1204 .setsockopt
= sock_no_setsockopt
,
1205 .getsockopt
= sock_no_getsockopt
1208 static struct net_proto_family iucv_sock_family_ops
= {
1210 .owner
= THIS_MODULE
,
1211 .create
= iucv_sock_create
,
1214 static int __init
afiucv_init(void)
1218 if (!MACHINE_IS_VM
) {
1219 pr_err("The af_iucv module cannot be loaded"
1221 err
= -EPROTONOSUPPORT
;
1224 cpcmd("QUERY USERID", iucv_userid
, sizeof(iucv_userid
), &err
);
1225 if (unlikely(err
)) {
1227 err
= -EPROTONOSUPPORT
;
1231 err
= iucv_register(&af_iucv_handler
, 0);
1234 err
= proto_register(&iucv_proto
, 0);
1237 err
= sock_register(&iucv_sock_family_ops
);
1243 proto_unregister(&iucv_proto
);
1245 iucv_unregister(&af_iucv_handler
, 0);
1250 static void __exit
afiucv_exit(void)
1252 sock_unregister(PF_IUCV
);
1253 proto_unregister(&iucv_proto
);
1254 iucv_unregister(&af_iucv_handler
, 0);
1257 module_init(afiucv_init
);
1258 module_exit(afiucv_exit
);
1260 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
1261 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION
);
1262 MODULE_VERSION(VERSION
);
1263 MODULE_LICENSE("GPL");
1264 MODULE_ALIAS_NETPROTO(PF_IUCV
);