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