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