drivers/s390/net/netiucv.c

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