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