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