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