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 ([email protected], [email protected])
  10  *      Sysfs integration and all bugs therein:
  11  *              Cornelia Huck ([email protected])
  12  *      PM functions:
  13  *              Ursula Braun ([email protected])
  14  *
  15  * Documentation used:
  16  *  the source of the original IUCV driver by:
  17  *    Stefan Hegewald <[email protected]>
  18  *    Hartmut Penner <[email protected]>
  19  *    Denis Joseph Barrow ([email protected],[email protected])
  20  *    Martin Schwidefsky ([email protected])
  21  *    Alan Altmark ([email protected])  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 <asm/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 ([email protected])");
  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  * @param skb Pointer to buffer containing the packet.
1253  * @param dev Pointer to interface struct.
1254  *
1255  * @return 0 if packet consumed, !0 if packet rejected.
1256  *         Note: If we return !0, then the packet is free'd by
1257  *               the generic network layer.
1258  */
1259 static int netiucv_tx(struct sk_buff *skb, struct net_device *dev)
1260 {
1261         struct netiucv_priv *privptr = netdev_priv(dev);
1262         int rc;
1263
1264         IUCV_DBF_TEXT(trace, 4, __func__);
1265         /*
1266          * Some sanity checks ...
1267          */
1268         if (skb == NULL) {
1269                 IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
1270                 privptr->stats.tx_dropped++;
1271                 return NETDEV_TX_OK;
1272         }
1273         if (skb_headroom(skb) < NETIUCV_HDRLEN) {
1274                 IUCV_DBF_TEXT(data, 2,
1275                         "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1276                 dev_kfree_skb(skb);
1277                 privptr->stats.tx_dropped++;
1278                 return NETDEV_TX_OK;
1279         }
1280
1281         /*
1282          * If connection is not running, try to restart it
1283          * and throw away packet.
1284          */
1285         if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
1286                 dev_kfree_skb(skb);
1287                 privptr->stats.tx_dropped++;
1288                 privptr->stats.tx_errors++;
1289                 privptr->stats.tx_carrier_errors++;
1290                 return NETDEV_TX_OK;
1291         }
1292
1293         if (netiucv_test_and_set_busy(dev)) {
1294                 IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
1295                 return NETDEV_TX_BUSY;
1296         }
1297         netif_trans_update(dev);
1298         rc = netiucv_transmit_skb(privptr->conn, skb);
1299         netiucv_clear_busy(dev);
1300         return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
1301 }
1302
1303 /*
1304  * netiucv_stats
1305  * @dev: Pointer to interface struct.
1306  *
1307  * Returns interface statistics of a device.
1308  *
1309  * Returns pointer to stats struct of this interface.
1310  */
1311 static struct net_device_stats *netiucv_stats (struct net_device * dev)
1312 {
1313         struct netiucv_priv *priv = netdev_priv(dev);
1314
1315         IUCV_DBF_TEXT(trace, 5, __func__);
1316         return &priv->stats;
1317 }
1318
1319 /*
1320  * attributes in sysfs
1321  */
1322
1323 static ssize_t user_show(struct device *dev, struct device_attribute *attr,
1324                          char *buf)
1325 {
1326         struct netiucv_priv *priv = dev_get_drvdata(dev);
1327
1328         IUCV_DBF_TEXT(trace, 5, __func__);
1329         return sprintf(buf, "%s\n", netiucv_printuser(priv->conn));
1330 }
1331
1332 static int netiucv_check_user(const char *buf, size_t count, char *username,
1333                               char *userdata)
1334 {
1335         const char *p;
1336         int i;
1337
1338         p = strchr(buf, '.');
1339         if ((p && ((count > 26) ||
1340                    ((p - buf) > 8) ||
1341                    (buf + count - p > 18))) ||
1342             (!p && (count > 9))) {
1343                 IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
1344                 return -EINVAL;
1345         }
1346
1347         for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
1348                 if (isalnum(*p) || *p == '$') {
1349                         username[i] = toupper(*p);
1350                         continue;
1351                 }
1352                 if (*p == '\n')
1353                         /* trailing lf, grr */
1354                         break;
1355                 IUCV_DBF_TEXT_(setup, 2,
1356                                "conn_write: invalid character %02x\n", *p);
1357                 return -EINVAL;
1358         }
1359         while (i < 8)
1360                 username[i++] = ' ';
1361         username[8] = '\0';
1362
1363         if (*p == '.') {
1364                 p++;
1365                 for (i = 0; i < 16 && *p; i++, p++) {
1366                         if (*p == '\n')
1367                                 break;
1368                         userdata[i] = toupper(*p);
1369                 }
1370                 while (i > 0 && i < 16)
1371                         userdata[i++] = ' ';
1372         } else
1373                 memcpy(userdata, iucvMagic_ascii, 16);
1374         userdata[16] = '\0';
1375         ASCEBC(userdata, 16);
1376
1377         return 0;
1378 }
1379
1380 static ssize_t user_write(struct device *dev, struct device_attribute *attr,
1381                           const char *buf, size_t count)
1382 {
1383         struct netiucv_priv *priv = dev_get_drvdata(dev);
1384         struct net_device *ndev = priv->conn->netdev;
1385         char    username[9];
1386         char    userdata[17];
1387         int     rc;
1388         struct iucv_connection *cp;
1389
1390         IUCV_DBF_TEXT(trace, 3, __func__);
1391         rc = netiucv_check_user(buf, count, username, userdata);
1392         if (rc)
1393                 return rc;
1394
1395         if (memcmp(username, priv->conn->userid, 9) &&
1396             (ndev->flags & (IFF_UP | IFF_RUNNING))) {
1397                 /* username changed while the interface is active. */
1398                 IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
1399                 return -EPERM;
1400         }
1401         read_lock_bh(&iucv_connection_rwlock);
1402         list_for_each_entry(cp, &iucv_connection_list, list) {
1403                 if (!strncmp(username, cp->userid, 9) &&
1404                    !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
1405                         read_unlock_bh(&iucv_connection_rwlock);
1406                         IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
1407                                 "already exists\n", netiucv_printuser(cp));
1408                         return -EEXIST;
1409                 }
1410         }
1411         read_unlock_bh(&iucv_connection_rwlock);
1412         memcpy(priv->conn->userid, username, 9);
1413         memcpy(priv->conn->userdata, userdata, 17);
1414         return count;
1415 }
1416
1417 static DEVICE_ATTR(user, 0644, user_show, user_write);
1418
1419 static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
1420                             char *buf)
1421 {
1422         struct netiucv_priv *priv = dev_get_drvdata(dev);
1423
1424         IUCV_DBF_TEXT(trace, 5, __func__);
1425         return sprintf(buf, "%d\n", priv->conn->max_buffsize);
1426 }
1427
1428 static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
1429                              const char *buf, size_t count)
1430 {
1431         struct netiucv_priv *priv = dev_get_drvdata(dev);
1432         struct net_device *ndev = priv->conn->netdev;
1433         unsigned int bs1;
1434         int rc;
1435
1436         IUCV_DBF_TEXT(trace, 3, __func__);
1437         if (count >= 39)
1438                 return -EINVAL;
1439
1440         rc = kstrtouint(buf, 0, &bs1);
1441
1442         if (rc == -EINVAL) {
1443                 IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %s\n",
1444                         buf);
1445                 return -EINVAL;
1446         }
1447         if ((rc == -ERANGE) || (bs1 > NETIUCV_BUFSIZE_MAX)) {
1448                 IUCV_DBF_TEXT_(setup, 2,
1449                         "buffer_write: buffer size %d too large\n",
1450                         bs1);
1451                 return -EINVAL;
1452         }
1453         if ((ndev->flags & IFF_RUNNING) &&
1454             (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
1455                 IUCV_DBF_TEXT_(setup, 2,
1456                         "buffer_write: buffer size %d too small\n",
1457                         bs1);
1458                 return -EINVAL;
1459         }
1460         if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
1461                 IUCV_DBF_TEXT_(setup, 2,
1462                         "buffer_write: buffer size %d too small\n",
1463                         bs1);
1464                 return -EINVAL;
1465         }
1466
1467         priv->conn->max_buffsize = bs1;
1468         if (!(ndev->flags & IFF_RUNNING))
1469                 ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
1470
1471         return count;
1472
1473 }
1474
1475 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1476
1477 static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
1478                              char *buf)
1479 {
1480         struct netiucv_priv *priv = dev_get_drvdata(dev);
1481
1482         IUCV_DBF_TEXT(trace, 5, __func__);
1483         return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
1484 }
1485
1486 static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1487
1488 static ssize_t conn_fsm_show (struct device *dev,
1489                               struct device_attribute *attr, char *buf)
1490 {
1491         struct netiucv_priv *priv = dev_get_drvdata(dev);
1492
1493         IUCV_DBF_TEXT(trace, 5, __func__);
1494         return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
1495 }
1496
1497 static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1498
1499 static ssize_t maxmulti_show (struct device *dev,
1500                               struct device_attribute *attr, char *buf)
1501 {
1502         struct netiucv_priv *priv = dev_get_drvdata(dev);
1503
1504         IUCV_DBF_TEXT(trace, 5, __func__);
1505         return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
1506 }
1507
1508 static ssize_t maxmulti_write (struct device *dev,
1509                                struct device_attribute *attr,
1510                                const char *buf, size_t count)
1511 {
1512         struct netiucv_priv *priv = dev_get_drvdata(dev);
1513
1514         IUCV_DBF_TEXT(trace, 4, __func__);
1515         priv->conn->prof.maxmulti = 0;
1516         return count;
1517 }
1518
1519 static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1520
1521 static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
1522                            char *buf)
1523 {
1524         struct netiucv_priv *priv = dev_get_drvdata(dev);
1525
1526         IUCV_DBF_TEXT(trace, 5, __func__);
1527         return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
1528 }
1529
1530 static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
1531                             const char *buf, size_t count)
1532 {
1533         struct netiucv_priv *priv = dev_get_drvdata(dev);
1534
1535         IUCV_DBF_TEXT(trace, 4, __func__);
1536         priv->conn->prof.maxcqueue = 0;
1537         return count;
1538 }
1539
1540 static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1541
1542 static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
1543                            char *buf)
1544 {
1545         struct netiucv_priv *priv = dev_get_drvdata(dev);
1546
1547         IUCV_DBF_TEXT(trace, 5, __func__);
1548         return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
1549 }
1550
1551 static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
1552                             const char *buf, size_t count)
1553 {
1554         struct netiucv_priv *priv = dev_get_drvdata(dev);
1555
1556         IUCV_DBF_TEXT(trace, 4, __func__);
1557         priv->conn->prof.doios_single = 0;
1558         return count;
1559 }
1560
1561 static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1562
1563 static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
1564                            char *buf)
1565 {
1566         struct netiucv_priv *priv = dev_get_drvdata(dev);
1567
1568         IUCV_DBF_TEXT(trace, 5, __func__);
1569         return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
1570 }
1571
1572 static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
1573                             const char *buf, size_t count)
1574 {
1575         struct netiucv_priv *priv = dev_get_drvdata(dev);
1576
1577         IUCV_DBF_TEXT(trace, 5, __func__);
1578         priv->conn->prof.doios_multi = 0;
1579         return count;
1580 }
1581
1582 static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1583
1584 static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
1585                            char *buf)
1586 {
1587         struct netiucv_priv *priv = dev_get_drvdata(dev);
1588
1589         IUCV_DBF_TEXT(trace, 5, __func__);
1590         return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
1591 }
1592
1593 static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
1594                             const char *buf, size_t count)
1595 {
1596         struct netiucv_priv *priv = dev_get_drvdata(dev);
1597
1598         IUCV_DBF_TEXT(trace, 4, __func__);
1599         priv->conn->prof.txlen = 0;
1600         return count;
1601 }
1602
1603 static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1604
1605 static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
1606                             char *buf)
1607 {
1608         struct netiucv_priv *priv = dev_get_drvdata(dev);
1609
1610         IUCV_DBF_TEXT(trace, 5, __func__);
1611         return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
1612 }
1613
1614 static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
1615                              const char *buf, size_t count)
1616 {
1617         struct netiucv_priv *priv = dev_get_drvdata(dev);
1618
1619         IUCV_DBF_TEXT(trace, 4, __func__);
1620         priv->conn->prof.tx_time = 0;
1621         return count;
1622 }
1623
1624 static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1625
1626 static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
1627                             char *buf)
1628 {
1629         struct netiucv_priv *priv = dev_get_drvdata(dev);
1630
1631         IUCV_DBF_TEXT(trace, 5, __func__);
1632         return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
1633 }
1634
1635 static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
1636                              const char *buf, size_t count)
1637 {
1638         struct netiucv_priv *priv = dev_get_drvdata(dev);
1639
1640         IUCV_DBF_TEXT(trace, 4, __func__);
1641         priv->conn->prof.tx_pending = 0;
1642         return count;
1643 }
1644
1645 static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1646
1647 static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
1648                             char *buf)
1649 {
1650         struct netiucv_priv *priv = dev_get_drvdata(dev);
1651
1652         IUCV_DBF_TEXT(trace, 5, __func__);
1653         return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
1654 }
1655
1656 static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
1657                              const char *buf, size_t count)
1658 {
1659         struct netiucv_priv *priv = dev_get_drvdata(dev);
1660
1661         IUCV_DBF_TEXT(trace, 4, __func__);
1662         priv->conn->prof.tx_max_pending = 0;
1663         return count;
1664 }
1665
1666 static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1667
1668 static struct attribute *netiucv_attrs[] = {
1669         &dev_attr_buffer.attr,
1670         &dev_attr_user.attr,
1671         NULL,
1672 };
1673
1674 static struct attribute_group netiucv_attr_group = {
1675         .attrs = netiucv_attrs,
1676 };
1677
1678 static struct attribute *netiucv_stat_attrs[] = {
1679         &dev_attr_device_fsm_state.attr,
1680         &dev_attr_connection_fsm_state.attr,
1681         &dev_attr_max_tx_buffer_used.attr,
1682         &dev_attr_max_chained_skbs.attr,
1683         &dev_attr_tx_single_write_ops.attr,
1684         &dev_attr_tx_multi_write_ops.attr,
1685         &dev_attr_netto_bytes.attr,
1686         &dev_attr_max_tx_io_time.attr,
1687         &dev_attr_tx_pending.attr,
1688         &dev_attr_tx_max_pending.attr,
1689         NULL,
1690 };
1691
1692 static struct attribute_group netiucv_stat_attr_group = {
1693         .name  = "stats",
1694         .attrs = netiucv_stat_attrs,
1695 };
1696
1697 static const struct attribute_group *netiucv_attr_groups[] = {
1698         &netiucv_stat_attr_group,
1699         &netiucv_attr_group,
1700         NULL,
1701 };
1702
1703 static int netiucv_register_device(struct net_device *ndev)
1704 {
1705         struct netiucv_priv *priv = netdev_priv(ndev);
1706         struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1707         int ret;
1708
1709         IUCV_DBF_TEXT(trace, 3, __func__);
1710
1711         if (dev) {
1712                 dev_set_name(dev, "net%s", ndev->name);
1713                 dev->bus = &iucv_bus;
1714                 dev->parent = iucv_root;
1715                 dev->groups = netiucv_attr_groups;
1716                 /*
1717                  * The release function could be called after the
1718                  * module has been unloaded. It's _only_ task is to
1719                  * free the struct. Therefore, we specify kfree()
1720                  * directly here. (Probably a little bit obfuscating
1721                  * but legitime ...).
1722                  */
1723                 dev->release = (void (*)(struct device *))kfree;
1724                 dev->driver = &netiucv_driver;
1725         } else
1726                 return -ENOMEM;
1727
1728         ret = device_register(dev);
1729         if (ret) {
1730                 put_device(dev);
1731                 return ret;
1732         }
1733         priv->dev = dev;
1734         dev_set_drvdata(dev, priv);
1735         return 0;
1736 }
1737
1738 static void netiucv_unregister_device(struct device *dev)
1739 {
1740         IUCV_DBF_TEXT(trace, 3, __func__);
1741         device_unregister(dev);
1742 }
1743
1744 /*
1745  * Allocate and initialize a new connection structure.
1746  * Add it to the list of netiucv connections;
1747  */
1748 static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
1749                                                       char *username,
1750                                                       char *userdata)
1751 {
1752         struct iucv_connection *conn;
1753
1754         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1755         if (!conn)
1756                 goto out;
1757         skb_queue_head_init(&conn->collect_queue);
1758         skb_queue_head_init(&conn->commit_queue);
1759         spin_lock_init(&conn->collect_lock);
1760         conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1761         conn->netdev = dev;
1762
1763         conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1764         if (!conn->rx_buff)
1765                 goto out_conn;
1766         conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1767         if (!conn->tx_buff)
1768                 goto out_rx;
1769         conn->fsm = init_fsm("netiucvconn", conn_state_names,
1770                              conn_event_names, NR_CONN_STATES,
1771                              NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1772                              GFP_KERNEL);
1773         if (!conn->fsm)
1774                 goto out_tx;
1775
1776         fsm_settimer(conn->fsm, &conn->timer);
1777         fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1778
1779         if (userdata)
1780                 memcpy(conn->userdata, userdata, 17);
1781         if (username) {
1782                 memcpy(conn->userid, username, 9);
1783                 fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1784         }
1785
1786         write_lock_bh(&iucv_connection_rwlock);
1787         list_add_tail(&conn->list, &iucv_connection_list);
1788         write_unlock_bh(&iucv_connection_rwlock);
1789         return conn;
1790
1791 out_tx:
1792         kfree_skb(conn->tx_buff);
1793 out_rx:
1794         kfree_skb(conn->rx_buff);
1795 out_conn:
1796         kfree(conn);
1797 out:
1798         return NULL;
1799 }
1800
1801 /*
1802  * Release a connection structure and remove it from the
1803  * list of netiucv connections.
1804  */
1805 static void netiucv_remove_connection(struct iucv_connection *conn)
1806 {
1807
1808         IUCV_DBF_TEXT(trace, 3, __func__);
1809         write_lock_bh(&iucv_connection_rwlock);
1810         list_del_init(&conn->list);
1811         write_unlock_bh(&iucv_connection_rwlock);
1812         fsm_deltimer(&conn->timer);
1813         netiucv_purge_skb_queue(&conn->collect_queue);
1814         if (conn->path) {
1815                 iucv_path_sever(conn->path, conn->userdata);
1816                 kfree(conn->path);
1817                 conn->path = NULL;
1818         }
1819         netiucv_purge_skb_queue(&conn->commit_queue);
1820         kfree_fsm(conn->fsm);
1821         kfree_skb(conn->rx_buff);
1822         kfree_skb(conn->tx_buff);
1823 }
1824
1825 /*
1826  * Release everything of a net device.
1827  */
1828 static void netiucv_free_netdevice(struct net_device *dev)
1829 {
1830         struct netiucv_priv *privptr = netdev_priv(dev);
1831
1832         IUCV_DBF_TEXT(trace, 3, __func__);
1833
1834         if (!dev)
1835                 return;
1836
1837         if (privptr) {
1838                 if (privptr->conn)
1839                         netiucv_remove_connection(privptr->conn);
1840                 if (privptr->fsm)
1841                         kfree_fsm(privptr->fsm);
1842                 privptr->conn = NULL; privptr->fsm = NULL;
1843                 /* privptr gets freed by free_netdev() */
1844         }
1845 }
1846
1847 /*
1848  * Initialize a net device. (Called from kernel in alloc_netdev())
1849  */
1850 static const struct net_device_ops netiucv_netdev_ops = {
1851         .ndo_open               = netiucv_open,
1852         .ndo_stop               = netiucv_close,
1853         .ndo_get_stats          = netiucv_stats,
1854         .ndo_start_xmit         = netiucv_tx,
1855 };
1856
1857 static void netiucv_setup_netdevice(struct net_device *dev)
1858 {
1859         dev->mtu                 = NETIUCV_MTU_DEFAULT;
1860         dev->min_mtu             = 576;
1861         dev->max_mtu             = NETIUCV_MTU_MAX;
1862         dev->needs_free_netdev   = true;
1863         dev->priv_destructor     = netiucv_free_netdevice;
1864         dev->hard_header_len     = NETIUCV_HDRLEN;
1865         dev->addr_len            = 0;
1866         dev->type                = ARPHRD_SLIP;
1867         dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
1868         dev->flags               = IFF_POINTOPOINT | IFF_NOARP;
1869         dev->netdev_ops          = &netiucv_netdev_ops;
1870 }
1871
1872 /*
1873  * Allocate and initialize everything of a net device.
1874  */
1875 static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
1876 {
1877         struct netiucv_priv *privptr;
1878         struct net_device *dev;
1879
1880         dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
1881                            NET_NAME_UNKNOWN, netiucv_setup_netdevice);
1882         if (!dev)
1883                 return NULL;
1884         rtnl_lock();
1885         if (dev_alloc_name(dev, dev->name) < 0)
1886                 goto out_netdev;
1887
1888         privptr = netdev_priv(dev);
1889         privptr->fsm = init_fsm("netiucvdev", dev_state_names,
1890                                 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
1891                                 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
1892         if (!privptr->fsm)
1893                 goto out_netdev;
1894
1895         privptr->conn = netiucv_new_connection(dev, username, userdata);
1896         if (!privptr->conn) {
1897                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
1898                 goto out_fsm;
1899         }
1900         fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
1901         return dev;
1902
1903 out_fsm:
1904         kfree_fsm(privptr->fsm);
1905 out_netdev:
1906         rtnl_unlock();
1907         free_netdev(dev);
1908         return NULL;
1909 }
1910
1911 static ssize_t connection_store(struct device_driver *drv, const char *buf,
1912                                 size_t count)
1913 {
1914         char username[9];
1915         char userdata[17];
1916         int rc;
1917         struct net_device *dev;
1918         struct netiucv_priv *priv;
1919         struct iucv_connection *cp;
1920
1921         IUCV_DBF_TEXT(trace, 3, __func__);
1922         rc = netiucv_check_user(buf, count, username, userdata);
1923         if (rc)
1924                 return rc;
1925
1926         read_lock_bh(&iucv_connection_rwlock);
1927         list_for_each_entry(cp, &iucv_connection_list, list) {
1928                 if (!strncmp(username, cp->userid, 9) &&
1929                     !strncmp(userdata, cp->userdata, 17)) {
1930                         read_unlock_bh(&iucv_connection_rwlock);
1931                         IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
1932                                 "already exists\n", netiucv_printuser(cp));
1933                         return -EEXIST;
1934                 }
1935         }
1936         read_unlock_bh(&iucv_connection_rwlock);
1937
1938         dev = netiucv_init_netdevice(username, userdata);
1939         if (!dev) {
1940                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
1941                 return -ENODEV;
1942         }
1943
1944         rc = netiucv_register_device(dev);
1945         if (rc) {
1946                 rtnl_unlock();
1947                 IUCV_DBF_TEXT_(setup, 2,
1948                         "ret %d from netiucv_register_device\n", rc);
1949                 goto out_free_ndev;
1950         }
1951
1952         /* sysfs magic */
1953         priv = netdev_priv(dev);
1954         SET_NETDEV_DEV(dev, priv->dev);
1955
1956         rc = register_netdevice(dev);
1957         rtnl_unlock();
1958         if (rc)
1959                 goto out_unreg;
1960
1961         dev_info(priv->dev, "The IUCV interface to %s has been established "
1962                             "successfully\n",
1963                 netiucv_printuser(priv->conn));
1964
1965         return count;
1966
1967 out_unreg:
1968         netiucv_unregister_device(priv->dev);
1969 out_free_ndev:
1970         netiucv_free_netdevice(dev);
1971         return rc;
1972 }
1973 static DRIVER_ATTR_WO(connection);
1974
1975 static ssize_t remove_store(struct device_driver *drv, const char *buf,
1976                             size_t count)
1977 {
1978         struct iucv_connection *cp;
1979         struct net_device *ndev;
1980         struct netiucv_priv *priv;
1981         struct device *dev;
1982         char name[IFNAMSIZ];
1983         const char *p;
1984         int i;
1985
1986         IUCV_DBF_TEXT(trace, 3, __func__);
1987
1988         if (count >= IFNAMSIZ)
1989                 count = IFNAMSIZ - 1;
1990
1991         for (i = 0, p = buf; i < count && *p; i++, p++) {
1992                 if (*p == '\n' || *p == ' ')
1993                         /* trailing lf, grr */
1994                         break;
1995                 name[i] = *p;
1996         }
1997         name[i] = '\0';
1998
1999         read_lock_bh(&iucv_connection_rwlock);
2000         list_for_each_entry(cp, &iucv_connection_list, list) {
2001                 ndev = cp->netdev;
2002                 priv = netdev_priv(ndev);
2003                 dev = priv->dev;
2004                 if (strncmp(name, ndev->name, count))
2005                         continue;
2006                 read_unlock_bh(&iucv_connection_rwlock);
2007                 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2008                         dev_warn(dev, "The IUCV device is connected"
2009                                 " to %s and cannot be removed\n",
2010                                 priv->conn->userid);
2011                         IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2012                         return -EPERM;
2013                 }
2014                 unregister_netdev(ndev);
2015                 netiucv_unregister_device(dev);
2016                 return count;
2017         }
2018         read_unlock_bh(&iucv_connection_rwlock);
2019         IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2020         return -EINVAL;
2021 }
2022 static DRIVER_ATTR_WO(remove);
2023
2024 static struct attribute * netiucv_drv_attrs[] = {
2025         &driver_attr_connection.attr,
2026         &driver_attr_remove.attr,
2027         NULL,
2028 };
2029
2030 static struct attribute_group netiucv_drv_attr_group = {
2031         .attrs = netiucv_drv_attrs,
2032 };
2033
2034 static const struct attribute_group *netiucv_drv_attr_groups[] = {
2035         &netiucv_drv_attr_group,
2036         NULL,
2037 };
2038
2039 static void netiucv_banner(void)
2040 {
2041         pr_info("driver initialized\n");
2042 }
2043
2044 static void __exit netiucv_exit(void)
2045 {
2046         struct iucv_connection *cp;
2047         struct net_device *ndev;
2048         struct netiucv_priv *priv;
2049         struct device *dev;
2050
2051         IUCV_DBF_TEXT(trace, 3, __func__);
2052         while (!list_empty(&iucv_connection_list)) {
2053                 cp = list_entry(iucv_connection_list.next,
2054                                 struct iucv_connection, list);
2055                 ndev = cp->netdev;
2056                 priv = netdev_priv(ndev);
2057                 dev = priv->dev;
2058
2059                 unregister_netdev(ndev);
2060                 netiucv_unregister_device(dev);
2061         }
2062
2063         driver_unregister(&netiucv_driver);
2064         iucv_unregister(&netiucv_handler, 1);
2065         iucv_unregister_dbf_views();
2066
2067         pr_info("driver unloaded\n");
2068         return;
2069 }
2070
2071 static int __init netiucv_init(void)
2072 {
2073         int rc;
2074
2075         rc = iucv_register_dbf_views();
2076         if (rc)
2077                 goto out;
2078         rc = iucv_register(&netiucv_handler, 1);
2079         if (rc)
2080                 goto out_dbf;
2081         IUCV_DBF_TEXT(trace, 3, __func__);
2082         netiucv_driver.groups = netiucv_drv_attr_groups;
2083         rc = driver_register(&netiucv_driver);
2084         if (rc) {
2085                 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2086                 goto out_iucv;
2087         }
2088
2089         netiucv_banner();
2090         return rc;
2091
2092 out_iucv:
2093         iucv_unregister(&netiucv_handler, 1);
2094 out_dbf:
2095         iucv_unregister_dbf_views();
2096 out:
2097         return rc;
2098 }
2099
2100 module_init(netiucv_init);
2101 module_exit(netiucv_exit);
2102 MODULE_LICENSE("GPL");