net/iucv/af_iucv.c

   1 /*
   2  *  IUCV protocol stack for Linux on zSeries
   3  *
   4  *  Copyright IBM Corp. 2006, 2009
   5  *
   6  *  Author(s):  Jennifer Hunt <jenhunt@us.ibm.com>
   7  *              Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
   8  *  PM functions:
   9  *              Ursula Braun <ursula.braun@de.ibm.com>
  10  */
  11
  12 #define KMSG_COMPONENT "af_iucv"
  13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  14
  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/signal.h>
  21 #include <linux/slab.h>
  22 #include <linux/skbuff.h>
  23 #include <linux/init.h>
  24 #include <linux/poll.h>
  25 #include <linux/security.h>
  26 #include <net/sock.h>
  27 #include <asm/ebcdic.h>
  28 #include <asm/cpcmd.h>
  29 #include <linux/kmod.h>
  30
  31 #include <net/iucv/af_iucv.h>
  32
  33 #define VERSION "1.2"
  34
  35 static char iucv_userid[80];
  36
  37 static const struct proto_ops iucv_sock_ops;
  38
  39 static struct proto iucv_proto = {
  40         .name           = "AF_IUCV",
  41         .owner          = THIS_MODULE,
  42         .obj_size       = sizeof(struct iucv_sock),
  43 };
  44
  45 static struct iucv_interface *pr_iucv;
  46
  47 /* special AF_IUCV IPRM messages */
  48 static const u8 iprm_shutdown[8] =
  49         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
  50
  51 #define TRGCLS_SIZE     FIELD_SIZEOF(struct iucv_message, class)
  52
  53 #define __iucv_sock_wait(sk, condition, timeo, ret)                     \
  54 do {                                                                    \
  55         DEFINE_WAIT(__wait);                                            \
  56         long __timeo = timeo;                                           \
  57         ret = 0;                                                        \
  58         prepare_to_wait(sk_sleep(sk), &__wait, TASK_INTERRUPTIBLE);     \
  59         while (!(condition)) {                                          \
  60                 if (!__timeo) {                                         \
  61                         ret = -EAGAIN;                                  \
  62                         break;                                          \
  63                 }                                                       \
  64                 if (signal_pending(current)) {                          \
  65                         ret = sock_intr_errno(__timeo);                 \
  66                         break;                                          \
  67                 }                                                       \
  68                 release_sock(sk);                                       \
  69                 __timeo = schedule_timeout(__timeo);                    \
  70                 lock_sock(sk);                                          \
  71                 ret = sock_error(sk);                                   \
  72                 if (ret)                                                \
  73                         break;                                          \
  74         }                                                               \
  75         finish_wait(sk_sleep(sk), &__wait);                             \
  76 } while (0)
  77
  78 #define iucv_sock_wait(sk, condition, timeo)                            \
  79 ({                                                                      \
  80         int __ret = 0;                                                  \
  81         if (!(condition))                                               \
  82                 __iucv_sock_wait(sk, condition, timeo, __ret);          \
  83         __ret;                                                          \
  84 })
  85
  86 static void iucv_sock_kill(struct sock *sk);
  87 static void iucv_sock_close(struct sock *sk);
  88 static void iucv_sever_path(struct sock *, int);
  89
  90 static int afiucv_hs_rcv(struct sk_buff *skb, struct net_device *dev,
  91         struct packet_type *pt, struct net_device *orig_dev);
  92 static int afiucv_hs_send(struct iucv_message *imsg, struct sock *sock,
  93                    struct sk_buff *skb, u8 flags);
  94 static void afiucv_hs_callback_txnotify(struct sk_buff *, enum iucv_tx_notify);
  95
  96 /* Call Back functions */
  97 static void iucv_callback_rx(struct iucv_path *, struct iucv_message *);
  98 static void iucv_callback_txdone(struct iucv_path *, struct iucv_message *);
  99 static void iucv_callback_connack(struct iucv_path *, u8 *);
 100 static int iucv_callback_connreq(struct iucv_path *, u8 *, u8 *);
 101 static void iucv_callback_connrej(struct iucv_path *, u8 *);
 102 static void iucv_callback_shutdown(struct iucv_path *, u8 *);
 103
 104 static struct iucv_sock_list iucv_sk_list = {
 105         .lock = __RW_LOCK_UNLOCKED(iucv_sk_list.lock),
 106         .autobind_name = ATOMIC_INIT(0)
 107 };
 108
 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,
 116 };
 117
 118 static inline void high_nmcpy(unsigned char *dst, char *src)
 119 {
 120        memcpy(dst, src, 8);
 121 }
 122
 123 static inline void low_nmcpy(unsigned char *dst, char *src)
 124 {
 125        memcpy(&dst[8], src, 8);
 126 }
 127
 128 static int afiucv_pm_prepare(struct device *dev)
 129 {
 130 #ifdef CONFIG_PM_DEBUG
 131         printk(KERN_WARNING "afiucv_pm_prepare\n");
 132 #endif
 133         return 0;
 134 }
 135
 136 static void afiucv_pm_complete(struct device *dev)
 137 {
 138 #ifdef CONFIG_PM_DEBUG
 139         printk(KERN_WARNING "afiucv_pm_complete\n");
 140 #endif
 141 }
 142
 143 /**
 144  * afiucv_pm_freeze() - Freeze PM callback
 145  * @dev:        AFIUCV dummy device
 146  *
 147  * Sever all established IUCV communication pathes
 148  */
 149 static int afiucv_pm_freeze(struct device *dev)
 150 {
 151         struct iucv_sock *iucv;
 152         struct sock *sk;
 153
 154 #ifdef CONFIG_PM_DEBUG
 155         printk(KERN_WARNING "afiucv_pm_freeze\n");
 156 #endif
 157         read_lock(&iucv_sk_list.lock);
 158         sk_for_each(sk, &iucv_sk_list.head) {
 159                 iucv = iucv_sk(sk);
 160                 switch (sk->sk_state) {
 161                 case IUCV_DISCONN:
 162                 case IUCV_CLOSING:
 163                 case IUCV_CONNECTED:
 164                         iucv_sever_path(sk, 0);
 165                         break;
 166                 case IUCV_OPEN:
 167                 case IUCV_BOUND:
 168                 case IUCV_LISTEN:
 169                 case IUCV_CLOSED:
 170                 default:
 171                         break;
 172                 }
 173                 skb_queue_purge(&iucv->send_skb_q);
 174                 skb_queue_purge(&iucv->backlog_skb_q);
 175         }
 176         read_unlock(&iucv_sk_list.lock);
 177         return 0;
 178 }
 179
 180 /**
 181  * afiucv_pm_restore_thaw() - Thaw and restore PM callback
 182  * @dev:        AFIUCV dummy device
 183  *
 184  * socket clean up after freeze
 185  */
 186 static int afiucv_pm_restore_thaw(struct device *dev)
 187 {
 188         struct sock *sk;
 189
 190 #ifdef CONFIG_PM_DEBUG
 191         printk(KERN_WARNING "afiucv_pm_restore_thaw\n");
 192 #endif
 193         read_lock(&iucv_sk_list.lock);
 194         sk_for_each(sk, &iucv_sk_list.head) {
 195                 switch (sk->sk_state) {
 196                 case IUCV_CONNECTED:
 197                         sk->sk_err = EPIPE;
 198                         sk->sk_state = IUCV_DISCONN;
 199                         sk->sk_state_change(sk);
 200                         break;
 201                 case IUCV_DISCONN:
 202                 case IUCV_CLOSING:
 203                 case IUCV_LISTEN:
 204                 case IUCV_BOUND:
 205                 case IUCV_OPEN:
 206                 default:
 207                         break;
 208                 }
 209         }
 210         read_unlock(&iucv_sk_list.lock);
 211         return 0;
 212 }
 213
 214 static const struct dev_pm_ops afiucv_pm_ops = {
 215         .prepare = afiucv_pm_prepare,
 216         .complete = afiucv_pm_complete,
 217         .freeze = afiucv_pm_freeze,
 218         .thaw = afiucv_pm_restore_thaw,
 219         .restore = afiucv_pm_restore_thaw,
 220 };
 221
 222 static struct device_driver af_iucv_driver = {
 223         .owner = THIS_MODULE,
 224         .name = "afiucv",
 225         .bus  = NULL,
 226         .pm   = &afiucv_pm_ops,
 227 };
 228
 229 /* dummy device used as trigger for PM functions */
 230 static struct device *af_iucv_dev;
 231
 232 /**
 233  * iucv_msg_length() - Returns the length of an iucv message.
 234  * @msg:        Pointer to struct iucv_message, MUST NOT be NULL
 235  *
 236  * The function returns the length of the specified iucv message @msg of data
 237  * stored in a buffer and of data stored in the parameter list (PRMDATA).
 238  *
 239  * For IUCV_IPRMDATA, AF_IUCV uses the following convention to transport socket
 240  * data:
 241  *      PRMDATA[0..6]   socket data (max 7 bytes);
 242  *      PRMDATA[7]      socket data length value (len is 0xff - PRMDATA[7])
 243  *
 244  * The socket data length is computed by subtracting the socket data length
 245  * value from 0xFF.
 246  * If the socket data len is greater 7, then PRMDATA can be used for special
 247  * notifications (see iucv_sock_shutdown); and further,
 248  * if the socket data len is > 7, the function returns 8.
 249  *
 250  * Use this function to allocate socket buffers to store iucv message data.
 251  */
 252 static inline size_t iucv_msg_length(struct iucv_message *msg)
 253 {
 254         size_t datalen;
 255
 256         if (msg->flags & IUCV_IPRMDATA) {
 257                 datalen = 0xff - msg->rmmsg[7];
 258                 return (datalen < 8) ? datalen : 8;
 259         }
 260         return msg->length;
 261 }
 262
 263 /**
 264  * iucv_sock_in_state() - check for specific states
 265  * @sk:         sock structure
 266  * @state:      first iucv sk state
 267  * @state:      second iucv sk state
 268  *
 269  * Returns true if the socket in either in the first or second state.
 270  */
 271 static int iucv_sock_in_state(struct sock *sk, int state, int state2)
 272 {
 273         return (sk->sk_state == state || sk->sk_state == state2);
 274 }
 275
 276 /**
 277  * iucv_below_msglim() - function to check if messages can be sent
 278  * @sk:         sock structure
 279  *
 280  * Returns true if the send queue length is lower than the message limit.
 281  * Always returns true if the socket is not connected (no iucv path for
 282  * checking the message limit).
 283  */
 284 static inline int iucv_below_msglim(struct sock *sk)
 285 {
 286         struct iucv_sock *iucv = iucv_sk(sk);
 287
 288         if (sk->sk_state != IUCV_CONNECTED)
 289                 return 1;
 290         if (iucv->transport == AF_IUCV_TRANS_IUCV)
 291                 return (skb_queue_len(&iucv->send_skb_q) < iucv->path->msglim);
 292         else
 293                 return ((atomic_read(&iucv->msg_sent) < iucv->msglimit_peer) &&
 294                         (atomic_read(&iucv->pendings) <= 0));
 295 }
 296
 297 /**
 298  * iucv_sock_wake_msglim() - Wake up thread waiting on msg limit
 299  */
 300 static void iucv_sock_wake_msglim(struct sock *sk)
 301 {
 302         struct socket_wq *wq;
 303
 304         rcu_read_lock();
 305         wq = rcu_dereference(sk->sk_wq);
 306         if (skwq_has_sleeper(wq))
 307                 wake_up_interruptible_all(&wq->wait);
 308         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 309         rcu_read_unlock();
 310 }
 311
 312 /**
 313  * afiucv_hs_send() - send a message through HiperSockets transport
 314  */
 315 static int afiucv_hs_send(struct iucv_message *imsg, struct sock *sock,
 316                    struct sk_buff *skb, u8 flags)
 317 {
 318         struct iucv_sock *iucv = iucv_sk(sock);
 319         struct af_iucv_trans_hdr *phs_hdr;
 320         struct sk_buff *nskb;
 321         int err, confirm_recv = 0;
 322
 323         phs_hdr = skb_push(skb, sizeof(*phs_hdr));
 324         memset(phs_hdr, 0, sizeof(*phs_hdr));
 325         skb_reset_network_header(skb);
 326
 327         phs_hdr->magic = ETH_P_AF_IUCV;
 328         phs_hdr->version = 1;
 329         phs_hdr->flags = flags;
 330         if (flags == AF_IUCV_FLAG_SYN)
 331                 phs_hdr->window = iucv->msglimit;
 332         else if ((flags == AF_IUCV_FLAG_WIN) || !flags) {
 333                 confirm_recv = atomic_read(&iucv->msg_recv);
 334                 phs_hdr->window = confirm_recv;
 335                 if (confirm_recv)
 336                         phs_hdr->flags = phs_hdr->flags | AF_IUCV_FLAG_WIN;
 337         }
 338         memcpy(phs_hdr->destUserID, iucv->dst_user_id, 8);
 339         memcpy(phs_hdr->destAppName, iucv->dst_name, 8);
 340         memcpy(phs_hdr->srcUserID, iucv->src_user_id, 8);
 341         memcpy(phs_hdr->srcAppName, iucv->src_name, 8);
 342         ASCEBC(phs_hdr->destUserID, sizeof(phs_hdr->destUserID));
 343         ASCEBC(phs_hdr->destAppName, sizeof(phs_hdr->destAppName));
 344         ASCEBC(phs_hdr->srcUserID, sizeof(phs_hdr->srcUserID));
 345         ASCEBC(phs_hdr->srcAppName, sizeof(phs_hdr->srcAppName));
 346         if (imsg)
 347                 memcpy(&phs_hdr->iucv_hdr, imsg, sizeof(struct iucv_message));
 348
 349         skb_push(skb, ETH_HLEN);
 350         memset(skb->data, 0, ETH_HLEN);
 351
 352         skb->dev = iucv->hs_dev;
 353         if (!skb->dev) {
 354                 err = -ENODEV;
 355                 goto err_free;
 356         }
 357         if (!(skb->dev->flags & IFF_UP) || !netif_carrier_ok(skb->dev)) {
 358                 err = -ENETDOWN;
 359                 goto err_free;
 360         }
 361         if (skb->len > skb->dev->mtu) {
 362                 if (sock->sk_type == SOCK_SEQPACKET) {
 363                         err = -EMSGSIZE;
 364                         goto err_free;
 365                 }
 366                 skb_trim(skb, skb->dev->mtu);
 367         }
 368         skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
 369         nskb = skb_clone(skb, GFP_ATOMIC);
 370         if (!nskb) {
 371                 err = -ENOMEM;
 372                 goto err_free;
 373         }
 374
 375         skb_queue_tail(&iucv->send_skb_q, nskb);
 376         err = dev_queue_xmit(skb);
 377         if (net_xmit_eval(err)) {
 378                 skb_unlink(nskb, &iucv->send_skb_q);
 379                 kfree_skb(nskb);
 380         } else {
 381                 atomic_sub(confirm_recv, &iucv->msg_recv);
 382                 WARN_ON(atomic_read(&iucv->msg_recv) < 0);
 383         }
 384         return net_xmit_eval(err);
 385
 386 err_free:
 387         kfree_skb(skb);
 388         return err;
 389 }
 390
 391 static struct sock *__iucv_get_sock_by_name(char *nm)
 392 {
 393         struct sock *sk;
 394
 395         sk_for_each(sk, &iucv_sk_list.head)
 396                 if (!memcmp(&iucv_sk(sk)->src_name, nm, 8))
 397                         return sk;
 398
 399         return NULL;
 400 }
 401
 402 static void iucv_sock_destruct(struct sock *sk)
 403 {
 404         skb_queue_purge(&sk->sk_receive_queue);
 405         skb_queue_purge(&sk->sk_error_queue);
 406
 407         sk_mem_reclaim(sk);
 408
 409         if (!sock_flag(sk, SOCK_DEAD)) {
 410                 pr_err("Attempt to release alive iucv socket %p\n", sk);
 411                 return;
 412         }
 413
 414         WARN_ON(atomic_read(&sk->sk_rmem_alloc));
 415         WARN_ON(refcount_read(&sk->sk_wmem_alloc));
 416         WARN_ON(sk->sk_wmem_queued);
 417         WARN_ON(sk->sk_forward_alloc);
 418 }
 419
 420 /* Cleanup Listen */
 421 static void iucv_sock_cleanup_listen(struct sock *parent)
 422 {
 423         struct sock *sk;
 424
 425         /* Close non-accepted connections */
 426         while ((sk = iucv_accept_dequeue(parent, NULL))) {
 427                 iucv_sock_close(sk);
 428                 iucv_sock_kill(sk);
 429         }
 430
 431         parent->sk_state = IUCV_CLOSED;
 432 }
 433
 434 /* Kill socket (only if zapped and orphaned) */
 435 static void iucv_sock_kill(struct sock *sk)
 436 {
 437         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 438                 return;
 439
 440         iucv_sock_unlink(&iucv_sk_list, sk);
 441         sock_set_flag(sk, SOCK_DEAD);
 442         sock_put(sk);
 443 }
 444
 445 /* Terminate an IUCV path */
 446 static void iucv_sever_path(struct sock *sk, int with_user_data)
 447 {
 448         unsigned char user_data[16];
 449         struct iucv_sock *iucv = iucv_sk(sk);
 450         struct iucv_path *path = iucv->path;
 451
 452         if (iucv->path) {
 453                 iucv->path = NULL;
 454                 if (with_user_data) {
 455                         low_nmcpy(user_data, iucv->src_name);
 456                         high_nmcpy(user_data, iucv->dst_name);
 457                         ASCEBC(user_data, sizeof(user_data));
 458                         pr_iucv->path_sever(path, user_data);
 459                 } else
 460                         pr_iucv->path_sever(path, NULL);
 461                 iucv_path_free(path);
 462         }
 463 }
 464
 465 /* Send controlling flags through an IUCV socket for HIPER transport */
 466 static int iucv_send_ctrl(struct sock *sk, u8 flags)
 467 {
 468         int err = 0;
 469         int blen;
 470         struct sk_buff *skb;
 471         u8 shutdown = 0;
 472
 473         blen = sizeof(struct af_iucv_trans_hdr) + ETH_HLEN;
 474         if (sk->sk_shutdown & SEND_SHUTDOWN) {
 475                 /* controlling flags should be sent anyway */
 476                 shutdown = sk->sk_shutdown;
 477                 sk->sk_shutdown &= RCV_SHUTDOWN;
 478         }
 479         skb = sock_alloc_send_skb(sk, blen, 1, &err);
 480         if (skb) {
 481                 skb_reserve(skb, blen);
 482                 err = afiucv_hs_send(NULL, sk, skb, flags);
 483         }
 484         if (shutdown)
 485                 sk->sk_shutdown = shutdown;
 486         return err;
 487 }
 488
 489 /* Close an IUCV socket */
 490 static void iucv_sock_close(struct sock *sk)
 491 {
 492         struct iucv_sock *iucv = iucv_sk(sk);
 493         unsigned long timeo;
 494         int err = 0;
 495
 496         lock_sock(sk);
 497
 498         switch (sk->sk_state) {
 499         case IUCV_LISTEN:
 500                 iucv_sock_cleanup_listen(sk);
 501                 break;
 502
 503         case IUCV_CONNECTED:
 504                 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
 505                         err = iucv_send_ctrl(sk, AF_IUCV_FLAG_FIN);
 506                         sk->sk_state = IUCV_DISCONN;
 507                         sk->sk_state_change(sk);
 508                 }
 509         case IUCV_DISCONN:   /* fall through */
 510                 sk->sk_state = IUCV_CLOSING;
 511                 sk->sk_state_change(sk);
 512
 513                 if (!err && !skb_queue_empty(&iucv->send_skb_q)) {
 514                         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 515                                 timeo = sk->sk_lingertime;
 516                         else
 517                                 timeo = IUCV_DISCONN_TIMEOUT;
 518                         iucv_sock_wait(sk,
 519                                         iucv_sock_in_state(sk, IUCV_CLOSED, 0),
 520                                         timeo);
 521                 }
 522
 523         case IUCV_CLOSING:   /* fall through */
 524                 sk->sk_state = IUCV_CLOSED;
 525                 sk->sk_state_change(sk);
 526
 527                 sk->sk_err = ECONNRESET;
 528                 sk->sk_state_change(sk);
 529
 530                 skb_queue_purge(&iucv->send_skb_q);
 531                 skb_queue_purge(&iucv->backlog_skb_q);
 532
 533         default:   /* fall through */
 534                 iucv_sever_path(sk, 1);
 535         }
 536
 537         if (iucv->hs_dev) {
 538                 dev_put(iucv->hs_dev);
 539                 iucv->hs_dev = NULL;
 540                 sk->sk_bound_dev_if = 0;
 541         }
 542
 543         /* mark socket for deletion by iucv_sock_kill() */
 544         sock_set_flag(sk, SOCK_ZAPPED);
 545
 546         release_sock(sk);
 547 }
 548
 549 static void iucv_sock_init(struct sock *sk, struct sock *parent)
 550 {
 551         if (parent) {
 552                 sk->sk_type = parent->sk_type;
 553                 security_sk_clone(parent, sk);
 554         }
 555 }
 556
 557 static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio, int kern)
 558 {
 559         struct sock *sk;
 560         struct iucv_sock *iucv;
 561
 562         sk = sk_alloc(&init_net, PF_IUCV, prio, &iucv_proto, kern);
 563         if (!sk)
 564                 return NULL;
 565         iucv = iucv_sk(sk);
 566
 567         sock_init_data(sock, sk);
 568         INIT_LIST_HEAD(&iucv->accept_q);
 569         spin_lock_init(&iucv->accept_q_lock);
 570         skb_queue_head_init(&iucv->send_skb_q);
 571         INIT_LIST_HEAD(&iucv->message_q.list);
 572         spin_lock_init(&iucv->message_q.lock);
 573         skb_queue_head_init(&iucv->backlog_skb_q);
 574         iucv->send_tag = 0;
 575         atomic_set(&iucv->pendings, 0);
 576         iucv->flags = 0;
 577         iucv->msglimit = 0;
 578         atomic_set(&iucv->msg_sent, 0);
 579         atomic_set(&iucv->msg_recv, 0);
 580         iucv->path = NULL;
 581         iucv->sk_txnotify = afiucv_hs_callback_txnotify;
 582         memset(&iucv->src_user_id , 0, 32);
 583         if (pr_iucv)
 584                 iucv->transport = AF_IUCV_TRANS_IUCV;
 585         else
 586                 iucv->transport = AF_IUCV_TRANS_HIPER;
 587
 588         sk->sk_destruct = iucv_sock_destruct;
 589         sk->sk_sndtimeo = IUCV_CONN_TIMEOUT;
 590         sk->sk_allocation = GFP_DMA;
 591
 592         sock_reset_flag(sk, SOCK_ZAPPED);
 593
 594         sk->sk_protocol = proto;
 595         sk->sk_state    = IUCV_OPEN;
 596
 597         iucv_sock_link(&iucv_sk_list, sk);
 598         return sk;
 599 }
 600
 601 /* Create an IUCV socket */
 602 static int iucv_sock_create(struct net *net, struct socket *sock, int protocol,
 603                             int kern)
 604 {
 605         struct sock *sk;
 606
 607         if (protocol && protocol != PF_IUCV)
 608                 return -EPROTONOSUPPORT;
 609
 610         sock->state = SS_UNCONNECTED;
 611
 612         switch (sock->type) {
 613         case SOCK_STREAM:
 614                 sock->ops = &iucv_sock_ops;
 615                 break;
 616         case SOCK_SEQPACKET:
 617                 /* currently, proto ops can handle both sk types */
 618                 sock->ops = &iucv_sock_ops;
 619                 break;
 620         default:
 621                 return -ESOCKTNOSUPPORT;
 622         }
 623
 624         sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL, kern);
 625         if (!sk)
 626                 return -ENOMEM;
 627
 628         iucv_sock_init(sk, NULL);
 629
 630         return 0;
 631 }
 632
 633 void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk)
 634 {
 635         write_lock_bh(&l->lock);
 636         sk_add_node(sk, &l->head);
 637         write_unlock_bh(&l->lock);
 638 }
 639
 640 void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk)
 641 {
 642         write_lock_bh(&l->lock);
 643         sk_del_node_init(sk);
 644         write_unlock_bh(&l->lock);
 645 }
 646
 647 void iucv_accept_enqueue(struct sock *parent, struct sock *sk)
 648 {
 649         unsigned long flags;
 650         struct iucv_sock *par = iucv_sk(parent);
 651
 652         sock_hold(sk);
 653         spin_lock_irqsave(&par->accept_q_lock, flags);
 654         list_add_tail(&iucv_sk(sk)->accept_q, &par->accept_q);
 655         spin_unlock_irqrestore(&par->accept_q_lock, flags);
 656         iucv_sk(sk)->parent = parent;
 657         sk_acceptq_added(parent);
 658 }
 659
 660 void iucv_accept_unlink(struct sock *sk)
 661 {
 662         unsigned long flags;
 663         struct iucv_sock *par = iucv_sk(iucv_sk(sk)->parent);
 664
 665         spin_lock_irqsave(&par->accept_q_lock, flags);
 666         list_del_init(&iucv_sk(sk)->accept_q);
 667         spin_unlock_irqrestore(&par->accept_q_lock, flags);
 668         sk_acceptq_removed(iucv_sk(sk)->parent);
 669         iucv_sk(sk)->parent = NULL;
 670         sock_put(sk);
 671 }
 672
 673 struct sock *iucv_accept_dequeue(struct sock *parent, struct socket *newsock)
 674 {
 675         struct iucv_sock *isk, *n;
 676         struct sock *sk;
 677
 678         list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
 679                 sk = (struct sock *) isk;
 680                 lock_sock(sk);
 681
 682                 if (sk->sk_state == IUCV_CLOSED) {
 683                         iucv_accept_unlink(sk);
 684                         release_sock(sk);
 685                         continue;
 686                 }
 687
 688                 if (sk->sk_state == IUCV_CONNECTED ||
 689                     sk->sk_state == IUCV_DISCONN ||
 690                     !newsock) {
 691                         iucv_accept_unlink(sk);
 692                         if (newsock)
 693                                 sock_graft(sk, newsock);
 694
 695                         release_sock(sk);
 696                         return sk;
 697                 }
 698
 699                 release_sock(sk);
 700         }
 701         return NULL;
 702 }
 703
 704 static void __iucv_auto_name(struct iucv_sock *iucv)
 705 {
 706         char name[12];
 707
 708         sprintf(name, "%08x", atomic_inc_return(&iucv_sk_list.autobind_name));
 709         while (__iucv_get_sock_by_name(name)) {
 710                 sprintf(name, "%08x",
 711                         atomic_inc_return(&iucv_sk_list.autobind_name));
 712         }
 713         memcpy(iucv->src_name, name, 8);
 714 }
 715
 716 /* Bind an unbound socket */
 717 static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr,
 718                           int addr_len)
 719 {
 720         struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
 721         struct sock *sk = sock->sk;
 722         struct iucv_sock *iucv;
 723         int err = 0;
 724         struct net_device *dev;
 725         char uid[9];
 726
 727         /* Verify the input sockaddr */
 728         if (addr_len < sizeof(struct sockaddr_iucv) ||
 729             addr->sa_family != AF_IUCV)
 730                 return -EINVAL;
 731
 732         lock_sock(sk);
 733         if (sk->sk_state != IUCV_OPEN) {
 734                 err = -EBADFD;
 735                 goto done;
 736         }
 737
 738         write_lock_bh(&iucv_sk_list.lock);
 739
 740         iucv = iucv_sk(sk);
 741         if (__iucv_get_sock_by_name(sa->siucv_name)) {
 742                 err = -EADDRINUSE;
 743                 goto done_unlock;
 744         }
 745         if (iucv->path)
 746                 goto done_unlock;
 747
 748         /* Bind the socket */
 749         if (pr_iucv)
 750                 if (!memcmp(sa->siucv_user_id, iucv_userid, 8))
 751                         goto vm_bind; /* VM IUCV transport */
 752
 753         /* try hiper transport */
 754         memcpy(uid, sa->siucv_user_id, sizeof(uid));
 755         ASCEBC(uid, 8);
 756         rcu_read_lock();
 757         for_each_netdev_rcu(&init_net, dev) {
 758                 if (!memcmp(dev->perm_addr, uid, 8)) {
 759                         memcpy(iucv->src_user_id, sa->siucv_user_id, 8);
 760                         /* Check for unitialized siucv_name */
 761                         if (strncmp(sa->siucv_name, "        ", 8) == 0)
 762                                 __iucv_auto_name(iucv);
 763                         else
 764                                 memcpy(iucv->src_name, sa->siucv_name, 8);
 765                         sk->sk_bound_dev_if = dev->ifindex;
 766                         iucv->hs_dev = dev;
 767                         dev_hold(dev);
 768                         sk->sk_state = IUCV_BOUND;
 769                         iucv->transport = AF_IUCV_TRANS_HIPER;
 770                         if (!iucv->msglimit)
 771                                 iucv->msglimit = IUCV_HIPER_MSGLIM_DEFAULT;
 772                         rcu_read_unlock();
 773                         goto done_unlock;
 774                 }
 775         }
 776         rcu_read_unlock();
 777 vm_bind:
 778         if (pr_iucv) {
 779                 /* use local userid for backward compat */
 780                 memcpy(iucv->src_name, sa->siucv_name, 8);
 781                 memcpy(iucv->src_user_id, iucv_userid, 8);
 782                 sk->sk_state = IUCV_BOUND;
 783                 iucv->transport = AF_IUCV_TRANS_IUCV;
 784                 if (!iucv->msglimit)
 785                         iucv->msglimit = IUCV_QUEUELEN_DEFAULT;
 786                 goto done_unlock;
 787         }
 788         /* found no dev to bind */
 789         err = -ENODEV;
 790 done_unlock:
 791         /* Release the socket list lock */
 792         write_unlock_bh(&iucv_sk_list.lock);
 793 done:
 794         release_sock(sk);
 795         return err;
 796 }
 797
 798 /* Automatically bind an unbound socket */
 799 static int iucv_sock_autobind(struct sock *sk)
 800 {
 801         struct iucv_sock *iucv = iucv_sk(sk);
 802         int err = 0;
 803
 804         if (unlikely(!pr_iucv))
 805                 return -EPROTO;
 806
 807         memcpy(iucv->src_user_id, iucv_userid, 8);
 808
 809         write_lock_bh(&iucv_sk_list.lock);
 810         __iucv_auto_name(iucv);
 811         write_unlock_bh(&iucv_sk_list.lock);
 812
 813         if (!iucv->msglimit)
 814                 iucv->msglimit = IUCV_QUEUELEN_DEFAULT;
 815
 816         return err;
 817 }
 818
 819 static int afiucv_path_connect(struct socket *sock, struct sockaddr *addr)
 820 {
 821         struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
 822         struct sock *sk = sock->sk;
 823         struct iucv_sock *iucv = iucv_sk(sk);
 824         unsigned char user_data[16];
 825         int err;
 826
 827         high_nmcpy(user_data, sa->siucv_name);
 828         low_nmcpy(user_data, iucv->src_name);
 829         ASCEBC(user_data, sizeof(user_data));
 830
 831         /* Create path. */
 832         iucv->path = iucv_path_alloc(iucv->msglimit,
 833                                      IUCV_IPRMDATA, GFP_KERNEL);
 834         if (!iucv->path) {
 835                 err = -ENOMEM;
 836                 goto done;
 837         }
 838         err = pr_iucv->path_connect(iucv->path, &af_iucv_handler,
 839                                     sa->siucv_user_id, NULL, user_data,
 840                                     sk);
 841         if (err) {
 842                 iucv_path_free(iucv->path);
 843                 iucv->path = NULL;
 844                 switch (err) {
 845                 case 0x0b:      /* Target communicator is not logged on */
 846                         err = -ENETUNREACH;
 847                         break;
 848                 case 0x0d:      /* Max connections for this guest exceeded */
 849                 case 0x0e:      /* Max connections for target guest exceeded */
 850                         err = -EAGAIN;
 851                         break;
 852                 case 0x0f:      /* Missing IUCV authorization */
 853                         err = -EACCES;
 854                         break;
 855                 default:
 856                         err = -ECONNREFUSED;
 857                         break;
 858                 }
 859         }
 860 done:
 861         return err;
 862 }
 863
 864 /* Connect an unconnected socket */
 865 static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
 866                              int alen, int flags)
 867 {
 868         struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
 869         struct sock *sk = sock->sk;
 870         struct iucv_sock *iucv = iucv_sk(sk);
 871         int err;
 872
 873         if (alen < sizeof(struct sockaddr_iucv) || addr->sa_family != AF_IUCV)
 874                 return -EINVAL;
 875
 876         if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
 877                 return -EBADFD;
 878
 879         if (sk->sk_state == IUCV_OPEN &&
 880             iucv->transport == AF_IUCV_TRANS_HIPER)
 881                 return -EBADFD; /* explicit bind required */
 882
 883         if (sk->sk_type != SOCK_STREAM && sk->sk_type != SOCK_SEQPACKET)
 884                 return -EINVAL;
 885
 886         if (sk->sk_state == IUCV_OPEN) {
 887                 err = iucv_sock_autobind(sk);
 888                 if (unlikely(err))
 889                         return err;
 890         }
 891
 892         lock_sock(sk);
 893
 894         /* Set the destination information */
 895         memcpy(iucv->dst_user_id, sa->siucv_user_id, 8);
 896         memcpy(iucv->dst_name, sa->siucv_name, 8);
 897
 898         if (iucv->transport == AF_IUCV_TRANS_HIPER)
 899                 err = iucv_send_ctrl(sock->sk, AF_IUCV_FLAG_SYN);
 900         else
 901                 err = afiucv_path_connect(sock, addr);
 902         if (err)
 903                 goto done;
 904
 905         if (sk->sk_state != IUCV_CONNECTED)
 906                 err = iucv_sock_wait(sk, iucv_sock_in_state(sk, IUCV_CONNECTED,
 907                                                             IUCV_DISCONN),
 908                                      sock_sndtimeo(sk, flags & O_NONBLOCK));
 909
 910         if (sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_CLOSED)
 911                 err = -ECONNREFUSED;
 912
 913         if (err && iucv->transport == AF_IUCV_TRANS_IUCV)
 914                 iucv_sever_path(sk, 0);
 915
 916 done:
 917         release_sock(sk);
 918         return err;
 919 }
 920
 921 /* Move a socket into listening state. */
 922 static int iucv_sock_listen(struct socket *sock, int backlog)
 923 {
 924         struct sock *sk = sock->sk;
 925         int err;
 926
 927         lock_sock(sk);
 928
 929         err = -EINVAL;
 930         if (sk->sk_state != IUCV_BOUND)
 931                 goto done;
 932
 933         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
 934                 goto done;
 935
 936         sk->sk_max_ack_backlog = backlog;
 937         sk->sk_ack_backlog = 0;
 938         sk->sk_state = IUCV_LISTEN;
 939         err = 0;
 940
 941 done:
 942         release_sock(sk);
 943         return err;
 944 }
 945
 946 /* Accept a pending connection */
 947 static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
 948                             int flags, bool kern)
 949 {
 950         DECLARE_WAITQUEUE(wait, current);
 951         struct sock *sk = sock->sk, *nsk;
 952         long timeo;
 953         int err = 0;
 954
 955         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 956
 957         if (sk->sk_state != IUCV_LISTEN) {
 958                 err = -EBADFD;
 959                 goto done;
 960         }
 961
 962         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 963
 964         /* Wait for an incoming connection */
 965         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 966         while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
 967                 set_current_state(TASK_INTERRUPTIBLE);
 968                 if (!timeo) {
 969                         err = -EAGAIN;
 970                         break;
 971                 }
 972
 973                 release_sock(sk);
 974                 timeo = schedule_timeout(timeo);
 975                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 976
 977                 if (sk->sk_state != IUCV_LISTEN) {
 978                         err = -EBADFD;
 979                         break;
 980                 }
 981
 982                 if (signal_pending(current)) {
 983                         err = sock_intr_errno(timeo);
 984                         break;
 985                 }
 986         }
 987
 988         set_current_state(TASK_RUNNING);
 989         remove_wait_queue(sk_sleep(sk), &wait);
 990
 991         if (err)
 992                 goto done;
 993
 994         newsock->state = SS_CONNECTED;
 995
 996 done:
 997         release_sock(sk);
 998         return err;
 999 }
