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