drivers/s390/net/netiucv.c

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