drivers/s390/net/netiucv.c

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