1000
1001 static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
1002                              int peer)
1003 {
1004         struct sockaddr_iucv *siucv = (struct sockaddr_iucv *) addr;
1005         struct sock *sk = sock->sk;
1006         struct iucv_sock *iucv = iucv_sk(sk);
1007
1008         addr->sa_family = AF_IUCV;
1009
1010         if (peer) {
1011                 memcpy(siucv->siucv_user_id, iucv->dst_user_id, 8);
1012                 memcpy(siucv->siucv_name, iucv->dst_name, 8);
1013         } else {
1014                 memcpy(siucv->siucv_user_id, iucv->src_user_id, 8);
1015                 memcpy(siucv->siucv_name, iucv->src_name, 8);
1016         }
1017         memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port));
1018         memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr));
1019         memset(&siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid));
1020
1021         return sizeof(struct sockaddr_iucv);
1022 }
1023
1024 /**
1025  * iucv_send_iprm() - Send socket data in parameter list of an iucv message.
1026  * @path:       IUCV path
1027  * @msg:        Pointer to a struct iucv_message
1028  * @skb:        The socket data to send, skb->len MUST BE <= 7
1029  *
1030  * Send the socket data in the parameter list in the iucv message
1031  * (IUCV_IPRMDATA). The socket data is stored at index 0 to 6 in the parameter
1032  * list and the socket data len at index 7 (last byte).
1033  * See also iucv_msg_length().
1034  *
1035  * Returns the error code from the iucv_message_send() call.
1036  */
1037 static int iucv_send_iprm(struct iucv_path *path, struct iucv_message *msg,
1038                           struct sk_buff *skb)
1039 {
1040         u8 prmdata[8];
1041
1042         memcpy(prmdata, (void *) skb->data, skb->len);
1043         prmdata[7] = 0xff - (u8) skb->len;
1044         return pr_iucv->message_send(path, msg, IUCV_IPRMDATA, 0,
1045                                  (void *) prmdata, 8);
1046 }
1047
1048 static int iucv_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1049                              size_t len)
1050 {
1051         struct sock *sk = sock->sk;
1052         struct iucv_sock *iucv = iucv_sk(sk);
1053         size_t headroom = 0;
1054         size_t linear;
1055         struct sk_buff *skb;
1056         struct iucv_message txmsg = {0};
1057         struct cmsghdr *cmsg;
1058         int cmsg_done;
1059         long timeo;
1060         char user_id[9];
1061         char appl_id[9];
1062         int err;
1063         int noblock = msg->msg_flags & MSG_DONTWAIT;
1064
1065         err = sock_error(sk);
1066         if (err)
1067                 return err;
1068
1069         if (msg->msg_flags & MSG_OOB)
1070                 return -EOPNOTSUPP;
1071
1072         /* SOCK_SEQPACKET: we do not support segmented records */
1073         if (sk->sk_type == SOCK_SEQPACKET && !(msg->msg_flags & MSG_EOR))
1074                 return -EOPNOTSUPP;
1075
1076         lock_sock(sk);
1077
1078         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1079                 err = -EPIPE;
1080                 goto out;
1081         }
1082
1083         /* Return if the socket is not in connected state */
1084         if (sk->sk_state != IUCV_CONNECTED) {
1085                 err = -ENOTCONN;
1086                 goto out;
1087         }
1088
1089         /* initialize defaults */
1090         cmsg_done   = 0;        /* check for duplicate headers */
1091         txmsg.class = 0;
1092
1093         /* iterate over control messages */
1094         for_each_cmsghdr(cmsg, msg) {
1095                 if (!CMSG_OK(msg, cmsg)) {
1096                         err = -EINVAL;
1097                         goto out;
1098                 }
1099
1100                 if (cmsg->cmsg_level != SOL_IUCV)
1101                         continue;
1102
1103                 if (cmsg->cmsg_type & cmsg_done) {
1104                         err = -EINVAL;
1105                         goto out;
1106                 }
1107                 cmsg_done |= cmsg->cmsg_type;
1108
1109                 switch (cmsg->cmsg_type) {
1110                 case SCM_IUCV_TRGCLS:
1111                         if (cmsg->cmsg_len != CMSG_LEN(TRGCLS_SIZE)) {
1112                                 err = -EINVAL;
1113                                 goto out;
1114                         }
1115
1116                         /* set iucv message target class */
1117                         memcpy(&txmsg.class,
1118                                 (void *) CMSG_DATA(cmsg), TRGCLS_SIZE);
1119
1120                         break;
1121
1122                 default:
1123                         err = -EINVAL;
1124                         goto out;
1125                 }
1126         }
1127
1128         /* allocate one skb for each iucv message:
1129          * this is fine for SOCK_SEQPACKET (unless we want to support
1130          * segmented records using the MSG_EOR flag), but
1131          * for SOCK_STREAM we might want to improve it in future */
1132         if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1133                 headroom = sizeof(struct af_iucv_trans_hdr) + ETH_HLEN;
1134                 linear = len;
1135         } else {
1136                 if (len < PAGE_SIZE) {
1137                         linear = len;
1138                 } else {
1139                         /* In nonlinear "classic" iucv skb,
1140                          * reserve space for iucv_array
1141                          */
1142                         headroom = sizeof(struct iucv_array) *
1143                                    (MAX_SKB_FRAGS + 1);
1144                         linear = PAGE_SIZE - headroom;
1145                 }
1146         }
1147         skb = sock_alloc_send_pskb(sk, headroom + linear, len - linear,
1148                                    noblock, &err, 0);
1149         if (!skb)
1150                 goto out;
1151         if (headroom)
1152                 skb_reserve(skb, headroom);
1153         skb_put(skb, linear);
1154         skb->len = len;
1155         skb->data_len = len - linear;
1156         err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1157         if (err)
1158                 goto fail;
1159
1160         /* wait if outstanding messages for iucv path has reached */
1161         timeo = sock_sndtimeo(sk, noblock);
1162         err = iucv_sock_wait(sk, iucv_below_msglim(sk), timeo);
1163         if (err)
1164                 goto fail;
1165
1166         /* return -ECONNRESET if the socket is no longer connected */
1167         if (sk->sk_state != IUCV_CONNECTED) {
1168                 err = -ECONNRESET;
1169                 goto fail;
1170         }
1171
1172         /* increment and save iucv message tag for msg_completion cbk */
1173         txmsg.tag = iucv->send_tag++;
1174         IUCV_SKB_CB(skb)->tag = txmsg.tag;
1175
1176         if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1177                 atomic_inc(&iucv->msg_sent);
1178                 err = afiucv_hs_send(&txmsg, sk, skb, 0);
1179                 if (err) {
1180                         atomic_dec(&iucv->msg_sent);
1181                         goto out;
1182                 }
1183         } else { /* Classic VM IUCV transport */
1184                 skb_queue_tail(&iucv->send_skb_q, skb);
1185
1186                 if (((iucv->path->flags & IUCV_IPRMDATA) & iucv->flags) &&
1187                     skb->len <= 7) {
1188                         err = iucv_send_iprm(iucv->path, &txmsg, skb);
1189
1190                         /* on success: there is no message_complete callback */
1191                         /* for an IPRMDATA msg; remove skb from send queue   */
1192                         if (err == 0) {
1193                                 skb_unlink(skb, &iucv->send_skb_q);
1194                                 kfree_skb(skb);
1195                         }
1196
1197                         /* this error should never happen since the     */
1198                         /* IUCV_IPRMDATA path flag is set... sever path */
1199                         if (err == 0x15) {
1200                                 pr_iucv->path_sever(iucv->path, NULL);
1201                                 skb_unlink(skb, &iucv->send_skb_q);
1202                                 err = -EPIPE;
1203                                 goto fail;
1204                         }
1205                 } else if (skb_is_nonlinear(skb)) {
1206                         struct iucv_array *iba = (struct iucv_array *)skb->head;
1207                         int i;
1208
1209                         /* skip iucv_array lying in the headroom */
1210                         iba[0].address = (u32)(addr_t)skb->data;
1211                         iba[0].length = (u32)skb_headlen(skb);
1212                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1213                                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1214
1215                                 iba[i + 1].address =
1216                                         (u32)(addr_t)skb_frag_address(frag);
1217                                 iba[i + 1].length = (u32)skb_frag_size(frag);
1218                         }
1219                         err = pr_iucv->message_send(iucv->path, &txmsg,
1220                                                     IUCV_IPBUFLST, 0,
1221                                                     (void *)iba, skb->len);
1222                 } else { /* non-IPRM Linear skb */
1223                         err = pr_iucv->message_send(iucv->path, &txmsg,
1224                                         0, 0, (void *)skb->data, skb->len);
1225                 }
1226                 if (err) {
1227                         if (err == 3) {
1228                                 user_id[8] = 0;
1229                                 memcpy(user_id, iucv->dst_user_id, 8);
1230                                 appl_id[8] = 0;
1231                                 memcpy(appl_id, iucv->dst_name, 8);
1232                                 pr_err(
1233                 "Application %s on z/VM guest %s exceeds message limit\n",
1234                                         appl_id, user_id);
1235                                 err = -EAGAIN;
1236                         } else {
1237                                 err = -EPIPE;
1238                         }
1239                         skb_unlink(skb, &iucv->send_skb_q);
1240                         goto fail;
1241                 }
1242         }
1243
1244         release_sock(sk);
1245         return len;
1246
1247 fail:
1248         kfree_skb(skb);
1249 out:
1250         release_sock(sk);
1251         return err;
1252 }
1253
1254 static struct sk_buff *alloc_iucv_recv_skb(unsigned long len)
1255 {
1256         size_t headroom, linear;
1257         struct sk_buff *skb;
1258         int err;
1259
1260         if (len < PAGE_SIZE) {
1261                 headroom = 0;
1262                 linear = len;
1263         } else {
1264                 headroom = sizeof(struct iucv_array) * (MAX_SKB_FRAGS + 1);
1265                 linear = PAGE_SIZE - headroom;
1266         }
1267         skb = alloc_skb_with_frags(headroom + linear, len - linear,
1268                                    0, &err, GFP_ATOMIC | GFP_DMA);
1269         WARN_ONCE(!skb,
1270                   "alloc of recv iucv skb len=%lu failed with errcode=%d\n",
1271                   len, err);
1272         if (skb) {
1273                 if (headroom)
1274                         skb_reserve(skb, headroom);
1275                 skb_put(skb, linear);
1276                 skb->len = len;
1277                 skb->data_len = len - linear;
1278         }
1279         return skb;
1280 }
1281
1282 /* iucv_process_message() - Receive a single outstanding IUCV message
1283  *
1284  * Locking: must be called with message_q.lock held
1285  */
1286 static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
1287                                  struct iucv_path *path,
1288                                  struct iucv_message *msg)
1289 {
1290         int rc;
1291         unsigned int len;
1292
1293         len = iucv_msg_length(msg);
1294
1295         /* store msg target class in the second 4 bytes of skb ctrl buffer */
1296         /* Note: the first 4 bytes are reserved for msg tag */
1297         IUCV_SKB_CB(skb)->class = msg->class;
1298
1299         /* check for special IPRM messages (e.g. iucv_sock_shutdown) */
1300         if ((msg->flags & IUCV_IPRMDATA) && len > 7) {
1301                 if (memcmp(msg->rmmsg, iprm_shutdown, 8) == 0) {
1302                         skb->data = NULL;
1303                         skb->len = 0;
1304                 }
1305         } else {
1306                 if (skb_is_nonlinear(skb)) {
1307                         struct iucv_array *iba = (struct iucv_array *)skb->head;
1308                         int i;
1309
1310                         iba[0].address = (u32)(addr_t)skb->data;
1311                         iba[0].length = (u32)skb_headlen(skb);
1312                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1313                                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1314
1315                                 iba[i + 1].address =
1316                                         (u32)(addr_t)skb_frag_address(frag);
1317                                 iba[i + 1].length = (u32)skb_frag_size(frag);
1318                         }
1319                         rc = pr_iucv->message_receive(path, msg,
1320                                               IUCV_IPBUFLST,
1321                                               (void *)iba, len, NULL);
1322                 } else {
1323                         rc = pr_iucv->message_receive(path, msg,
1324                                               msg->flags & IUCV_IPRMDATA,
1325                                               skb->data, len, NULL);
1326                 }
1327                 if (rc) {
1328                         kfree_skb(skb);
1329                         return;
1330                 }
1331                 WARN_ON_ONCE(skb->len != len);
1332         }
1333
1334         IUCV_SKB_CB(skb)->offset = 0;
1335         if (sk_filter(sk, skb)) {
1336                 atomic_inc(&sk->sk_drops);      /* skb rejected by filter */
1337                 kfree_skb(skb);
1338                 return;
1339         }
1340         if (__sock_queue_rcv_skb(sk, skb))      /* handle rcv queue full */
1341                 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1342 }
1343
1344 /* iucv_process_message_q() - Process outstanding IUCV messages
1345  *
1346  * Locking: must be called with message_q.lock held
1347  */
1348 static void iucv_process_message_q(struct sock *sk)
1349 {
1350         struct iucv_sock *iucv = iucv_sk(sk);
1351         struct sk_buff *skb;
1352         struct sock_msg_q *p, *n;
1353
1354         list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
1355                 skb = alloc_iucv_recv_skb(iucv_msg_length(&p->msg));
1356                 if (!skb)
1357                         break;
1358                 iucv_process_message(sk, skb, p->path, &p->msg);
1359                 list_del(&p->list);
1360                 kfree(p);
1361                 if (!skb_queue_empty(&iucv->backlog_skb_q))
1362                         break;
1363         }
1364 }
1365
1366 static int iucv_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1367                              size_t len, int flags)
1368 {
1369         int noblock = flags & MSG_DONTWAIT;
1370         struct sock *sk = sock->sk;
1371         struct iucv_sock *iucv = iucv_sk(sk);
1372         unsigned int copied, rlen;
1373         struct sk_buff *skb, *rskb, *cskb;
1374         int err = 0;
1375         u32 offset;
1376
1377         if ((sk->sk_state == IUCV_DISCONN) &&
1378             skb_queue_empty(&iucv->backlog_skb_q) &&
1379             skb_queue_empty(&sk->sk_receive_queue) &&
1380             list_empty(&iucv->message_q.list))
1381                 return 0;
1382
1383         if (flags & (MSG_OOB))
1384                 return -EOPNOTSUPP;
1385
1386         /* receive/dequeue next skb:
1387          * the function understands MSG_PEEK and, thus, does not dequeue skb */
1388         skb = skb_recv_datagram(sk, flags, noblock, &err);
1389         if (!skb) {
1390                 if (sk->sk_shutdown & RCV_SHUTDOWN)
1391                         return 0;
1392                 return err;
1393         }
1394
1395         offset = IUCV_SKB_CB(skb)->offset;
1396         rlen   = skb->len - offset;             /* real length of skb */
1397         copied = min_t(unsigned int, rlen, len);
1398         if (!rlen)
1399                 sk->sk_shutdown = sk->sk_shutdown | RCV_SHUTDOWN;
1400
1401         cskb = skb;
1402         if (skb_copy_datagram_msg(cskb, offset, msg, copied)) {
1403                 if (!(flags & MSG_PEEK))
1404                         skb_queue_head(&sk->sk_receive_queue, skb);
1405                 return -EFAULT;
1406         }
1407
1408         /* SOCK_SEQPACKET: set MSG_TRUNC if recv buf size is too small */
1409         if (sk->sk_type == SOCK_SEQPACKET) {
1410                 if (copied < rlen)
1411                         msg->msg_flags |= MSG_TRUNC;
1412                 /* each iucv message contains a complete record */
1413                 msg->msg_flags |= MSG_EOR;
1414         }
1415
1416         /* create control message to store iucv msg target class:
1417          * get the trgcls from the control buffer of the skb due to
1418          * fragmentation of original iucv message. */
1419         err = put_cmsg(msg, SOL_IUCV, SCM_IUCV_TRGCLS,
1420                        sizeof(IUCV_SKB_CB(skb)->class),
1421                        (void *)&IUCV_SKB_CB(skb)->class);
1422         if (err) {
1423                 if (!(flags & MSG_PEEK))
1424                         skb_queue_head(&sk->sk_receive_queue, skb);
1425                 return err;
1426         }
1427
1428         /* Mark read part of skb as used */
1429         if (!(flags & MSG_PEEK)) {
1430
1431                 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
1432                 if (sk->sk_type == SOCK_STREAM) {
1433                         if (copied < rlen) {
1434                                 IUCV_SKB_CB(skb)->offset = offset + copied;
1435                                 skb_queue_head(&sk->sk_receive_queue, skb);
1436                                 goto done;
1437                         }
1438                 }
1439
1440                 kfree_skb(skb);
1441                 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1442                         atomic_inc(&iucv->msg_recv);
1443                         if (atomic_read(&iucv->msg_recv) > iucv->msglimit) {
1444                                 WARN_ON(1);
1445                                 iucv_sock_close(sk);
1446                                 return -EFAULT;
1447                         }
1448                 }
1449
1450                 /* Queue backlog skbs */
1451                 spin_lock_bh(&iucv->message_q.lock);
1452                 rskb = skb_dequeue(&iucv->backlog_skb_q);
1453                 while (rskb) {
1454                         IUCV_SKB_CB(rskb)->offset = 0;
1455                         if (__sock_queue_rcv_skb(sk, rskb)) {
1456                                 /* handle rcv queue full */
1457                                 skb_queue_head(&iucv->backlog_skb_q,
1458                                                 rskb);
1459                                 break;
1460                         }
1461                         rskb = skb_dequeue(&iucv->backlog_skb_q);
1462                 }
1463                 if (skb_queue_empty(&iucv->backlog_skb_q)) {
1464                         if (!list_empty(&iucv->message_q.list))
1465                                 iucv_process_message_q(sk);
1466                         if (atomic_read(&iucv->msg_recv) >=
1467                                                         iucv->msglimit / 2) {
1468                                 err = iucv_send_ctrl(sk, AF_IUCV_FLAG_WIN);
1469                                 if (err) {
1470                                         sk->sk_state = IUCV_DISCONN;
1471                                         sk->sk_state_change(sk);
1472                                 }
1473                         }
1474                 }
1475                 spin_unlock_bh(&iucv->message_q.lock);
1476         }
1477
1478 done:
1479         /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
1480         if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
1481                 copied = rlen;
1482
1483         return copied;
1484 }
1485
1486 static inline __poll_t iucv_accept_poll(struct sock *parent)
1487 {
1488         struct iucv_sock *isk, *n;
1489         struct sock *sk;
1490
1491         list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
1492                 sk = (struct sock *) isk;
1493
1494                 if (sk->sk_state == IUCV_CONNECTED)
1495                         return EPOLLIN | EPOLLRDNORM;
1496         }
1497
1498         return 0;
1499 }
1500
1501 __poll_t iucv_sock_poll(struct file *file, struct socket *sock,
1502                             poll_table *wait)
1503 {
1504         struct sock *sk = sock->sk;
1505         __poll_t mask = 0;
1506
1507         sock_poll_wait(file, sock, wait);
1508
1509         if (sk->sk_state == IUCV_LISTEN)
1510                 return iucv_accept_poll(sk);
1511
1512         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
1513                 mask |= EPOLLERR |
1514                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
1515
1516         if (sk->sk_shutdown & RCV_SHUTDOWN)
1517                 mask |= EPOLLRDHUP;
1518
1519         if (sk->sk_shutdown == SHUTDOWN_MASK)
1520                 mask |= EPOLLHUP;
1521
1522         if (!skb_queue_empty(&sk->sk_receive_queue) ||
1523             (sk->sk_shutdown & RCV_SHUTDOWN))
1524                 mask |= EPOLLIN | EPOLLRDNORM;
1525
1526         if (sk->sk_state == IUCV_CLOSED)
1527                 mask |= EPOLLHUP;
1528
1529         if (sk->sk_state == IUCV_DISCONN)
1530                 mask |= EPOLLIN;
1531
1532         if (sock_writeable(sk) && iucv_below_msglim(sk))
1533                 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
1534         else
1535                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1536
1537         return mask;
1538 }
1539
1540 static int iucv_sock_shutdown(struct socket *sock, int how)
1541 {
1542         struct sock *sk = sock->sk;
1543         struct iucv_sock *iucv = iucv_sk(sk);
1544         struct iucv_message txmsg;
1545         int err = 0;
1546
1547         how++;
1548
1549         if ((how & ~SHUTDOWN_MASK) || !how)
1550                 return -EINVAL;
1551
1552         lock_sock(sk);
1553         switch (sk->sk_state) {
1554         case IUCV_LISTEN:
1555         case IUCV_DISCONN:
1556         case IUCV_CLOSING:
1557         case IUCV_CLOSED:
1558                 err = -ENOTCONN;
1559                 goto fail;
1560         default:
1561                 break;
1562         }
1563
1564         if (how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) {
1565                 if (iucv->transport == AF_IUCV_TRANS_IUCV) {
1566                         txmsg.class = 0;
1567                         txmsg.tag = 0;
1568                         err = pr_iucv->message_send(iucv->path, &txmsg,
1569                                 IUCV_IPRMDATA, 0, (void *) iprm_shutdown, 8);
1570                         if (err) {
1571                                 switch (err) {
1572                                 case 1:
1573                                         err = -ENOTCONN;
1574                                         break;
1575                                 case 2:
1576                                         err = -ECONNRESET;
1577                                         break;
1578                                 default:
1579                                         err = -ENOTCONN;
1580                                         break;
1581                                 }
1582                         }
1583                 } else
1584                         iucv_send_ctrl(sk, AF_IUCV_FLAG_SHT);
1585         }
1586
1587         sk->sk_shutdown |= how;
1588         if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) {
1589                 if ((iucv->transport == AF_IUCV_TRANS_IUCV) &&
1590                     iucv->path) {
1591                         err = pr_iucv->path_quiesce(iucv->path, NULL);
1592                         if (err)
1593                                 err = -ENOTCONN;
1594 /*                      skb_queue_purge(&sk->sk_receive_queue); */
1595                 }
1596                 skb_queue_purge(&sk->sk_receive_queue);
1597         }
1598
1599         /* Wake up anyone sleeping in poll */
1600         sk->sk_state_change(sk);
1601
1602 fail:
1603         release_sock(sk);
1604         return err;
1605 }
1606
1607 static int iucv_sock_release(struct socket *sock)
1608 {
1609         struct sock *sk = sock->sk;
1610         int err = 0;
1611
1612         if (!sk)
1613                 return 0;
1614
1615         iucv_sock_close(sk);
1616
1617         sock_orphan(sk);
1618         iucv_sock_kill(sk);
1619         return err;
1620 }
1621
1622 /* getsockopt and setsockopt */
1623 static int iucv_sock_setsockopt(struct socket *sock, int level, int optname,
1624                                 char __user *optval, unsigned int optlen)
1625 {
1626         struct sock *sk = sock->sk;
1627         struct iucv_sock *iucv = iucv_sk(sk);
1628         int val;
1629         int rc;
1630
1631         if (level != SOL_IUCV)
1632                 return -ENOPROTOOPT;
1633
1634         if (optlen < sizeof(int))
1635                 return -EINVAL;
1636
1637         if (get_user(val, (int __user *) optval))
1638                 return -EFAULT;
1639
1640         rc = 0;
1641
1642         lock_sock(sk);
1643         switch (optname) {
1644         case SO_IPRMDATA_MSG:
1645                 if (val)
1646                         iucv->flags |= IUCV_IPRMDATA;
1647                 else
1648                         iucv->flags &= ~IUCV_IPRMDATA;
1649                 break;
1650         case SO_MSGLIMIT:
1651                 switch (sk->sk_state) {
1652                 case IUCV_OPEN:
1653                 case IUCV_BOUND:
1654                         if (val < 1 || val > (u16)(~0))
1655                                 rc = -EINVAL;
1656                         else
1657                                 iucv->msglimit = val;
1658                         break;
1659                 default:
1660                         rc = -EINVAL;
1661                         break;
1662                 }
1663                 break;
1664         default:
1665                 rc = -ENOPROTOOPT;
1666                 break;
1667         }
1668         release_sock(sk);
1669
1670         return rc;
1671 }
1672
1673 static int iucv_sock_getsockopt(struct socket *sock, int level, int optname,
1674                                 char __user *optval, int __user *optlen)
1675 {
1676         struct sock *sk = sock->sk;
1677         struct iucv_sock *iucv = iucv_sk(sk);
1678         unsigned int val;
1679         int len;
1680
1681         if (level != SOL_IUCV)
1682                 return -ENOPROTOOPT;
1683
1684         if (get_user(len, optlen))
1685                 return -EFAULT;
1686
1687         if (len < 0)
1688                 return -EINVAL;
1689
1690         len = min_t(unsigned int, len, sizeof(int));
1691
1692         switch (optname) {
1693         case SO_IPRMDATA_MSG:
1694                 val = (iucv->flags & IUCV_IPRMDATA) ? 1 : 0;
1695                 break;
1696         case SO_MSGLIMIT:
1697                 lock_sock(sk);
1698                 val = (iucv->path != NULL) ? iucv->path->msglim /* connected */
1699                                            : iucv->msglimit;    /* default */
1700                 release_sock(sk);
1701                 break;
1702         case SO_MSGSIZE:
1703                 if (sk->sk_state == IUCV_OPEN)
1704                         return -EBADFD;
1705                 val = (iucv->hs_dev) ? iucv->hs_dev->mtu -
1706                                 sizeof(struct af_iucv_trans_hdr) - ETH_HLEN :
1707                                 0x7fffffff;
1708                 break;
1709         default:
1710                 return -ENOPROTOOPT;
1711         }
1712
1713         if (put_user(len, optlen))
1714                 return -EFAULT;
1715         if (copy_to_user(optval, &val, len))
1716                 return -EFAULT;
1717
1718         return 0;
1719 }
1720
1721
1722 /* Callback wrappers - called from iucv base support */
1723 static int iucv_callback_connreq(struct iucv_path *path,
1724                                  u8 ipvmid[8], u8 ipuser[16])
1725 {
1726         unsigned char user_data[16];
1727         unsigned char nuser_data[16];
1728         unsigned char src_name[8];
1729         struct sock *sk, *nsk;
1730         struct iucv_sock *iucv, *niucv;
1731         int err;
1732
1733         memcpy(src_name, ipuser, 8);
1734         EBCASC(src_name, 8);
1735         /* Find out if this path belongs to af_iucv. */
1736         read_lock(&iucv_sk_list.lock);
1737         iucv = NULL;
1738         sk = NULL;
1739         sk_for_each(sk, &iucv_sk_list.head)
1740                 if (sk->sk_state == IUCV_LISTEN &&
1741                     !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) {
1742                         /*
1743                          * Found a listening socket with
1744                          * src_name == ipuser[0-7].
1745                          */
1746                         iucv = iucv_sk(sk);
1747                         break;
1748                 }
1749         read_unlock(&iucv_sk_list.lock);
1750         if (!iucv)
1751                 /* No socket found, not one of our paths. */
1752                 return -EINVAL;
1753
1754         bh_lock_sock(sk);
1755
1756         /* Check if parent socket is listening */
1757         low_nmcpy(user_data, iucv->src_name);
1758         high_nmcpy(user_data, iucv->dst_name);
1759         ASCEBC(user_data, sizeof(user_data));
1760         if (sk->sk_state != IUCV_LISTEN) {
1761                 err = pr_iucv->path_sever(path, user_data);
1762                 iucv_path_free(path);
1763                 goto fail;
1764         }
1765
1766         /* Check for backlog size */
1767         if (sk_acceptq_is_full(sk)) {
1768                 err = pr_iucv->path_sever(path, user_data);
1769                 iucv_path_free(path);
1770                 goto fail;
1771         }
1772
1773         /* Create the new socket */
1774         nsk = iucv_sock_alloc(NULL, sk->sk_type, GFP_ATOMIC, 0);
1775         if (!nsk) {
1776                 err = pr_iucv->path_sever(path, user_data);
1777                 iucv_path_free(path);
1778                 goto fail;
1779         }
1780
1781         niucv = iucv_sk(nsk);
1782         iucv_sock_init(nsk, sk);
1783
1784         /* Set the new iucv_sock */
1785         memcpy(niucv->dst_name, ipuser + 8, 8);
1786         EBCASC(niucv->dst_name, 8);
1787         memcpy(niucv->dst_user_id, ipvmid, 8);
1788         memcpy(niucv->src_name, iucv->src_name, 8);
1789         memcpy(niucv->src_user_id, iucv->src_user_id, 8);
1790         niucv->path = path;
1791
1792         /* Call iucv_accept */
1793         high_nmcpy(nuser_data, ipuser + 8);
1794         memcpy(nuser_data + 8, niucv->src_name, 8);
1795         ASCEBC(nuser_data + 8, 8);
1796
1797         /* set message limit for path based on msglimit of accepting socket */
1798         niucv->msglimit = iucv->msglimit;
1799         path->msglim = iucv->msglimit;
1800         err = pr_iucv->path_accept(path, &af_iucv_handler, nuser_data, nsk);
1801         if (err) {
1802                 iucv_sever_path(nsk, 1);
1803                 iucv_sock_kill(nsk);
1804                 goto fail;
1805         }
1806
1807         iucv_accept_enqueue(sk, nsk);
1808
1809         /* Wake up accept */
1810         nsk->sk_state = IUCV_CONNECTED;
1811         sk->sk_data_ready(sk);
1812         err = 0;
1813 fail:
1814         bh_unlock_sock(sk);
1815         return 0;
1816 }
1817
1818 static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
1819 {
1820         struct sock *sk = path->private;
1821
1822         sk->sk_state = IUCV_CONNECTED;
1823         sk->sk_state_change(sk);
1824 }
1825
1826 static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
1827 {
1828         struct sock *sk = path->private;
1829         struct iucv_sock *iucv = iucv_sk(sk);
1830         struct sk_buff *skb;
1831         struct sock_msg_q *save_msg;
1832         int len;
1833
1834         if (sk->sk_shutdown & RCV_SHUTDOWN) {
1835                 pr_iucv->message_reject(path, msg);
1836                 return;
1837         }
1838
1839         spin_lock(&iucv->message_q.lock);
1840
1841         if (!list_empty(&iucv->message_q.list) ||
1842             !skb_queue_empty(&iucv->backlog_skb_q))
1843                 goto save_message;
1844
1845         len = atomic_read(&sk->sk_rmem_alloc);
1846         len += SKB_TRUESIZE(iucv_msg_length(msg));
1847         if (len > sk->sk_rcvbuf)
1848                 goto save_message;
1849
1850         skb = alloc_iucv_recv_skb(iucv_msg_length(msg));
1851         if (!skb)
1852                 goto save_message;
1853
1854         iucv_process_message(sk, skb, path, msg);
1855         goto out_unlock;
1856
1857 save_message:
1858         save_msg = kzalloc(sizeof(struct sock_msg_q), GFP_ATOMIC | GFP_DMA);
1859         if (!save_msg)
1860                 goto out_unlock;
1861         save_msg->path = path;
1862         save_msg->msg = *msg;
1863
1864         list_add_tail(&save_msg->list, &iucv->message_q.list);
1865
1866 out_unlock:
1867         spin_unlock(&iucv->message_q.lock);
1868 }
1869
1870 static void iucv_callback_txdone(struct iucv_path *path,
1871                                  struct iucv_message *msg)
1872 {
1873         struct sock *sk = path->private;
1874         struct sk_buff *this = NULL;
1875         struct sk_buff_head *list = &iucv_sk(sk)->send_skb_q;
1876         struct sk_buff *list_skb = list->next;
1877         unsigned long flags;
1878
1879         bh_lock_sock(sk);
1880         if (!skb_queue_empty(list)) {
1881                 spin_lock_irqsave(&list->lock, flags);
1882
1883                 while (list_skb != (struct sk_buff *)list) {
1884                         if (msg->tag == IUCV_SKB_CB(list_skb)->tag) {
1885                                 this = list_skb;
1886                                 break;
1887                         }
1888                         list_skb = list_skb->next;
1889                 }
1890                 if (this)
1891                         __skb_unlink(this, list);
1892
1893                 spin_unlock_irqrestore(&list->lock, flags);
1894
1895                 if (this) {
1896                         kfree_skb(this);
1897                         /* wake up any process waiting for sending */
1898                         iucv_sock_wake_msglim(sk);
1899                 }
1900         }
1901
1902         if (sk->sk_state == IUCV_CLOSING) {
1903                 if (skb_queue_empty(&iucv_sk(sk)->send_skb_q)) {
1904                         sk->sk_state = IUCV_CLOSED;
1905                         sk->sk_state_change(sk);
1906                 }
1907         }
1908         bh_unlock_sock(sk);
1909
1910 }
1911
1912 static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
1913 {
1914         struct sock *sk = path->private;
1915
1916         if (sk->sk_state == IUCV_CLOSED)
1917                 return;
1918
1919         bh_lock_sock(sk);
1920         iucv_sever_path(sk, 1);
1921         sk->sk_state = IUCV_DISCONN;
1922
1923         sk->sk_state_change(sk);
1924         bh_unlock_sock(sk);
1925 }
1926
1927 /* called if the other communication side shuts down its RECV direction;
1928  * in turn, the callback sets SEND_SHUTDOWN to disable sending of data.
1929  */
1930 static void iucv_callback_shutdown(struct iucv_path *path, u8 ipuser[16])
1931 {
1932         struct sock *sk = path->private;
1933
1934         bh_lock_sock(sk);
1935         if (sk->sk_state != IUCV_CLOSED) {
1936                 sk->sk_shutdown |= SEND_SHUTDOWN;
1937                 sk->sk_state_change(sk);
1938         }
1939         bh_unlock_sock(sk);
1940 }
1941
1942 /***************** HiperSockets transport callbacks ********************/
1943 static void afiucv_swap_src_dest(struct sk_buff *skb)
1944 {
1945         struct af_iucv_trans_hdr *trans_hdr = iucv_trans_hdr(skb);
1946         char tmpID[8];
1947         char tmpName[8];
1948
1949         ASCEBC(trans_hdr->destUserID, sizeof(trans_hdr->destUserID));
1950         ASCEBC(trans_hdr->destAppName, sizeof(trans_hdr->destAppName));
1951         ASCEBC(trans_hdr->srcUserID, sizeof(trans_hdr->srcUserID));
1952         ASCEBC(trans_hdr->srcAppName, sizeof(trans_hdr->srcAppName));
1953         memcpy(tmpID, trans_hdr->srcUserID, 8);
1954         memcpy(tmpName, trans_hdr->srcAppName, 8);
1955         memcpy(trans_hdr->srcUserID, trans_hdr->destUserID, 8);
1956         memcpy(trans_hdr->srcAppName, trans_hdr->destAppName, 8);
1957         memcpy(trans_hdr->destUserID, tmpID, 8);
1958         memcpy(trans_hdr->destAppName, tmpName, 8);
1959         skb_push(skb, ETH_HLEN);
1960         memset(skb->data, 0, ETH_HLEN);
1961 }
1962
1963 /**
1964  * afiucv_hs_callback_syn - react on received SYN
1965  **/
1966 static int afiucv_hs_callback_syn(struct sock *sk, struct sk_buff *skb)
1967 {
1968         struct af_iucv_trans_hdr *trans_hdr = iucv_trans_hdr(skb);
1969         struct sock *nsk;
1970         struct iucv_sock *iucv, *niucv;
1971         int err;
1972
1973         iucv = iucv_sk(sk);
1974         if (!iucv) {
1975                 /* no sock - connection refused */
1976                 afiucv_swap_src_dest(skb);
1977                 trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN;
1978                 err = dev_queue_xmit(skb);
1979                 goto out;
1980         }
1981
1982         nsk = iucv_sock_alloc(NULL, sk->sk_type, GFP_ATOMIC, 0);
1983         bh_lock_sock(sk);
1984         if ((sk->sk_state != IUCV_LISTEN) ||
1985             sk_acceptq_is_full(sk) ||
1986             !nsk) {
1987                 /* error on server socket - connection refused */
1988                 afiucv_swap_src_dest(skb);
1989                 trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN;
1990                 err = dev_queue_xmit(skb);
1991                 iucv_sock_kill(nsk);
1992                 bh_unlock_sock(sk);
1993                 goto out;
1994         }
1995
1996         niucv = iucv_sk(nsk);
1997         iucv_sock_init(nsk, sk);
1998         niucv->transport = AF_IUCV_TRANS_HIPER;
1999         niucv->msglimit = iucv->msglimit;
2000         if (!trans_hdr->window)
2001                 niucv->msglimit_peer = IUCV_HIPER_MSGLIM_DEFAULT;
2002         else
2003                 niucv->msglimit_peer = trans_hdr->window;
2004         memcpy(niucv->dst_name, trans_hdr->srcAppName, 8);
2005         memcpy(niucv->dst_user_id, trans_hdr->srcUserID, 8);
2006         memcpy(niucv->src_name, iucv->src_name, 8);
2007         memcpy(niucv->src_user_id, iucv->src_user_id, 8);
2008         nsk->sk_bound_dev_if = sk->sk_bound_dev_if;
2009         niucv->hs_dev = iucv->hs_dev;
2010         dev_hold(niucv->hs_dev);
2011         afiucv_swap_src_dest(skb);
2012         trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_ACK;
2013         trans_hdr->window = niucv->msglimit;
2014         /* if receiver acks the xmit connection is established */
2015         err = dev_queue_xmit(skb);
2016         if (!err) {
2017                 iucv_accept_enqueue(sk, nsk);
2018                 nsk->sk_state = IUCV_CONNECTED;
2019                 sk->sk_data_ready(sk);
2020         } else
2021                 iucv_sock_kill(nsk);
2022         bh_unlock_sock(sk);
2023
2024 out:
2025         return NET_RX_SUCCESS;
2026 }
2027
2028 /**
2029  * afiucv_hs_callback_synack() - react on received SYN-ACK
2030  **/
2031 static int afiucv_hs_callback_synack(struct sock *sk, struct sk_buff *skb)
2032 {
2033         struct iucv_sock *iucv = iucv_sk(sk);
2034
2035         if (!iucv)
2036                 goto out;
2037         if (sk->sk_state != IUCV_BOUND)
2038                 goto out;
2039         bh_lock_sock(sk);
2040         iucv->msglimit_peer = iucv_trans_hdr(skb)->window;
2041         sk->sk_state = IUCV_CONNECTED;
2042         sk->sk_state_change(sk);
2043         bh_unlock_sock(sk);
2044 out:
2045         kfree_skb(skb);
2046         return NET_RX_SUCCESS;
2047 }
2048
2049 /**
2050  * afiucv_hs_callback_synfin() - react on received SYN_FIN
2051  **/
2052 static int afiucv_hs_callback_synfin(struct sock *sk, struct sk_buff *skb)
2053 {
2054         struct iucv_sock *iucv = iucv_sk(sk);
2055
2056         if (!iucv)
2057                 goto out;
2058         if (sk->sk_state != IUCV_BOUND)
2059                 goto out;
2060         bh_lock_sock(sk);
2061         sk->sk_state = IUCV_DISCONN;
2062         sk->sk_state_change(sk);
2063         bh_unlock_sock(sk);
2064 out:
2065         kfree_skb(skb);
2066         return NET_RX_SUCCESS;
2067 }
2068
2069 /**
2070  * afiucv_hs_callback_fin() - react on received FIN
2071  **/
2072 static int afiucv_hs_callback_fin(struct sock *sk, struct sk_buff *skb)
2073 {
2074         struct iucv_sock *iucv = iucv_sk(sk);
2075
2076         /* other end of connection closed */
2077         if (!iucv)
2078                 goto out;
2079         bh_lock_sock(sk);
2080         if (sk->sk_state == IUCV_CONNECTED) {
2081                 sk->sk_state = IUCV_DISCONN;
2082                 sk->sk_state_change(sk);
2083         }
2084         bh_unlock_sock(sk);
2085 out:
2086         kfree_skb(skb);
2087         return NET_RX_SUCCESS;
2088 }
2089
2090 /**
2091  * afiucv_hs_callback_win() - react on received WIN
2092  **/
2093 static int afiucv_hs_callback_win(struct sock *sk, struct sk_buff *skb)
2094 {
2095         struct iucv_sock *iucv = iucv_sk(sk);
2096
2097         if (!iucv)
2098                 return NET_RX_SUCCESS;
2099
2100         if (sk->sk_state != IUCV_CONNECTED)
2101                 return NET_RX_SUCCESS;
2102
2103         atomic_sub(iucv_trans_hdr(skb)->window, &iucv->msg_sent);
2104         iucv_sock_wake_msglim(sk);
2105         return NET_RX_SUCCESS;
2106 }
2107
2108 /**
2109  * afiucv_hs_callback_rx() - react on received data
2110  **/
2111 static int afiucv_hs_callback_rx(struct sock *sk, struct sk_buff *skb)
2112 {
2113         struct iucv_sock *iucv = iucv_sk(sk);
2114
2115         if (!iucv) {
2116                 kfree_skb(skb);
2117                 return NET_RX_SUCCESS;
2118         }
2119
2120         if (sk->sk_state != IUCV_CONNECTED) {
2121                 kfree_skb(skb);
2122                 return NET_RX_SUCCESS;
2123         }
2124
2125         if (sk->sk_shutdown & RCV_SHUTDOWN) {
2126                 kfree_skb(skb);
2127                 return NET_RX_SUCCESS;
2128         }
2129
2130         /* write stuff from iucv_msg to skb cb */
2131         skb_pull(skb, sizeof(struct af_iucv_trans_hdr));
2132         skb_reset_transport_header(skb);
2133         skb_reset_network_header(skb);
2134         IUCV_SKB_CB(skb)->offset = 0;
2135         if (sk_filter(sk, skb)) {
2136                 atomic_inc(&sk->sk_drops);      /* skb rejected by filter */
2137                 kfree_skb(skb);
2138                 return NET_RX_SUCCESS;
2139         }
2140
2141         spin_lock(&iucv->message_q.lock);
2142         if (skb_queue_empty(&iucv->backlog_skb_q)) {
2143                 if (__sock_queue_rcv_skb(sk, skb))
2144                         /* handle rcv queue full */
2145                         skb_queue_tail(&iucv->backlog_skb_q, skb);
2146         } else
2147                 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
2148         spin_unlock(&iucv->message_q.lock);
2149         return NET_RX_SUCCESS;
2150 }
2151
2152 /**
2153  * afiucv_hs_rcv() - base function for arriving data through HiperSockets
2154  *                   transport
2155  *                   called from netif RX softirq
2156  **/
2157 static int afiucv_hs_rcv(struct sk_buff *skb, struct net_device *dev,
2158         struct packet_type *pt, struct net_device *orig_dev)
2159 {
2160         struct sock *sk;
2161         struct iucv_sock *iucv;
2162         struct af_iucv_trans_hdr *trans_hdr;
2163         int err = NET_RX_SUCCESS;
2164         char nullstring[8];
2165
2166         if (!pskb_may_pull(skb, sizeof(*trans_hdr))) {
2167                 WARN_ONCE(1, "AF_IUCV failed to receive skb, len=%u", skb->len);
2168                 kfree_skb(skb);
2169                 return NET_RX_SUCCESS;
2170         }
2171
2172         trans_hdr = iucv_trans_hdr(skb);
2173         EBCASC(trans_hdr->destAppName, sizeof(trans_hdr->destAppName));
2174         EBCASC(trans_hdr->destUserID, sizeof(trans_hdr->destUserID));
2175         EBCASC(trans_hdr->srcAppName, sizeof(trans_hdr->srcAppName));
2176         EBCASC(trans_hdr->srcUserID, sizeof(trans_hdr->srcUserID));
2177         memset(nullstring, 0, sizeof(nullstring));
2178         iucv = NULL;
2179         sk = NULL;
2180         read_lock(&iucv_sk_list.lock);
2181         sk_for_each(sk, &iucv_sk_list.head) {
2182                 if (trans_hdr->flags == AF_IUCV_FLAG_SYN) {
2183                         if ((!memcmp(&iucv_sk(sk)->src_name,
2184                                      trans_hdr->destAppName, 8)) &&
2185                             (!memcmp(&iucv_sk(sk)->src_user_id,
2186                                      trans_hdr->destUserID, 8)) &&
2187                             (!memcmp(&iucv_sk(sk)->dst_name, nullstring, 8)) &&
2188                             (!memcmp(&iucv_sk(sk)->dst_user_id,
2189                                      nullstring, 8))) {
2190                                 iucv = iucv_sk(sk);
2191                                 break;
2192                         }
2193                 } else {
2194                         if ((!memcmp(&iucv_sk(sk)->src_name,
2195                                      trans_hdr->destAppName, 8)) &&
2196                             (!memcmp(&iucv_sk(sk)->src_user_id,
2197                                      trans_hdr->destUserID, 8)) &&
2198                             (!memcmp(&iucv_sk(sk)->dst_name,
2199                                      trans_hdr->srcAppName, 8)) &&
2200                             (!memcmp(&iucv_sk(sk)->dst_user_id,
2201                                      trans_hdr->srcUserID, 8))) {
2202                                 iucv = iucv_sk(sk);
2203                                 break;
2204                         }
2205                 }
2206         }
2207         read_unlock(&iucv_sk_list.lock);
2208         if (!iucv)
2209                 sk = NULL;
2210
2211         /* no sock
2212         how should we send with no sock
2213         1) send without sock no send rc checking?
2214         2) introduce default sock to handle this cases
2215
2216          SYN -> send SYN|ACK in good case, send SYN|FIN in bad case
2217          data -> send FIN
2218          SYN|ACK, SYN|FIN, FIN -> no action? */
2219
2220         switch (trans_hdr->flags) {
2221         case AF_IUCV_FLAG_SYN:
2222                 /* connect request */
2223                 err = afiucv_hs_callback_syn(sk, skb);
2224                 break;
2225         case (AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_ACK):
2226                 /* connect request confirmed */
2227                 err = afiucv_hs_callback_synack(sk, skb);
2228                 break;
2229         case (AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN):
2230                 /* connect request refused */
2231                 err = afiucv_hs_callback_synfin(sk, skb);
2232                 break;
2233         case (AF_IUCV_FLAG_FIN):
2234                 /* close request */
2235                 err = afiucv_hs_callback_fin(sk, skb);
2236                 break;
2237         case (AF_IUCV_FLAG_WIN):
2238                 err = afiucv_hs_callback_win(sk, skb);
2239                 if (skb->len == sizeof(struct af_iucv_trans_hdr)) {
2240                         kfree_skb(skb);
2241                         break;
2242                 }
2243                 /* fall through and receive non-zero length data */
2244         case (AF_IUCV_FLAG_SHT):
2245                 /* shutdown request */
2246                 /* fall through and receive zero length data */
2247         case 0:
2248                 /* plain data frame */
2249                 IUCV_SKB_CB(skb)->class = trans_hdr->iucv_hdr.class;
2250                 err = afiucv_hs_callback_rx(sk, skb);
2251                 break;
2252         default:
2253                 kfree_skb(skb);
2254         }
2255
2256         return err;
2257 }
2258
2259 /**
2260  * afiucv_hs_callback_txnotify() - handle send notifcations from HiperSockets
2261  *                                 transport
2262  **/
2263 static void afiucv_hs_callback_txnotify(struct sk_buff *skb,
2264                                         enum iucv_tx_notify n)
2265 {
2266         struct sock *isk = skb->sk;
2267         struct sock *sk = NULL;
2268         struct iucv_sock *iucv = NULL;
2269         struct sk_buff_head *list;
2270         struct sk_buff *list_skb;
2271         struct sk_buff *nskb;
2272         unsigned long flags;
2273
2274         read_lock_irqsave(&iucv_sk_list.lock, flags);
2275         sk_for_each(sk, &iucv_sk_list.head)
2276                 if (sk == isk) {
2277                         iucv = iucv_sk(sk);
2278                         break;
2279                 }
2280         read_unlock_irqrestore(&iucv_sk_list.lock, flags);
2281
2282         if (!iucv || sock_flag(sk, SOCK_ZAPPED))
2283                 return;
2284
2285         list = &iucv->send_skb_q;
2286         spin_lock_irqsave(&list->lock, flags);
2287         if (skb_queue_empty(list))
2288                 goto out_unlock;
2289         list_skb = list->next;
2290         nskb = list_skb->next;
2291         while (list_skb != (struct sk_buff *)list) {
2292                 if (skb_shinfo(list_skb) == skb_shinfo(skb)) {
2293                         switch (n) {
2294                         case TX_NOTIFY_OK:
2295                                 __skb_unlink(list_skb, list);
2296                                 kfree_skb(list_skb);
2297                                 iucv_sock_wake_msglim(sk);
2298                                 break;
2299                         case TX_NOTIFY_PENDING:
2300                                 atomic_inc(&iucv->pendings);
2301                                 break;
2302                         case TX_NOTIFY_DELAYED_OK:
2303                                 __skb_unlink(list_skb, list);
2304                                 atomic_dec(&iucv->pendings);
2305                                 if (atomic_read(&iucv->pendings) <= 0)
2306                                         iucv_sock_wake_msglim(sk);
2307                                 kfree_skb(list_skb);
2308                                 break;
2309                         case TX_NOTIFY_UNREACHABLE:
2310                         case TX_NOTIFY_DELAYED_UNREACHABLE:
2311                         case TX_NOTIFY_TPQFULL: /* not yet used */
2312                         case TX_NOTIFY_GENERALERROR:
2313                         case TX_NOTIFY_DELAYED_GENERALERROR:
2314                                 __skb_unlink(list_skb, list);
2315                                 kfree_skb(list_skb);
2316                                 if (sk->sk_state == IUCV_CONNECTED) {
2317                                         sk->sk_state = IUCV_DISCONN;
2318                                         sk->sk_state_change(sk);
2319                                 }
2320                                 break;
2321                         }
2322                         break;
2323                 }
2324                 list_skb = nskb;
2325                 nskb = nskb->next;
2326         }
2327 out_unlock:
2328         spin_unlock_irqrestore(&list->lock, flags);
2329
2330         if (sk->sk_state == IUCV_CLOSING) {
2331                 if (skb_queue_empty(&iucv_sk(sk)->send_skb_q)) {
2332                         sk->sk_state = IUCV_CLOSED;
2333                         sk->sk_state_change(sk);
2334                 }
2335         }
2336
2337 }
2338
2339 /*
2340  * afiucv_netdev_event: handle netdev notifier chain events
2341  */
2342 static int afiucv_netdev_event(struct notifier_block *this,
2343                                unsigned long event, void *ptr)
2344 {
2345         struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
2346         struct sock *sk;
2347         struct iucv_sock *iucv;
2348
2349         switch (event) {
2350         case NETDEV_REBOOT:
2351         case NETDEV_GOING_DOWN:
2352                 sk_for_each(sk, &iucv_sk_list.head) {
2353                         iucv = iucv_sk(sk);
2354                         if ((iucv->hs_dev == event_dev) &&
2355                             (sk->sk_state == IUCV_CONNECTED)) {
2356                                 if (event == NETDEV_GOING_DOWN)
2357                                         iucv_send_ctrl(sk, AF_IUCV_FLAG_FIN);
2358                                 sk->sk_state = IUCV_DISCONN;
2359                                 sk->sk_state_change(sk);
2360                         }
2361                 }
2362                 break;
2363         case NETDEV_DOWN:
2364         case NETDEV_UNREGISTER:
2365         default:
2366                 break;
2367         }
2368         return NOTIFY_DONE;
2369 }
2370
2371 static struct notifier_block afiucv_netdev_notifier = {
2372         .notifier_call = afiucv_netdev_event,
2373 };
2374
2375 static const struct proto_ops iucv_sock_ops = {
2376         .family         = PF_IUCV,
2377         .owner          = THIS_MODULE,
2378         .release        = iucv_sock_release,
2379         .bind           = iucv_sock_bind,
2380         .connect        = iucv_sock_connect,
2381         .listen         = iucv_sock_listen,
2382         .accept         = iucv_sock_accept,
2383         .getname        = iucv_sock_getname,
2384         .sendmsg        = iucv_sock_sendmsg,
2385         .recvmsg        = iucv_sock_recvmsg,
2386         .poll           = iucv_sock_poll,
2387         .ioctl          = sock_no_ioctl,
2388         .mmap           = sock_no_mmap,
2389         .socketpair     = sock_no_socketpair,
2390         .shutdown       = iucv_sock_shutdown,
2391         .setsockopt     = iucv_sock_setsockopt,
2392         .getsockopt     = iucv_sock_getsockopt,
2393 };
2394
2395 static const struct net_proto_family iucv_sock_family_ops = {
2396         .family = AF_IUCV,
2397         .owner  = THIS_MODULE,
2398         .create = iucv_sock_create,
2399 };
2400
2401 static struct packet_type iucv_packet_type = {
2402         .type = cpu_to_be16(ETH_P_AF_IUCV),
2403         .func = afiucv_hs_rcv,
2404 };
2405
2406 static int afiucv_iucv_init(void)
2407 {
2408         int err;
2409
2410         err = pr_iucv->iucv_register(&af_iucv_handler, 0);
2411         if (err)
2412                 goto out;
2413         /* establish dummy device */
2414         af_iucv_driver.bus = pr_iucv->bus;
2415         err = driver_register(&af_iucv_driver);
2416         if (err)
2417                 goto out_iucv;
2418         af_iucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
2419         if (!af_iucv_dev) {
2420                 err = -ENOMEM;
2421                 goto out_driver;
2422         }
2423         dev_set_name(af_iucv_dev, "af_iucv");
2424         af_iucv_dev->bus = pr_iucv->bus;
2425         af_iucv_dev->parent = pr_iucv->root;
2426         af_iucv_dev->release = (void (*)(struct device *))kfree;
2427         af_iucv_dev->driver = &af_iucv_driver;
2428         err = device_register(af_iucv_dev);
2429         if (err)
2430                 goto out_iucv_dev;
2431         return 0;
2432
2433 out_iucv_dev:
2434         put_device(af_iucv_dev);
2435 out_driver:
2436         driver_unregister(&af_iucv_driver);
2437 out_iucv:
2438         pr_iucv->iucv_unregister(&af_iucv_handler, 0);
2439 out:
2440         return err;
2441 }
2442
2443 static int __init afiucv_init(void)
2444 {
2445         int err;
2446
2447         if (MACHINE_IS_VM) {
2448                 cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err);
2449                 if (unlikely(err)) {
2450                         WARN_ON(err);
2451                         err = -EPROTONOSUPPORT;
2452                         goto out;
2453                 }
2454
2455                 pr_iucv = try_then_request_module(symbol_get(iucv_if), "iucv");
2456                 if (!pr_iucv) {
2457                         printk(KERN_WARNING "iucv_if lookup failed\n");
2458                         memset(&iucv_userid, 0, sizeof(iucv_userid));
2459                 }
2460         } else {
2461                 memset(&iucv_userid, 0, sizeof(iucv_userid));
2462                 pr_iucv = NULL;
2463         }
2464
2465         err = proto_register(&iucv_proto, 0);
2466         if (err)
2467                 goto out;
2468         err = sock_register(&iucv_sock_family_ops);
2469         if (err)
2470                 goto out_proto;
2471
2472         if (pr_iucv) {
2473                 err = afiucv_iucv_init();
2474                 if (err)
2475                         goto out_sock;
2476         } else
2477                 register_netdevice_notifier(&afiucv_netdev_notifier);
2478         dev_add_pack(&iucv_packet_type);
2479         return 0;
2480
2481 out_sock:
2482         sock_unregister(PF_IUCV);
2483 out_proto:
2484         proto_unregister(&iucv_proto);
2485 out:
2486         if (pr_iucv)
2487                 symbol_put(iucv_if);
2488         return err;
2489 }
2490
2491 static void __exit afiucv_exit(void)
2492 {
2493         if (pr_iucv) {
2494                 device_unregister(af_iucv_dev);
2495                 driver_unregister(&af_iucv_driver);
2496                 pr_iucv->iucv_unregister(&af_iucv_handler, 0);
2497                 symbol_put(iucv_if);
2498         } else
2499                 unregister_netdevice_notifier(&afiucv_netdev_notifier);
2500         dev_remove_pack(&iucv_packet_type);
2501         sock_unregister(PF_IUCV);
2502         proto_unregister(&iucv_proto);
2503 }
2504
2505 module_init(afiucv_init);
2506 module_exit(afiucv_exit);
2507
2508 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
2509 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION);
2510 MODULE_VERSION(VERSION);
2511 MODULE_LICENSE("GPL");
2512 MODULE_ALIAS_NETPROTO(PF_IUCV);