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