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