2 * IUCV protocol stack for Linux on zSeries
4 * Copyright IBM Corp. 2006, 2009
6 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com>
7 * Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
9 * Ursula Braun <ursula.braun@de.ibm.com>
12 #define KMSG_COMPONENT "af_iucv"
13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/list.h>
18 #include <linux/errno.h>
19 #include <linux/kernel.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/skbuff.h>
23 #include <linux/init.h>
24 #include <linux/poll.h>
26 #include <asm/ebcdic.h>
27 #include <asm/cpcmd.h>
28 #include <linux/kmod.h>
30 #include <net/iucv/af_iucv.h>
34 static char iucv_userid
[80];
36 static const struct proto_ops iucv_sock_ops
;
38 static struct proto iucv_proto
= {
41 .obj_size
= sizeof(struct iucv_sock
),
44 static struct iucv_interface
*pr_iucv
;
46 /* special AF_IUCV IPRM messages */
47 static const u8 iprm_shutdown
[8] =
48 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
50 #define TRGCLS_SIZE (sizeof(((struct iucv_message *)0)->class))
52 #define __iucv_sock_wait(sk, condition, timeo, ret) \
54 DEFINE_WAIT(__wait); \
55 long __timeo = timeo; \
57 prepare_to_wait(sk_sleep(sk), &__wait, TASK_INTERRUPTIBLE); \
58 while (!(condition)) { \
63 if (signal_pending(current)) { \
64 ret = sock_intr_errno(__timeo); \
68 __timeo = schedule_timeout(__timeo); \
70 ret = sock_error(sk); \
74 finish_wait(sk_sleep(sk), &__wait); \
77 #define iucv_sock_wait(sk, condition, timeo) \
81 __iucv_sock_wait(sk, condition, timeo, __ret); \
85 static void iucv_sock_kill(struct sock
*sk
);
86 static void iucv_sock_close(struct sock
*sk
);
87 static void iucv_sever_path(struct sock
*, int);
89 static int afiucv_hs_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
90 struct packet_type
*pt
, struct net_device
*orig_dev
);
91 static int afiucv_hs_send(struct iucv_message
*imsg
, struct sock
*sock
,
92 struct sk_buff
*skb
, u8 flags
);
93 static void afiucv_hs_callback_txnotify(struct sk_buff
*, enum iucv_tx_notify
);
95 /* Call Back functions */
96 static void iucv_callback_rx(struct iucv_path
*, struct iucv_message
*);
97 static void iucv_callback_txdone(struct iucv_path
*, struct iucv_message
*);
98 static void iucv_callback_connack(struct iucv_path
*, u8 ipuser
[16]);
99 static int iucv_callback_connreq(struct iucv_path
*, u8 ipvmid
[8],
101 static void iucv_callback_connrej(struct iucv_path
*, u8 ipuser
[16]);
102 static void iucv_callback_shutdown(struct iucv_path
*, u8 ipuser
[16]);
104 static struct iucv_sock_list iucv_sk_list
= {
105 .lock
= __RW_LOCK_UNLOCKED(iucv_sk_list
.lock
),
106 .autobind_name
= ATOMIC_INIT(0)
109 static struct iucv_handler af_iucv_handler
= {
110 .path_pending
= iucv_callback_connreq
,
111 .path_complete
= iucv_callback_connack
,
112 .path_severed
= iucv_callback_connrej
,
113 .message_pending
= iucv_callback_rx
,
114 .message_complete
= iucv_callback_txdone
,
115 .path_quiesced
= iucv_callback_shutdown
,
118 static inline void high_nmcpy(unsigned char *dst
, char *src
)
123 static inline void low_nmcpy(unsigned char *dst
, char *src
)
125 memcpy(&dst
[8], src
, 8);
128 static int afiucv_pm_prepare(struct device
*dev
)
130 #ifdef CONFIG_PM_DEBUG
131 printk(KERN_WARNING
"afiucv_pm_prepare\n");
136 static void afiucv_pm_complete(struct device
*dev
)
138 #ifdef CONFIG_PM_DEBUG
139 printk(KERN_WARNING
"afiucv_pm_complete\n");
144 * afiucv_pm_freeze() - Freeze PM callback
145 * @dev: AFIUCV dummy device
147 * Sever all established IUCV communication pathes
149 static int afiucv_pm_freeze(struct device
*dev
)
151 struct iucv_sock
*iucv
;
155 #ifdef CONFIG_PM_DEBUG
156 printk(KERN_WARNING
"afiucv_pm_freeze\n");
158 read_lock(&iucv_sk_list
.lock
);
159 sk_for_each(sk
, &iucv_sk_list
.head
) {
161 switch (sk
->sk_state
) {
165 iucv_sever_path(sk
, 0);
174 skb_queue_purge(&iucv
->send_skb_q
);
175 skb_queue_purge(&iucv
->backlog_skb_q
);
177 read_unlock(&iucv_sk_list
.lock
);
182 * afiucv_pm_restore_thaw() - Thaw and restore PM callback
183 * @dev: AFIUCV dummy device
185 * socket clean up after freeze
187 static int afiucv_pm_restore_thaw(struct device
*dev
)
191 #ifdef CONFIG_PM_DEBUG
192 printk(KERN_WARNING
"afiucv_pm_restore_thaw\n");
194 read_lock(&iucv_sk_list
.lock
);
195 sk_for_each(sk
, &iucv_sk_list
.head
) {
196 switch (sk
->sk_state
) {
199 sk
->sk_state
= IUCV_DISCONN
;
200 sk
->sk_state_change(sk
);
211 read_unlock(&iucv_sk_list
.lock
);
215 static const struct dev_pm_ops afiucv_pm_ops
= {
216 .prepare
= afiucv_pm_prepare
,
217 .complete
= afiucv_pm_complete
,
218 .freeze
= afiucv_pm_freeze
,
219 .thaw
= afiucv_pm_restore_thaw
,
220 .restore
= afiucv_pm_restore_thaw
,
223 static struct device_driver af_iucv_driver
= {
224 .owner
= THIS_MODULE
,
227 .pm
= &afiucv_pm_ops
,
230 /* dummy device used as trigger for PM functions */
231 static struct device
*af_iucv_dev
;
234 * iucv_msg_length() - Returns the length of an iucv message.
235 * @msg: Pointer to struct iucv_message, MUST NOT be NULL
237 * The function returns the length of the specified iucv message @msg of data
238 * stored in a buffer and of data stored in the parameter list (PRMDATA).
240 * For IUCV_IPRMDATA, AF_IUCV uses the following convention to transport socket
242 * PRMDATA[0..6] socket data (max 7 bytes);
243 * PRMDATA[7] socket data length value (len is 0xff - PRMDATA[7])
245 * The socket data length is computed by subtracting the socket data length
247 * If the socket data len is greater 7, then PRMDATA can be used for special
248 * notifications (see iucv_sock_shutdown); and further,
249 * if the socket data len is > 7, the function returns 8.
251 * Use this function to allocate socket buffers to store iucv message data.
253 static inline size_t iucv_msg_length(struct iucv_message
*msg
)
257 if (msg
->flags
& IUCV_IPRMDATA
) {
258 datalen
= 0xff - msg
->rmmsg
[7];
259 return (datalen
< 8) ? datalen
: 8;
265 * iucv_sock_in_state() - check for specific states
266 * @sk: sock structure
267 * @state: first iucv sk state
268 * @state: second iucv sk state
270 * Returns true if the socket in either in the first or second state.
272 static int iucv_sock_in_state(struct sock
*sk
, int state
, int state2
)
274 return (sk
->sk_state
== state
|| sk
->sk_state
== state2
);
278 * iucv_below_msglim() - function to check if messages can be sent
279 * @sk: sock structure
281 * Returns true if the send queue length is lower than the message limit.
282 * Always returns true if the socket is not connected (no iucv path for
283 * checking the message limit).
285 static inline int iucv_below_msglim(struct sock
*sk
)
287 struct iucv_sock
*iucv
= iucv_sk(sk
);
289 if (sk
->sk_state
!= IUCV_CONNECTED
)
291 if (iucv
->transport
== AF_IUCV_TRANS_IUCV
)
292 return (skb_queue_len(&iucv
->send_skb_q
) < iucv
->path
->msglim
);
294 return ((atomic_read(&iucv
->msg_sent
) < iucv
->msglimit_peer
) &&
295 (atomic_read(&iucv
->pendings
) <= 0));
299 * iucv_sock_wake_msglim() - Wake up thread waiting on msg limit
301 static void iucv_sock_wake_msglim(struct sock
*sk
)
303 struct socket_wq
*wq
;
306 wq
= rcu_dereference(sk
->sk_wq
);
307 if (wq_has_sleeper(wq
))
308 wake_up_interruptible_all(&wq
->wait
);
309 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
314 * afiucv_hs_send() - send a message through HiperSockets transport
316 static int afiucv_hs_send(struct iucv_message
*imsg
, struct sock
*sock
,
317 struct sk_buff
*skb
, u8 flags
)
319 struct iucv_sock
*iucv
= iucv_sk(sock
);
320 struct af_iucv_trans_hdr
*phs_hdr
;
321 struct sk_buff
*nskb
;
322 int err
, confirm_recv
= 0;
324 memset(skb
->head
, 0, ETH_HLEN
);
325 phs_hdr
= (struct af_iucv_trans_hdr
*)skb_push(skb
,
326 sizeof(struct af_iucv_trans_hdr
));
327 skb_reset_mac_header(skb
);
328 skb_reset_network_header(skb
);
329 skb_push(skb
, ETH_HLEN
);
330 skb_reset_mac_header(skb
);
331 memset(phs_hdr
, 0, sizeof(struct af_iucv_trans_hdr
));
333 phs_hdr
->magic
= ETH_P_AF_IUCV
;
334 phs_hdr
->version
= 1;
335 phs_hdr
->flags
= flags
;
336 if (flags
== AF_IUCV_FLAG_SYN
)
337 phs_hdr
->window
= iucv
->msglimit
;
338 else if ((flags
== AF_IUCV_FLAG_WIN
) || !flags
) {
339 confirm_recv
= atomic_read(&iucv
->msg_recv
);
340 phs_hdr
->window
= confirm_recv
;
342 phs_hdr
->flags
= phs_hdr
->flags
| AF_IUCV_FLAG_WIN
;
344 memcpy(phs_hdr
->destUserID
, iucv
->dst_user_id
, 8);
345 memcpy(phs_hdr
->destAppName
, iucv
->dst_name
, 8);
346 memcpy(phs_hdr
->srcUserID
, iucv
->src_user_id
, 8);
347 memcpy(phs_hdr
->srcAppName
, iucv
->src_name
, 8);
348 ASCEBC(phs_hdr
->destUserID
, sizeof(phs_hdr
->destUserID
));
349 ASCEBC(phs_hdr
->destAppName
, sizeof(phs_hdr
->destAppName
));
350 ASCEBC(phs_hdr
->srcUserID
, sizeof(phs_hdr
->srcUserID
));
351 ASCEBC(phs_hdr
->srcAppName
, sizeof(phs_hdr
->srcAppName
));
353 memcpy(&phs_hdr
->iucv_hdr
, imsg
, sizeof(struct iucv_message
));
355 skb
->dev
= iucv
->hs_dev
;
358 if (!(skb
->dev
->flags
& IFF_UP
) || !netif_carrier_ok(skb
->dev
))
360 if (skb
->len
> skb
->dev
->mtu
) {
361 if (sock
->sk_type
== SOCK_SEQPACKET
)
364 skb_trim(skb
, skb
->dev
->mtu
);
366 skb
->protocol
= ETH_P_AF_IUCV
;
367 nskb
= skb_clone(skb
, GFP_ATOMIC
);
370 skb_queue_tail(&iucv
->send_skb_q
, nskb
);
371 err
= dev_queue_xmit(skb
);
372 if (net_xmit_eval(err
)) {
373 skb_unlink(nskb
, &iucv
->send_skb_q
);
376 atomic_sub(confirm_recv
, &iucv
->msg_recv
);
377 WARN_ON(atomic_read(&iucv
->msg_recv
) < 0);
379 return net_xmit_eval(err
);
382 static struct sock
*__iucv_get_sock_by_name(char *nm
)
386 sk_for_each(sk
, &iucv_sk_list
.head
)
387 if (!memcmp(&iucv_sk(sk
)->src_name
, nm
, 8))
393 static void iucv_sock_destruct(struct sock
*sk
)
395 skb_queue_purge(&sk
->sk_receive_queue
);
396 skb_queue_purge(&sk
->sk_error_queue
);
400 if (!sock_flag(sk
, SOCK_DEAD
)) {
401 pr_err("Attempt to release alive iucv socket %p\n", sk
);
405 WARN_ON(atomic_read(&sk
->sk_rmem_alloc
));
406 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
407 WARN_ON(sk
->sk_wmem_queued
);
408 WARN_ON(sk
->sk_forward_alloc
);
412 static void iucv_sock_cleanup_listen(struct sock
*parent
)
416 /* Close non-accepted connections */
417 while ((sk
= iucv_accept_dequeue(parent
, NULL
))) {
422 parent
->sk_state
= IUCV_CLOSED
;
425 /* Kill socket (only if zapped and orphaned) */
426 static void iucv_sock_kill(struct sock
*sk
)
428 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
431 iucv_sock_unlink(&iucv_sk_list
, sk
);
432 sock_set_flag(sk
, SOCK_DEAD
);
436 /* Terminate an IUCV path */
437 static void iucv_sever_path(struct sock
*sk
, int with_user_data
)
439 unsigned char user_data
[16];
440 struct iucv_sock
*iucv
= iucv_sk(sk
);
441 struct iucv_path
*path
= iucv
->path
;
445 if (with_user_data
) {
446 low_nmcpy(user_data
, iucv
->src_name
);
447 high_nmcpy(user_data
, iucv
->dst_name
);
448 ASCEBC(user_data
, sizeof(user_data
));
449 pr_iucv
->path_sever(path
, user_data
);
451 pr_iucv
->path_sever(path
, NULL
);
452 iucv_path_free(path
);
456 /* Send FIN through an IUCV socket for HIPER transport */
457 static int iucv_send_ctrl(struct sock
*sk
, u8 flags
)
463 blen
= sizeof(struct af_iucv_trans_hdr
) + ETH_HLEN
;
464 skb
= sock_alloc_send_skb(sk
, blen
, 1, &err
);
466 skb_reserve(skb
, blen
);
467 err
= afiucv_hs_send(NULL
, sk
, skb
, flags
);
472 /* Close an IUCV socket */
473 static void iucv_sock_close(struct sock
*sk
)
475 struct iucv_sock
*iucv
= iucv_sk(sk
);
481 switch (sk
->sk_state
) {
483 iucv_sock_cleanup_listen(sk
);
487 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
) {
488 err
= iucv_send_ctrl(sk
, AF_IUCV_FLAG_FIN
);
489 sk
->sk_state
= IUCV_DISCONN
;
490 sk
->sk_state_change(sk
);
492 case IUCV_DISCONN
: /* fall through */
493 sk
->sk_state
= IUCV_CLOSING
;
494 sk
->sk_state_change(sk
);
496 if (!err
&& !skb_queue_empty(&iucv
->send_skb_q
)) {
497 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
498 timeo
= sk
->sk_lingertime
;
500 timeo
= IUCV_DISCONN_TIMEOUT
;
502 iucv_sock_in_state(sk
, IUCV_CLOSED
, 0),
506 case IUCV_CLOSING
: /* fall through */
507 sk
->sk_state
= IUCV_CLOSED
;
508 sk
->sk_state_change(sk
);
510 sk
->sk_err
= ECONNRESET
;
511 sk
->sk_state_change(sk
);
513 skb_queue_purge(&iucv
->send_skb_q
);
514 skb_queue_purge(&iucv
->backlog_skb_q
);
516 default: /* fall through */
517 iucv_sever_path(sk
, 1);
521 dev_put(iucv
->hs_dev
);
523 sk
->sk_bound_dev_if
= 0;
526 /* mark socket for deletion by iucv_sock_kill() */
527 sock_set_flag(sk
, SOCK_ZAPPED
);
532 static void iucv_sock_init(struct sock
*sk
, struct sock
*parent
)
535 sk
->sk_type
= parent
->sk_type
;
538 static struct sock
*iucv_sock_alloc(struct socket
*sock
, int proto
, gfp_t prio
)
541 struct iucv_sock
*iucv
;
543 sk
= sk_alloc(&init_net
, PF_IUCV
, prio
, &iucv_proto
);
548 sock_init_data(sock
, sk
);
549 INIT_LIST_HEAD(&iucv
->accept_q
);
550 spin_lock_init(&iucv
->accept_q_lock
);
551 skb_queue_head_init(&iucv
->send_skb_q
);
552 INIT_LIST_HEAD(&iucv
->message_q
.list
);
553 spin_lock_init(&iucv
->message_q
.lock
);
554 skb_queue_head_init(&iucv
->backlog_skb_q
);
556 atomic_set(&iucv
->pendings
, 0);
559 atomic_set(&iucv
->msg_sent
, 0);
560 atomic_set(&iucv
->msg_recv
, 0);
562 iucv
->sk_txnotify
= afiucv_hs_callback_txnotify
;
563 memset(&iucv
->src_user_id
, 0, 32);
565 iucv
->transport
= AF_IUCV_TRANS_IUCV
;
567 iucv
->transport
= AF_IUCV_TRANS_HIPER
;
569 sk
->sk_destruct
= iucv_sock_destruct
;
570 sk
->sk_sndtimeo
= IUCV_CONN_TIMEOUT
;
571 sk
->sk_allocation
= GFP_DMA
;
573 sock_reset_flag(sk
, SOCK_ZAPPED
);
575 sk
->sk_protocol
= proto
;
576 sk
->sk_state
= IUCV_OPEN
;
578 iucv_sock_link(&iucv_sk_list
, sk
);
582 /* Create an IUCV socket */
583 static int iucv_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
588 if (protocol
&& protocol
!= PF_IUCV
)
589 return -EPROTONOSUPPORT
;
591 sock
->state
= SS_UNCONNECTED
;
593 switch (sock
->type
) {
595 sock
->ops
= &iucv_sock_ops
;
598 /* currently, proto ops can handle both sk types */
599 sock
->ops
= &iucv_sock_ops
;
602 return -ESOCKTNOSUPPORT
;
605 sk
= iucv_sock_alloc(sock
, protocol
, GFP_KERNEL
);
609 iucv_sock_init(sk
, NULL
);
614 void iucv_sock_link(struct iucv_sock_list
*l
, struct sock
*sk
)
616 write_lock_bh(&l
->lock
);
617 sk_add_node(sk
, &l
->head
);
618 write_unlock_bh(&l
->lock
);
621 void iucv_sock_unlink(struct iucv_sock_list
*l
, struct sock
*sk
)
623 write_lock_bh(&l
->lock
);
624 sk_del_node_init(sk
);
625 write_unlock_bh(&l
->lock
);
628 void iucv_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
631 struct iucv_sock
*par
= iucv_sk(parent
);
634 spin_lock_irqsave(&par
->accept_q_lock
, flags
);
635 list_add_tail(&iucv_sk(sk
)->accept_q
, &par
->accept_q
);
636 spin_unlock_irqrestore(&par
->accept_q_lock
, flags
);
637 iucv_sk(sk
)->parent
= parent
;
638 sk_acceptq_added(parent
);
641 void iucv_accept_unlink(struct sock
*sk
)
644 struct iucv_sock
*par
= iucv_sk(iucv_sk(sk
)->parent
);
646 spin_lock_irqsave(&par
->accept_q_lock
, flags
);
647 list_del_init(&iucv_sk(sk
)->accept_q
);
648 spin_unlock_irqrestore(&par
->accept_q_lock
, flags
);
649 sk_acceptq_removed(iucv_sk(sk
)->parent
);
650 iucv_sk(sk
)->parent
= NULL
;
654 struct sock
*iucv_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
656 struct iucv_sock
*isk
, *n
;
659 list_for_each_entry_safe(isk
, n
, &iucv_sk(parent
)->accept_q
, accept_q
) {
660 sk
= (struct sock
*) isk
;
663 if (sk
->sk_state
== IUCV_CLOSED
) {
664 iucv_accept_unlink(sk
);
669 if (sk
->sk_state
== IUCV_CONNECTED
||
670 sk
->sk_state
== IUCV_DISCONN
||
672 iucv_accept_unlink(sk
);
674 sock_graft(sk
, newsock
);
685 static void __iucv_auto_name(struct iucv_sock
*iucv
)
689 sprintf(name
, "%08x", atomic_inc_return(&iucv_sk_list
.autobind_name
));
690 while (__iucv_get_sock_by_name(name
)) {
691 sprintf(name
, "%08x",
692 atomic_inc_return(&iucv_sk_list
.autobind_name
));
694 memcpy(iucv
->src_name
, name
, 8);
697 /* Bind an unbound socket */
698 static int iucv_sock_bind(struct socket
*sock
, struct sockaddr
*addr
,
701 struct sockaddr_iucv
*sa
= (struct sockaddr_iucv
*) addr
;
702 struct sock
*sk
= sock
->sk
;
703 struct iucv_sock
*iucv
;
705 struct net_device
*dev
;
708 /* Verify the input sockaddr */
709 if (!addr
|| addr
->sa_family
!= AF_IUCV
)
713 if (sk
->sk_state
!= IUCV_OPEN
) {
718 write_lock_bh(&iucv_sk_list
.lock
);
721 if (__iucv_get_sock_by_name(sa
->siucv_name
)) {
728 /* Bind the socket */
730 if (!memcmp(sa
->siucv_user_id
, iucv_userid
, 8))
731 goto vm_bind
; /* VM IUCV transport */
733 /* try hiper transport */
734 memcpy(uid
, sa
->siucv_user_id
, sizeof(uid
));
737 for_each_netdev_rcu(&init_net
, dev
) {
738 if (!memcmp(dev
->perm_addr
, uid
, 8)) {
739 memcpy(iucv
->src_user_id
, sa
->siucv_user_id
, 8);
740 /* Check for unitialized siucv_name */
741 if (strncmp(sa
->siucv_name
, " ", 8) == 0)
742 __iucv_auto_name(iucv
);
744 memcpy(iucv
->src_name
, sa
->siucv_name
, 8);
745 sk
->sk_bound_dev_if
= dev
->ifindex
;
748 sk
->sk_state
= IUCV_BOUND
;
749 iucv
->transport
= AF_IUCV_TRANS_HIPER
;
751 iucv
->msglimit
= IUCV_HIPER_MSGLIM_DEFAULT
;
759 /* use local userid for backward compat */
760 memcpy(iucv
->src_name
, sa
->siucv_name
, 8);
761 memcpy(iucv
->src_user_id
, iucv_userid
, 8);
762 sk
->sk_state
= IUCV_BOUND
;
763 iucv
->transport
= AF_IUCV_TRANS_IUCV
;
765 iucv
->msglimit
= IUCV_QUEUELEN_DEFAULT
;
768 /* found no dev to bind */
771 /* Release the socket list lock */
772 write_unlock_bh(&iucv_sk_list
.lock
);
778 /* Automatically bind an unbound socket */
779 static int iucv_sock_autobind(struct sock
*sk
)
781 struct iucv_sock
*iucv
= iucv_sk(sk
);
784 if (unlikely(!pr_iucv
))
787 memcpy(iucv
->src_user_id
, iucv_userid
, 8);
789 write_lock_bh(&iucv_sk_list
.lock
);
790 __iucv_auto_name(iucv
);
791 write_unlock_bh(&iucv_sk_list
.lock
);
794 iucv
->msglimit
= IUCV_QUEUELEN_DEFAULT
;
799 static int afiucv_path_connect(struct socket
*sock
, struct sockaddr
*addr
)
801 struct sockaddr_iucv
*sa
= (struct sockaddr_iucv
*) addr
;
802 struct sock
*sk
= sock
->sk
;
803 struct iucv_sock
*iucv
= iucv_sk(sk
);
804 unsigned char user_data
[16];
807 high_nmcpy(user_data
, sa
->siucv_name
);
808 low_nmcpy(user_data
, iucv
->src_name
);
809 ASCEBC(user_data
, sizeof(user_data
));
812 iucv
->path
= iucv_path_alloc(iucv
->msglimit
,
813 IUCV_IPRMDATA
, GFP_KERNEL
);
818 err
= pr_iucv
->path_connect(iucv
->path
, &af_iucv_handler
,
819 sa
->siucv_user_id
, NULL
, user_data
,
822 iucv_path_free(iucv
->path
);
825 case 0x0b: /* Target communicator is not logged on */
828 case 0x0d: /* Max connections for this guest exceeded */
829 case 0x0e: /* Max connections for target guest exceeded */
832 case 0x0f: /* Missing IUCV authorization */
844 /* Connect an unconnected socket */
845 static int iucv_sock_connect(struct socket
*sock
, struct sockaddr
*addr
,
848 struct sockaddr_iucv
*sa
= (struct sockaddr_iucv
*) addr
;
849 struct sock
*sk
= sock
->sk
;
850 struct iucv_sock
*iucv
= iucv_sk(sk
);
853 if (addr
->sa_family
!= AF_IUCV
|| alen
< sizeof(struct sockaddr_iucv
))
856 if (sk
->sk_state
!= IUCV_OPEN
&& sk
->sk_state
!= IUCV_BOUND
)
859 if (sk
->sk_state
== IUCV_OPEN
&&
860 iucv
->transport
== AF_IUCV_TRANS_HIPER
)
861 return -EBADFD
; /* explicit bind required */
863 if (sk
->sk_type
!= SOCK_STREAM
&& sk
->sk_type
!= SOCK_SEQPACKET
)
866 if (sk
->sk_state
== IUCV_OPEN
) {
867 err
= iucv_sock_autobind(sk
);
874 /* Set the destination information */
875 memcpy(iucv
->dst_user_id
, sa
->siucv_user_id
, 8);
876 memcpy(iucv
->dst_name
, sa
->siucv_name
, 8);
878 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
)
879 err
= iucv_send_ctrl(sock
->sk
, AF_IUCV_FLAG_SYN
);
881 err
= afiucv_path_connect(sock
, addr
);
885 if (sk
->sk_state
!= IUCV_CONNECTED
)
886 err
= iucv_sock_wait(sk
, iucv_sock_in_state(sk
, IUCV_CONNECTED
,
888 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
890 if (sk
->sk_state
== IUCV_DISCONN
|| sk
->sk_state
== IUCV_CLOSED
)
893 if (err
&& iucv
->transport
== AF_IUCV_TRANS_IUCV
)
894 iucv_sever_path(sk
, 0);
901 /* Move a socket into listening state. */
902 static int iucv_sock_listen(struct socket
*sock
, int backlog
)
904 struct sock
*sk
= sock
->sk
;
910 if (sk
->sk_state
!= IUCV_BOUND
)
913 if (sock
->type
!= SOCK_STREAM
&& sock
->type
!= SOCK_SEQPACKET
)
916 sk
->sk_max_ack_backlog
= backlog
;
917 sk
->sk_ack_backlog
= 0;
918 sk
->sk_state
= IUCV_LISTEN
;
926 /* Accept a pending connection */
927 static int iucv_sock_accept(struct socket
*sock
, struct socket
*newsock
,
930 DECLARE_WAITQUEUE(wait
, current
);
931 struct sock
*sk
= sock
->sk
, *nsk
;
935 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
937 if (sk
->sk_state
!= IUCV_LISTEN
) {
942 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
944 /* Wait for an incoming connection */
945 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
946 while (!(nsk
= iucv_accept_dequeue(sk
, newsock
))) {
947 set_current_state(TASK_INTERRUPTIBLE
);
954 timeo
= schedule_timeout(timeo
);
955 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
957 if (sk
->sk_state
!= IUCV_LISTEN
) {
962 if (signal_pending(current
)) {
963 err
= sock_intr_errno(timeo
);
968 set_current_state(TASK_RUNNING
);
969 remove_wait_queue(sk_sleep(sk
), &wait
);
974 newsock
->state
= SS_CONNECTED
;
981 static int iucv_sock_getname(struct socket
*sock
, struct sockaddr
*addr
,
984 struct sockaddr_iucv
*siucv
= (struct sockaddr_iucv
*) addr
;
985 struct sock
*sk
= sock
->sk
;
986 struct iucv_sock
*iucv
= iucv_sk(sk
);
988 addr
->sa_family
= AF_IUCV
;
989 *len
= sizeof(struct sockaddr_iucv
);
992 memcpy(siucv
->siucv_user_id
, iucv
->dst_user_id
, 8);
993 memcpy(siucv
->siucv_name
, iucv
->dst_name
, 8);
995 memcpy(siucv
->siucv_user_id
, iucv
->src_user_id
, 8);
996 memcpy(siucv
->siucv_name
, iucv
->src_name
, 8);
998 memset(&siucv
->siucv_port
, 0, sizeof(siucv
->siucv_port
));
999 memset(&siucv
->siucv_addr
, 0, sizeof(siucv
->siucv_addr
));
1000 memset(&siucv
->siucv_nodeid
, 0, sizeof(siucv
->siucv_nodeid
));
1006 * iucv_send_iprm() - Send socket data in parameter list of an iucv message.
1008 * @msg: Pointer to a struct iucv_message
1009 * @skb: The socket data to send, skb->len MUST BE <= 7
1011 * Send the socket data in the parameter list in the iucv message
1012 * (IUCV_IPRMDATA). The socket data is stored at index 0 to 6 in the parameter
1013 * list and the socket data len at index 7 (last byte).
1014 * See also iucv_msg_length().
1016 * Returns the error code from the iucv_message_send() call.
1018 static int iucv_send_iprm(struct iucv_path
*path
, struct iucv_message
*msg
,
1019 struct sk_buff
*skb
)
1023 memcpy(prmdata
, (void *) skb
->data
, skb
->len
);
1024 prmdata
[7] = 0xff - (u8
) skb
->len
;
1025 return pr_iucv
->message_send(path
, msg
, IUCV_IPRMDATA
, 0,
1026 (void *) prmdata
, 8);
1029 static int iucv_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1030 struct msghdr
*msg
, size_t len
)
1032 struct sock
*sk
= sock
->sk
;
1033 struct iucv_sock
*iucv
= iucv_sk(sk
);
1034 struct sk_buff
*skb
;
1035 struct iucv_message txmsg
;
1036 struct cmsghdr
*cmsg
;
1042 int noblock
= msg
->msg_flags
& MSG_DONTWAIT
;
1044 err
= sock_error(sk
);
1048 if (msg
->msg_flags
& MSG_OOB
)
1051 /* SOCK_SEQPACKET: we do not support segmented records */
1052 if (sk
->sk_type
== SOCK_SEQPACKET
&& !(msg
->msg_flags
& MSG_EOR
))
1057 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1062 /* Return if the socket is not in connected state */
1063 if (sk
->sk_state
!= IUCV_CONNECTED
) {
1068 /* initialize defaults */
1069 cmsg_done
= 0; /* check for duplicate headers */
1072 /* iterate over control messages */
1073 for_each_cmsghdr(cmsg
, msg
) {
1074 if (!CMSG_OK(msg
, cmsg
)) {
1079 if (cmsg
->cmsg_level
!= SOL_IUCV
)
1082 if (cmsg
->cmsg_type
& cmsg_done
) {
1086 cmsg_done
|= cmsg
->cmsg_type
;
1088 switch (cmsg
->cmsg_type
) {
1089 case SCM_IUCV_TRGCLS
:
1090 if (cmsg
->cmsg_len
!= CMSG_LEN(TRGCLS_SIZE
)) {
1095 /* set iucv message target class */
1096 memcpy(&txmsg
.class,
1097 (void *) CMSG_DATA(cmsg
), TRGCLS_SIZE
);
1107 /* allocate one skb for each iucv message:
1108 * this is fine for SOCK_SEQPACKET (unless we want to support
1109 * segmented records using the MSG_EOR flag), but
1110 * for SOCK_STREAM we might want to improve it in future */
1111 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
)
1112 skb
= sock_alloc_send_skb(sk
,
1113 len
+ sizeof(struct af_iucv_trans_hdr
) + ETH_HLEN
,
1116 skb
= sock_alloc_send_skb(sk
, len
, noblock
, &err
);
1119 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
)
1120 skb_reserve(skb
, sizeof(struct af_iucv_trans_hdr
) + ETH_HLEN
);
1121 if (memcpy_from_msg(skb_put(skb
, len
), msg
, len
)) {
1126 /* wait if outstanding messages for iucv path has reached */
1127 timeo
= sock_sndtimeo(sk
, noblock
);
1128 err
= iucv_sock_wait(sk
, iucv_below_msglim(sk
), timeo
);
1132 /* return -ECONNRESET if the socket is no longer connected */
1133 if (sk
->sk_state
!= IUCV_CONNECTED
) {
1138 /* increment and save iucv message tag for msg_completion cbk */
1139 txmsg
.tag
= iucv
->send_tag
++;
1140 IUCV_SKB_CB(skb
)->tag
= txmsg
.tag
;
1142 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
) {
1143 atomic_inc(&iucv
->msg_sent
);
1144 err
= afiucv_hs_send(&txmsg
, sk
, skb
, 0);
1146 atomic_dec(&iucv
->msg_sent
);
1151 skb_queue_tail(&iucv
->send_skb_q
, skb
);
1153 if (((iucv
->path
->flags
& IUCV_IPRMDATA
) & iucv
->flags
)
1155 err
= iucv_send_iprm(iucv
->path
, &txmsg
, skb
);
1157 /* on success: there is no message_complete callback
1158 * for an IPRMDATA msg; remove skb from send queue */
1160 skb_unlink(skb
, &iucv
->send_skb_q
);
1164 /* this error should never happen since the
1165 * IUCV_IPRMDATA path flag is set... sever path */
1167 pr_iucv
->path_sever(iucv
->path
, NULL
);
1168 skb_unlink(skb
, &iucv
->send_skb_q
);
1173 err
= pr_iucv
->message_send(iucv
->path
, &txmsg
, 0, 0,
1174 (void *) skb
->data
, skb
->len
);
1178 memcpy(user_id
, iucv
->dst_user_id
, 8);
1180 memcpy(appl_id
, iucv
->dst_name
, 8);
1181 pr_err("Application %s on z/VM guest %s"
1182 " exceeds message limit\n",
1187 skb_unlink(skb
, &iucv
->send_skb_q
);
1202 /* iucv_fragment_skb() - Fragment a single IUCV message into multiple skb's
1204 * Locking: must be called with message_q.lock held
1206 static int iucv_fragment_skb(struct sock
*sk
, struct sk_buff
*skb
, int len
)
1208 int dataleft
, size
, copied
= 0;
1209 struct sk_buff
*nskb
;
1213 if (dataleft
>= sk
->sk_rcvbuf
/ 4)
1214 size
= sk
->sk_rcvbuf
/ 4;
1218 nskb
= alloc_skb(size
, GFP_ATOMIC
| GFP_DMA
);
1222 /* copy target class to control buffer of new skb */
1223 IUCV_SKB_CB(nskb
)->class = IUCV_SKB_CB(skb
)->class;
1225 /* copy data fragment */
1226 memcpy(nskb
->data
, skb
->data
+ copied
, size
);
1230 skb_reset_transport_header(nskb
);
1231 skb_reset_network_header(nskb
);
1234 skb_queue_tail(&iucv_sk(sk
)->backlog_skb_q
, nskb
);
1240 /* iucv_process_message() - Receive a single outstanding IUCV message
1242 * Locking: must be called with message_q.lock held
1244 static void iucv_process_message(struct sock
*sk
, struct sk_buff
*skb
,
1245 struct iucv_path
*path
,
1246 struct iucv_message
*msg
)
1251 len
= iucv_msg_length(msg
);
1253 /* store msg target class in the second 4 bytes of skb ctrl buffer */
1254 /* Note: the first 4 bytes are reserved for msg tag */
1255 IUCV_SKB_CB(skb
)->class = msg
->class;
1257 /* check for special IPRM messages (e.g. iucv_sock_shutdown) */
1258 if ((msg
->flags
& IUCV_IPRMDATA
) && len
> 7) {
1259 if (memcmp(msg
->rmmsg
, iprm_shutdown
, 8) == 0) {
1264 rc
= pr_iucv
->message_receive(path
, msg
,
1265 msg
->flags
& IUCV_IPRMDATA
,
1266 skb
->data
, len
, NULL
);
1271 /* we need to fragment iucv messages for SOCK_STREAM only;
1272 * for SOCK_SEQPACKET, it is only relevant if we support
1273 * record segmentation using MSG_EOR (see also recvmsg()) */
1274 if (sk
->sk_type
== SOCK_STREAM
&&
1275 skb
->truesize
>= sk
->sk_rcvbuf
/ 4) {
1276 rc
= iucv_fragment_skb(sk
, skb
, len
);
1280 pr_iucv
->path_sever(path
, NULL
);
1283 skb
= skb_dequeue(&iucv_sk(sk
)->backlog_skb_q
);
1285 skb_reset_transport_header(skb
);
1286 skb_reset_network_header(skb
);
1291 IUCV_SKB_CB(skb
)->offset
= 0;
1292 if (sock_queue_rcv_skb(sk
, skb
))
1293 skb_queue_head(&iucv_sk(sk
)->backlog_skb_q
, skb
);
1296 /* iucv_process_message_q() - Process outstanding IUCV messages
1298 * Locking: must be called with message_q.lock held
1300 static void iucv_process_message_q(struct sock
*sk
)
1302 struct iucv_sock
*iucv
= iucv_sk(sk
);
1303 struct sk_buff
*skb
;
1304 struct sock_msg_q
*p
, *n
;
1306 list_for_each_entry_safe(p
, n
, &iucv
->message_q
.list
, list
) {
1307 skb
= alloc_skb(iucv_msg_length(&p
->msg
), GFP_ATOMIC
| GFP_DMA
);
1310 iucv_process_message(sk
, skb
, p
->path
, &p
->msg
);
1313 if (!skb_queue_empty(&iucv
->backlog_skb_q
))
1318 static int iucv_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1319 struct msghdr
*msg
, size_t len
, int flags
)
1321 int noblock
= flags
& MSG_DONTWAIT
;
1322 struct sock
*sk
= sock
->sk
;
1323 struct iucv_sock
*iucv
= iucv_sk(sk
);
1324 unsigned int copied
, rlen
;
1325 struct sk_buff
*skb
, *rskb
, *cskb
;
1329 if ((sk
->sk_state
== IUCV_DISCONN
) &&
1330 skb_queue_empty(&iucv
->backlog_skb_q
) &&
1331 skb_queue_empty(&sk
->sk_receive_queue
) &&
1332 list_empty(&iucv
->message_q
.list
))
1335 if (flags
& (MSG_OOB
))
1338 /* receive/dequeue next skb:
1339 * the function understands MSG_PEEK and, thus, does not dequeue skb */
1340 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
1342 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1347 offset
= IUCV_SKB_CB(skb
)->offset
;
1348 rlen
= skb
->len
- offset
; /* real length of skb */
1349 copied
= min_t(unsigned int, rlen
, len
);
1351 sk
->sk_shutdown
= sk
->sk_shutdown
| RCV_SHUTDOWN
;
1354 if (skb_copy_datagram_msg(cskb
, offset
, msg
, copied
)) {
1355 if (!(flags
& MSG_PEEK
))
1356 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1360 /* SOCK_SEQPACKET: set MSG_TRUNC if recv buf size is too small */
1361 if (sk
->sk_type
== SOCK_SEQPACKET
) {
1363 msg
->msg_flags
|= MSG_TRUNC
;
1364 /* each iucv message contains a complete record */
1365 msg
->msg_flags
|= MSG_EOR
;
1368 /* create control message to store iucv msg target class:
1369 * get the trgcls from the control buffer of the skb due to
1370 * fragmentation of original iucv message. */
1371 err
= put_cmsg(msg
, SOL_IUCV
, SCM_IUCV_TRGCLS
,
1372 sizeof(IUCV_SKB_CB(skb
)->class),
1373 (void *)&IUCV_SKB_CB(skb
)->class);
1375 if (!(flags
& MSG_PEEK
))
1376 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1380 /* Mark read part of skb as used */
1381 if (!(flags
& MSG_PEEK
)) {
1383 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
1384 if (sk
->sk_type
== SOCK_STREAM
) {
1385 if (copied
< rlen
) {
1386 IUCV_SKB_CB(skb
)->offset
= offset
+ copied
;
1387 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1393 if (iucv
->transport
== AF_IUCV_TRANS_HIPER
) {
1394 atomic_inc(&iucv
->msg_recv
);
1395 if (atomic_read(&iucv
->msg_recv
) > iucv
->msglimit
) {
1397 iucv_sock_close(sk
);
1402 /* Queue backlog skbs */
1403 spin_lock_bh(&iucv
->message_q
.lock
);
1404 rskb
= skb_dequeue(&iucv
->backlog_skb_q
);
1406 IUCV_SKB_CB(rskb
)->offset
= 0;
1407 if (sock_queue_rcv_skb(sk
, rskb
)) {
1408 skb_queue_head(&iucv
->backlog_skb_q
,
1412 rskb
= skb_dequeue(&iucv
->backlog_skb_q
);
1415 if (skb_queue_empty(&iucv
->backlog_skb_q
)) {
1416 if (!list_empty(&iucv
->message_q
.list
))
1417 iucv_process_message_q(sk
);
1418 if (atomic_read(&iucv
->msg_recv
) >=
1419 iucv
->msglimit
/ 2) {
1420 err
= iucv_send_ctrl(sk
, AF_IUCV_FLAG_WIN
);
1422 sk
->sk_state
= IUCV_DISCONN
;
1423 sk
->sk_state_change(sk
);
1427 spin_unlock_bh(&iucv
->message_q
.lock
);
1431 /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
1432 if (sk
->sk_type
== SOCK_SEQPACKET
&& (flags
& MSG_TRUNC
))
1438 static inline unsigned int iucv_accept_poll(struct sock
*parent
)
1440 struct iucv_sock
*isk
, *n
;
1443 list_for_each_entry_safe(isk
, n
, &iucv_sk(parent
)->accept_q
, accept_q
) {
1444 sk
= (struct sock
*) isk
;
1446 if (sk
->sk_state
== IUCV_CONNECTED
)
1447 return POLLIN
| POLLRDNORM
;
1453 unsigned int iucv_sock_poll(struct file
*file
, struct socket
*sock
,
1456 struct sock
*sk
= sock
->sk
;
1457 unsigned int mask
= 0;
1459 sock_poll_wait(file
, sk_sleep(sk
), wait
);
1461 if (sk
->sk_state
== IUCV_LISTEN
)
1462 return iucv_accept_poll(sk
);
1464 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
1466 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? POLLPRI
: 0);
1468 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1471 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
1474 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
1475 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
1476 mask
|= POLLIN
| POLLRDNORM
;
1478 if (sk
->sk_state
== IUCV_CLOSED
)
1481 if (sk
->sk_state
== IUCV_DISCONN
)
1484 if (sock_writeable(sk
) && iucv_below_msglim(sk
))
1485 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
1487 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
1492 static int iucv_sock_shutdown(struct socket
*sock
, int how
)
1494 struct sock
*sk
= sock
->sk
;
1495 struct iucv_sock
*iucv
= iucv_sk(sk
);
1496 struct iucv_message txmsg
;
1501 if ((how
& ~SHUTDOWN_MASK
) || !how
)
1505 switch (sk
->sk_state
) {
1516 if (how
== SEND_SHUTDOWN
|| how
== SHUTDOWN_MASK
) {
1517 if (iucv
->transport
== AF_IUCV_TRANS_IUCV
) {
1520 err
= pr_iucv
->message_send(iucv
->path
, &txmsg
,
1521 IUCV_IPRMDATA
, 0, (void *) iprm_shutdown
, 8);
1536 iucv_send_ctrl(sk
, AF_IUCV_FLAG_SHT
);
1539 sk
->sk_shutdown
|= how
;
1540 if (how
== RCV_SHUTDOWN
|| how
== SHUTDOWN_MASK
) {
1541 if ((iucv
->transport
== AF_IUCV_TRANS_IUCV
) &&
1543 err
= pr_iucv
->path_quiesce(iucv
->path
, NULL
);
1546 /* skb_queue_purge(&sk->sk_receive_queue); */
1548 skb_queue_purge(&sk
->sk_receive_queue
);
1551 /* Wake up anyone sleeping in poll */
1552 sk
->sk_state_change(sk
);
1559 static int iucv_sock_release(struct socket
*sock
)
1561 struct sock
*sk
= sock
->sk
;
1567 iucv_sock_close(sk
);
1574 /* getsockopt and setsockopt */
1575 static int iucv_sock_setsockopt(struct socket
*sock
, int level
, int optname
,
1576 char __user
*optval
, unsigned int optlen
)
1578 struct sock
*sk
= sock
->sk
;
1579 struct iucv_sock
*iucv
= iucv_sk(sk
);
1583 if (level
!= SOL_IUCV
)
1584 return -ENOPROTOOPT
;
1586 if (optlen
< sizeof(int))
1589 if (get_user(val
, (int __user
*) optval
))
1596 case SO_IPRMDATA_MSG
:
1598 iucv
->flags
|= IUCV_IPRMDATA
;
1600 iucv
->flags
&= ~IUCV_IPRMDATA
;
1603 switch (sk
->sk_state
) {
1606 if (val
< 1 || val
> (u16
)(~0))
1609 iucv
->msglimit
= val
;
1625 static int iucv_sock_getsockopt(struct socket
*sock
, int level
, int optname
,
1626 char __user
*optval
, int __user
*optlen
)
1628 struct sock
*sk
= sock
->sk
;
1629 struct iucv_sock
*iucv
= iucv_sk(sk
);
1633 if (level
!= SOL_IUCV
)
1634 return -ENOPROTOOPT
;
1636 if (get_user(len
, optlen
))
1642 len
= min_t(unsigned int, len
, sizeof(int));
1645 case SO_IPRMDATA_MSG
:
1646 val
= (iucv
->flags
& IUCV_IPRMDATA
) ? 1 : 0;
1650 val
= (iucv
->path
!= NULL
) ? iucv
->path
->msglim
/* connected */
1651 : iucv
->msglimit
; /* default */
1655 if (sk
->sk_state
== IUCV_OPEN
)
1657 val
= (iucv
->hs_dev
) ? iucv
->hs_dev
->mtu
-
1658 sizeof(struct af_iucv_trans_hdr
) - ETH_HLEN
:
1662 return -ENOPROTOOPT
;
1665 if (put_user(len
, optlen
))
1667 if (copy_to_user(optval
, &val
, len
))
1674 /* Callback wrappers - called from iucv base support */
1675 static int iucv_callback_connreq(struct iucv_path
*path
,
1676 u8 ipvmid
[8], u8 ipuser
[16])
1678 unsigned char user_data
[16];
1679 unsigned char nuser_data
[16];
1680 unsigned char src_name
[8];
1681 struct sock
*sk
, *nsk
;
1682 struct iucv_sock
*iucv
, *niucv
;
1685 memcpy(src_name
, ipuser
, 8);
1686 EBCASC(src_name
, 8);
1687 /* Find out if this path belongs to af_iucv. */
1688 read_lock(&iucv_sk_list
.lock
);
1691 sk_for_each(sk
, &iucv_sk_list
.head
)
1692 if (sk
->sk_state
== IUCV_LISTEN
&&
1693 !memcmp(&iucv_sk(sk
)->src_name
, src_name
, 8)) {
1695 * Found a listening socket with
1696 * src_name == ipuser[0-7].
1701 read_unlock(&iucv_sk_list
.lock
);
1703 /* No socket found, not one of our paths. */
1708 /* Check if parent socket is listening */
1709 low_nmcpy(user_data
, iucv
->src_name
);
1710 high_nmcpy(user_data
, iucv
->dst_name
);
1711 ASCEBC(user_data
, sizeof(user_data
));
1712 if (sk
->sk_state
!= IUCV_LISTEN
) {
1713 err
= pr_iucv
->path_sever(path
, user_data
);
1714 iucv_path_free(path
);
1718 /* Check for backlog size */
1719 if (sk_acceptq_is_full(sk
)) {
1720 err
= pr_iucv
->path_sever(path
, user_data
);
1721 iucv_path_free(path
);
1725 /* Create the new socket */
1726 nsk
= iucv_sock_alloc(NULL
, sk
->sk_type
, GFP_ATOMIC
);
1728 err
= pr_iucv
->path_sever(path
, user_data
);
1729 iucv_path_free(path
);
1733 niucv
= iucv_sk(nsk
);
1734 iucv_sock_init(nsk
, sk
);
1736 /* Set the new iucv_sock */
1737 memcpy(niucv
->dst_name
, ipuser
+ 8, 8);
1738 EBCASC(niucv
->dst_name
, 8);
1739 memcpy(niucv
->dst_user_id
, ipvmid
, 8);
1740 memcpy(niucv
->src_name
, iucv
->src_name
, 8);
1741 memcpy(niucv
->src_user_id
, iucv
->src_user_id
, 8);
1744 /* Call iucv_accept */
1745 high_nmcpy(nuser_data
, ipuser
+ 8);
1746 memcpy(nuser_data
+ 8, niucv
->src_name
, 8);
1747 ASCEBC(nuser_data
+ 8, 8);
1749 /* set message limit for path based on msglimit of accepting socket */
1750 niucv
->msglimit
= iucv
->msglimit
;
1751 path
->msglim
= iucv
->msglimit
;
1752 err
= pr_iucv
->path_accept(path
, &af_iucv_handler
, nuser_data
, nsk
);
1754 iucv_sever_path(nsk
, 1);
1755 iucv_sock_kill(nsk
);
1759 iucv_accept_enqueue(sk
, nsk
);
1761 /* Wake up accept */
1762 nsk
->sk_state
= IUCV_CONNECTED
;
1763 sk
->sk_data_ready(sk
);
1770 static void iucv_callback_connack(struct iucv_path
*path
, u8 ipuser
[16])
1772 struct sock
*sk
= path
->private;
1774 sk
->sk_state
= IUCV_CONNECTED
;
1775 sk
->sk_state_change(sk
);
1778 static void iucv_callback_rx(struct iucv_path
*path
, struct iucv_message
*msg
)
1780 struct sock
*sk
= path
->private;
1781 struct iucv_sock
*iucv
= iucv_sk(sk
);
1782 struct sk_buff
*skb
;
1783 struct sock_msg_q
*save_msg
;
1786 if (sk
->sk_shutdown
& RCV_SHUTDOWN
) {
1787 pr_iucv
->message_reject(path
, msg
);
1791 spin_lock(&iucv
->message_q
.lock
);
1793 if (!list_empty(&iucv
->message_q
.list
) ||
1794 !skb_queue_empty(&iucv
->backlog_skb_q
))
1797 len
= atomic_read(&sk
->sk_rmem_alloc
);
1798 len
+= SKB_TRUESIZE(iucv_msg_length(msg
));
1799 if (len
> sk
->sk_rcvbuf
)
1802 skb
= alloc_skb(iucv_msg_length(msg
), GFP_ATOMIC
| GFP_DMA
);
1806 iucv_process_message(sk
, skb
, path
, msg
);
1810 save_msg
= kzalloc(sizeof(struct sock_msg_q
), GFP_ATOMIC
| GFP_DMA
);
1813 save_msg
->path
= path
;
1814 save_msg
->msg
= *msg
;
1816 list_add_tail(&save_msg
->list
, &iucv
->message_q
.list
);
1819 spin_unlock(&iucv
->message_q
.lock
);
1822 static void iucv_callback_txdone(struct iucv_path
*path
,
1823 struct iucv_message
*msg
)
1825 struct sock
*sk
= path
->private;
1826 struct sk_buff
*this = NULL
;
1827 struct sk_buff_head
*list
= &iucv_sk(sk
)->send_skb_q
;
1828 struct sk_buff
*list_skb
= list
->next
;
1829 unsigned long flags
;
1832 if (!skb_queue_empty(list
)) {
1833 spin_lock_irqsave(&list
->lock
, flags
);
1835 while (list_skb
!= (struct sk_buff
*)list
) {
1836 if (msg
->tag
== IUCV_SKB_CB(list_skb
)->tag
) {
1840 list_skb
= list_skb
->next
;
1843 __skb_unlink(this, list
);
1845 spin_unlock_irqrestore(&list
->lock
, flags
);
1849 /* wake up any process waiting for sending */
1850 iucv_sock_wake_msglim(sk
);
1854 if (sk
->sk_state
== IUCV_CLOSING
) {
1855 if (skb_queue_empty(&iucv_sk(sk
)->send_skb_q
)) {
1856 sk
->sk_state
= IUCV_CLOSED
;
1857 sk
->sk_state_change(sk
);
1864 static void iucv_callback_connrej(struct iucv_path
*path
, u8 ipuser
[16])
1866 struct sock
*sk
= path
->private;
1868 if (sk
->sk_state
== IUCV_CLOSED
)
1872 iucv_sever_path(sk
, 1);
1873 sk
->sk_state
= IUCV_DISCONN
;
1875 sk
->sk_state_change(sk
);
1879 /* called if the other communication side shuts down its RECV direction;
1880 * in turn, the callback sets SEND_SHUTDOWN to disable sending of data.
1882 static void iucv_callback_shutdown(struct iucv_path
*path
, u8 ipuser
[16])
1884 struct sock
*sk
= path
->private;
1887 if (sk
->sk_state
!= IUCV_CLOSED
) {
1888 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1889 sk
->sk_state_change(sk
);
1894 /***************** HiperSockets transport callbacks ********************/
1895 static void afiucv_swap_src_dest(struct sk_buff
*skb
)
1897 struct af_iucv_trans_hdr
*trans_hdr
=
1898 (struct af_iucv_trans_hdr
*)skb
->data
;
1902 ASCEBC(trans_hdr
->destUserID
, sizeof(trans_hdr
->destUserID
));
1903 ASCEBC(trans_hdr
->destAppName
, sizeof(trans_hdr
->destAppName
));
1904 ASCEBC(trans_hdr
->srcUserID
, sizeof(trans_hdr
->srcUserID
));
1905 ASCEBC(trans_hdr
->srcAppName
, sizeof(trans_hdr
->srcAppName
));
1906 memcpy(tmpID
, trans_hdr
->srcUserID
, 8);
1907 memcpy(tmpName
, trans_hdr
->srcAppName
, 8);
1908 memcpy(trans_hdr
->srcUserID
, trans_hdr
->destUserID
, 8);
1909 memcpy(trans_hdr
->srcAppName
, trans_hdr
->destAppName
, 8);
1910 memcpy(trans_hdr
->destUserID
, tmpID
, 8);
1911 memcpy(trans_hdr
->destAppName
, tmpName
, 8);
1912 skb_push(skb
, ETH_HLEN
);
1913 memset(skb
->data
, 0, ETH_HLEN
);
1917 * afiucv_hs_callback_syn - react on received SYN
1919 static int afiucv_hs_callback_syn(struct sock
*sk
, struct sk_buff
*skb
)
1922 struct iucv_sock
*iucv
, *niucv
;
1923 struct af_iucv_trans_hdr
*trans_hdr
;
1927 trans_hdr
= (struct af_iucv_trans_hdr
*)skb
->data
;
1929 /* no sock - connection refused */
1930 afiucv_swap_src_dest(skb
);
1931 trans_hdr
->flags
= AF_IUCV_FLAG_SYN
| AF_IUCV_FLAG_FIN
;
1932 err
= dev_queue_xmit(skb
);
1936 nsk
= iucv_sock_alloc(NULL
, sk
->sk_type
, GFP_ATOMIC
);
1938 if ((sk
->sk_state
!= IUCV_LISTEN
) ||
1939 sk_acceptq_is_full(sk
) ||
1941 /* error on server socket - connection refused */
1942 afiucv_swap_src_dest(skb
);
1943 trans_hdr
->flags
= AF_IUCV_FLAG_SYN
| AF_IUCV_FLAG_FIN
;
1944 err
= dev_queue_xmit(skb
);
1945 iucv_sock_kill(nsk
);
1950 niucv
= iucv_sk(nsk
);
1951 iucv_sock_init(nsk
, sk
);
1952 niucv
->transport
= AF_IUCV_TRANS_HIPER
;
1953 niucv
->msglimit
= iucv
->msglimit
;
1954 if (!trans_hdr
->window
)
1955 niucv
->msglimit_peer
= IUCV_HIPER_MSGLIM_DEFAULT
;
1957 niucv
->msglimit_peer
= trans_hdr
->window
;
1958 memcpy(niucv
->dst_name
, trans_hdr
->srcAppName
, 8);
1959 memcpy(niucv
->dst_user_id
, trans_hdr
->srcUserID
, 8);
1960 memcpy(niucv
->src_name
, iucv
->src_name
, 8);
1961 memcpy(niucv
->src_user_id
, iucv
->src_user_id
, 8);
1962 nsk
->sk_bound_dev_if
= sk
->sk_bound_dev_if
;
1963 niucv
->hs_dev
= iucv
->hs_dev
;
1964 dev_hold(niucv
->hs_dev
);
1965 afiucv_swap_src_dest(skb
);
1966 trans_hdr
->flags
= AF_IUCV_FLAG_SYN
| AF_IUCV_FLAG_ACK
;
1967 trans_hdr
->window
= niucv
->msglimit
;
1968 /* if receiver acks the xmit connection is established */
1969 err
= dev_queue_xmit(skb
);
1971 iucv_accept_enqueue(sk
, nsk
);
1972 nsk
->sk_state
= IUCV_CONNECTED
;
1973 sk
->sk_data_ready(sk
);
1975 iucv_sock_kill(nsk
);
1979 return NET_RX_SUCCESS
;
1983 * afiucv_hs_callback_synack() - react on received SYN-ACK
1985 static int afiucv_hs_callback_synack(struct sock
*sk
, struct sk_buff
*skb
)
1987 struct iucv_sock
*iucv
= iucv_sk(sk
);
1988 struct af_iucv_trans_hdr
*trans_hdr
=
1989 (struct af_iucv_trans_hdr
*)skb
->data
;
1993 if (sk
->sk_state
!= IUCV_BOUND
)
1996 iucv
->msglimit_peer
= trans_hdr
->window
;
1997 sk
->sk_state
= IUCV_CONNECTED
;
1998 sk
->sk_state_change(sk
);
2002 return NET_RX_SUCCESS
;
2006 * afiucv_hs_callback_synfin() - react on received SYN_FIN
2008 static int afiucv_hs_callback_synfin(struct sock
*sk
, struct sk_buff
*skb
)
2010 struct iucv_sock
*iucv
= iucv_sk(sk
);
2014 if (sk
->sk_state
!= IUCV_BOUND
)
2017 sk
->sk_state
= IUCV_DISCONN
;
2018 sk
->sk_state_change(sk
);
2022 return NET_RX_SUCCESS
;
2026 * afiucv_hs_callback_fin() - react on received FIN
2028 static int afiucv_hs_callback_fin(struct sock
*sk
, struct sk_buff
*skb
)
2030 struct iucv_sock
*iucv
= iucv_sk(sk
);
2032 /* other end of connection closed */
2036 if (sk
->sk_state
== IUCV_CONNECTED
) {
2037 sk
->sk_state
= IUCV_DISCONN
;
2038 sk
->sk_state_change(sk
);
2043 return NET_RX_SUCCESS
;
2047 * afiucv_hs_callback_win() - react on received WIN
2049 static int afiucv_hs_callback_win(struct sock
*sk
, struct sk_buff
*skb
)
2051 struct iucv_sock
*iucv
= iucv_sk(sk
);
2052 struct af_iucv_trans_hdr
*trans_hdr
=
2053 (struct af_iucv_trans_hdr
*)skb
->data
;
2056 return NET_RX_SUCCESS
;
2058 if (sk
->sk_state
!= IUCV_CONNECTED
)
2059 return NET_RX_SUCCESS
;
2061 atomic_sub(trans_hdr
->window
, &iucv
->msg_sent
);
2062 iucv_sock_wake_msglim(sk
);
2063 return NET_RX_SUCCESS
;
2067 * afiucv_hs_callback_rx() - react on received data
2069 static int afiucv_hs_callback_rx(struct sock
*sk
, struct sk_buff
*skb
)
2071 struct iucv_sock
*iucv
= iucv_sk(sk
);
2075 return NET_RX_SUCCESS
;
2078 if (sk
->sk_state
!= IUCV_CONNECTED
) {
2080 return NET_RX_SUCCESS
;
2083 if (sk
->sk_shutdown
& RCV_SHUTDOWN
) {
2085 return NET_RX_SUCCESS
;
2088 /* write stuff from iucv_msg to skb cb */
2089 if (skb
->len
< sizeof(struct af_iucv_trans_hdr
)) {
2091 return NET_RX_SUCCESS
;
2093 skb_pull(skb
, sizeof(struct af_iucv_trans_hdr
));
2094 skb_reset_transport_header(skb
);
2095 skb_reset_network_header(skb
);
2096 IUCV_SKB_CB(skb
)->offset
= 0;
2097 spin_lock(&iucv
->message_q
.lock
);
2098 if (skb_queue_empty(&iucv
->backlog_skb_q
)) {
2099 if (sock_queue_rcv_skb(sk
, skb
)) {
2100 /* handle rcv queue full */
2101 skb_queue_tail(&iucv
->backlog_skb_q
, skb
);
2104 skb_queue_tail(&iucv_sk(sk
)->backlog_skb_q
, skb
);
2105 spin_unlock(&iucv
->message_q
.lock
);
2106 return NET_RX_SUCCESS
;
2110 * afiucv_hs_rcv() - base function for arriving data through HiperSockets
2112 * called from netif RX softirq
2114 static int afiucv_hs_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
2115 struct packet_type
*pt
, struct net_device
*orig_dev
)
2118 struct iucv_sock
*iucv
;
2119 struct af_iucv_trans_hdr
*trans_hdr
;
2123 skb_pull(skb
, ETH_HLEN
);
2124 trans_hdr
= (struct af_iucv_trans_hdr
*)skb
->data
;
2125 EBCASC(trans_hdr
->destAppName
, sizeof(trans_hdr
->destAppName
));
2126 EBCASC(trans_hdr
->destUserID
, sizeof(trans_hdr
->destUserID
));
2127 EBCASC(trans_hdr
->srcAppName
, sizeof(trans_hdr
->srcAppName
));
2128 EBCASC(trans_hdr
->srcUserID
, sizeof(trans_hdr
->srcUserID
));
2129 memset(nullstring
, 0, sizeof(nullstring
));
2132 read_lock(&iucv_sk_list
.lock
);
2133 sk_for_each(sk
, &iucv_sk_list
.head
) {
2134 if (trans_hdr
->flags
== AF_IUCV_FLAG_SYN
) {
2135 if ((!memcmp(&iucv_sk(sk
)->src_name
,
2136 trans_hdr
->destAppName
, 8)) &&
2137 (!memcmp(&iucv_sk(sk
)->src_user_id
,
2138 trans_hdr
->destUserID
, 8)) &&
2139 (!memcmp(&iucv_sk(sk
)->dst_name
, nullstring
, 8)) &&
2140 (!memcmp(&iucv_sk(sk
)->dst_user_id
,
2146 if ((!memcmp(&iucv_sk(sk
)->src_name
,
2147 trans_hdr
->destAppName
, 8)) &&
2148 (!memcmp(&iucv_sk(sk
)->src_user_id
,
2149 trans_hdr
->destUserID
, 8)) &&
2150 (!memcmp(&iucv_sk(sk
)->dst_name
,
2151 trans_hdr
->srcAppName
, 8)) &&
2152 (!memcmp(&iucv_sk(sk
)->dst_user_id
,
2153 trans_hdr
->srcUserID
, 8))) {
2159 read_unlock(&iucv_sk_list
.lock
);
2164 how should we send with no sock
2165 1) send without sock no send rc checking?
2166 2) introduce default sock to handle this cases
2168 SYN -> send SYN|ACK in good case, send SYN|FIN in bad case
2170 SYN|ACK, SYN|FIN, FIN -> no action? */
2172 switch (trans_hdr
->flags
) {
2173 case AF_IUCV_FLAG_SYN
:
2174 /* connect request */
2175 err
= afiucv_hs_callback_syn(sk
, skb
);
2177 case (AF_IUCV_FLAG_SYN
| AF_IUCV_FLAG_ACK
):
2178 /* connect request confirmed */
2179 err
= afiucv_hs_callback_synack(sk
, skb
);
2181 case (AF_IUCV_FLAG_SYN
| AF_IUCV_FLAG_FIN
):
2182 /* connect request refused */
2183 err
= afiucv_hs_callback_synfin(sk
, skb
);
2185 case (AF_IUCV_FLAG_FIN
):
2187 err
= afiucv_hs_callback_fin(sk
, skb
);
2189 case (AF_IUCV_FLAG_WIN
):
2190 err
= afiucv_hs_callback_win(sk
, skb
);
2191 if (skb
->len
== sizeof(struct af_iucv_trans_hdr
)) {
2195 /* fall through and receive non-zero length data */
2196 case (AF_IUCV_FLAG_SHT
):
2197 /* shutdown request */
2198 /* fall through and receive zero length data */
2200 /* plain data frame */
2201 IUCV_SKB_CB(skb
)->class = trans_hdr
->iucv_hdr
.class;
2202 err
= afiucv_hs_callback_rx(sk
, skb
);
2212 * afiucv_hs_callback_txnotify() - handle send notifcations from HiperSockets
2215 static void afiucv_hs_callback_txnotify(struct sk_buff
*skb
,
2216 enum iucv_tx_notify n
)
2218 struct sock
*isk
= skb
->sk
;
2219 struct sock
*sk
= NULL
;
2220 struct iucv_sock
*iucv
= NULL
;
2221 struct sk_buff_head
*list
;
2222 struct sk_buff
*list_skb
;
2223 struct sk_buff
*nskb
;
2224 unsigned long flags
;
2226 read_lock_irqsave(&iucv_sk_list
.lock
, flags
);
2227 sk_for_each(sk
, &iucv_sk_list
.head
)
2232 read_unlock_irqrestore(&iucv_sk_list
.lock
, flags
);
2234 if (!iucv
|| sock_flag(sk
, SOCK_ZAPPED
))
2237 list
= &iucv
->send_skb_q
;
2238 spin_lock_irqsave(&list
->lock
, flags
);
2239 if (skb_queue_empty(list
))
2241 list_skb
= list
->next
;
2242 nskb
= list_skb
->next
;
2243 while (list_skb
!= (struct sk_buff
*)list
) {
2244 if (skb_shinfo(list_skb
) == skb_shinfo(skb
)) {
2247 __skb_unlink(list_skb
, list
);
2248 kfree_skb(list_skb
);
2249 iucv_sock_wake_msglim(sk
);
2251 case TX_NOTIFY_PENDING
:
2252 atomic_inc(&iucv
->pendings
);
2254 case TX_NOTIFY_DELAYED_OK
:
2255 __skb_unlink(list_skb
, list
);
2256 atomic_dec(&iucv
->pendings
);
2257 if (atomic_read(&iucv
->pendings
) <= 0)
2258 iucv_sock_wake_msglim(sk
);
2259 kfree_skb(list_skb
);
2261 case TX_NOTIFY_UNREACHABLE
:
2262 case TX_NOTIFY_DELAYED_UNREACHABLE
:
2263 case TX_NOTIFY_TPQFULL
: /* not yet used */
2264 case TX_NOTIFY_GENERALERROR
:
2265 case TX_NOTIFY_DELAYED_GENERALERROR
:
2266 __skb_unlink(list_skb
, list
);
2267 kfree_skb(list_skb
);
2268 if (sk
->sk_state
== IUCV_CONNECTED
) {
2269 sk
->sk_state
= IUCV_DISCONN
;
2270 sk
->sk_state_change(sk
);
2280 spin_unlock_irqrestore(&list
->lock
, flags
);
2282 if (sk
->sk_state
== IUCV_CLOSING
) {
2283 if (skb_queue_empty(&iucv_sk(sk
)->send_skb_q
)) {
2284 sk
->sk_state
= IUCV_CLOSED
;
2285 sk
->sk_state_change(sk
);
2292 * afiucv_netdev_event: handle netdev notifier chain events
2294 static int afiucv_netdev_event(struct notifier_block
*this,
2295 unsigned long event
, void *ptr
)
2297 struct net_device
*event_dev
= netdev_notifier_info_to_dev(ptr
);
2299 struct iucv_sock
*iucv
;
2303 case NETDEV_GOING_DOWN
:
2304 sk_for_each(sk
, &iucv_sk_list
.head
) {
2306 if ((iucv
->hs_dev
== event_dev
) &&
2307 (sk
->sk_state
== IUCV_CONNECTED
)) {
2308 if (event
== NETDEV_GOING_DOWN
)
2309 iucv_send_ctrl(sk
, AF_IUCV_FLAG_FIN
);
2310 sk
->sk_state
= IUCV_DISCONN
;
2311 sk
->sk_state_change(sk
);
2316 case NETDEV_UNREGISTER
:
2323 static struct notifier_block afiucv_netdev_notifier
= {
2324 .notifier_call
= afiucv_netdev_event
,
2327 static const struct proto_ops iucv_sock_ops
= {
2329 .owner
= THIS_MODULE
,
2330 .release
= iucv_sock_release
,
2331 .bind
= iucv_sock_bind
,
2332 .connect
= iucv_sock_connect
,
2333 .listen
= iucv_sock_listen
,
2334 .accept
= iucv_sock_accept
,
2335 .getname
= iucv_sock_getname
,
2336 .sendmsg
= iucv_sock_sendmsg
,
2337 .recvmsg
= iucv_sock_recvmsg
,
2338 .poll
= iucv_sock_poll
,
2339 .ioctl
= sock_no_ioctl
,
2340 .mmap
= sock_no_mmap
,
2341 .socketpair
= sock_no_socketpair
,
2342 .shutdown
= iucv_sock_shutdown
,
2343 .setsockopt
= iucv_sock_setsockopt
,
2344 .getsockopt
= iucv_sock_getsockopt
,
2347 static const struct net_proto_family iucv_sock_family_ops
= {
2349 .owner
= THIS_MODULE
,
2350 .create
= iucv_sock_create
,
2353 static struct packet_type iucv_packet_type
= {
2354 .type
= cpu_to_be16(ETH_P_AF_IUCV
),
2355 .func
= afiucv_hs_rcv
,
2358 static int afiucv_iucv_init(void)
2362 err
= pr_iucv
->iucv_register(&af_iucv_handler
, 0);
2365 /* establish dummy device */
2366 af_iucv_driver
.bus
= pr_iucv
->bus
;
2367 err
= driver_register(&af_iucv_driver
);
2370 af_iucv_dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
2375 dev_set_name(af_iucv_dev
, "af_iucv");
2376 af_iucv_dev
->bus
= pr_iucv
->bus
;
2377 af_iucv_dev
->parent
= pr_iucv
->root
;
2378 af_iucv_dev
->release
= (void (*)(struct device
*))kfree
;
2379 af_iucv_dev
->driver
= &af_iucv_driver
;
2380 err
= device_register(af_iucv_dev
);
2386 driver_unregister(&af_iucv_driver
);
2388 pr_iucv
->iucv_unregister(&af_iucv_handler
, 0);
2393 static int __init
afiucv_init(void)
2397 if (MACHINE_IS_VM
) {
2398 cpcmd("QUERY USERID", iucv_userid
, sizeof(iucv_userid
), &err
);
2399 if (unlikely(err
)) {
2401 err
= -EPROTONOSUPPORT
;
2405 pr_iucv
= try_then_request_module(symbol_get(iucv_if
), "iucv");
2407 printk(KERN_WARNING
"iucv_if lookup failed\n");
2408 memset(&iucv_userid
, 0, sizeof(iucv_userid
));
2411 memset(&iucv_userid
, 0, sizeof(iucv_userid
));
2415 err
= proto_register(&iucv_proto
, 0);
2418 err
= sock_register(&iucv_sock_family_ops
);
2423 err
= afiucv_iucv_init();
2427 register_netdevice_notifier(&afiucv_netdev_notifier
);
2428 dev_add_pack(&iucv_packet_type
);
2432 sock_unregister(PF_IUCV
);
2434 proto_unregister(&iucv_proto
);
2437 symbol_put(iucv_if
);
2441 static void __exit
afiucv_exit(void)
2444 device_unregister(af_iucv_dev
);
2445 driver_unregister(&af_iucv_driver
);
2446 pr_iucv
->iucv_unregister(&af_iucv_handler
, 0);
2447 symbol_put(iucv_if
);
2449 unregister_netdevice_notifier(&afiucv_netdev_notifier
);
2450 dev_remove_pack(&iucv_packet_type
);
2451 sock_unregister(PF_IUCV
);
2452 proto_unregister(&iucv_proto
);
2455 module_init(afiucv_init
);
2456 module_exit(afiucv_exit
);
2458 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
2459 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION
);
2460 MODULE_VERSION(VERSION
);
2461 MODULE_LICENSE("GPL");
2462 MODULE_ALIAS_NETPROTO(PF_IUCV
);