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