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