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