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