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