drivers/s390/net/netiucv.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * IUCV network driver
   4  *
   5  * Copyright IBM Corp. 2001, 2009
   6  *
   7  * Author(s):
   8  *      Original netiucv driver:
   9  *              Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
  10  *      Sysfs integration and all bugs therein:
  11  *              Cornelia Huck (cornelia.huck@de.ibm.com)
  12  *      PM functions:
  13  *              Ursula Braun (ursula.braun@de.ibm.com)
  14  *
  15  * Documentation used:
  16  *  the source of the original IUCV driver by:
  17  *    Stefan Hegewald <hegewald@de.ibm.com>
  18  *    Hartmut Penner <hpenner@de.ibm.com>
  19  *    Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  20  *    Martin Schwidefsky (schwidefsky@de.ibm.com)
  21  *    Alan Altmark (Alan_Altmark@us.ibm.com)  Sept. 2000
  22  */
  23
  24 #define KMSG_COMPONENT "netiucv"
  25 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  26
  27 #undef DEBUG
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/errno.h>
  34 #include <linux/types.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/timer.h>
  37 #include <linux/bitops.h>
  38
  39 #include <linux/signal.h>
  40 #include <linux/string.h>
  41 #include <linux/device.h>
  42
  43 #include <linux/ip.h>
  44 #include <linux/if_arp.h>
  45 #include <linux/tcp.h>
  46 #include <linux/skbuff.h>
  47 #include <linux/ctype.h>
  48 #include <net/dst.h>
  49
  50 #include <linux/io.h>
  51 #include <linux/uaccess.h>
  52 #include <asm/ebcdic.h>
  53
  54 #include <net/iucv/iucv.h>
  55 #include "fsm.h"
  56
  57 MODULE_AUTHOR
  58     ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
  59 MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
  60
  61 /*
  62  * Debug Facility stuff
  63  */
  64 #define IUCV_DBF_SETUP_NAME "iucv_setup"
  65 #define IUCV_DBF_SETUP_LEN 64
  66 #define IUCV_DBF_SETUP_PAGES 2
  67 #define IUCV_DBF_SETUP_NR_AREAS 1
  68 #define IUCV_DBF_SETUP_LEVEL 3
  69
  70 #define IUCV_DBF_DATA_NAME "iucv_data"
  71 #define IUCV_DBF_DATA_LEN 128
  72 #define IUCV_DBF_DATA_PAGES 2
  73 #define IUCV_DBF_DATA_NR_AREAS 1
  74 #define IUCV_DBF_DATA_LEVEL 2
  75
  76 #define IUCV_DBF_TRACE_NAME "iucv_trace"
  77 #define IUCV_DBF_TRACE_LEN 16
  78 #define IUCV_DBF_TRACE_PAGES 4
  79 #define IUCV_DBF_TRACE_NR_AREAS 1
  80 #define IUCV_DBF_TRACE_LEVEL 3
  81
  82 #define IUCV_DBF_TEXT(name,level,text) \
  83         do { \
  84                 debug_text_event(iucv_dbf_##name,level,text); \
  85         } while (0)
  86
  87 #define IUCV_DBF_HEX(name,level,addr,len) \
  88         do { \
  89                 debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
  90         } while (0)
  91
  92 DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf);
  93
  94 #define IUCV_DBF_TEXT_(name, level, text...) \
  95         do { \
  96                 if (debug_level_enabled(iucv_dbf_##name, level)) { \
  97                         char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
  98                         sprintf(__buf, text); \
  99                         debug_text_event(iucv_dbf_##name, level, __buf); \
 100                         put_cpu_var(iucv_dbf_txt_buf); \
 101                 } \
 102         } while (0)
 103
 104 #define IUCV_DBF_SPRINTF(name,level,text...) \
 105         do { \
 106                 debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
 107                 debug_sprintf_event(iucv_dbf_trace, level, text ); \
 108         } while (0)
 109
 110 /*
 111  * some more debug stuff
 112  */
 113 #define PRINTK_HEADER " iucv: "       /* for debugging */
 114
 115 static struct device_driver netiucv_driver = {
 116         .owner = THIS_MODULE,
 117         .name = "netiucv",
 118         .bus  = &iucv_bus,
 119 };
 120
 121 /*
 122  * Per connection profiling data
 123  */
 124 struct connection_profile {
 125         unsigned long maxmulti;
 126         unsigned long maxcqueue;
 127         unsigned long doios_single;
 128         unsigned long doios_multi;
 129         unsigned long txlen;
 130         unsigned long tx_time;
 131         unsigned long send_stamp;
 132         unsigned long tx_pending;
 133         unsigned long tx_max_pending;
 134 };
 135
 136 /*
 137  * Representation of one iucv connection
 138  */
 139 struct iucv_connection {
 140         struct list_head          list;
 141         struct iucv_path          *path;
 142         struct sk_buff            *rx_buff;
 143         struct sk_buff            *tx_buff;
 144         struct sk_buff_head       collect_queue;
 145         struct sk_buff_head       commit_queue;
 146         spinlock_t                collect_lock;
 147         int                       collect_len;
 148         int                       max_buffsize;
 149         fsm_timer                 timer;
 150         fsm_instance              *fsm;
 151         struct net_device         *netdev;
 152         struct connection_profile prof;
 153         char                      userid[9];
 154         char                      userdata[17];
 155 };
 156
 157 /*
 158  * Linked list of all connection structs.
 159  */
 160 static LIST_HEAD(iucv_connection_list);
 161 static DEFINE_RWLOCK(iucv_connection_rwlock);
 162
 163 /*
 164  * Representation of event-data for the
 165  * connection state machine.
 166  */
 167 struct iucv_event {
 168         struct iucv_connection *conn;
 169         void                   *data;
 170 };
 171
 172 /*
 173  * Private part of the network device structure
 174  */
 175 struct netiucv_priv {
 176         struct net_device_stats stats;
 177         unsigned long           tbusy;
 178         fsm_instance            *fsm;
 179         struct iucv_connection  *conn;
 180         struct device           *dev;
 181 };
 182
 183 /*
 184  * Link level header for a packet.
 185  */
 186 struct ll_header {
 187         u16 next;
 188 };
 189
 190 #define NETIUCV_HDRLEN           (sizeof(struct ll_header))
 191 #define NETIUCV_BUFSIZE_MAX      65537
 192 #define NETIUCV_BUFSIZE_DEFAULT  NETIUCV_BUFSIZE_MAX
 193 #define NETIUCV_MTU_MAX          (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
 194 #define NETIUCV_MTU_DEFAULT      9216
 195 #define NETIUCV_QUEUELEN_DEFAULT 50
 196 #define NETIUCV_TIMEOUT_5SEC     5000
 197
 198 /*
 199  * Compatibility macros for busy handling
 200  * of network devices.
 201  */
 202 static void netiucv_clear_busy(struct net_device *dev)
 203 {
 204         struct netiucv_priv *priv = netdev_priv(dev);
 205         clear_bit(0, &priv->tbusy);
 206         netif_wake_queue(dev);
 207 }
 208
 209 static int netiucv_test_and_set_busy(struct net_device *dev)
 210 {
 211         struct netiucv_priv *priv = netdev_priv(dev);
 212         netif_stop_queue(dev);
 213         return test_and_set_bit(0, &priv->tbusy);
 214 }
 215
 216 static u8 iucvMagic_ascii[16] = {
 217         0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 218         0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
 219 };
 220
 221 static u8 iucvMagic_ebcdic[16] = {
 222         0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
 223         0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
 224 };
 225
 226 /*
 227  * Convert an iucv userId to its printable
 228  * form (strip whitespace at end).
 229  *
 230  * @param An iucv userId
 231  *
 232  * @returns The printable string (static data!!)
 233  */
 234 static char *netiucv_printname(char *name, int len)
 235 {
 236         static char tmp[17];
 237         char *p = tmp;
 238         memcpy(tmp, name, len);
 239         tmp[len] = '\0';
 240         while (*p && ((p - tmp) < len) && (!isspace(*p)))
 241                 p++;
 242         *p = '\0';
 243         return tmp;
 244 }
 245
 246 static char *netiucv_printuser(struct iucv_connection *conn)
 247 {
 248         static char tmp_uid[9];
 249         static char tmp_udat[17];
 250         static char buf[100];
 251
 252         if (memcmp(conn->userdata, iucvMagic_ebcdic, 16)) {
 253                 tmp_uid[8] = '\0';
 254                 tmp_udat[16] = '\0';
 255                 memcpy(tmp_uid, netiucv_printname(conn->userid, 8), 8);
 256                 memcpy(tmp_udat, conn->userdata, 16);
 257                 EBCASC(tmp_udat, 16);
 258                 memcpy(tmp_udat, netiucv_printname(tmp_udat, 16), 16);
 259                 sprintf(buf, "%s.%s", tmp_uid, tmp_udat);
 260                 return buf;
 261         } else
 262                 return netiucv_printname(conn->userid, 8);
 263 }
 264
 265 /*
 266  * States of the interface statemachine.
 267  */
 268 enum dev_states {
 269         DEV_STATE_STOPPED,
 270         DEV_STATE_STARTWAIT,
 271         DEV_STATE_STOPWAIT,
 272         DEV_STATE_RUNNING,
 273         /*
 274          * MUST be always the last element!!
 275          */
 276         NR_DEV_STATES
 277 };
 278
 279 static const char *dev_state_names[] = {
 280         "Stopped",
 281         "StartWait",
 282         "StopWait",
 283         "Running",
 284 };
 285
 286 /*
 287  * Events of the interface statemachine.
 288  */
 289 enum dev_events {
 290         DEV_EVENT_START,
 291         DEV_EVENT_STOP,
 292         DEV_EVENT_CONUP,
 293         DEV_EVENT_CONDOWN,
 294         /*
 295          * MUST be always the last element!!
 296          */
 297         NR_DEV_EVENTS
 298 };
 299
 300 static const char *dev_event_names[] = {
 301         "Start",
 302         "Stop",
 303         "Connection up",
 304         "Connection down",
 305 };
 306
 307 /*
 308  * Events of the connection statemachine
 309  */
 310 enum conn_events {
 311         /*
 312          * Events, representing callbacks from
 313          * lowlevel iucv layer)
 314          */
 315         CONN_EVENT_CONN_REQ,
 316         CONN_EVENT_CONN_ACK,
 317         CONN_EVENT_CONN_REJ,
 318         CONN_EVENT_CONN_SUS,
 319         CONN_EVENT_CONN_RES,
 320         CONN_EVENT_RX,
 321         CONN_EVENT_TXDONE,
 322
 323         /*
 324          * Events, representing errors return codes from
 325          * calls to lowlevel iucv layer
 326          */
 327
 328         /*
 329          * Event, representing timer expiry.
 330          */
 331         CONN_EVENT_TIMER,
 332
 333         /*
 334          * Events, representing commands from upper levels.
 335          */
 336         CONN_EVENT_START,
 337         CONN_EVENT_STOP,
 338
 339         /*
 340          * MUST be always the last element!!
 341          */
 342         NR_CONN_EVENTS,
 343 };
 344
 345 static const char *conn_event_names[] = {
 346         "Remote connection request",
 347         "Remote connection acknowledge",
 348         "Remote connection reject",
 349         "Connection suspended",
 350         "Connection resumed",
 351         "Data received",
 352         "Data sent",
 353
 354         "Timer",
 355
 356         "Start",
 357         "Stop",
 358 };
 359
 360 /*
 361  * States of the connection statemachine.
 362  */
 363 enum conn_states {
 364         /*
 365          * Connection not assigned to any device,
 366          * initial state, invalid
 367          */
 368         CONN_STATE_INVALID,
 369
 370         /*
 371          * Userid assigned but not operating
 372          */
 373         CONN_STATE_STOPPED,
 374
 375         /*
 376          * Connection registered,
 377          * no connection request sent yet,
 378          * no connection request received
 379          */
 380         CONN_STATE_STARTWAIT,
 381
 382         /*
 383          * Connection registered and connection request sent,
 384          * no acknowledge and no connection request received yet.
 385          */
 386         CONN_STATE_SETUPWAIT,
 387
 388         /*
 389          * Connection up and running idle
 390          */
 391         CONN_STATE_IDLE,
 392
 393         /*
 394          * Data sent, awaiting CONN_EVENT_TXDONE
 395          */
 396         CONN_STATE_TX,
 397
 398         /*
 399          * Error during registration.
 400          */
 401         CONN_STATE_REGERR,
 402
 403         /*
 404          * Error during registration.
 405          */
 406         CONN_STATE_CONNERR,
 407
 408         /*
 409          * MUST be always the last element!!
 410          */
 411         NR_CONN_STATES,
 412 };
 413
 414 static const char *conn_state_names[] = {
 415         "Invalid",
 416         "Stopped",
 417         "StartWait",
 418         "SetupWait",
 419         "Idle",
 420         "TX",
 421         "Terminating",
 422         "Registration error",
 423         "Connect error",
 424 };
 425
 426
 427 /*
 428  * Debug Facility Stuff
 429  */
 430 static debug_info_t *iucv_dbf_setup = NULL;
 431 static debug_info_t *iucv_dbf_data = NULL;
 432 static debug_info_t *iucv_dbf_trace = NULL;
 433
 434 DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf);
 435
 436 static void iucv_unregister_dbf_views(void)
 437 {
 438         debug_unregister(iucv_dbf_setup);
 439         debug_unregister(iucv_dbf_data);
 440         debug_unregister(iucv_dbf_trace);
 441 }
 442 static int iucv_register_dbf_views(void)
 443 {
 444         iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
 445                                         IUCV_DBF_SETUP_PAGES,
 446                                         IUCV_DBF_SETUP_NR_AREAS,
 447                                         IUCV_DBF_SETUP_LEN);
 448         iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
 449                                        IUCV_DBF_DATA_PAGES,
 450                                        IUCV_DBF_DATA_NR_AREAS,
 451                                        IUCV_DBF_DATA_LEN);
 452         iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
 453                                         IUCV_DBF_TRACE_PAGES,
 454                                         IUCV_DBF_TRACE_NR_AREAS,
 455                                         IUCV_DBF_TRACE_LEN);
 456
 457         if ((iucv_dbf_setup == NULL) || (iucv_dbf_data == NULL) ||
 458             (iucv_dbf_trace == NULL)) {
 459                 iucv_unregister_dbf_views();
 460                 return -ENOMEM;
 461         }
 462         debug_register_view(iucv_dbf_setup, &debug_hex_ascii_view);
 463         debug_set_level(iucv_dbf_setup, IUCV_DBF_SETUP_LEVEL);
 464
 465         debug_register_view(iucv_dbf_data, &debug_hex_ascii_view);
 466         debug_set_level(iucv_dbf_data, IUCV_DBF_DATA_LEVEL);
 467
 468         debug_register_view(iucv_dbf_trace, &debug_hex_ascii_view);
 469         debug_set_level(iucv_dbf_trace, IUCV_DBF_TRACE_LEVEL);
 470
 471         return 0;
 472 }
 473
 474 /*
 475  * Callback-wrappers, called from lowlevel iucv layer.
 476  */
 477
 478 static void netiucv_callback_rx(struct iucv_path *path,
 479                                 struct iucv_message *msg)
 480 {
 481         struct iucv_connection *conn = path->private;
 482         struct iucv_event ev;
 483
 484         ev.conn = conn;
 485         ev.data = msg;
 486         fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
 487 }
 488
 489 static void netiucv_callback_txdone(struct iucv_path *path,
 490                                     struct iucv_message *msg)
 491 {
 492         struct iucv_connection *conn = path->private;
 493         struct iucv_event ev;
 494
 495         ev.conn = conn;
 496         ev.data = msg;
 497         fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
 498 }
 499
 500 static void netiucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
 501 {
 502         struct iucv_connection *conn = path->private;
 503
 504         fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn);
 505 }
 506
 507 static int netiucv_callback_connreq(struct iucv_path *path, u8 *ipvmid,
 508                                     u8 *ipuser)
 509 {
 510         struct iucv_connection *conn = path->private;
 511         struct iucv_event ev;
 512         static char tmp_user[9];
 513         static char tmp_udat[17];
 514         int rc;
 515
 516         rc = -EINVAL;
 517         memcpy(tmp_user, netiucv_printname(ipvmid, 8), 8);
 518         memcpy(tmp_udat, ipuser, 16);
 519         EBCASC(tmp_udat, 16);
 520         read_lock_bh(&iucv_connection_rwlock);
 521         list_for_each_entry(conn, &iucv_connection_list, list) {
 522                 if (strncmp(ipvmid, conn->userid, 8) ||
 523                     strncmp(ipuser, conn->userdata, 16))
 524                         continue;
 525                 /* Found a matching connection for this path. */
 526                 conn->path = path;
 527                 ev.conn = conn;
 528                 ev.data = path;
 529                 fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
 530                 rc = 0;
 531         }
 532         IUCV_DBF_TEXT_(setup, 2, "Connection requested for %s.%s\n",
 533                        tmp_user, netiucv_printname(tmp_udat, 16));
 534         read_unlock_bh(&iucv_connection_rwlock);
 535         return rc;
 536 }
 537
 538 static void netiucv_callback_connrej(struct iucv_path *path, u8 *ipuser)
 539 {
 540         struct iucv_connection *conn = path->private;
 541
 542         fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn);
 543 }
 544
 545 static void netiucv_callback_connsusp(struct iucv_path *path, u8 *ipuser)
 546 {
 547         struct iucv_connection *conn = path->private;
 548
 549         fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn);
 550 }
 551
 552 static void netiucv_callback_connres(struct iucv_path *path, u8 *ipuser)
 553 {
 554         struct iucv_connection *conn = path->private;
 555
 556         fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn);
 557 }
 558
 559 /*
 560  * NOP action for statemachines
 561  */
 562 static void netiucv_action_nop(fsm_instance *fi, int event, void *arg)
 563 {
 564 }
 565
 566 /*
 567  * Actions of the connection statemachine
 568  */
 569
 570 /*
 571  * netiucv_unpack_skb
 572  * @conn: The connection where this skb has been received.
 573  * @pskb: The received skb.
 574  *
 575  * Unpack a just received skb and hand it over to upper layers.
 576  * Helper function for conn_action_rx.
 577  */
 578 static void netiucv_unpack_skb(struct iucv_connection *conn,
 579                                struct sk_buff *pskb)
 580 {
 581         struct net_device     *dev = conn->netdev;
 582         struct netiucv_priv   *privptr = netdev_priv(dev);
 583         u16 offset = 0;
 584
 585         skb_put(pskb, NETIUCV_HDRLEN);
 586         pskb->dev = dev;
 587         pskb->ip_summed = CHECKSUM_NONE;
 588         pskb->protocol = cpu_to_be16(ETH_P_IP);
 589
 590         while (1) {
 591                 struct sk_buff *skb;
 592                 struct ll_header *header = (struct ll_header *) pskb->data;
 593
 594                 if (!header->next)
 595                         break;
 596
 597                 skb_pull(pskb, NETIUCV_HDRLEN);
 598                 header->next -= offset;
 599                 offset += header->next;
 600                 header->next -= NETIUCV_HDRLEN;
 601                 if (skb_tailroom(pskb) < header->next) {
 602                         IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n",
 603                                 header->next, skb_tailroom(pskb));
 604                         return;
 605                 }
 606                 skb_put(pskb, header->next);
 607                 skb_reset_mac_header(pskb);
 608                 skb = dev_alloc_skb(pskb->len);
 609                 if (!skb) {
 610                         IUCV_DBF_TEXT(data, 2,
 611                                 "Out of memory in netiucv_unpack_skb\n");
 612                         privptr->stats.rx_dropped++;
 613                         return;
 614                 }
 615                 skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
 616                                           pskb->len);
 617                 skb_reset_mac_header(skb);
 618                 skb->dev = pskb->dev;
 619                 skb->protocol = pskb->protocol;
 620                 pskb->ip_summed = CHECKSUM_UNNECESSARY;
 621                 privptr->stats.rx_packets++;
 622                 privptr->stats.rx_bytes += skb->len;
 623                 netif_rx(skb);
 624                 skb_pull(pskb, header->next);
 625                 skb_put(pskb, NETIUCV_HDRLEN);
 626         }
 627 }
 628
 629 static void conn_action_rx(fsm_instance *fi, int event, void *arg)
 630 {
 631         struct iucv_event *ev = arg;
 632         struct iucv_connection *conn = ev->conn;
 633         struct iucv_message *msg = ev->data;
 634         struct netiucv_priv *privptr = netdev_priv(conn->netdev);
 635         int rc;
 636
 637         IUCV_DBF_TEXT(trace, 4, __func__);
 638
 639         if (!conn->netdev) {
 640                 iucv_message_reject(conn->path, msg);
 641                 IUCV_DBF_TEXT(data, 2,
 642                               "Received data for unlinked connection\n");
 643                 return;
 644         }
 645         if (msg->length > conn->max_buffsize) {
 646                 iucv_message_reject(conn->path, msg);
 647                 privptr->stats.rx_dropped++;
 648                 IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n",
 649                                msg->length, conn->max_buffsize);
 650                 return;
 651         }
 652         conn->rx_buff->data = conn->rx_buff->head;
 653         skb_reset_tail_pointer(conn->rx_buff);
 654         conn->rx_buff->len = 0;
 655         rc = iucv_message_receive(conn->path, msg, 0, conn->rx_buff->data,
 656                                   msg->length, NULL);
 657         if (rc || msg->length < 5) {
 658                 privptr->stats.rx_errors++;
 659                 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc);
 660                 return;
 661         }
 662         netiucv_unpack_skb(conn, conn->rx_buff);
 663 }
 664
 665 static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
 666 {
 667         struct iucv_event *ev = arg;
 668         struct iucv_connection *conn = ev->conn;
 669         struct iucv_message *msg = ev->data;
 670         struct iucv_message txmsg;
 671         struct netiucv_priv *privptr = NULL;
 672         u32 single_flag = msg->tag;
 673         u32 txbytes = 0;
 674         u32 txpackets = 0;
 675         u32 stat_maxcq = 0;
 676         struct sk_buff *skb;
 677         unsigned long saveflags;
 678         struct ll_header header;
 679         int rc;
 680
 681         IUCV_DBF_TEXT(trace, 4, __func__);
 682
 683         if (!conn || !conn->netdev) {
 684                 IUCV_DBF_TEXT(data, 2,
 685                               "Send confirmation for unlinked connection\n");
 686                 return;
 687         }
 688         privptr = netdev_priv(conn->netdev);
 689         conn->prof.tx_pending--;
 690         if (single_flag) {
 691                 if ((skb = skb_dequeue(&conn->commit_queue))) {
 692                         refcount_dec(&skb->users);
 693                         if (privptr) {
 694                                 privptr->stats.tx_packets++;
 695                                 privptr->stats.tx_bytes +=
 696                                         (skb->len - NETIUCV_HDRLEN
 697                                                   - NETIUCV_HDRLEN);
 698                         }
 699                         dev_kfree_skb_any(skb);
 700                 }
 701         }
 702         conn->tx_buff->data = conn->tx_buff->head;
 703         skb_reset_tail_pointer(conn->tx_buff);
 704         conn->tx_buff->len = 0;
 705         spin_lock_irqsave(&conn->collect_lock, saveflags);
 706         while ((skb = skb_dequeue(&conn->collect_queue))) {
 707                 header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
 708                 skb_put_data(conn->tx_buff, &header, NETIUCV_HDRLEN);
 709                 skb_copy_from_linear_data(skb,
 710                                           skb_put(conn->tx_buff, skb->len),
 711                                           skb->len);
 712                 txbytes += skb->len;
 713                 txpackets++;
 714                 stat_maxcq++;
 715                 refcount_dec(&skb->users);
 716                 dev_kfree_skb_any(skb);
 717         }
 718         if (conn->collect_len > conn->prof.maxmulti)
 719                 conn->prof.maxmulti = conn->collect_len;
 720         conn->collect_len = 0;
 721         spin_unlock_irqrestore(&conn->collect_lock, saveflags);
 722         if (conn->tx_buff->len == 0) {
 723                 fsm_newstate(fi, CONN_STATE_IDLE);
 724                 return;
 725         }
 726
 727         header.next = 0;
 728         skb_put_data(conn->tx_buff, &header, NETIUCV_HDRLEN);
 729         conn->prof.send_stamp = jiffies;
 730         txmsg.class = 0;
 731         txmsg.tag = 0;
 732         rc = iucv_message_send(conn->path, &txmsg, 0, 0,
 733                                conn->tx_buff->data, conn->tx_buff->len);
 734         conn->prof.doios_multi++;
 735         conn->prof.txlen += conn->tx_buff->len;
 736         conn->prof.tx_pending++;
 737         if (conn->prof.tx_pending > conn->prof.tx_max_pending)
 738                 conn->prof.tx_max_pending = conn->prof.tx_pending;
 739         if (rc) {
 740                 conn->prof.tx_pending--;
 741                 fsm_newstate(fi, CONN_STATE_IDLE);
 742                 if (privptr)
 743                         privptr->stats.tx_errors += txpackets;
 744                 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
 745         } else {
 746                 if (privptr) {
 747                         privptr->stats.tx_packets += txpackets;
 748                         privptr->stats.tx_bytes += txbytes;
 749                 }
 750                 if (stat_maxcq > conn->prof.maxcqueue)
 751                         conn->prof.maxcqueue = stat_maxcq;
 752         }
 753 }
 754
 755 static struct iucv_handler netiucv_handler = {
 756         .path_pending     = netiucv_callback_connreq,
 757         .path_complete    = netiucv_callback_connack,
 758         .path_severed     = netiucv_callback_connrej,
 759         .path_quiesced    = netiucv_callback_connsusp,
 760         .path_resumed     = netiucv_callback_connres,
 761         .message_pending  = netiucv_callback_rx,
 762         .message_complete = netiucv_callback_txdone,
 763 };
 764
 765 static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
 766 {
 767         struct iucv_event *ev = arg;
 768         struct iucv_connection *conn = ev->conn;
 769         struct iucv_path *path = ev->data;
 770         struct net_device *netdev = conn->netdev;
 771         struct netiucv_priv *privptr = netdev_priv(netdev);
 772         int rc;
 773
 774         IUCV_DBF_TEXT(trace, 3, __func__);
 775
 776         conn->path = path;
 777         path->msglim = NETIUCV_QUEUELEN_DEFAULT;
 778         path->flags = 0;
 779         rc = iucv_path_accept(path, &netiucv_handler, conn->userdata , conn);
 780         if (rc) {
 781                 IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
 782                 return;
 783         }
 784         fsm_newstate(fi, CONN_STATE_IDLE);
 785         netdev->tx_queue_len = conn->path->msglim;
 786         fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 787 }
 788
 789 static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
 790 {
 791         struct iucv_event *ev = arg;
 792         struct iucv_path *path = ev->data;
 793
 794         IUCV_DBF_TEXT(trace, 3, __func__);
 795         iucv_path_sever(path, NULL);
 796 }
 797
 798 static void conn_action_connack(fsm_instance *fi, int event, void *arg)
 799 {
 800         struct iucv_connection *conn = arg;
 801         struct net_device *netdev = conn->netdev;
 802         struct netiucv_priv *privptr = netdev_priv(netdev);
 803
 804         IUCV_DBF_TEXT(trace, 3, __func__);
 805         fsm_deltimer(&conn->timer);
 806         fsm_newstate(fi, CONN_STATE_IDLE);
 807         netdev->tx_queue_len = conn->path->msglim;
 808         fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 809 }
 810
 811 static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
 812 {
 813         struct iucv_connection *conn = arg;
 814
 815         IUCV_DBF_TEXT(trace, 3, __func__);
 816         fsm_deltimer(&conn->timer);
 817         iucv_path_sever(conn->path, conn->userdata);
 818         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 819 }
 820
 821 static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
 822 {
 823         struct iucv_connection *conn = arg;
 824         struct net_device *netdev = conn->netdev;
 825         struct netiucv_priv *privptr = netdev_priv(netdev);
 826
 827         IUCV_DBF_TEXT(trace, 3, __func__);
 828
 829         fsm_deltimer(&conn->timer);
 830         iucv_path_sever(conn->path, conn->userdata);
 831         dev_info(privptr->dev, "The peer z/VM guest %s has closed the "
 832                                "connection\n", netiucv_printuser(conn));
 833         IUCV_DBF_TEXT(data, 2,
 834                       "conn_action_connsever: Remote dropped connection\n");
 835         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 836         fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 837 }
 838
 839 static void conn_action_start(fsm_instance *fi, int event, void *arg)
 840 {
 841         struct iucv_connection *conn = arg;
 842         struct net_device *netdev = conn->netdev;
 843         struct netiucv_priv *privptr = netdev_priv(netdev);
 844         int rc;
 845
 846         IUCV_DBF_TEXT(trace, 3, __func__);
 847
 848         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 849
 850         /*
 851          * We must set the state before calling iucv_connect because the
 852          * callback handler could be called at any point after the connection
 853          * request is sent
 854          */
 855
 856         fsm_newstate(fi, CONN_STATE_SETUPWAIT);
 857         conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
 858         IUCV_DBF_TEXT_(setup, 2, "%s: connecting to %s ...\n",
 859                 netdev->name, netiucv_printuser(conn));
 860
 861         rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
 862                                NULL, conn->userdata, conn);
 863         switch (rc) {
 864         case 0:
 865                 netdev->tx_queue_len = conn->path->msglim;
 866                 fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
 867                              CONN_EVENT_TIMER, conn);
 868                 return;
 869         case 11:
 870                 dev_warn(privptr->dev,
 871                         "The IUCV device failed to connect to z/VM guest %s\n",
 872                         netiucv_printname(conn->userid, 8));
 873                 fsm_newstate(fi, CONN_STATE_STARTWAIT);
 874                 break;
 875         case 12:
 876                 dev_warn(privptr->dev,
 877                         "The IUCV device failed to connect to the peer on z/VM"
 878                         " guest %s\n", netiucv_printname(conn->userid, 8));
 879                 fsm_newstate(fi, CONN_STATE_STARTWAIT);
 880                 break;
 881         case 13:
 882                 dev_err(privptr->dev,
 883                         "Connecting the IUCV device would exceed the maximum"
 884                         " number of IUCV connections\n");
 885                 fsm_newstate(fi, CONN_STATE_CONNERR);
 886                 break;
 887         case 14:
 888                 dev_err(privptr->dev,
 889                         "z/VM guest %s has too many IUCV connections"
 890                         " to connect with the IUCV device\n",
 891                         netiucv_printname(conn->userid, 8));
 892                 fsm_newstate(fi, CONN_STATE_CONNERR);
 893                 break;
 894         case 15:
 895                 dev_err(privptr->dev,
 896                         "The IUCV device cannot connect to a z/VM guest with no"
 897                         " IUCV authorization\n");
 898                 fsm_newstate(fi, CONN_STATE_CONNERR);
 899                 break;
 900         default:
 901                 dev_err(privptr->dev,
 902                         "Connecting the IUCV device failed with error %d\n",
 903                         rc);
 904                 fsm_newstate(fi, CONN_STATE_CONNERR);
 905                 break;
 906         }
 907         IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
 908         kfree(conn->path);
 909         conn->path = NULL;
 910 }
 911
 912 static void netiucv_purge_skb_queue(struct sk_buff_head *q)
 913 {
 914         struct sk_buff *skb;
 915
 916         while ((skb = skb_dequeue(q))) {
 917                 refcount_dec(&skb->users);
 918                 dev_kfree_skb_any(skb);
 919         }
 920 }
 921
 922 static void conn_action_stop(fsm_instance *fi, int event, void *arg)
 923 {
 924         struct iucv_event *ev = arg;
 925         struct iucv_connection *conn = ev->conn;
 926         struct net_device *netdev = conn->netdev;
 927         struct netiucv_priv *privptr = netdev_priv(netdev);
 928
 929         IUCV_DBF_TEXT(trace, 3, __func__);
 930
 931         fsm_deltimer(&conn->timer);
 932         fsm_newstate(fi, CONN_STATE_STOPPED);
 933         netiucv_purge_skb_queue(&conn->collect_queue);
 934         if (conn->path) {
 935                 IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
 936                 iucv_path_sever(conn->path, conn->userdata);
 937                 kfree(conn->path);
 938                 conn->path = NULL;
 939         }
 940         netiucv_purge_skb_queue(&conn->commit_queue);
 941         fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 942 }
 943
 944 static void conn_action_inval(fsm_instance *fi, int event, void *arg)
 945 {
 946         struct iucv_connection *conn = arg;
 947         struct net_device *netdev = conn->netdev;
 948
 949         IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
 950                 netdev->name, conn->userid);
 951 }
 952
 953 static const fsm_node conn_fsm[] = {
 954         { CONN_STATE_INVALID,   CONN_EVENT_START,    conn_action_inval      },
 955         { CONN_STATE_STOPPED,   CONN_EVENT_START,    conn_action_start      },
 956
 957         { CONN_STATE_STOPPED,   CONN_EVENT_STOP,     conn_action_stop       },
 958         { CONN_STATE_STARTWAIT, CONN_EVENT_STOP,     conn_action_stop       },
 959         { CONN_STATE_SETUPWAIT, CONN_EVENT_STOP,     conn_action_stop       },
 960         { CONN_STATE_IDLE,      CONN_EVENT_STOP,     conn_action_stop       },
 961         { CONN_STATE_TX,        CONN_EVENT_STOP,     conn_action_stop       },
 962         { CONN_STATE_REGERR,    CONN_EVENT_STOP,     conn_action_stop       },
 963         { CONN_STATE_CONNERR,   CONN_EVENT_STOP,     conn_action_stop       },
 964
 965         { CONN_STATE_STOPPED,   CONN_EVENT_CONN_REQ, conn_action_connreject },
 966         { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
 967         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
 968         { CONN_STATE_IDLE,      CONN_EVENT_CONN_REQ, conn_action_connreject },
 969         { CONN_STATE_TX,        CONN_EVENT_CONN_REQ, conn_action_connreject },
 970
 971         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack    },
 972         { CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER,    conn_action_conntimsev },
 973
 974         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever  },
 975         { CONN_STATE_IDLE,      CONN_EVENT_CONN_REJ, conn_action_connsever  },
 976         { CONN_STATE_TX,        CONN_EVENT_CONN_REJ, conn_action_connsever  },
 977
 978         { CONN_STATE_IDLE,      CONN_EVENT_RX,       conn_action_rx         },
 979         { CONN_STATE_TX,        CONN_EVENT_RX,       conn_action_rx         },
 980
 981         { CONN_STATE_TX,        CONN_EVENT_TXDONE,   conn_action_txdone     },
 982         { CONN_STATE_IDLE,      CONN_EVENT_TXDONE,   conn_action_txdone     },
 983 };
 984
 985 static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
 986
 987
 988 /*
 989  * Actions for interface - statemachine.
 990  */
 991
 992 /*
 993  * dev_action_start
 994  * @fi: An instance of an interface statemachine.
 995  * @event: The event, just happened.
 996  * @arg: Generic pointer, casted from struct net_device * upon call.
 997  *
 998  * Startup connection by sending CONN_EVENT_START to it.
 999  */
