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 inline 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 inline 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                         atomic_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                 memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
 763                        NETIUCV_HDRLEN);
 764                 skb_copy_from_linear_data(skb,
 765                                           skb_put(conn->tx_buff, skb->len),
 766                                           skb->len);
 767                 txbytes += skb->len;
 768                 txpackets++;
 769                 stat_maxcq++;
 770                 atomic_dec(&skb->users);
 771                 dev_kfree_skb_any(skb);
 772         }
 773         if (conn->collect_len > conn->prof.maxmulti)
 774                 conn->prof.maxmulti = conn->collect_len;
 775         conn->collect_len = 0;
 776         spin_unlock_irqrestore(&conn->collect_lock, saveflags);
 777         if (conn->tx_buff->len == 0) {
 778                 fsm_newstate(fi, CONN_STATE_IDLE);
 779                 return;
 780         }
 781
 782         header.next = 0;
 783         memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
 784         conn->prof.send_stamp = jiffies;
 785         txmsg.class = 0;
 786         txmsg.tag = 0;
 787         rc = iucv_message_send(conn->path, &txmsg, 0, 0,
 788                                conn->tx_buff->data, conn->tx_buff->len);
 789         conn->prof.doios_multi++;
 790         conn->prof.txlen += conn->tx_buff->len;
 791         conn->prof.tx_pending++;
 792         if (conn->prof.tx_pending > conn->prof.tx_max_pending)
 793                 conn->prof.tx_max_pending = conn->prof.tx_pending;
 794         if (rc) {
 795                 conn->prof.tx_pending--;
 796                 fsm_newstate(fi, CONN_STATE_IDLE);
 797                 if (privptr)
 798                         privptr->stats.tx_errors += txpackets;
 799                 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
 800         } else {
 801                 if (privptr) {
 802                         privptr->stats.tx_packets += txpackets;
 803                         privptr->stats.tx_bytes += txbytes;
 804                 }
 805                 if (stat_maxcq > conn->prof.maxcqueue)
 806                         conn->prof.maxcqueue = stat_maxcq;
 807         }
 808 }
 809
 810 static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
 811 {
 812         struct iucv_event *ev = arg;
 813         struct iucv_connection *conn = ev->conn;
 814         struct iucv_path *path = ev->data;
 815         struct net_device *netdev = conn->netdev;
 816         struct netiucv_priv *privptr = netdev_priv(netdev);
 817         int rc;
 818
 819         IUCV_DBF_TEXT(trace, 3, __func__);
 820
 821         conn->path = path;
 822         path->msglim = NETIUCV_QUEUELEN_DEFAULT;
 823         path->flags = 0;
 824         rc = iucv_path_accept(path, &netiucv_handler, conn->userdata , conn);
 825         if (rc) {
 826                 IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
 827                 return;
 828         }
 829         fsm_newstate(fi, CONN_STATE_IDLE);
 830         netdev->tx_queue_len = conn->path->msglim;
 831         fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 832 }
 833
 834 static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
 835 {
 836         struct iucv_event *ev = arg;
 837         struct iucv_path *path = ev->data;
 838
 839         IUCV_DBF_TEXT(trace, 3, __func__);
 840         iucv_path_sever(path, NULL);
 841 }
 842
 843 static void conn_action_connack(fsm_instance *fi, int event, void *arg)
 844 {
 845         struct iucv_connection *conn = arg;
 846         struct net_device *netdev = conn->netdev;
 847         struct netiucv_priv *privptr = netdev_priv(netdev);
 848
 849         IUCV_DBF_TEXT(trace, 3, __func__);
 850         fsm_deltimer(&conn->timer);
 851         fsm_newstate(fi, CONN_STATE_IDLE);
 852         netdev->tx_queue_len = conn->path->msglim;
 853         fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 854 }
 855
 856 static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
 857 {
 858         struct iucv_connection *conn = arg;
 859
 860         IUCV_DBF_TEXT(trace, 3, __func__);
 861         fsm_deltimer(&conn->timer);
 862         iucv_path_sever(conn->path, conn->userdata);
 863         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 864 }
 865
 866 static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
 867 {
 868         struct iucv_connection *conn = arg;
 869         struct net_device *netdev = conn->netdev;
 870         struct netiucv_priv *privptr = netdev_priv(netdev);
 871
 872         IUCV_DBF_TEXT(trace, 3, __func__);
 873
 874         fsm_deltimer(&conn->timer);
 875         iucv_path_sever(conn->path, conn->userdata);
 876         dev_info(privptr->dev, "The peer z/VM guest %s has closed the "
 877                                "connection\n", netiucv_printuser(conn));
 878         IUCV_DBF_TEXT(data, 2,
 879                       "conn_action_connsever: Remote dropped connection\n");
 880         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 881         fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 882 }
 883
 884 static void conn_action_start(fsm_instance *fi, int event, void *arg)
 885 {
 886         struct iucv_connection *conn = arg;
 887         struct net_device *netdev = conn->netdev;
 888         struct netiucv_priv *privptr = netdev_priv(netdev);
 889         int rc;
 890
 891         IUCV_DBF_TEXT(trace, 3, __func__);
 892
 893         fsm_newstate(fi, CONN_STATE_STARTWAIT);
 894
 895         /*
 896          * We must set the state before calling iucv_connect because the
 897          * callback handler could be called at any point after the connection
 898          * request is sent
 899          */
 900
 901         fsm_newstate(fi, CONN_STATE_SETUPWAIT);
 902         conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
 903         IUCV_DBF_TEXT_(setup, 2, "%s: connecting to %s ...\n",
 904                 netdev->name, netiucv_printuser(conn));
 905
 906         rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
 907                                NULL, conn->userdata, conn);
 908         switch (rc) {
 909         case 0:
 910                 netdev->tx_queue_len = conn->path->msglim;
 911                 fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
 912                              CONN_EVENT_TIMER, conn);
 913                 return;
 914         case 11:
 915                 dev_warn(privptr->dev,
 916                         "The IUCV device failed to connect to z/VM guest %s\n",
 917                         netiucv_printname(conn->userid, 8));
 918                 fsm_newstate(fi, CONN_STATE_STARTWAIT);
 919                 break;
 920         case 12:
 921                 dev_warn(privptr->dev,
 922                         "The IUCV device failed to connect to the peer on z/VM"
 923                         " guest %s\n", netiucv_printname(conn->userid, 8));
 924                 fsm_newstate(fi, CONN_STATE_STARTWAIT);
 925                 break;
 926         case 13:
 927                 dev_err(privptr->dev,
 928                         "Connecting the IUCV device would exceed the maximum"
 929                         " number of IUCV connections\n");
 930                 fsm_newstate(fi, CONN_STATE_CONNERR);
 931                 break;
 932         case 14:
 933                 dev_err(privptr->dev,
 934                         "z/VM guest %s has too many IUCV connections"
 935                         " to connect with the IUCV device\n",
 936                         netiucv_printname(conn->userid, 8));
 937                 fsm_newstate(fi, CONN_STATE_CONNERR);
 938                 break;
 939         case 15:
 940                 dev_err(privptr->dev,
 941                         "The IUCV device cannot connect to a z/VM guest with no"
 942                         " IUCV authorization\n");
 943                 fsm_newstate(fi, CONN_STATE_CONNERR);
 944                 break;
 945         default:
 946                 dev_err(privptr->dev,
 947                         "Connecting the IUCV device failed with error %d\n",
 948                         rc);
 949                 fsm_newstate(fi, CONN_STATE_CONNERR);
 950                 break;
 951         }
 952         IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
 953         kfree(conn->path);
 954         conn->path = NULL;
 955 }
 956
 957 static void netiucv_purge_skb_queue(struct sk_buff_head *q)
 958 {
 959         struct sk_buff *skb;
 960
 961         while ((skb = skb_dequeue(q))) {
 962                 atomic_dec(&skb->users);
 963                 dev_kfree_skb_any(skb);
 964         }
 965 }
 966
 967 static void conn_action_stop(fsm_instance *fi, int event, void *arg)
 968 {
 969         struct iucv_event *ev = arg;
 970         struct iucv_connection *conn = ev->conn;
 971         struct net_device *netdev = conn->netdev;
 972         struct netiucv_priv *privptr = netdev_priv(netdev);
 973
 974         IUCV_DBF_TEXT(trace, 3, __func__);
 975
 976         fsm_deltimer(&conn->timer);
 977         fsm_newstate(fi, CONN_STATE_STOPPED);
 978         netiucv_purge_skb_queue(&conn->collect_queue);
 979         if (conn->path) {
 980                 IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
 981                 iucv_path_sever(conn->path, conn->userdata);
 982                 kfree(conn->path);
 983                 conn->path = NULL;
 984         }
 985         netiucv_purge_skb_queue(&conn->commit_queue);
 986         fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 987 }
 988
 989 static void conn_action_inval(fsm_instance *fi, int event, void *arg)
 990 {
 991         struct iucv_connection *conn = arg;
 992         struct net_device *netdev = conn->netdev;
 993
 994         IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
 995                 netdev->name, conn->userid);
 996 }
 997
 998 static const fsm_node conn_fsm[] = {
 999         { CONN_STATE_INVALID,   CONN_EVENT_START,    conn_action_inval      },
1000         { CONN_STATE_STOPPED,   CONN_EVENT_START,    conn_action_start      },
1001
1002         { CONN_STATE_STOPPED,   CONN_EVENT_STOP,     conn_action_stop       },
1003         { CONN_STATE_STARTWAIT, CONN_EVENT_STOP,     conn_action_stop       },
1004         { CONN_STATE_SETUPWAIT, CONN_EVENT_STOP,     conn_action_stop       },
1005         { CONN_STATE_IDLE,      CONN_EVENT_STOP,     conn_action_stop       },
1006         { CONN_STATE_TX,        CONN_EVENT_STOP,     conn_action_stop       },
1007         { CONN_STATE_REGERR,    CONN_EVENT_STOP,     conn_action_stop       },
1008         { CONN_STATE_CONNERR,   CONN_EVENT_STOP,     conn_action_stop       },
1009
1010         { CONN_STATE_STOPPED,   CONN_EVENT_CONN_REQ, conn_action_connreject },
1011         { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1012         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1013         { CONN_STATE_IDLE,      CONN_EVENT_CONN_REQ, conn_action_connreject },
1014         { CONN_STATE_TX,        CONN_EVENT_CONN_REQ, conn_action_connreject },
1015
1016         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack    },
1017         { CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER,    conn_action_conntimsev },
1018
1019         { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever  },
1020         { CONN_STATE_IDLE,      CONN_EVENT_CONN_REJ, conn_action_connsever  },
1021         { CONN_STATE_TX,        CONN_EVENT_CONN_REJ, conn_action_connsever  },
1022
1023         { CONN_STATE_IDLE,      CONN_EVENT_RX,       conn_action_rx         },
1024         { CONN_STATE_TX,        CONN_EVENT_RX,       conn_action_rx         },
1025
1026         { CONN_STATE_TX,        CONN_EVENT_TXDONE,   conn_action_txdone     },
1027         { CONN_STATE_IDLE,      CONN_EVENT_TXDONE,   conn_action_txdone     },
1028 };
1029
1030 static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
1031
1032
1033 /*
1034  * Actions for interface - statemachine.
1035  */
1036
1037 /**
1038  * dev_action_start
1039  * @fi: An instance of an interface statemachine.
1040  * @event: The event, just happened.
1041  * @arg: Generic pointer, casted from struct net_device * upon call.
1042  *
1043  * Startup connection by sending CONN_EVENT_START to it.
1044  */
1045 static void dev_action_start(fsm_instance *fi, int event, void *arg)
1046 {
1047         struct net_device   *dev = arg;
1048         struct netiucv_priv *privptr = netdev_priv(dev);
1049
1050         IUCV_DBF_TEXT(trace, 3, __func__);
1051
1052         fsm_newstate(fi, DEV_STATE_STARTWAIT);
1053         fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
1054 }
1055
1056 /**
1057  * Shutdown connection by sending CONN_EVENT_STOP to it.
1058  *
1059  * @param fi    An instance of an interface statemachine.
1060  * @param event The event, just happened.
1061  * @param arg   Generic pointer, casted from struct net_device * upon call.
1062  */
1063 static void
1064 dev_action_stop(fsm_instance *fi, int event, void *arg)
1065 {
1066         struct net_device   *dev = arg;
1067         struct netiucv_priv *privptr = netdev_priv(dev);
1068         struct iucv_event   ev;
1069
1070         IUCV_DBF_TEXT(trace, 3, __func__);
1071
1072         ev.conn = privptr->conn;
1073
1074         fsm_newstate(fi, DEV_STATE_STOPWAIT);
1075         fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
1076 }
1077
1078 /**
1079  * Called from connection statemachine
1080  * when a connection is up and running.
1081  *
1082  * @param fi    An instance of an interface statemachine.
1083  * @param event The event, just happened.
1084  * @param arg   Generic pointer, casted from struct net_device * upon call.
1085  */
1086 static void
1087 dev_action_connup(fsm_instance *fi, int event, void *arg)
1088 {
1089         struct net_device   *dev = arg;
1090         struct netiucv_priv *privptr = netdev_priv(dev);
1091
1092         IUCV_DBF_TEXT(trace, 3, __func__);
1093
1094         switch (fsm_getstate(fi)) {
1095                 case DEV_STATE_STARTWAIT:
1096                         fsm_newstate(fi, DEV_STATE_RUNNING);
1097                         dev_info(privptr->dev,
1098                                 "The IUCV device has been connected"
1099                                 " successfully to %s\n",
1100                                 netiucv_printuser(privptr->conn));
1101                         IUCV_DBF_TEXT(setup, 3,
1102                                 "connection is up and running\n");
1103                         break;
1104                 case DEV_STATE_STOPWAIT:
1105                         IUCV_DBF_TEXT(data, 2,
1106                                 "dev_action_connup: in DEV_STATE_STOPWAIT\n");
1107                         break;
1108         }
1109 }
1110
1111 /**
1112  * Called from connection statemachine
1113  * when a connection has been shutdown.
1114  *
1115  * @param fi    An instance of an interface statemachine.
1116  * @param event The event, just happened.
1117  * @param arg   Generic pointer, casted from struct net_device * upon call.
1118  */
1119 static void
1120 dev_action_conndown(fsm_instance *fi, int event, void *arg)
1121 {
1122         IUCV_DBF_TEXT(trace, 3, __func__);
1123
1124         switch (fsm_getstate(fi)) {
1125                 case DEV_STATE_RUNNING:
1126                         fsm_newstate(fi, DEV_STATE_STARTWAIT);
1127                         break;
1128                 case DEV_STATE_STOPWAIT:
1129                         fsm_newstate(fi, DEV_STATE_STOPPED);
1130                         IUCV_DBF_TEXT(setup, 3, "connection is down\n");
1131                         break;
1132         }
1133 }
1134
1135 static const fsm_node dev_fsm[] = {
1136         { DEV_STATE_STOPPED,    DEV_EVENT_START,   dev_action_start    },
1137
1138         { DEV_STATE_STOPWAIT,   DEV_EVENT_START,   dev_action_start    },
1139         { DEV_STATE_STOPWAIT,   DEV_EVENT_CONDOWN, dev_action_conndown },
1140
1141         { DEV_STATE_STARTWAIT,  DEV_EVENT_STOP,    dev_action_stop     },
1142         { DEV_STATE_STARTWAIT,  DEV_EVENT_CONUP,   dev_action_connup   },
1143
1144         { DEV_STATE_RUNNING,    DEV_EVENT_STOP,    dev_action_stop     },
1145         { DEV_STATE_RUNNING,    DEV_EVENT_CONDOWN, dev_action_conndown },
1146         { DEV_STATE_RUNNING,    DEV_EVENT_CONUP,   netiucv_action_nop  },
1147 };
1148
1149 static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
1150
1151 /**
1152  * Transmit a packet.
1153  * This is a helper function for netiucv_tx().
1154  *
1155  * @param conn Connection to be used for sending.
1156  * @param skb Pointer to struct sk_buff of packet to send.
1157  *            The linklevel header has already been set up
1158  *            by netiucv_tx().
1159  *
1160  * @return 0 on success, -ERRNO on failure. (Never fails.)
1161  */
1162 static int netiucv_transmit_skb(struct iucv_connection *conn,
1163                                 struct sk_buff *skb)
1164 {
1165         struct iucv_message msg;
1166         unsigned long saveflags;
1167         struct ll_header header;
1168         int rc;
1169
1170         if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
1171                 int l = skb->len + NETIUCV_HDRLEN;
1172
1173                 spin_lock_irqsave(&conn->collect_lock, saveflags);
1174                 if (conn->collect_len + l >
1175                     (conn->max_buffsize - NETIUCV_HDRLEN)) {
1176                         rc = -EBUSY;
1177                         IUCV_DBF_TEXT(data, 2,
1178                                       "EBUSY from netiucv_transmit_skb\n");
1179                 } else {
1180                         atomic_inc(&skb->users);
1181                         skb_queue_tail(&conn->collect_queue, skb);
1182                         conn->collect_len += l;
1183                         rc = 0;
1184                 }
1185                 spin_unlock_irqrestore(&conn->collect_lock, saveflags);
1186         } else {
1187                 struct sk_buff *nskb = skb;
1188                 /**
1189                  * Copy the skb to a new allocated skb in lowmem only if the
1190                  * data is located above 2G in memory or tailroom is < 2.
1191                  */
1192                 unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
1193                                     NETIUCV_HDRLEN)) >> 31;
1194                 int copied = 0;
1195                 if (hi || (skb_tailroom(skb) < 2)) {
1196                         nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
1197                                          NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
1198                         if (!nskb) {
1199                                 IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
1200                                 rc = -ENOMEM;
1201                                 return rc;
1202                         } else {
1203                                 skb_reserve(nskb, NETIUCV_HDRLEN);
1204                                 memcpy(skb_put(nskb, skb->len),
1205                                        skb->data, skb->len);
1206                         }
1207                         copied = 1;
1208                 }
1209                 /**
1210                  * skb now is below 2G and has enough room. Add headers.
1211                  */
1212                 header.next = nskb->len + NETIUCV_HDRLEN;
1213                 memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
1214                 header.next = 0;
1215                 memcpy(skb_put(nskb, NETIUCV_HDRLEN), &header,  NETIUCV_HDRLEN);
1216
1217                 fsm_newstate(conn->fsm, CONN_STATE_TX);
1218                 conn->prof.send_stamp = jiffies;
1219
1220                 msg.tag = 1;
1221                 msg.class = 0;
1222                 rc = iucv_message_send(conn->path, &msg, 0, 0,
1223                                        nskb->data, nskb->len);
1224                 conn->prof.doios_single++;
1225                 conn->prof.txlen += skb->len;
1226                 conn->prof.tx_pending++;
1227                 if (conn->prof.tx_pending > conn->prof.tx_max_pending)
1228                         conn->prof.tx_max_pending = conn->prof.tx_pending;
1229                 if (rc) {
1230                         struct netiucv_priv *privptr;
1231                         fsm_newstate(conn->fsm, CONN_STATE_IDLE);
1232                         conn->prof.tx_pending--;
1233                         privptr = netdev_priv(conn->netdev);
1234                         if (privptr)
1235                                 privptr->stats.tx_errors++;
1236                         if (copied)
1237                                 dev_kfree_skb(nskb);
1238                         else {
1239                                 /**
1240                                  * Remove our headers. They get added
1241                                  * again on retransmit.
1242                                  */
1243                                 skb_pull(skb, NETIUCV_HDRLEN);
1244                                 skb_trim(skb, skb->len - NETIUCV_HDRLEN);
1245                         }
1246                         IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
1247                 } else {
1248                         if (copied)
1249                                 dev_kfree_skb(skb);
1250                         atomic_inc(&nskb->users);
1251                         skb_queue_tail(&conn->commit_queue, nskb);
1252                 }
1253         }
1254
1255         return rc;
1256 }
1257
1258 /*
1259  * Interface API for upper network layers
1260  */
1261
1262 /**
1263  * Open an interface.
1264  * Called from generic network layer when ifconfig up is run.
1265  *
1266  * @param dev Pointer to interface struct.
1267  *
1268  * @return 0 on success, -ERRNO on failure. (Never fails.)
1269  */
1270 static int netiucv_open(struct net_device *dev)
1271 {
1272         struct netiucv_priv *priv = netdev_priv(dev);
1273
1274         fsm_event(priv->fsm, DEV_EVENT_START, dev);
1275         return 0;
1276 }
1277
1278 /**
1279  * Close an interface.
1280  * Called from generic network layer when ifconfig down is run.
1281  *
1282  * @param dev Pointer to interface struct.
1283  *
1284  * @return 0 on success, -ERRNO on failure. (Never fails.)
1285  */
1286 static int netiucv_close(struct net_device *dev)
1287 {
1288         struct netiucv_priv *priv = netdev_priv(dev);
1289
1290         fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
1291         return 0;
1292 }
1293
1294 static int netiucv_pm_prepare(struct device *dev)
1295 {
1296         IUCV_DBF_TEXT(trace, 3, __func__);
1297         return 0;
1298 }
1299
1300 static void netiucv_pm_complete(struct device *dev)
1301 {
1302         IUCV_DBF_TEXT(trace, 3, __func__);
1303         return;
1304 }
1305
1306 /**
1307  * netiucv_pm_freeze() - Freeze PM callback
1308  * @dev:        netiucv device
1309  *
1310  * close open netiucv interfaces
1311  */
1312 static int netiucv_pm_freeze(struct device *dev)
1313 {
1314         struct netiucv_priv *priv = dev_get_drvdata(dev);
1315         struct net_device *ndev = NULL;
1316         int rc = 0;
1317
1318         IUCV_DBF_TEXT(trace, 3, __func__);
1319         if (priv && priv->conn)
1320                 ndev = priv->conn->netdev;
1321         if (!ndev)
1322                 goto out;
1323         netif_device_detach(ndev);
1324         priv->pm_state = fsm_getstate(priv->fsm);
1325         rc = netiucv_close(ndev);
1326 out:
1327         return rc;
1328 }
1329
1330 /**
1331  * netiucv_pm_restore_thaw() - Thaw and restore PM callback
1332  * @dev:        netiucv device
1333  *
1334  * re-open netiucv interfaces closed during freeze
1335  */
1336 static int netiucv_pm_restore_thaw(struct device *dev)
1337 {
1338         struct netiucv_priv *priv = dev_get_drvdata(dev);
1339         struct net_device *ndev = NULL;
1340         int rc = 0;
1341
1342         IUCV_DBF_TEXT(trace, 3, __func__);
1343         if (priv && priv->conn)
1344                 ndev = priv->conn->netdev;
1345         if (!ndev)
1346                 goto out;
1347         switch (priv->pm_state) {
1348         case DEV_STATE_RUNNING:
1349         case DEV_STATE_STARTWAIT:
1350                 rc = netiucv_open(ndev);
1351                 break;
1352         default:
1353                 break;
1354         }
1355         netif_device_attach(ndev);
1356 out:
1357         return rc;
1358 }
1359
1360 /**
1361  * Start transmission of a packet.
1362  * Called from generic network device layer.
1363  *
1364  * @param skb Pointer to buffer containing the packet.
1365  * @param dev Pointer to interface struct.
1366  *
1367  * @return 0 if packet consumed, !0 if packet rejected.
1368  *         Note: If we return !0, then the packet is free'd by
1369  *               the generic network layer.
1370  */
1371 static int netiucv_tx(struct sk_buff *skb, struct net_device *dev)
1372 {
1373         struct netiucv_priv *privptr = netdev_priv(dev);
1374         int rc;
1375
1376         IUCV_DBF_TEXT(trace, 4, __func__);
1377         /**
1378          * Some sanity checks ...
1379          */
1380         if (skb == NULL) {
1381                 IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
1382                 privptr->stats.tx_dropped++;
1383                 return NETDEV_TX_OK;
1384         }
1385         if (skb_headroom(skb) < NETIUCV_HDRLEN) {
1386                 IUCV_DBF_TEXT(data, 2,
1387                         "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1388                 dev_kfree_skb(skb);
1389                 privptr->stats.tx_dropped++;
1390                 return NETDEV_TX_OK;
1391         }
1392
1393         /**
1394          * If connection is not running, try to restart it
1395          * and throw away packet.
1396          */
1397         if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
1398                 dev_kfree_skb(skb);
1399                 privptr->stats.tx_dropped++;
1400                 privptr->stats.tx_errors++;
1401                 privptr->stats.tx_carrier_errors++;
1402                 return NETDEV_TX_OK;
1403         }
1404
1405         if (netiucv_test_and_set_busy(dev)) {
1406                 IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
1407                 return NETDEV_TX_BUSY;
1408         }
1409         netif_trans_update(dev);
1410         rc = netiucv_transmit_skb(privptr->conn, skb);
1411         netiucv_clear_busy(dev);
1412         return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
1413 }
1414
1415 /**
1416  * netiucv_stats
1417  * @dev: Pointer to interface struct.
1418  *
1419  * Returns interface statistics of a device.
1420  *
1421  * Returns pointer to stats struct of this interface.
1422  */
1423 static struct net_device_stats *netiucv_stats (struct net_device * dev)
1424 {
1425         struct netiucv_priv *priv = netdev_priv(dev);
1426
1427         IUCV_DBF_TEXT(trace, 5, __func__);
1428         return &priv->stats;
1429 }
1430
1431 /*
1432  * attributes in sysfs
1433  */
1434
1435 static ssize_t user_show(struct device *dev, struct device_attribute *attr,
1436                          char *buf)
1437 {
1438         struct netiucv_priv *priv = dev_get_drvdata(dev);
1439
1440         IUCV_DBF_TEXT(trace, 5, __func__);
1441         return sprintf(buf, "%s\n", netiucv_printuser(priv->conn));
1442 }
1443
1444 static int netiucv_check_user(const char *buf, size_t count, char *username,
1445                               char *userdata)
1446 {
1447         const char *p;
1448         int i;
1449
1450         p = strchr(buf, '.');
1451         if ((p && ((count > 26) ||
1452                    ((p - buf) > 8) ||
1453                    (buf + count - p > 18))) ||
1454             (!p && (count > 9))) {
1455                 IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
1456                 return -EINVAL;
1457         }
1458
1459         for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
1460                 if (isalnum(*p) || *p == '$') {
1461                         username[i] = toupper(*p);
1462                         continue;
1463                 }
1464                 if (*p == '\n')
1465                         /* trailing lf, grr */
1466                         break;
1467                 IUCV_DBF_TEXT_(setup, 2,
1468                                "conn_write: invalid character %02x\n", *p);
1469                 return -EINVAL;
1470         }
1471         while (i < 8)
1472                 username[i++] = ' ';
1473         username[8] = '\0';
1474
1475         if (*p == '.') {
1476                 p++;
1477                 for (i = 0; i < 16 && *p; i++, p++) {
1478                         if (*p == '\n')
1479                                 break;
1480                         userdata[i] = toupper(*p);
1481                 }
1482                 while (i > 0 && i < 16)
1483                         userdata[i++] = ' ';
1484         } else
1485                 memcpy(userdata, iucvMagic_ascii, 16);
1486         userdata[16] = '\0';
1487         ASCEBC(userdata, 16);
1488
1489         return 0;
1490 }
1491
1492 static ssize_t user_write(struct device *dev, struct device_attribute *attr,
1493                           const char *buf, size_t count)
1494 {
1495         struct netiucv_priv *priv = dev_get_drvdata(dev);
1496         struct net_device *ndev = priv->conn->netdev;
1497         char    username[9];
1498         char    userdata[17];
1499         int     rc;
1500         struct iucv_connection *cp;
1501
1502         IUCV_DBF_TEXT(trace, 3, __func__);
1503         rc = netiucv_check_user(buf, count, username, userdata);
1504         if (rc)
1505                 return rc;
1506
1507         if (memcmp(username, priv->conn->userid, 9) &&
1508             (ndev->flags & (IFF_UP | IFF_RUNNING))) {
1509                 /* username changed while the interface is active. */
1510                 IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
1511                 return -EPERM;
1512         }
1513         read_lock_bh(&iucv_connection_rwlock);
1514         list_for_each_entry(cp, &iucv_connection_list, list) {
1515                 if (!strncmp(username, cp->userid, 9) &&
1516                    !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
1517                         read_unlock_bh(&iucv_connection_rwlock);
1518                         IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
1519                                 "already exists\n", netiucv_printuser(cp));
1520                         return -EEXIST;
1521                 }
1522         }
1523         read_unlock_bh(&iucv_connection_rwlock);
1524         memcpy(priv->conn->userid, username, 9);
1525         memcpy(priv->conn->userdata, userdata, 17);
1526         return count;
1527 }
1528
1529 static DEVICE_ATTR(user, 0644, user_show, user_write);
1530
1531 static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
1532                             char *buf)
1533 {
1534         struct netiucv_priv *priv = dev_get_drvdata(dev);
1535
1536         IUCV_DBF_TEXT(trace, 5, __func__);
1537         return sprintf(buf, "%d\n", priv->conn->max_buffsize);
1538 }
1539
1540 static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
1541                              const char *buf, size_t count)
1542 {
1543         struct netiucv_priv *priv = dev_get_drvdata(dev);
1544         struct net_device *ndev = priv->conn->netdev;
1545         unsigned int bs1;
1546         int rc;
1547
1548         IUCV_DBF_TEXT(trace, 3, __func__);
1549         if (count >= 39)
1550                 return -EINVAL;
1551
1552         rc = kstrtouint(buf, 0, &bs1);
1553
1554         if (rc == -EINVAL) {
1555                 IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %s\n",
1556                         buf);
1557                 return -EINVAL;
1558         }
1559         if ((rc == -ERANGE) || (bs1 > NETIUCV_BUFSIZE_MAX)) {
1560                 IUCV_DBF_TEXT_(setup, 2,
1561                         "buffer_write: buffer size %d too large\n",
1562                         bs1);
1563                 return -EINVAL;
1564         }
1565         if ((ndev->flags & IFF_RUNNING) &&
1566             (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
1567                 IUCV_DBF_TEXT_(setup, 2,
1568                         "buffer_write: buffer size %d too small\n",
1569                         bs1);
1570                 return -EINVAL;
1571         }
1572         if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
1573                 IUCV_DBF_TEXT_(setup, 2,
1574                         "buffer_write: buffer size %d too small\n",
1575                         bs1);
1576                 return -EINVAL;
1577         }
1578
1579         priv->conn->max_buffsize = bs1;
1580         if (!(ndev->flags & IFF_RUNNING))
1581                 ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
1582
1583         return count;
1584
1585 }
1586
1587 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1588
1589 static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
1590                              char *buf)
1591 {
1592         struct netiucv_priv *priv = dev_get_drvdata(dev);
1593
1594         IUCV_DBF_TEXT(trace, 5, __func__);
1595         return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
1596 }
1597
1598 static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1599
1600 static ssize_t conn_fsm_show (struct device *dev,
1601                               struct device_attribute *attr, char *buf)
1602 {
1603         struct netiucv_priv *priv = dev_get_drvdata(dev);
1604
1605         IUCV_DBF_TEXT(trace, 5, __func__);
1606         return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
1607 }
1608
1609 static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1610
1611 static ssize_t maxmulti_show (struct device *dev,
1612                               struct device_attribute *attr, char *buf)
1613 {
1614         struct netiucv_priv *priv = dev_get_drvdata(dev);
1615
1616         IUCV_DBF_TEXT(trace, 5, __func__);
1617         return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
1618 }
1619
1620 static ssize_t maxmulti_write (struct device *dev,
1621                                struct device_attribute *attr,
1622                                const char *buf, size_t count)
1623 {
1624         struct netiucv_priv *priv = dev_get_drvdata(dev);
1625
1626         IUCV_DBF_TEXT(trace, 4, __func__);
1627         priv->conn->prof.maxmulti = 0;
1628         return count;
1629 }
1630
1631 static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1632
1633 static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
1634                            char *buf)
1635 {
1636         struct netiucv_priv *priv = dev_get_drvdata(dev);
1637
1638         IUCV_DBF_TEXT(trace, 5, __func__);
1639         return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
1640 }
1641
1642 static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
1643                             const char *buf, size_t count)
1644 {
1645         struct netiucv_priv *priv = dev_get_drvdata(dev);
1646
1647         IUCV_DBF_TEXT(trace, 4, __func__);
1648         priv->conn->prof.maxcqueue = 0;
1649         return count;
1650 }
1651
1652 static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1653
1654 static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
1655                            char *buf)
1656 {
1657         struct netiucv_priv *priv = dev_get_drvdata(dev);
1658
1659         IUCV_DBF_TEXT(trace, 5, __func__);
1660         return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
1661 }
1662
1663 static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
1664                             const char *buf, size_t count)
1665 {
1666         struct netiucv_priv *priv = dev_get_drvdata(dev);
1667
1668         IUCV_DBF_TEXT(trace, 4, __func__);
1669         priv->conn->prof.doios_single = 0;
1670         return count;
1671 }
1672
1673 static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1674
1675 static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
1676                            char *buf)
1677 {
1678         struct netiucv_priv *priv = dev_get_drvdata(dev);
1679
1680         IUCV_DBF_TEXT(trace, 5, __func__);
1681         return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
1682 }
1683
1684 static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
1685                             const char *buf, size_t count)
1686 {
1687         struct netiucv_priv *priv = dev_get_drvdata(dev);
1688
1689         IUCV_DBF_TEXT(trace, 5, __func__);
1690         priv->conn->prof.doios_multi = 0;
1691         return count;
1692 }
1693
1694 static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1695
1696 static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
1697                            char *buf)
1698 {
1699         struct netiucv_priv *priv = dev_get_drvdata(dev);
1700
1701         IUCV_DBF_TEXT(trace, 5, __func__);
1702         return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
1703 }
1704
1705 static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
1706                             const char *buf, size_t count)
1707 {
1708         struct netiucv_priv *priv = dev_get_drvdata(dev);
1709
1710         IUCV_DBF_TEXT(trace, 4, __func__);
1711         priv->conn->prof.txlen = 0;
1712         return count;
1713 }
1714
1715 static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1716
1717 static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
1718                             char *buf)
1719 {
1720         struct netiucv_priv *priv = dev_get_drvdata(dev);
1721
1722         IUCV_DBF_TEXT(trace, 5, __func__);
1723         return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
1724 }
1725
1726 static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
1727                              const char *buf, size_t count)
1728 {
1729         struct netiucv_priv *priv = dev_get_drvdata(dev);
1730
1731         IUCV_DBF_TEXT(trace, 4, __func__);
1732         priv->conn->prof.tx_time = 0;
1733         return count;
1734 }
1735
1736 static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1737
1738 static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
1739                             char *buf)
1740 {
1741         struct netiucv_priv *priv = dev_get_drvdata(dev);
1742
1743         IUCV_DBF_TEXT(trace, 5, __func__);
1744         return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
1745 }
1746
1747 static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
1748                              const char *buf, size_t count)
1749 {
1750         struct netiucv_priv *priv = dev_get_drvdata(dev);
1751
1752         IUCV_DBF_TEXT(trace, 4, __func__);
1753         priv->conn->prof.tx_pending = 0;
1754         return count;
1755 }
1756
1757 static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1758
1759 static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
1760                             char *buf)
1761 {
1762         struct netiucv_priv *priv = dev_get_drvdata(dev);
1763
1764         IUCV_DBF_TEXT(trace, 5, __func__);
1765         return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
1766 }
1767
1768 static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
1769                              const char *buf, size_t count)
1770 {
1771         struct netiucv_priv *priv = dev_get_drvdata(dev);
1772
1773         IUCV_DBF_TEXT(trace, 4, __func__);
1774         priv->conn->prof.tx_max_pending = 0;
1775         return count;
1776 }
1777
1778 static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1779
1780 static struct attribute *netiucv_attrs[] = {
1781         &dev_attr_buffer.attr,
1782         &dev_attr_user.attr,
1783         NULL,
1784 };
1785
1786 static struct attribute_group netiucv_attr_group = {
1787         .attrs = netiucv_attrs,
1788 };
1789
1790 static struct attribute *netiucv_stat_attrs[] = {
1791         &dev_attr_device_fsm_state.attr,
1792         &dev_attr_connection_fsm_state.attr,
1793         &dev_attr_max_tx_buffer_used.attr,
1794         &dev_attr_max_chained_skbs.attr,
1795         &dev_attr_tx_single_write_ops.attr,
1796         &dev_attr_tx_multi_write_ops.attr,
1797         &dev_attr_netto_bytes.attr,
1798         &dev_attr_max_tx_io_time.attr,
1799         &dev_attr_tx_pending.attr,
1800         &dev_attr_tx_max_pending.attr,
1801         NULL,
1802 };
1803
1804 static struct attribute_group netiucv_stat_attr_group = {
1805         .name  = "stats",
1806         .attrs = netiucv_stat_attrs,
1807 };
1808
1809 static const struct attribute_group *netiucv_attr_groups[] = {
1810         &netiucv_stat_attr_group,
1811         &netiucv_attr_group,
1812         NULL,
1813 };
1814
1815 static int netiucv_register_device(struct net_device *ndev)
1816 {
1817         struct netiucv_priv *priv = netdev_priv(ndev);
1818         struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1819         int ret;
1820
1821         IUCV_DBF_TEXT(trace, 3, __func__);
1822
1823         if (dev) {
1824                 dev_set_name(dev, "net%s", ndev->name);
1825                 dev->bus = &iucv_bus;
1826                 dev->parent = iucv_root;
1827                 dev->groups = netiucv_attr_groups;
1828                 /*
1829                  * The release function could be called after the
1830                  * module has been unloaded. It's _only_ task is to
1831                  * free the struct. Therefore, we specify kfree()
1832                  * directly here. (Probably a little bit obfuscating
1833                  * but legitime ...).
1834                  */
1835                 dev->release = (void (*)(struct device *))kfree;
1836                 dev->driver = &netiucv_driver;
1837         } else
1838                 return -ENOMEM;
1839
1840         ret = device_register(dev);
1841         if (ret) {
1842                 put_device(dev);
1843                 return ret;
1844         }
1845         priv->dev = dev;
1846         dev_set_drvdata(dev, priv);
1847         return 0;
1848 }
1849
1850 static void netiucv_unregister_device(struct device *dev)
1851 {
1852         IUCV_DBF_TEXT(trace, 3, __func__);
1853         device_unregister(dev);
1854 }
1855
1856 /**
1857  * Allocate and initialize a new connection structure.
1858  * Add it to the list of netiucv connections;
1859  */
1860 static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
1861                                                       char *username,
1862                                                       char *userdata)
1863 {
1864         struct iucv_connection *conn;
1865
1866         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1867         if (!conn)
1868                 goto out;
1869         skb_queue_head_init(&conn->collect_queue);
1870         skb_queue_head_init(&conn->commit_queue);
1871         spin_lock_init(&conn->collect_lock);
1872         conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1873         conn->netdev = dev;
1874
1875         conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1876         if (!conn->rx_buff)
1877                 goto out_conn;
1878         conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1879         if (!conn->tx_buff)
1880                 goto out_rx;
1881         conn->fsm = init_fsm("netiucvconn", conn_state_names,
1882                              conn_event_names, NR_CONN_STATES,
1883                              NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1884                              GFP_KERNEL);
1885         if (!conn->fsm)
1886                 goto out_tx;
1887
1888         fsm_settimer(conn->fsm, &conn->timer);
1889         fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1890
1891         if (userdata)
1892                 memcpy(conn->userdata, userdata, 17);
1893         if (username) {
1894                 memcpy(conn->userid, username, 9);
1895                 fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1896         }
1897
1898         write_lock_bh(&iucv_connection_rwlock);
1899         list_add_tail(&conn->list, &iucv_connection_list);
1900         write_unlock_bh(&iucv_connection_rwlock);
1901         return conn;
1902
1903 out_tx:
1904         kfree_skb(conn->tx_buff);
1905 out_rx:
1906         kfree_skb(conn->rx_buff);
1907 out_conn:
1908         kfree(conn);
1909 out:
1910         return NULL;
1911 }
1912
1913 /**
1914  * Release a connection structure and remove it from the
1915  * list of netiucv connections.
1916  */
1917 static void netiucv_remove_connection(struct iucv_connection *conn)
1918 {
1919
1920         IUCV_DBF_TEXT(trace, 3, __func__);
1921         write_lock_bh(&iucv_connection_rwlock);
1922         list_del_init(&conn->list);
1923         write_unlock_bh(&iucv_connection_rwlock);
1924         fsm_deltimer(&conn->timer);
1925         netiucv_purge_skb_queue(&conn->collect_queue);
1926         if (conn->path) {
1927                 iucv_path_sever(conn->path, conn->userdata);
1928                 kfree(conn->path);
1929                 conn->path = NULL;
1930         }
1931         netiucv_purge_skb_queue(&conn->commit_queue);
1932         kfree_fsm(conn->fsm);
1933         kfree_skb(conn->rx_buff);
1934         kfree_skb(conn->tx_buff);
1935 }
1936
1937 /**
1938  * Release everything of a net device.
1939  */
1940 static void netiucv_free_netdevice(struct net_device *dev)
1941 {
1942         struct netiucv_priv *privptr = netdev_priv(dev);
1943
1944         IUCV_DBF_TEXT(trace, 3, __func__);
1945
1946         if (!dev)
1947                 return;
1948
1949         if (privptr) {
1950                 if (privptr->conn)
1951                         netiucv_remove_connection(privptr->conn);
1952                 if (privptr->fsm)
1953                         kfree_fsm(privptr->fsm);
1954                 privptr->conn = NULL; privptr->fsm = NULL;
1955                 /* privptr gets freed by free_netdev() */
1956         }
1957 }
1958
1959 /**
1960  * Initialize a net device. (Called from kernel in alloc_netdev())
1961  */
1962 static const struct net_device_ops netiucv_netdev_ops = {
1963         .ndo_open               = netiucv_open,
1964         .ndo_stop               = netiucv_close,
1965         .ndo_get_stats          = netiucv_stats,
1966         .ndo_start_xmit         = netiucv_tx,
1967 };
1968
1969 static void netiucv_setup_netdevice(struct net_device *dev)
1970 {
1971         dev->mtu                 = NETIUCV_MTU_DEFAULT;
1972         dev->min_mtu             = 576;
1973         dev->max_mtu             = NETIUCV_MTU_MAX;
1974         dev->needs_free_netdev   = true;
1975         dev->priv_destructor     = netiucv_free_netdevice;
1976         dev->hard_header_len     = NETIUCV_HDRLEN;
1977         dev->addr_len            = 0;
1978         dev->type                = ARPHRD_SLIP;
1979         dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
1980         dev->flags               = IFF_POINTOPOINT | IFF_NOARP;
1981         dev->netdev_ops          = &netiucv_netdev_ops;
1982 }
1983
1984 /**
1985  * Allocate and initialize everything of a net device.
1986  */
1987 static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
1988 {
1989         struct netiucv_priv *privptr;
1990         struct net_device *dev;
1991
1992         dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
1993                            NET_NAME_UNKNOWN, netiucv_setup_netdevice);
1994         if (!dev)
1995                 return NULL;
1996         rtnl_lock();
1997         if (dev_alloc_name(dev, dev->name) < 0)
1998                 goto out_netdev;
1999
2000         privptr = netdev_priv(dev);
2001         privptr->fsm = init_fsm("netiucvdev", dev_state_names,
2002                                 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
2003                                 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2004         if (!privptr->fsm)
2005                 goto out_netdev;
2006
2007         privptr->conn = netiucv_new_connection(dev, username, userdata);
2008         if (!privptr->conn) {
2009                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
2010                 goto out_fsm;
2011         }
2012         fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2013         return dev;
2014
2015 out_fsm:
2016         kfree_fsm(privptr->fsm);
2017 out_netdev:
2018         rtnl_unlock();
2019         free_netdev(dev);
2020         return NULL;
2021 }
2022
2023 static ssize_t conn_write(struct device_driver *drv,
2024                           const char *buf, size_t count)
2025 {
2026         char username[9];
2027         char userdata[17];
2028         int rc;
2029         struct net_device *dev;
2030         struct netiucv_priv *priv;
2031         struct iucv_connection *cp;
2032
2033         IUCV_DBF_TEXT(trace, 3, __func__);
2034         rc = netiucv_check_user(buf, count, username, userdata);
2035         if (rc)
2036                 return rc;
2037
2038         read_lock_bh(&iucv_connection_rwlock);
2039         list_for_each_entry(cp, &iucv_connection_list, list) {
2040                 if (!strncmp(username, cp->userid, 9) &&
2041                     !strncmp(userdata, cp->userdata, 17)) {
2042                         read_unlock_bh(&iucv_connection_rwlock);
2043                         IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
2044                                 "already exists\n", netiucv_printuser(cp));
2045                         return -EEXIST;
2046                 }
2047         }
2048         read_unlock_bh(&iucv_connection_rwlock);
2049
2050         dev = netiucv_init_netdevice(username, userdata);
2051         if (!dev) {
2052                 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
2053                 return -ENODEV;
2054         }
2055
2056         rc = netiucv_register_device(dev);
2057         if (rc) {
2058                 rtnl_unlock();
2059                 IUCV_DBF_TEXT_(setup, 2,
2060                         "ret %d from netiucv_register_device\n", rc);
2061                 goto out_free_ndev;
2062         }
2063
2064         /* sysfs magic */
2065         priv = netdev_priv(dev);
2066         SET_NETDEV_DEV(dev, priv->dev);
2067
2068         rc = register_netdevice(dev);
2069         rtnl_unlock();
2070         if (rc)
2071                 goto out_unreg;
2072
2073         dev_info(priv->dev, "The IUCV interface to %s has been established "
2074                             "successfully\n",
2075                 netiucv_printuser(priv->conn));
2076
2077         return count;
2078
2079 out_unreg:
2080         netiucv_unregister_device(priv->dev);
2081 out_free_ndev:
2082         netiucv_free_netdevice(dev);
2083         return rc;
2084 }
2085
2086 static DRIVER_ATTR(connection, 0200, NULL, conn_write);
2087
2088 static ssize_t remove_write (struct device_driver *drv,
2089                              const char *buf, size_t count)
2090 {
2091         struct iucv_connection *cp;
2092         struct net_device *ndev;
2093         struct netiucv_priv *priv;
2094         struct device *dev;
2095         char name[IFNAMSIZ];
2096         const char *p;
2097         int i;
2098
2099         IUCV_DBF_TEXT(trace, 3, __func__);
2100
2101         if (count >= IFNAMSIZ)
2102                 count = IFNAMSIZ - 1;
2103
2104         for (i = 0, p = buf; i < count && *p; i++, p++) {
2105                 if (*p == '\n' || *p == ' ')
2106                         /* trailing lf, grr */
2107                         break;
2108                 name[i] = *p;
2109         }
2110         name[i] = '\0';
2111
2112         read_lock_bh(&iucv_connection_rwlock);
2113         list_for_each_entry(cp, &iucv_connection_list, list) {
2114                 ndev = cp->netdev;
2115                 priv = netdev_priv(ndev);
2116                 dev = priv->dev;
2117                 if (strncmp(name, ndev->name, count))
2118                         continue;
2119                 read_unlock_bh(&iucv_connection_rwlock);
2120                 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2121                         dev_warn(dev, "The IUCV device is connected"
2122                                 " to %s and cannot be removed\n",
2123                                 priv->conn->userid);
2124                         IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2125                         return -EPERM;
2126                 }
2127                 unregister_netdev(ndev);
2128                 netiucv_unregister_device(dev);
2129                 return count;
2130         }
2131         read_unlock_bh(&iucv_connection_rwlock);
2132         IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2133         return -EINVAL;
2134 }
2135
2136 static DRIVER_ATTR(remove, 0200, NULL, remove_write);
2137
2138 static struct attribute * netiucv_drv_attrs[] = {
2139         &driver_attr_connection.attr,
2140         &driver_attr_remove.attr,
2141         NULL,
2142 };
2143
2144 static struct attribute_group netiucv_drv_attr_group = {
2145         .attrs = netiucv_drv_attrs,
2146 };
2147
2148 static const struct attribute_group *netiucv_drv_attr_groups[] = {
2149         &netiucv_drv_attr_group,
2150         NULL,
2151 };
2152
2153 static void netiucv_banner(void)
2154 {
2155         pr_info("driver initialized\n");
2156 }
2157
2158 static void __exit netiucv_exit(void)
2159 {
2160         struct iucv_connection *cp;
2161         struct net_device *ndev;
2162         struct netiucv_priv *priv;
2163         struct device *dev;
2164
2165         IUCV_DBF_TEXT(trace, 3, __func__);
2166         while (!list_empty(&iucv_connection_list)) {
2167                 cp = list_entry(iucv_connection_list.next,
2168                                 struct iucv_connection, list);
2169                 ndev = cp->netdev;
2170                 priv = netdev_priv(ndev);
2171                 dev = priv->dev;
2172
2173                 unregister_netdev(ndev);
2174                 netiucv_unregister_device(dev);
2175         }
2176
2177         device_unregister(netiucv_dev);
2178         driver_unregister(&netiucv_driver);
2179         iucv_unregister(&netiucv_handler, 1);
2180         iucv_unregister_dbf_views();
2181
2182         pr_info("driver unloaded\n");
2183         return;
2184 }
2185
2186 static int __init netiucv_init(void)
2187 {
2188         int rc;
2189
2190         rc = iucv_register_dbf_views();
2191         if (rc)
2192                 goto out;
2193         rc = iucv_register(&netiucv_handler, 1);
2194         if (rc)
2195                 goto out_dbf;
2196         IUCV_DBF_TEXT(trace, 3, __func__);
2197         netiucv_driver.groups = netiucv_drv_attr_groups;
2198         rc = driver_register(&netiucv_driver);
2199         if (rc) {
2200                 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2201                 goto out_iucv;
2202         }
2203         /* establish dummy device */
2204         netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
2205         if (!netiucv_dev) {
2206                 rc = -ENOMEM;
2207                 goto out_driver;
2208         }
2209         dev_set_name(netiucv_dev, "netiucv");
2210         netiucv_dev->bus = &iucv_bus;
2211         netiucv_dev->parent = iucv_root;
2212         netiucv_dev->release = (void (*)(struct device *))kfree;
2213         netiucv_dev->driver = &netiucv_driver;
2214         rc = device_register(netiucv_dev);
2215         if (rc) {
2216                 put_device(netiucv_dev);
2217                 goto out_driver;
2218         }
2219         netiucv_banner();
2220         return rc;
2221
2222 out_driver:
2223         driver_unregister(&netiucv_driver);
2224 out_iucv:
2225         iucv_unregister(&netiucv_handler, 1);
2226 out_dbf:
2227         iucv_unregister_dbf_views();
2228 out:
2229         return rc;
2230 }
2231
2232 module_init(netiucv_init);
2233 module_exit(netiucv_exit);
2234 MODULE_LICENSE("GPL");