drivers/s390/net/netiucv.c

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