1000 static void dev_action_start(fsm_instance *fi, int event, void *arg)
1001 {
1002         struct net_device   *dev = arg;
1003         struct netiucv_priv *privptr = netdev_priv(dev);
1004
1005         IUCV_DBF_TEXT(trace, 3, __func__);
1006
1007         fsm_newstate(fi, DEV_STATE_STARTWAIT);
1008         fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
1009 }
1010
1011 /*
1012  * Shutdown connection by sending CONN_EVENT_STOP to it.
1013  *
1014  * @param fi    An instance of an interface statemachine.
1015  * @param event The event, just happened.
1016  * @param arg   Generic pointer, casted from struct net_device * upon call.
1017  */
1018 static void
1019 dev_action_stop(fsm_instance *fi, int event, void *arg)
1020 {
1021         struct net_device   *dev = arg;
1022         struct netiucv_priv *privptr = netdev_priv(dev);
1023         struct iucv_event   ev;
1024
1025         IUCV_DBF_TEXT(trace, 3, __func__);
1026
1027         ev.conn = privptr->conn;
1028
1029         fsm_newstate(fi, DEV_STATE_STOPWAIT);
1030         fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
1031 }
1032
1033 /*
1034  * Called from connection statemachine
1035  * when a connection is up and running.
1036  *
1037  * @param fi    An instance of an interface statemachine.
1038  * @param event The event, just happened.
1039  * @param arg   Generic pointer, casted from struct net_device * upon call.
1040  */
1041 static void
1042 dev_action_connup(fsm_instance *fi, int event, void *arg)
1043 {
1044         struct net_device   *dev = arg;
1045         struct netiucv_priv *privptr = netdev_priv(dev);
1046
1047         IUCV_DBF_TEXT(trace, 3, __func__);
1048
1049         switch (fsm_getstate(fi)) {
1050                 case DEV_STATE_STARTWAIT:
1051                         fsm_newstate(fi, DEV_STATE_RUNNING);
1052                         dev_info(privptr->dev,
1053                                 "The IUCV device has been connected"
1054                                 " successfully to %s\n",
1055                                 netiucv_printuser(privptr->conn));
1056                         IUCV_DBF_TEXT(setup, 3,
1057                                 "connection is up and running\n");
1058                         break;
1059                 case DEV_STATE_STOPWAIT:
1060                         IUCV_DBF_TEXT(data, 2,
1061                                 "dev_action_connup: in DEV_STATE_STOPWAIT\n");
1062                         break;
1063         }
1064 }
1065
1066 /*
1067  * Called from connection statemachine
1068  * when a connection has been shutdown.
1069  *
1070  * @param fi    An instance of an interface statemachine.
1071  * @param event The event, just happened.
1072  * @param arg   Generic pointer, casted from struct net_device * upon call.
1073  */
1074 static void
1075 dev_action_conndown(fsm_instance *fi, int event, void *arg)
1076 {
1077         IUCV_DBF_TEXT(trace, 3, __func__);
1078
1079         switch (fsm_getstate(fi)) {
1080                 case DEV_STATE_RUNNING:
1081                         fsm_newstate(fi, DEV_STATE_STARTWAIT);
1082                         break;
1083                 case DEV_STATE_STOPWAIT:
1084                         fsm_newstate(fi, DEV_STATE_STOPPED);
1085                         IUCV_DBF_TEXT(setup, 3, "connection is down\n");
1086                         break;
1087         }
1088 }
1089
1090 static const fsm_node dev_fsm[] = {
1091         { DEV_STATE_STOPPED,    DEV_EVENT_START,   dev_action_start    },
1092
1093         { DEV_STATE_STOPWAIT,   DEV_EVENT_START,   dev_action_start    },
1094         { DEV_STATE_STOPWAIT,   DEV_EVENT_CONDOWN, dev_action_conndown },
1095
1096         { DEV_STATE_STARTWAIT,  DEV_EVENT_STOP,    dev_action_stop     },
1097         { DEV_STATE_STARTWAIT,  DEV_EVENT_CONUP,   dev_action_connup   },
1098
1099         { DEV_STATE_RUNNING,    DEV_EVENT_STOP,    dev_action_stop     },
1100         { DEV_STATE_RUNNING,    DEV_EVENT_CONDOWN, dev_action_conndown },
1101         { DEV_STATE_RUNNING,    DEV_EVENT_CONUP,   netiucv_action_nop  },
1102 };
1103
1104 static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
1105
1106 /*
1107  * Transmit a packet.
1108  * This is a helper function for netiucv_tx().
1109  *
1110  * @param conn Connection to be used for sending.
1111  * @param skb Pointer to struct sk_buff of packet to send.
1112  *            The linklevel header has already been set up
1113  *            by netiucv_tx().
1114  *
1115  * @return 0 on success, -ERRNO on failure. (Never fails.)
1116  */
1117 static int netiucv_transmit_skb(struct iucv_connection *conn,
1118                                 struct sk_buff *skb)
1119 {
1120         struct iucv_message msg;
1121         unsigned long saveflags;
1122         struct ll_header header;
1123         int rc;
1124
1125         if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
1126                 int l = skb->len + NETIUCV_HDRLEN;
1127
1128                 spin_lock_irqsave(&conn->collect_lock, saveflags);
1129                 if (conn->collect_len + l >
1130                     (conn->max_buffsize - NETIUCV_HDRLEN)) {
1131                         rc = -EBUSY;
1132                         IUCV_DBF_TEXT(data, 2,
1133                                       "EBUSY from netiucv_transmit_skb\n");
1134                 } else {
1135                         refcount_inc(&skb->users);
1136                         skb_queue_tail(&conn->collect_queue, skb);
1137                         conn->collect_len += l;
1138                         rc = 0;
1139                 }
1140                 spin_unlock_irqrestore(&conn->collect_lock, saveflags);
1141         } else {
1142                 struct sk_buff *nskb = skb;
1143                 /*
1144                  * Copy the skb to a new allocated skb in lowmem only if the
1145                  * data is located above 2G in memory or tailroom is < 2.
1146                  */
1147                 unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
1148                                     NETIUCV_HDRLEN)) >> 31;
1149                 int copied = 0;
1150                 if (hi || (skb_tailroom(skb) < 2)) {
1151                         nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
1152                                          NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
1153                         if (!nskb) {
1154                                 IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
1155                                 rc = -ENOMEM;
1156                                 return rc;
1157                         } else {
1158                                 skb_reserve(nskb, NETIUCV_HDRLEN);
1159                                 skb_put_data(nskb, skb->data, skb->len);
1160                         }
1161                         copied = 1;
1162                 }
1163                 /*
1164                  * skb now is below 2G and has enough room. Add headers.
1165                  */
1166                 header.next = nskb->len + NETIUCV_HDRLEN;
1167                 memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
1168                 header.next = 0;
1169                 skb_put_data(nskb, &header, NETIUCV_HDRLEN);
1170
1171                 fsm_newstate(conn->fsm, CONN_STATE_TX);
1172                 conn->prof.send_stamp = jiffies;
1173
1174                 msg.tag = 1;
1175                 msg.class = 0;
1176                 rc = iucv_message_send(conn->path, &msg, 0, 0,
1177                                        nskb->data, nskb->len);
1178                 conn->prof.doios_single++;
1179                 conn->prof.txlen += skb->len;
1180                 conn->prof.tx_pending++;
1181                 if (conn->prof.tx_pending > conn->prof.tx_max_pending)
1182                         conn->prof.tx_max_pending = conn->prof.tx_pending;
1183                 if (rc) {
1184                         struct netiucv_priv *privptr;
1185                         fsm_newstate(conn->fsm, CONN_STATE_IDLE);
1186                         conn->prof.tx_pending--;
1187                         privptr = netdev_priv(conn->netdev);
1188                         if (privptr)
1189                                 privptr->stats.tx_errors++;
1190                         if (copied)
1191                                 dev_kfree_skb(nskb);
1192                         else {
1193                                 /*
1194                                  * Remove our headers. They get added
1195                                  * again on retransmit.
1196                                  */
1197                                 skb_pull(skb, NETIUCV_HDRLEN);
1198                                 skb_trim(skb, skb->len - NETIUCV_HDRLEN);
1199                         }
1200                         IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
1201                 } else {
1202                         if (copied)
1203                                 dev_kfree_skb(skb);
1204                         refcount_inc(&nskb->users);
1205                         skb_queue_tail(&conn->commit_queue, nskb);
1206                 }
1207         }
1208
1209         return rc;
1210 }
1211
1212 /*
1213  * Interface API for upper network layers
1214  */
1215
1216 /*
1217  * Open an interface.
1218  * Called from generic network layer when ifconfig up is run.
1219  *
1220  * @param dev Pointer to interface struct.
1221  *
1222  * @return 0 on success, -ERRNO on failure. (Never fails.)
1223  */
1224 static int netiucv_open(struct net_device *dev)
1225 {
1226         struct netiucv_priv *priv = netdev_priv(dev);
1227
1228         fsm_event(priv->fsm, DEV_EVENT_START, dev);
1229         return 0;
1230 }
1231
1232 /*
1233  * Close an interface.
1234  * Called from generic network layer when ifconfig down is run.
1235  *
1236  * @param dev Pointer to interface struct.
1237  *
1238  * @return 0 on success, -ERRNO on failure. (Never fails.)
1239  */
1240 static int netiucv_close(struct net_device *dev)
1241 {
1242         struct netiucv_priv *priv = netdev_priv(dev);
1243
1244         fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
1245         return 0;
1246 }
1247
1248 /*
1249  * Start transmission of a packet.
1250  * Called from generic network device layer.
1251  */
1252 static netdev_tx_t netiucv_tx(struct sk_buff *skb, struct net_device *dev)
1253 {
1254         struct netiucv_priv *privptr = netdev_priv(dev);
1255         int rc;
1256
1257         IUCV_DBF_TEXT(trace, 4, __func__);
1258         /*
1259          * Some sanity checks ...
1260          */
1261         if (skb == NULL) {
1262                 IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
1263                 privptr->stats.tx_dropped++;
1264                 return NETDEV_TX_OK;
1265         }
1266         if (skb_headroom(skb) < NETIUCV_HDRLEN) {
1267                 IUCV_DBF_TEXT(data, 2,
1268                         "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1269                 dev_kfree_skb(skb);
1270                 privptr->stats.tx_dropped++;
1271                 return NETDEV_TX_OK;
1272         }
1273
1274         /*
1275          * If connection is not running, try to restart it
1276          * and throw away packet.
1277          */
1278         if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
1279                 dev_kfree_skb(skb);
1280                 privptr->stats.tx_dropped++;
1281                 privptr->stats.tx_errors++;
1282                 privptr->stats.tx_carrier_errors++;
1283                 return NETDEV_TX_OK;
1284         }
1285
1286         if (netiucv_test_and_set_busy(dev)) {
1287                 IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
1288                 return NETDEV_TX_BUSY;
1289         }
1290         netif_trans_update(dev);
1291         rc = netiucv_transmit_skb(privptr->conn, skb);
1292         netiucv_clear_busy(dev);
1293         return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
1294 }
1295
1296 /*
1297  * netiucv_stats
1298  * @dev: Pointer to interface struct.
1299  *
1300  * Returns interface statistics of a device.
1301  *
1302  * Returns pointer to stats struct of this interface.
1303  */
1304 static struct net_device_stats *netiucv_stats (struct net_device * dev)
1305 {
1306         struct netiucv_priv *priv = netdev_priv(dev);
1307
1308         IUCV_DBF_TEXT(trace, 5, __func__);
1309         return &priv->stats;
1310 }
1311
1312 /*
1313  * attributes in sysfs
1314  */
1315
1316 static ssize_t user_show(struct device *dev, struct device_attribute *attr,
1317                          char *buf)
1318 {
1319         struct netiucv_priv *priv = dev_get_drvdata(dev);
1320
1321         IUCV_DBF_TEXT(trace, 5, __func__);
1322         return sprintf(buf, "%s\n", netiucv_printuser(priv->conn));
1323 }
1324
1325 static int netiucv_check_user(const char *buf, size_t count, char *username,
1326                               char *userdata)
1327 {
1328         const char *p;
1329         int i;
1330
1331         p = strchr(buf, '.');
1332         if ((p && ((count > 26) ||
1333                    ((p - buf) > 8) ||
1334                    (buf + count - p > 18))) ||
1335             (!p && (count > 9))) {
1336                 IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
1337                 return -EINVAL;
1338         }
1339
1340         for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
1341                 if (isalnum(*p) || *p == '$') {
1342                         username[i] = toupper(*p);
1343                         continue;
1344                 }
1345                 if (*p == '\n')
1346                         /* trailing lf, grr */
1347                         break;
1348                 IUCV_DBF_TEXT_(setup, 2,
1349                                "conn_write: invalid character %02x\n", *p);
1350                 return -EINVAL;
1351         }
1352         while (i < 8)
1353                 username[i++] = ' ';
1354         username[8] = '\0';
1355
1356         if (*p == '.') {
1357                 p++;
1358                 for (i = 0; i < 16 && *p; i++, p++) {
1359                         if (*p == '\n')
1360                                 break;
1361                         userdata[i] = toupper(*p);
1362                 }
1363                 while (i > 0 && i < 16)
1364                         userdata[i++] = ' ';
1365         } else
1366                 memcpy(userdata, iucvMagic_ascii, 16);
1367         userdata[16] = '\0';
1368         ASCEBC(userdata, 16);
1369
1370         return 0;
1371 }
1372
1373 static ssize_t user_write(struct device *dev, struct device_attribute *attr,
1374                           const char *buf, size_t count)
1375 {
1376         struct netiucv_priv *priv = dev_get_drvdata(dev);
1377         struct net_device *ndev = priv->conn->netdev;
1378         char    username[9];
1379         char    userdata[17];
1380         int     rc;
1381         struct iucv_connection *cp;
1382
1383         IUCV_DBF_TEXT(trace, 3, __func__);
1384         rc = netiucv_check_user(buf, count, username, userdata);
1385         if (rc)
1386                 return rc;
1387
1388         if (memcmp(username, priv->conn->userid, 9) &&
1389             (ndev->flags & (IFF_UP | IFF_RUNNING))) {
1390                 /* username changed while the interface is active. */
1391                 IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
1392                 return -EPERM;
1393         }
1394         read_lock_bh(&iucv_connection_rwlock);
1395         list_for_each_entry(cp, &iucv_connection_list, list) {
1396                 if (!strncmp(username, cp->userid, 9) &&
1397                    !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
1398                         read_unlock_bh(&iucv_connection_rwlock);
1399                         IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
1400                                 "already exists\n", netiucv_printuser(cp));
1401                         return -EEXIST;
1402                 }
1403         }
1404         read_unlock_bh(&iucv_connection_rwlock);
1405         memcpy(priv->conn->userid, username, 9);
1406         memcpy(priv->conn->userdata, userdata, 17);
1407         return count;
1408 }
1409
1410 static DEVICE_ATTR(user, 0644, user_show, user_write);
1411
1412 static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
1413                             char *buf)
1414 {
1415         struct netiucv_priv *priv = dev_get_drvdata(dev);
1416
1417         IUCV_DBF_TEXT(trace, 5, __func__);
1418         return sprintf(buf, "%d\n", priv->conn->max_buffsize);
1419 }
1420
1421 static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
1422                              const char *buf, size_t count)
1423 {
1424         struct netiucv_priv *priv = dev_get_drvdata(dev);
1425         struct net_device *ndev = priv->conn->netdev;
1426         unsigned int bs1;
1427         int rc;
1428
1429         IUCV_DBF_TEXT(trace, 3, __func__);
1430         if (count >= 39)
1431                 return -EINVAL;
1432
1433         rc = kstrtouint(buf, 0, &bs1);
1434
1435         if (rc == -EINVAL) {
1436                 IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %s\n",
1437                         buf);
1438                 return -EINVAL;
1439         }
1440         if ((rc == -ERANGE) || (bs1 > NETIUCV_BUFSIZE_MAX)) {
1441                 IUCV_DBF_TEXT_(setup, 2,
1442                         "buffer_write: buffer size %d too large\n",
1443                         bs1);
1444                 return -EINVAL;
1445         }
1446         if ((ndev->flags & IFF_RUNNING) &&
1447             (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
1448                 IUCV_DBF_TEXT_(setup, 2,
1449                         "buffer_write: buffer size %d too small\n",
1450                         bs1);
1451                 return -EINVAL;
1452         }
1453         if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
1454                 IUCV_DBF_TEXT_(setup, 2,
1455                         "buffer_write: buffer size %d too small\n",
1456                         bs1);
1457                 return -EINVAL;
1458         }
1459
1460         priv->conn->max_buffsize = bs1;
1461         if (!(ndev->flags & IFF_RUNNING))
1462                 ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
1463
1464         return count;
1465
1466 }
1467
1468 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1469
1470 static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
1471                              char *buf)
1472 {
1473         struct netiucv_priv *priv = dev_get_drvdata(dev);
1474
1475         IUCV_DBF_TEXT(trace, 5, __func__);
1476         return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
1477 }
1478
1479 static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1480
1481 static ssize_t conn_fsm_show (struct device *dev,
1482                               struct device_attribute *attr, char *buf)
1483 {
1484         struct netiucv_priv *priv = dev_get_drvdata(dev);
1485
1486         IUCV_DBF_TEXT(trace, 5, __func__);
1487         return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
1488 }
1489
1490 static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1491
1492 static ssize_t maxmulti_show (struct device *dev,
1493                               struct device_attribute *attr, char *buf)
1494 {
1495         struct netiucv_priv *priv = dev_get_drvdata(dev);
1496
1497         IUCV_DBF_TEXT(trace, 5, __func__);
1498         return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
1499 }
1500
1501 static ssize_t maxmulti_write (struct device *dev,
1502                                struct device_attribute *attr,
1503                                const char *buf, size_t count)
1504 {
1505         struct netiucv_priv *priv = dev_get_drvdata(dev);
1506
1507         IUCV_DBF_TEXT(trace, 4, __func__);
1508         priv->conn->prof.maxmulti = 0;
1509         return count;
1510 }
1511
1512 static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1513
1514 static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
1515                            char *buf)
1516 {
1517         struct netiucv_priv *priv = dev_get_drvdata(dev);
1518
1519         IUCV_DBF_TEXT(trace, 5, __func__);
1520         return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
1521 }
1522
1523 static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
1524                             const char *buf, size_t count)
1525 {
1526         struct netiucv_priv *priv = dev_get_drvdata(dev);
1527
1528         IUCV_DBF_TEXT(trace, 4, __func__);
1529         priv->conn->prof.maxcqueue = 0;
1530         return count;
1531 }
1532
1533 static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1534
1535 static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
1536                            char *buf)
1537 {
1538         struct netiucv_priv *priv = dev_get_drvdata(dev);
1539
1540         IUCV_DBF_TEXT(trace, 5, __func__);
1541         return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
1542 }
1543
1544 static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
1545                             const char *buf, size_t count)
1546 {
1547         struct netiucv_priv *priv = dev_get_drvdata(dev);
1548
1549         IUCV_DBF_TEXT(trace, 4, __func__);
1550         priv->conn->prof.doios_single = 0;
1551         return count;
1552 }
1553
1554 static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1555
1556 static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
1557                            char *buf)
1558 {
1559         struct netiucv_priv *priv = dev_get_drvdata(dev);
1560
1561         IUCV_DBF_TEXT(trace, 5, __func__);
1562         return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
1563 }
1564
1565 static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
1566                             const char *buf, size_t count)
1567 {
1568         struct netiucv_priv *priv = dev_get_drvdata(dev);
1569
1570         IUCV_DBF_TEXT(trace, 5, __func__);
1571         priv->conn->prof.doios_multi = 0;
1572         return count;
1573 }
1574
1575 static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1576
1577 static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
1578                            char *buf)
1579 {
1580         struct netiucv_priv *priv = dev_get_drvdata(dev);
1581
1582         IUCV_DBF_TEXT(trace, 5, __func__);
1583         return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
1584 }
1585
1586 static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
1587                             const char *buf, size_t count)
1588 {
1589         struct netiucv_priv *priv = dev_get_drvdata(dev);
1590
1591         IUCV_DBF_TEXT(trace, 4, __func__);
1592         priv->conn->prof.txlen = 0;
1593         return count;
1594 }
1595
1596 static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1597
1598 static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
1599                             char *buf)
1600 {
1601         struct netiucv_priv *priv = dev_get_drvdata(dev);
1602
1603         IUCV_DBF_TEXT(trace, 5, __func__);
1604         return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
1605 }
1606
1607 static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
1608                              const char *buf, size_t count)
1609 {
1610         struct netiucv_priv *priv = dev_get_drvdata(dev);
1611
1612         IUCV_DBF_TEXT(trace, 4, __func__);
1613         priv->conn->prof.tx_time = 0;
1614         return count;
1615 }
1616
1617 static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1618
1619 static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
1620                             char *buf)
1621 {
1622         struct netiucv_priv *priv = dev_get_drvdata(dev);
1623
1624         IUCV_DBF_TEXT(trace, 5, __func__);
1625         return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
1626 }
1627
1628 static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
1629                              const char *buf, size_t count)
1630 {
1631         struct netiucv_priv *priv = dev_get_drvdata(dev);
1632
1633         IUCV_DBF_TEXT(trace, 4, __func__);
1634         priv->conn->prof.tx_pending = 0;
1635         return count;
1636 }
1637
1638 static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1639
1640 static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
1641                             char *buf)
1642 {
1643         struct netiucv_priv *priv = dev_get_drvdata(dev);
1644
1645         IUCV_DBF_TEXT(trace, 5, __func__);
1646         return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
1647 }
1648
1649 static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
1650                              const char *buf, size_t count)
1651 {
1652         struct netiucv_priv *priv = dev_get_drvdata(dev);
1653
1654         IUCV_DBF_TEXT(trace, 4, __func__);
1655         priv->conn->prof.tx_max_pending = 0;
1656         return count;
1657 }
1658
1659 static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1660
1661 static struct attribute *netiucv_attrs[] = {
1662         &dev_attr_buffer.attr,
1663         &dev_attr_user.attr,
1664         NULL,
1665 };
1666
1667 static struct attribute_group netiucv_attr_group = {
1668         .attrs = netiucv_attrs,
1669 };
1670
1671 static struct attribute *netiucv_stat_attrs[] = {
1672         &dev_attr_device_fsm_state.attr,
1673         &dev_attr_connection_fsm_state.attr,
1674         &dev_attr_max_tx_buffer_used.attr,
1675         &dev_attr_max_chained_skbs.attr,
1676         &dev_attr_tx_single_write_ops.attr,
1677         &dev_attr_tx_multi_write_ops.attr,
1678         &dev_attr_netto_bytes.attr,
1679         &dev_attr_max_tx_io_time.attr,
1680         &dev_attr_tx_pending.attr,
1681         &dev_attr_tx_max_pending.attr,
1682         NULL,
1683 };
1684
1685 static struct attribute_group netiucv_stat_attr_group = {
1686         .name  = "stats",
1687         .attrs = netiucv_stat_attrs,
1688 };
1689
1690 static const struct attribute_group *netiucv_attr_groups[] = {
1691         &netiucv_stat_attr_group,
1692         &netiucv_attr_group,
1693         NULL,
1694 };
1695
1696 static int netiucv_register_device(struct net_device *ndev)
1697 {
1698         struct netiucv_priv *priv = netdev_priv(ndev);
1699         struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1700         int ret;
1701
1702         IUCV_DBF_TEXT(trace, 3, __func__);
1703
1704         if (dev) {
1705                 dev_set_name(dev, "net%s", ndev->name);
1706                 dev->bus = &iucv_bus;
1707                 dev->parent = iucv_root;
1708                 dev->groups = netiucv_attr_groups;
1709                 /*
1710                  * The release function could be called after the
1711                  * module has been unloaded. It's _only_ task is to
1712                  * free the struct. Therefore, we specify kfree()
1713                  * directly here. (Probably a little bit obfuscating
1714                  * but legitime ...).
1715                  */
1716                 dev->release = (void (*)(struct device *))kfree;
1717                 dev->driver = &netiucv_driver;
1718         } else
1719                 return -ENOMEM;
1720
1721         ret = device_register(dev);
1722         if (ret) {
1723                 put_device(dev);
1724                 return ret;
1725         }
1726         priv->dev = dev;
1727         dev_set_drvdata(dev, priv);
1728         return 0;
1729 }
1730
1731 static void netiucv_unregister_device(struct device *dev)
1732 {
1733         IUCV_DBF_TEXT(trace, 3, __func__);
1734         device_unregister(dev);
1735 }
1736
1737 /*
1738  * Allocate and initialize a new connection structure.
1739  * Add it to the list of netiucv connections;
1740  */
1741 static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
1742                                                       char *username,
1743                                                       char *userdata)
1744 {
1745         struct iucv_connection *conn;
1746
1747         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1748         if (!conn)
1749                 goto out;
1750         skb_queue_head_init(&conn->collect_queue);
1751         skb_queue_head_init(&conn->commit_queue);
1752         spin_lock_init(&conn->collect_lock);
1753         conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1754         conn->netdev = dev;
1755
1756         conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1757         if (!conn->rx_buff)
1758                 goto out_conn;
1759         conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1760         if (!conn->tx_buff)
1761                 goto out_rx;
1762         conn->fsm = init_fsm("netiucvconn", conn_state_names,
1763                              conn_event_names, NR_CONN_STATES,
1764                              NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1765                              GFP_KERNEL);
1766         if (!conn->fsm)
1767                 goto out_tx;
1768
1769         fsm_settimer(conn->fsm, &conn->timer);
1770         fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1771
1772         if (userdata)
1773                 memcpy(conn->userdata, userdata, 17);
1774         if (username) {
1775                 memcpy(conn->userid, username, 9);
1776                 fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1777         }
1778
1779         write_lock_bh(&iucv_connection_rwlock);
1780         list_add_tail(&conn->list, &iucv_connection_list);
1781         write_unlock_bh(&iucv_connection_rwlock);
1782         return conn;
1783
1784 out_tx:
1785         kfree_skb(conn->tx_buff);
1786 out_rx:
1787         kfree_skb(conn->rx_buff);
1788 out_conn:
1789         kfree(conn);
1790 out:
1791         return NULL;
1792 }
1793
1794 /*
1795  * Release a connection structure and remove it from the
1796  * list of netiucv connections.
1797  */
1798 static void netiucv_remove_connection(struct iucv_connection *conn)
1799 {
1800
1801         IUCV_DBF_TEXT(trace, 3, __func__);
1802         write_lock_bh(&iucv_connection_rwlock);
1803         list_del_init(&conn->list);
1804         write_unlock_bh(&iucv_connection_rwlock);
1805         fsm_deltimer(&conn->timer);
1806         netiucv_purge_skb_queue(&conn->collect_queue);
1807         if (conn->path) {
1808                 iucv_path_sever(conn->path, conn->userdata);
1809                 kfree(conn->path);
1810                 conn->path = NULL;
1811         }
1812         netiucv_purge_skb_queue(&conn->commit_queue);
1813         kfree_fsm(conn->fsm);
1814         kfree_skb(conn->rx_buff);
1815         kfree_skb(conn->tx_buff);
1816 }
1817
1818 /*
1819  * Release everything of a net device.
1820  */
1821 static void netiucv_free_netdevice(struct net_device *dev)
1822 {
1823         struct netiucv_priv *privptr = netdev_priv(dev);
1824
1825         IUCV_DBF_TEXT(trace, 3, __func__);
1826
1827         if (!dev)
1828                 return;
1829
1830         if (privptr) {
1831                 if (privptr->conn)
1832                         netiucv_remove_connection(privptr->conn);
1833                 if (privptr->fsm)
1834                         kfree_fsm(privptr->fsm);
1835                 privptr->conn = NULL; privptr->fsm = NULL;
1836                 /* privptr gets freed by free_netdev() */
1837         }
1838 }
1839
1840 /*
1841  * Initialize a net device. (Called from kernel in alloc_netdev())
1842  */
1843 static const struct net_device_ops netiucv_netdev_ops = {
1844         .ndo_open               = netiucv_open,
1845         .ndo_stop               = netiucv_close,
1846         .ndo_get_stats          = netiucv_stats,
1847         .ndo_start_xmit         = netiucv_tx,
1848 };
1849
1850 static void netiucv_setup_netdevice(struct net_device *dev)
1851 {
1852         dev->mtu                 = NETIUCV_MTU_DEFAULT;
1853         dev->min_mtu             = 576;
1854         dev->max_mtu             = NETIUCV_MTU_MAX;
1855         dev->needs_free_netdev   = true;
1856         dev->priv_destructor     = netiucv_free_netdevice;
1857         dev->hard_header_len     = NETIUCV_HDRLEN;
1858         dev->addr_len            = 0;
1859         dev->type                = ARPHRD_SLIP;
1860         dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
1861         dev->flags               = IFF_POINTOPOINT | IFF_NOARP;
1862         dev->netdev_ops          = &netiucv_netdev_ops;
1863 }
1864
1865 /*
1866  * Allocate and initialize everything of a net device.
1867  */
1868 static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
1869 {
1870         struct netiucv_priv *privptr;
1871         struct net_device *dev;
1872
1873         dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
1874                            NET_NAME_UNKNOWN, netiucv_setup_netdevice);
1875         if (!dev)
1876                 return NULL;
1877         rtnl_lock();
1878         if (dev_alloc_name(dev, dev->name) < 0)
1879                 goto out_netdev;
1880
1881         privptr = netdev_priv(dev);
1882         privptr->fsm = init_fsm("netiucvdev", dev_state_names,
1883                                 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
1884                                 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
1885         if (!privptr->fsm)
1886                 goto out_netdev;
1887
1888         privptr->conn = netiucv_new_connection(dev, username, userdata);
1889         if (!privptr->conn) {
1890                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
1891                 goto out_fsm;
1892         }
1893         fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
1894         return dev;
1895
1896 out_fsm:
1897         kfree_fsm(privptr->fsm);
1898 out_netdev:
1899         rtnl_unlock();
1900         free_netdev(dev);
1901         return NULL;
1902 }
1903
1904 static ssize_t connection_store(struct device_driver *drv, const char *buf,
1905                                 size_t count)
1906 {
1907         char username[9];
1908         char userdata[17];
1909         int rc;
1910         struct net_device *dev;
1911         struct netiucv_priv *priv;
1912         struct iucv_connection *cp;
1913
1914         IUCV_DBF_TEXT(trace, 3, __func__);
1915         rc = netiucv_check_user(buf, count, username, userdata);
1916         if (rc)
1917                 return rc;
1918
1919         read_lock_bh(&iucv_connection_rwlock);
1920         list_for_each_entry(cp, &iucv_connection_list, list) {
1921                 if (!strncmp(username, cp->userid, 9) &&
1922                     !strncmp(userdata, cp->userdata, 17)) {
1923                         read_unlock_bh(&iucv_connection_rwlock);
1924                         IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
1925                                 "already exists\n", netiucv_printuser(cp));
1926                         return -EEXIST;
1927                 }
1928         }
1929         read_unlock_bh(&iucv_connection_rwlock);
1930
1931         dev = netiucv_init_netdevice(username, userdata);
1932         if (!dev) {
1933                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
1934                 return -ENODEV;
1935         }
1936
1937         rc = netiucv_register_device(dev);
1938         if (rc) {
1939                 rtnl_unlock();
1940                 IUCV_DBF_TEXT_(setup, 2,
1941                         "ret %d from netiucv_register_device\n", rc);
1942                 goto out_free_ndev;
1943         }
1944
1945         /* sysfs magic */
1946         priv = netdev_priv(dev);
1947         SET_NETDEV_DEV(dev, priv->dev);
1948
1949         rc = register_netdevice(dev);
1950         rtnl_unlock();
1951         if (rc)
1952                 goto out_unreg;
1953
1954         dev_info(priv->dev, "The IUCV interface to %s has been established "
1955                             "successfully\n",
1956                 netiucv_printuser(priv->conn));
1957
1958         return count;
1959
1960 out_unreg:
1961         netiucv_unregister_device(priv->dev);
1962 out_free_ndev:
1963         netiucv_free_netdevice(dev);
1964         return rc;
1965 }
1966 static DRIVER_ATTR_WO(connection);
1967
1968 static ssize_t remove_store(struct device_driver *drv, const char *buf,
1969                             size_t count)
1970 {
1971         struct iucv_connection *cp;
1972         struct net_device *ndev;
1973         struct netiucv_priv *priv;
1974         struct device *dev;
1975         char name[IFNAMSIZ];
1976         const char *p;
1977         int i;
1978
1979         IUCV_DBF_TEXT(trace, 3, __func__);
1980
1981         if (count >= IFNAMSIZ)
1982                 count = IFNAMSIZ - 1;
1983
1984         for (i = 0, p = buf; i < count && *p; i++, p++) {
1985                 if (*p == '\n' || *p == ' ')
1986                         /* trailing lf, grr */
1987                         break;
1988                 name[i] = *p;
1989         }
1990         name[i] = '\0';
1991
1992         read_lock_bh(&iucv_connection_rwlock);
1993         list_for_each_entry(cp, &iucv_connection_list, list) {
1994                 ndev = cp->netdev;
1995                 priv = netdev_priv(ndev);
1996                 dev = priv->dev;
1997                 if (strncmp(name, ndev->name, count))
1998                         continue;
1999                 read_unlock_bh(&iucv_connection_rwlock);
2000                 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2001                         dev_warn(dev, "The IUCV device is connected"
2002                                 " to %s and cannot be removed\n",
2003                                 priv->conn->userid);
2004                         IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2005                         return -EPERM;
2006                 }
2007                 unregister_netdev(ndev);
2008                 netiucv_unregister_device(dev);
2009                 return count;
2010         }
2011         read_unlock_bh(&iucv_connection_rwlock);
2012         IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2013         return -EINVAL;
2014 }
2015 static DRIVER_ATTR_WO(remove);
2016
2017 static struct attribute * netiucv_drv_attrs[] = {
2018         &driver_attr_connection.attr,
2019         &driver_attr_remove.attr,
2020         NULL,
2021 };
2022
2023 static struct attribute_group netiucv_drv_attr_group = {
2024         .attrs = netiucv_drv_attrs,
2025 };
2026
2027 static const struct attribute_group *netiucv_drv_attr_groups[] = {
2028         &netiucv_drv_attr_group,
2029         NULL,
2030 };
2031
2032 static void netiucv_banner(void)
2033 {
2034         pr_info("driver initialized\n");
2035 }
2036
2037 static void __exit netiucv_exit(void)
2038 {
2039         struct iucv_connection *cp;
2040         struct net_device *ndev;
2041         struct netiucv_priv *priv;
2042         struct device *dev;
2043
2044         IUCV_DBF_TEXT(trace, 3, __func__);
2045         while (!list_empty(&iucv_connection_list)) {
2046                 cp = list_entry(iucv_connection_list.next,
2047                                 struct iucv_connection, list);
2048                 ndev = cp->netdev;
2049                 priv = netdev_priv(ndev);
2050                 dev = priv->dev;
2051
2052                 unregister_netdev(ndev);
2053                 netiucv_unregister_device(dev);
2054         }
2055
2056         driver_unregister(&netiucv_driver);
2057         iucv_unregister(&netiucv_handler, 1);
2058         iucv_unregister_dbf_views();
2059
2060         pr_info("driver unloaded\n");
2061         return;
2062 }
2063
2064 static int __init netiucv_init(void)
2065 {
2066         int rc;
2067
2068         rc = iucv_register_dbf_views();
2069         if (rc)
2070                 goto out;
2071         rc = iucv_register(&netiucv_handler, 1);
2072         if (rc)
2073                 goto out_dbf;
2074         IUCV_DBF_TEXT(trace, 3, __func__);
2075         netiucv_driver.groups = netiucv_drv_attr_groups;
2076         rc = driver_register(&netiucv_driver);
2077         if (rc) {
2078                 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2079                 goto out_iucv;
2080         }
2081
2082         netiucv_banner();
2083         return rc;
2084
2085 out_iucv:
2086         iucv_unregister(&netiucv_handler, 1);
2087 out_dbf:
2088         iucv_unregister_dbf_views();
2089 out:
2090         return rc;
2091 }
2092
2093 module_init(netiucv_init);
2094 module_exit(netiucv_exit);
2095 MODULE_LICENSE("GPL");