4 * Copyright IBM Corp. 2001, 2009
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)
12 * Ursula Braun (ursula.braun@de.ibm.com)
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
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)
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.
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.
38 #define KMSG_COMPONENT "netiucv"
39 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
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>
53 #include <linux/signal.h>
54 #include <linux/string.h>
55 #include <linux/device.h>
58 #include <linux/if_arp.h>
59 #include <linux/tcp.h>
60 #include <linux/skbuff.h>
61 #include <linux/ctype.h>
65 #include <linux/uaccess.h>
66 #include <asm/ebcdic.h>
68 #include <net/iucv/iucv.h>
72 ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
73 MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
76 * Debug Facility stuff
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
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
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
96 #define IUCV_DBF_TEXT(name,level,text) \
98 debug_text_event(iucv_dbf_##name,level,text); \
101 #define IUCV_DBF_HEX(name,level,addr,len) \
103 debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
106 DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf
);
108 #define IUCV_DBF_TEXT_(name, level, text...) \
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); \
118 #define IUCV_DBF_SPRINTF(name,level,text...) \
120 debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
121 debug_sprintf_event(iucv_dbf_trace, level, text ); \
125 * some more debug stuff
127 #define PRINTK_HEADER " iucv: " /* for debugging */
129 /* dummy device to make sure netiucv_pm functions are called */
130 static struct device
*netiucv_dev
;
132 static int netiucv_pm_prepare(struct device
*);
133 static void netiucv_pm_complete(struct device
*);
134 static int netiucv_pm_freeze(struct device
*);
135 static int netiucv_pm_restore_thaw(struct device
*);
137 static const struct dev_pm_ops netiucv_pm_ops
= {
138 .prepare
= netiucv_pm_prepare
,
139 .complete
= netiucv_pm_complete
,
140 .freeze
= netiucv_pm_freeze
,
141 .thaw
= netiucv_pm_restore_thaw
,
142 .restore
= netiucv_pm_restore_thaw
,
145 static struct device_driver netiucv_driver
= {
146 .owner
= THIS_MODULE
,
149 .pm
= &netiucv_pm_ops
,
152 static int netiucv_callback_connreq(struct iucv_path
*, u8
*, u8
*);
153 static void netiucv_callback_connack(struct iucv_path
*, u8
*);
154 static void netiucv_callback_connrej(struct iucv_path
*, u8
*);
155 static void netiucv_callback_connsusp(struct iucv_path
*, u8
*);
156 static void netiucv_callback_connres(struct iucv_path
*, u8
*);
157 static void netiucv_callback_rx(struct iucv_path
*, struct iucv_message
*);
158 static void netiucv_callback_txdone(struct iucv_path
*, struct iucv_message
*);
160 static struct iucv_handler netiucv_handler
= {
161 .path_pending
= netiucv_callback_connreq
,
162 .path_complete
= netiucv_callback_connack
,
163 .path_severed
= netiucv_callback_connrej
,
164 .path_quiesced
= netiucv_callback_connsusp
,
165 .path_resumed
= netiucv_callback_connres
,
166 .message_pending
= netiucv_callback_rx
,
167 .message_complete
= netiucv_callback_txdone
171 * Per connection profiling data
173 struct connection_profile
{
174 unsigned long maxmulti
;
175 unsigned long maxcqueue
;
176 unsigned long doios_single
;
177 unsigned long doios_multi
;
179 unsigned long tx_time
;
180 unsigned long send_stamp
;
181 unsigned long tx_pending
;
182 unsigned long tx_max_pending
;
186 * Representation of one iucv connection
188 struct iucv_connection
{
189 struct list_head list
;
190 struct iucv_path
*path
;
191 struct sk_buff
*rx_buff
;
192 struct sk_buff
*tx_buff
;
193 struct sk_buff_head collect_queue
;
194 struct sk_buff_head commit_queue
;
195 spinlock_t collect_lock
;
200 struct net_device
*netdev
;
201 struct connection_profile prof
;
207 * Linked list of all connection structs.
209 static LIST_HEAD(iucv_connection_list
);
210 static DEFINE_RWLOCK(iucv_connection_rwlock
);
213 * Representation of event-data for the
214 * connection state machine.
217 struct iucv_connection
*conn
;
222 * Private part of the network device structure
224 struct netiucv_priv
{
225 struct net_device_stats stats
;
228 struct iucv_connection
*conn
;
234 * Link level header for a packet.
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
249 * Compatibility macros for busy handling
250 * of network devices.
252 static void netiucv_clear_busy(struct net_device
*dev
)
254 struct netiucv_priv
*priv
= netdev_priv(dev
);
255 clear_bit(0, &priv
->tbusy
);
256 netif_wake_queue(dev
);
259 static int netiucv_test_and_set_busy(struct net_device
*dev
)
261 struct netiucv_priv
*priv
= netdev_priv(dev
);
262 netif_stop_queue(dev
);
263 return test_and_set_bit(0, &priv
->tbusy
);
266 static u8 iucvMagic_ascii
[16] = {
267 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
268 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
271 static u8 iucvMagic_ebcdic
[16] = {
272 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
273 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
277 * Convert an iucv userId to its printable
278 * form (strip whitespace at end).
280 * @param An iucv userId
282 * @returns The printable string (static data!!)
284 static char *netiucv_printname(char *name
, int len
)
288 memcpy(tmp
, name
, len
);
290 while (*p
&& ((p
- tmp
) < len
) && (!isspace(*p
)))
296 static char *netiucv_printuser(struct iucv_connection
*conn
)
298 static char tmp_uid
[9];
299 static char tmp_udat
[17];
300 static char buf
[100];
302 if (memcmp(conn
->userdata
, iucvMagic_ebcdic
, 16)) {
305 memcpy(tmp_uid
, netiucv_printname(conn
->userid
, 8), 8);
306 memcpy(tmp_udat
, conn
->userdata
, 16);
307 EBCASC(tmp_udat
, 16);
308 memcpy(tmp_udat
, netiucv_printname(tmp_udat
, 16), 16);
309 sprintf(buf
, "%s.%s", tmp_uid
, tmp_udat
);
312 return netiucv_printname(conn
->userid
, 8);
316 * States of the interface statemachine.
324 * MUST be always the last element!!
329 static const char *dev_state_names
[] = {
337 * Events of the interface statemachine.
345 * MUST be always the last element!!
350 static const char *dev_event_names
[] = {
358 * Events of the connection statemachine
362 * Events, representing callbacks from
363 * lowlevel iucv layer)
374 * Events, representing errors return codes from
375 * calls to lowlevel iucv layer
379 * Event, representing timer expiry.
384 * Events, representing commands from upper levels.
390 * MUST be always the last element!!
395 static const char *conn_event_names
[] = {
396 "Remote connection request",
397 "Remote connection acknowledge",
398 "Remote connection reject",
399 "Connection suspended",
400 "Connection resumed",
411 * States of the connection statemachine.
415 * Connection not assigned to any device,
416 * initial state, invalid
421 * Userid assigned but not operating
426 * Connection registered,
427 * no connection request sent yet,
428 * no connection request received
430 CONN_STATE_STARTWAIT
,
433 * Connection registered and connection request sent,
434 * no acknowledge and no connection request received yet.
436 CONN_STATE_SETUPWAIT
,
439 * Connection up and running idle
444 * Data sent, awaiting CONN_EVENT_TXDONE
449 * Error during registration.
454 * Error during registration.
459 * MUST be always the last element!!
464 static const char *conn_state_names
[] = {
472 "Registration error",
478 * Debug Facility Stuff
480 static debug_info_t
*iucv_dbf_setup
= NULL
;
481 static debug_info_t
*iucv_dbf_data
= NULL
;
482 static debug_info_t
*iucv_dbf_trace
= NULL
;
484 DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf
);
486 static void iucv_unregister_dbf_views(void)
488 debug_unregister(iucv_dbf_setup
);
489 debug_unregister(iucv_dbf_data
);
490 debug_unregister(iucv_dbf_trace
);
492 static int iucv_register_dbf_views(void)
494 iucv_dbf_setup
= debug_register(IUCV_DBF_SETUP_NAME
,
495 IUCV_DBF_SETUP_PAGES
,
496 IUCV_DBF_SETUP_NR_AREAS
,
498 iucv_dbf_data
= debug_register(IUCV_DBF_DATA_NAME
,
500 IUCV_DBF_DATA_NR_AREAS
,
502 iucv_dbf_trace
= debug_register(IUCV_DBF_TRACE_NAME
,
503 IUCV_DBF_TRACE_PAGES
,
504 IUCV_DBF_TRACE_NR_AREAS
,
507 if ((iucv_dbf_setup
== NULL
) || (iucv_dbf_data
== NULL
) ||
508 (iucv_dbf_trace
== NULL
)) {
509 iucv_unregister_dbf_views();
512 debug_register_view(iucv_dbf_setup
, &debug_hex_ascii_view
);
513 debug_set_level(iucv_dbf_setup
, IUCV_DBF_SETUP_LEVEL
);
515 debug_register_view(iucv_dbf_data
, &debug_hex_ascii_view
);
516 debug_set_level(iucv_dbf_data
, IUCV_DBF_DATA_LEVEL
);
518 debug_register_view(iucv_dbf_trace
, &debug_hex_ascii_view
);
519 debug_set_level(iucv_dbf_trace
, IUCV_DBF_TRACE_LEVEL
);
525 * Callback-wrappers, called from lowlevel iucv layer.
528 static void netiucv_callback_rx(struct iucv_path
*path
,
529 struct iucv_message
*msg
)
531 struct iucv_connection
*conn
= path
->private;
532 struct iucv_event ev
;
536 fsm_event(conn
->fsm
, CONN_EVENT_RX
, &ev
);
539 static void netiucv_callback_txdone(struct iucv_path
*path
,
540 struct iucv_message
*msg
)
542 struct iucv_connection
*conn
= path
->private;
543 struct iucv_event ev
;
547 fsm_event(conn
->fsm
, CONN_EVENT_TXDONE
, &ev
);
550 static void netiucv_callback_connack(struct iucv_path
*path
, u8 ipuser
[16])
552 struct iucv_connection
*conn
= path
->private;
554 fsm_event(conn
->fsm
, CONN_EVENT_CONN_ACK
, conn
);
557 static int netiucv_callback_connreq(struct iucv_path
*path
, u8
*ipvmid
,
560 struct iucv_connection
*conn
= path
->private;
561 struct iucv_event ev
;
562 static char tmp_user
[9];
563 static char tmp_udat
[17];
567 memcpy(tmp_user
, netiucv_printname(ipvmid
, 8), 8);
568 memcpy(tmp_udat
, ipuser
, 16);
569 EBCASC(tmp_udat
, 16);
570 read_lock_bh(&iucv_connection_rwlock
);
571 list_for_each_entry(conn
, &iucv_connection_list
, list
) {
572 if (strncmp(ipvmid
, conn
->userid
, 8) ||
573 strncmp(ipuser
, conn
->userdata
, 16))
575 /* Found a matching connection for this path. */
579 fsm_event(conn
->fsm
, CONN_EVENT_CONN_REQ
, &ev
);
582 IUCV_DBF_TEXT_(setup
, 2, "Connection requested for %s.%s\n",
583 tmp_user
, netiucv_printname(tmp_udat
, 16));
584 read_unlock_bh(&iucv_connection_rwlock
);
588 static void netiucv_callback_connrej(struct iucv_path
*path
, u8
*ipuser
)
590 struct iucv_connection
*conn
= path
->private;
592 fsm_event(conn
->fsm
, CONN_EVENT_CONN_REJ
, conn
);
595 static void netiucv_callback_connsusp(struct iucv_path
*path
, u8
*ipuser
)
597 struct iucv_connection
*conn
= path
->private;
599 fsm_event(conn
->fsm
, CONN_EVENT_CONN_SUS
, conn
);
602 static void netiucv_callback_connres(struct iucv_path
*path
, u8
*ipuser
)
604 struct iucv_connection
*conn
= path
->private;
606 fsm_event(conn
->fsm
, CONN_EVENT_CONN_RES
, conn
);
610 * NOP action for statemachines
612 static void netiucv_action_nop(fsm_instance
*fi
, int event
, void *arg
)
617 * Actions of the connection statemachine
622 * @conn: The connection where this skb has been received.
623 * @pskb: The received skb.
625 * Unpack a just received skb and hand it over to upper layers.
626 * Helper function for conn_action_rx.
628 static void netiucv_unpack_skb(struct iucv_connection
*conn
,
629 struct sk_buff
*pskb
)
631 struct net_device
*dev
= conn
->netdev
;
632 struct netiucv_priv
*privptr
= netdev_priv(dev
);
635 skb_put(pskb
, NETIUCV_HDRLEN
);
637 pskb
->ip_summed
= CHECKSUM_NONE
;
638 pskb
->protocol
= cpu_to_be16(ETH_P_IP
);
642 struct ll_header
*header
= (struct ll_header
*) pskb
->data
;
647 skb_pull(pskb
, NETIUCV_HDRLEN
);
648 header
->next
-= offset
;
649 offset
+= header
->next
;
650 header
->next
-= NETIUCV_HDRLEN
;
651 if (skb_tailroom(pskb
) < header
->next
) {
652 IUCV_DBF_TEXT_(data
, 2, "Illegal next field: %d > %d\n",
653 header
->next
, skb_tailroom(pskb
));
656 skb_put(pskb
, header
->next
);
657 skb_reset_mac_header(pskb
);
658 skb
= dev_alloc_skb(pskb
->len
);
660 IUCV_DBF_TEXT(data
, 2,
661 "Out of memory in netiucv_unpack_skb\n");
662 privptr
->stats
.rx_dropped
++;
665 skb_copy_from_linear_data(pskb
, skb_put(skb
, pskb
->len
),
667 skb_reset_mac_header(skb
);
668 skb
->dev
= pskb
->dev
;
669 skb
->protocol
= pskb
->protocol
;
670 pskb
->ip_summed
= CHECKSUM_UNNECESSARY
;
671 privptr
->stats
.rx_packets
++;
672 privptr
->stats
.rx_bytes
+= skb
->len
;
674 * Since receiving is always initiated from a tasklet (in iucv.c),
675 * we must use netif_rx_ni() instead of netif_rx()
678 skb_pull(pskb
, header
->next
);
679 skb_put(pskb
, NETIUCV_HDRLEN
);
683 static void conn_action_rx(fsm_instance
*fi
, int event
, void *arg
)
685 struct iucv_event
*ev
= arg
;
686 struct iucv_connection
*conn
= ev
->conn
;
687 struct iucv_message
*msg
= ev
->data
;
688 struct netiucv_priv
*privptr
= netdev_priv(conn
->netdev
);
691 IUCV_DBF_TEXT(trace
, 4, __func__
);
694 iucv_message_reject(conn
->path
, msg
);
695 IUCV_DBF_TEXT(data
, 2,
696 "Received data for unlinked connection\n");
699 if (msg
->length
> conn
->max_buffsize
) {
700 iucv_message_reject(conn
->path
, msg
);
701 privptr
->stats
.rx_dropped
++;
702 IUCV_DBF_TEXT_(data
, 2, "msglen %d > max_buffsize %d\n",
703 msg
->length
, conn
->max_buffsize
);
706 conn
->rx_buff
->data
= conn
->rx_buff
->head
;
707 skb_reset_tail_pointer(conn
->rx_buff
);
708 conn
->rx_buff
->len
= 0;
709 rc
= iucv_message_receive(conn
->path
, msg
, 0, conn
->rx_buff
->data
,
711 if (rc
|| msg
->length
< 5) {
712 privptr
->stats
.rx_errors
++;
713 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_receive\n", rc
);
716 netiucv_unpack_skb(conn
, conn
->rx_buff
);
719 static void conn_action_txdone(fsm_instance
*fi
, int event
, void *arg
)
721 struct iucv_event
*ev
= arg
;
722 struct iucv_connection
*conn
= ev
->conn
;
723 struct iucv_message
*msg
= ev
->data
;
724 struct iucv_message txmsg
;
725 struct netiucv_priv
*privptr
= NULL
;
726 u32 single_flag
= msg
->tag
;
731 unsigned long saveflags
;
732 struct ll_header header
;
735 IUCV_DBF_TEXT(trace
, 4, __func__
);
737 if (!conn
|| !conn
->netdev
) {
738 IUCV_DBF_TEXT(data
, 2,
739 "Send confirmation for unlinked connection\n");
742 privptr
= netdev_priv(conn
->netdev
);
743 conn
->prof
.tx_pending
--;
745 if ((skb
= skb_dequeue(&conn
->commit_queue
))) {
746 refcount_dec(&skb
->users
);
748 privptr
->stats
.tx_packets
++;
749 privptr
->stats
.tx_bytes
+=
750 (skb
->len
- NETIUCV_HDRLEN
753 dev_kfree_skb_any(skb
);
756 conn
->tx_buff
->data
= conn
->tx_buff
->head
;
757 skb_reset_tail_pointer(conn
->tx_buff
);
758 conn
->tx_buff
->len
= 0;
759 spin_lock_irqsave(&conn
->collect_lock
, saveflags
);
760 while ((skb
= skb_dequeue(&conn
->collect_queue
))) {
761 header
.next
= conn
->tx_buff
->len
+ skb
->len
+ NETIUCV_HDRLEN
;
762 skb_put_data(conn
->tx_buff
, &header
, NETIUCV_HDRLEN
);
763 skb_copy_from_linear_data(skb
,
764 skb_put(conn
->tx_buff
, skb
->len
),
769 refcount_dec(&skb
->users
);
770 dev_kfree_skb_any(skb
);
772 if (conn
->collect_len
> conn
->prof
.maxmulti
)
773 conn
->prof
.maxmulti
= conn
->collect_len
;
774 conn
->collect_len
= 0;
775 spin_unlock_irqrestore(&conn
->collect_lock
, saveflags
);
776 if (conn
->tx_buff
->len
== 0) {
777 fsm_newstate(fi
, CONN_STATE_IDLE
);
782 skb_put_data(conn
->tx_buff
, &header
, NETIUCV_HDRLEN
);
783 conn
->prof
.send_stamp
= jiffies
;
786 rc
= iucv_message_send(conn
->path
, &txmsg
, 0, 0,
787 conn
->tx_buff
->data
, conn
->tx_buff
->len
);
788 conn
->prof
.doios_multi
++;
789 conn
->prof
.txlen
+= conn
->tx_buff
->len
;
790 conn
->prof
.tx_pending
++;
791 if (conn
->prof
.tx_pending
> conn
->prof
.tx_max_pending
)
792 conn
->prof
.tx_max_pending
= conn
->prof
.tx_pending
;
794 conn
->prof
.tx_pending
--;
795 fsm_newstate(fi
, CONN_STATE_IDLE
);
797 privptr
->stats
.tx_errors
+= txpackets
;
798 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_send\n", rc
);
801 privptr
->stats
.tx_packets
+= txpackets
;
802 privptr
->stats
.tx_bytes
+= txbytes
;
804 if (stat_maxcq
> conn
->prof
.maxcqueue
)
805 conn
->prof
.maxcqueue
= stat_maxcq
;
809 static void conn_action_connaccept(fsm_instance
*fi
, int event
, void *arg
)
811 struct iucv_event
*ev
= arg
;
812 struct iucv_connection
*conn
= ev
->conn
;
813 struct iucv_path
*path
= ev
->data
;
814 struct net_device
*netdev
= conn
->netdev
;
815 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
818 IUCV_DBF_TEXT(trace
, 3, __func__
);
821 path
->msglim
= NETIUCV_QUEUELEN_DEFAULT
;
823 rc
= iucv_path_accept(path
, &netiucv_handler
, conn
->userdata
, conn
);
825 IUCV_DBF_TEXT_(setup
, 2, "rc %d from iucv_accept", rc
);
828 fsm_newstate(fi
, CONN_STATE_IDLE
);
829 netdev
->tx_queue_len
= conn
->path
->msglim
;
830 fsm_event(privptr
->fsm
, DEV_EVENT_CONUP
, netdev
);
833 static void conn_action_connreject(fsm_instance
*fi
, int event
, void *arg
)
835 struct iucv_event
*ev
= arg
;
836 struct iucv_path
*path
= ev
->data
;
838 IUCV_DBF_TEXT(trace
, 3, __func__
);
839 iucv_path_sever(path
, NULL
);
842 static void conn_action_connack(fsm_instance
*fi
, int event
, void *arg
)
844 struct iucv_connection
*conn
= arg
;
845 struct net_device
*netdev
= conn
->netdev
;
846 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
848 IUCV_DBF_TEXT(trace
, 3, __func__
);
849 fsm_deltimer(&conn
->timer
);
850 fsm_newstate(fi
, CONN_STATE_IDLE
);
851 netdev
->tx_queue_len
= conn
->path
->msglim
;
852 fsm_event(privptr
->fsm
, DEV_EVENT_CONUP
, netdev
);
855 static void conn_action_conntimsev(fsm_instance
*fi
, int event
, void *arg
)
857 struct iucv_connection
*conn
= arg
;
859 IUCV_DBF_TEXT(trace
, 3, __func__
);
860 fsm_deltimer(&conn
->timer
);
861 iucv_path_sever(conn
->path
, conn
->userdata
);
862 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
865 static void conn_action_connsever(fsm_instance
*fi
, int event
, void *arg
)
867 struct iucv_connection
*conn
= arg
;
868 struct net_device
*netdev
= conn
->netdev
;
869 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
871 IUCV_DBF_TEXT(trace
, 3, __func__
);
873 fsm_deltimer(&conn
->timer
);
874 iucv_path_sever(conn
->path
, conn
->userdata
);
875 dev_info(privptr
->dev
, "The peer z/VM guest %s has closed the "
876 "connection\n", netiucv_printuser(conn
));
877 IUCV_DBF_TEXT(data
, 2,
878 "conn_action_connsever: Remote dropped connection\n");
879 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
880 fsm_event(privptr
->fsm
, DEV_EVENT_CONDOWN
, netdev
);
883 static void conn_action_start(fsm_instance
*fi
, int event
, void *arg
)
885 struct iucv_connection
*conn
= arg
;
886 struct net_device
*netdev
= conn
->netdev
;
887 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
890 IUCV_DBF_TEXT(trace
, 3, __func__
);
892 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
895 * We must set the state before calling iucv_connect because the
896 * callback handler could be called at any point after the connection
900 fsm_newstate(fi
, CONN_STATE_SETUPWAIT
);
901 conn
->path
= iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT
, 0, GFP_KERNEL
);
902 IUCV_DBF_TEXT_(setup
, 2, "%s: connecting to %s ...\n",
903 netdev
->name
, netiucv_printuser(conn
));
905 rc
= iucv_path_connect(conn
->path
, &netiucv_handler
, conn
->userid
,
906 NULL
, conn
->userdata
, conn
);
909 netdev
->tx_queue_len
= conn
->path
->msglim
;
910 fsm_addtimer(&conn
->timer
, NETIUCV_TIMEOUT_5SEC
,
911 CONN_EVENT_TIMER
, conn
);
914 dev_warn(privptr
->dev
,
915 "The IUCV device failed to connect to z/VM guest %s\n",
916 netiucv_printname(conn
->userid
, 8));
917 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
920 dev_warn(privptr
->dev
,
921 "The IUCV device failed to connect to the peer on z/VM"
922 " guest %s\n", netiucv_printname(conn
->userid
, 8));
923 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
926 dev_err(privptr
->dev
,
927 "Connecting the IUCV device would exceed the maximum"
928 " number of IUCV connections\n");
929 fsm_newstate(fi
, CONN_STATE_CONNERR
);
932 dev_err(privptr
->dev
,
933 "z/VM guest %s has too many IUCV connections"
934 " to connect with the IUCV device\n",
935 netiucv_printname(conn
->userid
, 8));
936 fsm_newstate(fi
, CONN_STATE_CONNERR
);
939 dev_err(privptr
->dev
,
940 "The IUCV device cannot connect to a z/VM guest with no"
941 " IUCV authorization\n");
942 fsm_newstate(fi
, CONN_STATE_CONNERR
);
945 dev_err(privptr
->dev
,
946 "Connecting the IUCV device failed with error %d\n",
948 fsm_newstate(fi
, CONN_STATE_CONNERR
);
951 IUCV_DBF_TEXT_(setup
, 5, "iucv_connect rc is %d\n", rc
);
956 static void netiucv_purge_skb_queue(struct sk_buff_head
*q
)
960 while ((skb
= skb_dequeue(q
))) {
961 refcount_dec(&skb
->users
);
962 dev_kfree_skb_any(skb
);
966 static void conn_action_stop(fsm_instance
*fi
, int event
, void *arg
)
968 struct iucv_event
*ev
= arg
;
969 struct iucv_connection
*conn
= ev
->conn
;
970 struct net_device
*netdev
= conn
->netdev
;
971 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
973 IUCV_DBF_TEXT(trace
, 3, __func__
);
975 fsm_deltimer(&conn
->timer
);
976 fsm_newstate(fi
, CONN_STATE_STOPPED
);
977 netiucv_purge_skb_queue(&conn
->collect_queue
);
979 IUCV_DBF_TEXT(trace
, 5, "calling iucv_path_sever\n");
980 iucv_path_sever(conn
->path
, conn
->userdata
);
984 netiucv_purge_skb_queue(&conn
->commit_queue
);
985 fsm_event(privptr
->fsm
, DEV_EVENT_CONDOWN
, netdev
);
988 static void conn_action_inval(fsm_instance
*fi
, int event
, void *arg
)
990 struct iucv_connection
*conn
= arg
;
991 struct net_device
*netdev
= conn
->netdev
;
993 IUCV_DBF_TEXT_(data
, 2, "%s('%s'): conn_action_inval called\n",
994 netdev
->name
, conn
->userid
);
997 static const fsm_node conn_fsm
[] = {
998 { CONN_STATE_INVALID
, CONN_EVENT_START
, conn_action_inval
},
999 { CONN_STATE_STOPPED
, CONN_EVENT_START
, conn_action_start
},
1001 { CONN_STATE_STOPPED
, CONN_EVENT_STOP
, conn_action_stop
},
1002 { CONN_STATE_STARTWAIT
, CONN_EVENT_STOP
, conn_action_stop
},
1003 { CONN_STATE_SETUPWAIT
, CONN_EVENT_STOP
, conn_action_stop
},
1004 { CONN_STATE_IDLE
, CONN_EVENT_STOP
, conn_action_stop
},
1005 { CONN_STATE_TX
, CONN_EVENT_STOP
, conn_action_stop
},
1006 { CONN_STATE_REGERR
, CONN_EVENT_STOP
, conn_action_stop
},
1007 { CONN_STATE_CONNERR
, CONN_EVENT_STOP
, conn_action_stop
},
1009 { CONN_STATE_STOPPED
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
1010 { CONN_STATE_STARTWAIT
, CONN_EVENT_CONN_REQ
, conn_action_connaccept
},
1011 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_REQ
, conn_action_connaccept
},
1012 { CONN_STATE_IDLE
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
1013 { CONN_STATE_TX
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
1015 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_ACK
, conn_action_connack
},
1016 { CONN_STATE_SETUPWAIT
, CONN_EVENT_TIMER
, conn_action_conntimsev
},
1018 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
1019 { CONN_STATE_IDLE
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
1020 { CONN_STATE_TX
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
1022 { CONN_STATE_IDLE
, CONN_EVENT_RX
, conn_action_rx
},
1023 { CONN_STATE_TX
, CONN_EVENT_RX
, conn_action_rx
},
1025 { CONN_STATE_TX
, CONN_EVENT_TXDONE
, conn_action_txdone
},
1026 { CONN_STATE_IDLE
, CONN_EVENT_TXDONE
, conn_action_txdone
},
1029 static const int CONN_FSM_LEN
= sizeof(conn_fsm
) / sizeof(fsm_node
);
1033 * Actions for interface - statemachine.
1038 * @fi: An instance of an interface statemachine.
1039 * @event: The event, just happened.
1040 * @arg: Generic pointer, casted from struct net_device * upon call.
1042 * Startup connection by sending CONN_EVENT_START to it.
1044 static void dev_action_start(fsm_instance
*fi
, int event
, void *arg
)
1046 struct net_device
*dev
= arg
;
1047 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1049 IUCV_DBF_TEXT(trace
, 3, __func__
);
1051 fsm_newstate(fi
, DEV_STATE_STARTWAIT
);
1052 fsm_event(privptr
->conn
->fsm
, CONN_EVENT_START
, privptr
->conn
);
1056 * Shutdown connection by sending CONN_EVENT_STOP to it.
1058 * @param fi An instance of an interface statemachine.
1059 * @param event The event, just happened.
1060 * @param arg Generic pointer, casted from struct net_device * upon call.
1063 dev_action_stop(fsm_instance
*fi
, int event
, void *arg
)
1065 struct net_device
*dev
= arg
;
1066 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1067 struct iucv_event ev
;
1069 IUCV_DBF_TEXT(trace
, 3, __func__
);
1071 ev
.conn
= privptr
->conn
;
1073 fsm_newstate(fi
, DEV_STATE_STOPWAIT
);
1074 fsm_event(privptr
->conn
->fsm
, CONN_EVENT_STOP
, &ev
);
1078 * Called from connection statemachine
1079 * when a connection is up and running.
1081 * @param fi An instance of an interface statemachine.
1082 * @param event The event, just happened.
1083 * @param arg Generic pointer, casted from struct net_device * upon call.
1086 dev_action_connup(fsm_instance
*fi
, int event
, void *arg
)
1088 struct net_device
*dev
= arg
;
1089 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1091 IUCV_DBF_TEXT(trace
, 3, __func__
);
1093 switch (fsm_getstate(fi
)) {
1094 case DEV_STATE_STARTWAIT
:
1095 fsm_newstate(fi
, DEV_STATE_RUNNING
);
1096 dev_info(privptr
->dev
,
1097 "The IUCV device has been connected"
1098 " successfully to %s\n",
1099 netiucv_printuser(privptr
->conn
));
1100 IUCV_DBF_TEXT(setup
, 3,
1101 "connection is up and running\n");
1103 case DEV_STATE_STOPWAIT
:
1104 IUCV_DBF_TEXT(data
, 2,
1105 "dev_action_connup: in DEV_STATE_STOPWAIT\n");
1111 * Called from connection statemachine
1112 * when a connection has been shutdown.
1114 * @param fi An instance of an interface statemachine.
1115 * @param event The event, just happened.
1116 * @param arg Generic pointer, casted from struct net_device * upon call.
1119 dev_action_conndown(fsm_instance
*fi
, int event
, void *arg
)
1121 IUCV_DBF_TEXT(trace
, 3, __func__
);
1123 switch (fsm_getstate(fi
)) {
1124 case DEV_STATE_RUNNING
:
1125 fsm_newstate(fi
, DEV_STATE_STARTWAIT
);
1127 case DEV_STATE_STOPWAIT
:
1128 fsm_newstate(fi
, DEV_STATE_STOPPED
);
1129 IUCV_DBF_TEXT(setup
, 3, "connection is down\n");
1134 static const fsm_node dev_fsm
[] = {
1135 { DEV_STATE_STOPPED
, DEV_EVENT_START
, dev_action_start
},
1137 { DEV_STATE_STOPWAIT
, DEV_EVENT_START
, dev_action_start
},
1138 { DEV_STATE_STOPWAIT
, DEV_EVENT_CONDOWN
, dev_action_conndown
},
1140 { DEV_STATE_STARTWAIT
, DEV_EVENT_STOP
, dev_action_stop
},
1141 { DEV_STATE_STARTWAIT
, DEV_EVENT_CONUP
, dev_action_connup
},
1143 { DEV_STATE_RUNNING
, DEV_EVENT_STOP
, dev_action_stop
},
1144 { DEV_STATE_RUNNING
, DEV_EVENT_CONDOWN
, dev_action_conndown
},
1145 { DEV_STATE_RUNNING
, DEV_EVENT_CONUP
, netiucv_action_nop
},
1148 static const int DEV_FSM_LEN
= sizeof(dev_fsm
) / sizeof(fsm_node
);
1151 * Transmit a packet.
1152 * This is a helper function for netiucv_tx().
1154 * @param conn Connection to be used for sending.
1155 * @param skb Pointer to struct sk_buff of packet to send.
1156 * The linklevel header has already been set up
1159 * @return 0 on success, -ERRNO on failure. (Never fails.)
1161 static int netiucv_transmit_skb(struct iucv_connection
*conn
,
1162 struct sk_buff
*skb
)
1164 struct iucv_message msg
;
1165 unsigned long saveflags
;
1166 struct ll_header header
;
1169 if (fsm_getstate(conn
->fsm
) != CONN_STATE_IDLE
) {
1170 int l
= skb
->len
+ NETIUCV_HDRLEN
;
1172 spin_lock_irqsave(&conn
->collect_lock
, saveflags
);
1173 if (conn
->collect_len
+ l
>
1174 (conn
->max_buffsize
- NETIUCV_HDRLEN
)) {
1176 IUCV_DBF_TEXT(data
, 2,
1177 "EBUSY from netiucv_transmit_skb\n");
1179 refcount_inc(&skb
->users
);
1180 skb_queue_tail(&conn
->collect_queue
, skb
);
1181 conn
->collect_len
+= l
;
1184 spin_unlock_irqrestore(&conn
->collect_lock
, saveflags
);
1186 struct sk_buff
*nskb
= skb
;
1188 * Copy the skb to a new allocated skb in lowmem only if the
1189 * data is located above 2G in memory or tailroom is < 2.
1191 unsigned long hi
= ((unsigned long)(skb_tail_pointer(skb
) +
1192 NETIUCV_HDRLEN
)) >> 31;
1194 if (hi
|| (skb_tailroom(skb
) < 2)) {
1195 nskb
= alloc_skb(skb
->len
+ NETIUCV_HDRLEN
+
1196 NETIUCV_HDRLEN
, GFP_ATOMIC
| GFP_DMA
);
1198 IUCV_DBF_TEXT(data
, 2, "alloc_skb failed\n");
1202 skb_reserve(nskb
, NETIUCV_HDRLEN
);
1203 skb_put_data(nskb
, skb
->data
, skb
->len
);
1208 * skb now is below 2G and has enough room. Add headers.
1210 header
.next
= nskb
->len
+ NETIUCV_HDRLEN
;
1211 memcpy(skb_push(nskb
, NETIUCV_HDRLEN
), &header
, NETIUCV_HDRLEN
);
1213 skb_put_data(nskb
, &header
, NETIUCV_HDRLEN
);
1215 fsm_newstate(conn
->fsm
, CONN_STATE_TX
);
1216 conn
->prof
.send_stamp
= jiffies
;
1220 rc
= iucv_message_send(conn
->path
, &msg
, 0, 0,
1221 nskb
->data
, nskb
->len
);
1222 conn
->prof
.doios_single
++;
1223 conn
->prof
.txlen
+= skb
->len
;
1224 conn
->prof
.tx_pending
++;
1225 if (conn
->prof
.tx_pending
> conn
->prof
.tx_max_pending
)
1226 conn
->prof
.tx_max_pending
= conn
->prof
.tx_pending
;
1228 struct netiucv_priv
*privptr
;
1229 fsm_newstate(conn
->fsm
, CONN_STATE_IDLE
);
1230 conn
->prof
.tx_pending
--;
1231 privptr
= netdev_priv(conn
->netdev
);
1233 privptr
->stats
.tx_errors
++;
1235 dev_kfree_skb(nskb
);
1238 * Remove our headers. They get added
1239 * again on retransmit.
1241 skb_pull(skb
, NETIUCV_HDRLEN
);
1242 skb_trim(skb
, skb
->len
- NETIUCV_HDRLEN
);
1244 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_send\n", rc
);
1248 refcount_inc(&nskb
->users
);
1249 skb_queue_tail(&conn
->commit_queue
, nskb
);
1257 * Interface API for upper network layers
1261 * Open an interface.
1262 * Called from generic network layer when ifconfig up is run.
1264 * @param dev Pointer to interface struct.
1266 * @return 0 on success, -ERRNO on failure. (Never fails.)
1268 static int netiucv_open(struct net_device
*dev
)
1270 struct netiucv_priv
*priv
= netdev_priv(dev
);
1272 fsm_event(priv
->fsm
, DEV_EVENT_START
, dev
);
1277 * Close an interface.
1278 * Called from generic network layer when ifconfig down is run.
1280 * @param dev Pointer to interface struct.
1282 * @return 0 on success, -ERRNO on failure. (Never fails.)
1284 static int netiucv_close(struct net_device
*dev
)
1286 struct netiucv_priv
*priv
= netdev_priv(dev
);
1288 fsm_event(priv
->fsm
, DEV_EVENT_STOP
, dev
);
1292 static int netiucv_pm_prepare(struct device
*dev
)
1294 IUCV_DBF_TEXT(trace
, 3, __func__
);
1298 static void netiucv_pm_complete(struct device
*dev
)
1300 IUCV_DBF_TEXT(trace
, 3, __func__
);
1305 * netiucv_pm_freeze() - Freeze PM callback
1306 * @dev: netiucv device
1308 * close open netiucv interfaces
1310 static int netiucv_pm_freeze(struct device
*dev
)
1312 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1313 struct net_device
*ndev
= NULL
;
1316 IUCV_DBF_TEXT(trace
, 3, __func__
);
1317 if (priv
&& priv
->conn
)
1318 ndev
= priv
->conn
->netdev
;
1321 netif_device_detach(ndev
);
1322 priv
->pm_state
= fsm_getstate(priv
->fsm
);
1323 rc
= netiucv_close(ndev
);
1329 * netiucv_pm_restore_thaw() - Thaw and restore PM callback
1330 * @dev: netiucv device
1332 * re-open netiucv interfaces closed during freeze
1334 static int netiucv_pm_restore_thaw(struct device
*dev
)
1336 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1337 struct net_device
*ndev
= NULL
;
1340 IUCV_DBF_TEXT(trace
, 3, __func__
);
1341 if (priv
&& priv
->conn
)
1342 ndev
= priv
->conn
->netdev
;
1345 switch (priv
->pm_state
) {
1346 case DEV_STATE_RUNNING
:
1347 case DEV_STATE_STARTWAIT
:
1348 rc
= netiucv_open(ndev
);
1353 netif_device_attach(ndev
);
1359 * Start transmission of a packet.
1360 * Called from generic network device layer.
1362 * @param skb Pointer to buffer containing the packet.
1363 * @param dev Pointer to interface struct.
1365 * @return 0 if packet consumed, !0 if packet rejected.
1366 * Note: If we return !0, then the packet is free'd by
1367 * the generic network layer.
1369 static int netiucv_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1371 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1374 IUCV_DBF_TEXT(trace
, 4, __func__
);
1376 * Some sanity checks ...
1379 IUCV_DBF_TEXT(data
, 2, "netiucv_tx: skb is NULL\n");
1380 privptr
->stats
.tx_dropped
++;
1381 return NETDEV_TX_OK
;
1383 if (skb_headroom(skb
) < NETIUCV_HDRLEN
) {
1384 IUCV_DBF_TEXT(data
, 2,
1385 "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1387 privptr
->stats
.tx_dropped
++;
1388 return NETDEV_TX_OK
;
1392 * If connection is not running, try to restart it
1393 * and throw away packet.
1395 if (fsm_getstate(privptr
->fsm
) != DEV_STATE_RUNNING
) {
1397 privptr
->stats
.tx_dropped
++;
1398 privptr
->stats
.tx_errors
++;
1399 privptr
->stats
.tx_carrier_errors
++;
1400 return NETDEV_TX_OK
;
1403 if (netiucv_test_and_set_busy(dev
)) {
1404 IUCV_DBF_TEXT(data
, 2, "EBUSY from netiucv_tx\n");
1405 return NETDEV_TX_BUSY
;
1407 netif_trans_update(dev
);
1408 rc
= netiucv_transmit_skb(privptr
->conn
, skb
);
1409 netiucv_clear_busy(dev
);
1410 return rc
? NETDEV_TX_BUSY
: NETDEV_TX_OK
;
1415 * @dev: Pointer to interface struct.
1417 * Returns interface statistics of a device.
1419 * Returns pointer to stats struct of this interface.
1421 static struct net_device_stats
*netiucv_stats (struct net_device
* dev
)
1423 struct netiucv_priv
*priv
= netdev_priv(dev
);
1425 IUCV_DBF_TEXT(trace
, 5, __func__
);
1426 return &priv
->stats
;
1430 * attributes in sysfs
1433 static ssize_t
user_show(struct device
*dev
, struct device_attribute
*attr
,
1436 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1438 IUCV_DBF_TEXT(trace
, 5, __func__
);
1439 return sprintf(buf
, "%s\n", netiucv_printuser(priv
->conn
));
1442 static int netiucv_check_user(const char *buf
, size_t count
, char *username
,
1448 p
= strchr(buf
, '.');
1449 if ((p
&& ((count
> 26) ||
1451 (buf
+ count
- p
> 18))) ||
1452 (!p
&& (count
> 9))) {
1453 IUCV_DBF_TEXT(setup
, 2, "conn_write: too long\n");
1457 for (i
= 0, p
= buf
; i
< 8 && *p
&& *p
!= '.'; i
++, p
++) {
1458 if (isalnum(*p
) || *p
== '$') {
1459 username
[i
] = toupper(*p
);
1463 /* trailing lf, grr */
1465 IUCV_DBF_TEXT_(setup
, 2,
1466 "conn_write: invalid character %02x\n", *p
);
1470 username
[i
++] = ' ';
1475 for (i
= 0; i
< 16 && *p
; i
++, p
++) {
1478 userdata
[i
] = toupper(*p
);
1480 while (i
> 0 && i
< 16)
1481 userdata
[i
++] = ' ';
1483 memcpy(userdata
, iucvMagic_ascii
, 16);
1484 userdata
[16] = '\0';
1485 ASCEBC(userdata
, 16);
1490 static ssize_t
user_write(struct device
*dev
, struct device_attribute
*attr
,
1491 const char *buf
, size_t count
)
1493 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1494 struct net_device
*ndev
= priv
->conn
->netdev
;
1498 struct iucv_connection
*cp
;
1500 IUCV_DBF_TEXT(trace
, 3, __func__
);
1501 rc
= netiucv_check_user(buf
, count
, username
, userdata
);
1505 if (memcmp(username
, priv
->conn
->userid
, 9) &&
1506 (ndev
->flags
& (IFF_UP
| IFF_RUNNING
))) {
1507 /* username changed while the interface is active. */
1508 IUCV_DBF_TEXT(setup
, 2, "user_write: device active\n");
1511 read_lock_bh(&iucv_connection_rwlock
);
1512 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
1513 if (!strncmp(username
, cp
->userid
, 9) &&
1514 !strncmp(userdata
, cp
->userdata
, 17) && cp
->netdev
!= ndev
) {
1515 read_unlock_bh(&iucv_connection_rwlock
);
1516 IUCV_DBF_TEXT_(setup
, 2, "user_write: Connection to %s "
1517 "already exists\n", netiucv_printuser(cp
));
1521 read_unlock_bh(&iucv_connection_rwlock
);
1522 memcpy(priv
->conn
->userid
, username
, 9);
1523 memcpy(priv
->conn
->userdata
, userdata
, 17);
1527 static DEVICE_ATTR(user
, 0644, user_show
, user_write
);
1529 static ssize_t
buffer_show (struct device
*dev
, struct device_attribute
*attr
,
1532 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1534 IUCV_DBF_TEXT(trace
, 5, __func__
);
1535 return sprintf(buf
, "%d\n", priv
->conn
->max_buffsize
);
1538 static ssize_t
buffer_write (struct device
*dev
, struct device_attribute
*attr
,
1539 const char *buf
, size_t count
)
1541 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1542 struct net_device
*ndev
= priv
->conn
->netdev
;
1546 IUCV_DBF_TEXT(trace
, 3, __func__
);
1550 rc
= kstrtouint(buf
, 0, &bs1
);
1552 if (rc
== -EINVAL
) {
1553 IUCV_DBF_TEXT_(setup
, 2, "buffer_write: invalid char %s\n",
1557 if ((rc
== -ERANGE
) || (bs1
> NETIUCV_BUFSIZE_MAX
)) {
1558 IUCV_DBF_TEXT_(setup
, 2,
1559 "buffer_write: buffer size %d too large\n",
1563 if ((ndev
->flags
& IFF_RUNNING
) &&
1564 (bs1
< (ndev
->mtu
+ NETIUCV_HDRLEN
+ 2))) {
1565 IUCV_DBF_TEXT_(setup
, 2,
1566 "buffer_write: buffer size %d too small\n",
1570 if (bs1
< (576 + NETIUCV_HDRLEN
+ NETIUCV_HDRLEN
)) {
1571 IUCV_DBF_TEXT_(setup
, 2,
1572 "buffer_write: buffer size %d too small\n",
1577 priv
->conn
->max_buffsize
= bs1
;
1578 if (!(ndev
->flags
& IFF_RUNNING
))
1579 ndev
->mtu
= bs1
- NETIUCV_HDRLEN
- NETIUCV_HDRLEN
;
1585 static DEVICE_ATTR(buffer
, 0644, buffer_show
, buffer_write
);
1587 static ssize_t
dev_fsm_show (struct device
*dev
, struct device_attribute
*attr
,
1590 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1592 IUCV_DBF_TEXT(trace
, 5, __func__
);
1593 return sprintf(buf
, "%s\n", fsm_getstate_str(priv
->fsm
));
1596 static DEVICE_ATTR(device_fsm_state
, 0444, dev_fsm_show
, NULL
);
1598 static ssize_t
conn_fsm_show (struct device
*dev
,
1599 struct device_attribute
*attr
, char *buf
)
1601 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1603 IUCV_DBF_TEXT(trace
, 5, __func__
);
1604 return sprintf(buf
, "%s\n", fsm_getstate_str(priv
->conn
->fsm
));
1607 static DEVICE_ATTR(connection_fsm_state
, 0444, conn_fsm_show
, NULL
);
1609 static ssize_t
maxmulti_show (struct device
*dev
,
1610 struct device_attribute
*attr
, char *buf
)
1612 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1614 IUCV_DBF_TEXT(trace
, 5, __func__
);
1615 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.maxmulti
);
1618 static ssize_t
maxmulti_write (struct device
*dev
,
1619 struct device_attribute
*attr
,
1620 const char *buf
, size_t count
)
1622 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1624 IUCV_DBF_TEXT(trace
, 4, __func__
);
1625 priv
->conn
->prof
.maxmulti
= 0;
1629 static DEVICE_ATTR(max_tx_buffer_used
, 0644, maxmulti_show
, maxmulti_write
);
1631 static ssize_t
maxcq_show (struct device
*dev
, struct device_attribute
*attr
,
1634 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1636 IUCV_DBF_TEXT(trace
, 5, __func__
);
1637 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.maxcqueue
);
1640 static ssize_t
maxcq_write (struct device
*dev
, struct device_attribute
*attr
,
1641 const char *buf
, size_t count
)
1643 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1645 IUCV_DBF_TEXT(trace
, 4, __func__
);
1646 priv
->conn
->prof
.maxcqueue
= 0;
1650 static DEVICE_ATTR(max_chained_skbs
, 0644, maxcq_show
, maxcq_write
);
1652 static ssize_t
sdoio_show (struct device
*dev
, struct device_attribute
*attr
,
1655 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1657 IUCV_DBF_TEXT(trace
, 5, __func__
);
1658 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.doios_single
);
1661 static ssize_t
sdoio_write (struct device
*dev
, struct device_attribute
*attr
,
1662 const char *buf
, size_t count
)
1664 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1666 IUCV_DBF_TEXT(trace
, 4, __func__
);
1667 priv
->conn
->prof
.doios_single
= 0;
1671 static DEVICE_ATTR(tx_single_write_ops
, 0644, sdoio_show
, sdoio_write
);
1673 static ssize_t
mdoio_show (struct device
*dev
, struct device_attribute
*attr
,
1676 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1678 IUCV_DBF_TEXT(trace
, 5, __func__
);
1679 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.doios_multi
);
1682 static ssize_t
mdoio_write (struct device
*dev
, struct device_attribute
*attr
,
1683 const char *buf
, size_t count
)
1685 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1687 IUCV_DBF_TEXT(trace
, 5, __func__
);
1688 priv
->conn
->prof
.doios_multi
= 0;
1692 static DEVICE_ATTR(tx_multi_write_ops
, 0644, mdoio_show
, mdoio_write
);
1694 static ssize_t
txlen_show (struct device
*dev
, struct device_attribute
*attr
,
1697 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1699 IUCV_DBF_TEXT(trace
, 5, __func__
);
1700 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.txlen
);
1703 static ssize_t
txlen_write (struct device
*dev
, struct device_attribute
*attr
,
1704 const char *buf
, size_t count
)
1706 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1708 IUCV_DBF_TEXT(trace
, 4, __func__
);
1709 priv
->conn
->prof
.txlen
= 0;
1713 static DEVICE_ATTR(netto_bytes
, 0644, txlen_show
, txlen_write
);
1715 static ssize_t
txtime_show (struct device
*dev
, struct device_attribute
*attr
,
1718 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1720 IUCV_DBF_TEXT(trace
, 5, __func__
);
1721 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_time
);
1724 static ssize_t
txtime_write (struct device
*dev
, struct device_attribute
*attr
,
1725 const char *buf
, size_t count
)
1727 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1729 IUCV_DBF_TEXT(trace
, 4, __func__
);
1730 priv
->conn
->prof
.tx_time
= 0;
1734 static DEVICE_ATTR(max_tx_io_time
, 0644, txtime_show
, txtime_write
);
1736 static ssize_t
txpend_show (struct device
*dev
, struct device_attribute
*attr
,
1739 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1741 IUCV_DBF_TEXT(trace
, 5, __func__
);
1742 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_pending
);
1745 static ssize_t
txpend_write (struct device
*dev
, struct device_attribute
*attr
,
1746 const char *buf
, size_t count
)
1748 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1750 IUCV_DBF_TEXT(trace
, 4, __func__
);
1751 priv
->conn
->prof
.tx_pending
= 0;
1755 static DEVICE_ATTR(tx_pending
, 0644, txpend_show
, txpend_write
);
1757 static ssize_t
txmpnd_show (struct device
*dev
, struct device_attribute
*attr
,
1760 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1762 IUCV_DBF_TEXT(trace
, 5, __func__
);
1763 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_max_pending
);
1766 static ssize_t
txmpnd_write (struct device
*dev
, struct device_attribute
*attr
,
1767 const char *buf
, size_t count
)
1769 struct netiucv_priv
*priv
= dev_get_drvdata(dev
);
1771 IUCV_DBF_TEXT(trace
, 4, __func__
);
1772 priv
->conn
->prof
.tx_max_pending
= 0;
1776 static DEVICE_ATTR(tx_max_pending
, 0644, txmpnd_show
, txmpnd_write
);
1778 static struct attribute
*netiucv_attrs
[] = {
1779 &dev_attr_buffer
.attr
,
1780 &dev_attr_user
.attr
,
1784 static struct attribute_group netiucv_attr_group
= {
1785 .attrs
= netiucv_attrs
,
1788 static struct attribute
*netiucv_stat_attrs
[] = {
1789 &dev_attr_device_fsm_state
.attr
,
1790 &dev_attr_connection_fsm_state
.attr
,
1791 &dev_attr_max_tx_buffer_used
.attr
,
1792 &dev_attr_max_chained_skbs
.attr
,
1793 &dev_attr_tx_single_write_ops
.attr
,
1794 &dev_attr_tx_multi_write_ops
.attr
,
1795 &dev_attr_netto_bytes
.attr
,
1796 &dev_attr_max_tx_io_time
.attr
,
1797 &dev_attr_tx_pending
.attr
,
1798 &dev_attr_tx_max_pending
.attr
,
1802 static struct attribute_group netiucv_stat_attr_group
= {
1804 .attrs
= netiucv_stat_attrs
,
1807 static const struct attribute_group
*netiucv_attr_groups
[] = {
1808 &netiucv_stat_attr_group
,
1809 &netiucv_attr_group
,
1813 static int netiucv_register_device(struct net_device
*ndev
)
1815 struct netiucv_priv
*priv
= netdev_priv(ndev
);
1816 struct device
*dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1819 IUCV_DBF_TEXT(trace
, 3, __func__
);
1822 dev_set_name(dev
, "net%s", ndev
->name
);
1823 dev
->bus
= &iucv_bus
;
1824 dev
->parent
= iucv_root
;
1825 dev
->groups
= netiucv_attr_groups
;
1827 * The release function could be called after the
1828 * module has been unloaded. It's _only_ task is to
1829 * free the struct. Therefore, we specify kfree()
1830 * directly here. (Probably a little bit obfuscating
1831 * but legitime ...).
1833 dev
->release
= (void (*)(struct device
*))kfree
;
1834 dev
->driver
= &netiucv_driver
;
1838 ret
= device_register(dev
);
1844 dev_set_drvdata(dev
, priv
);
1848 static void netiucv_unregister_device(struct device
*dev
)
1850 IUCV_DBF_TEXT(trace
, 3, __func__
);
1851 device_unregister(dev
);
1855 * Allocate and initialize a new connection structure.
1856 * Add it to the list of netiucv connections;
1858 static struct iucv_connection
*netiucv_new_connection(struct net_device
*dev
,
1862 struct iucv_connection
*conn
;
1864 conn
= kzalloc(sizeof(*conn
), GFP_KERNEL
);
1867 skb_queue_head_init(&conn
->collect_queue
);
1868 skb_queue_head_init(&conn
->commit_queue
);
1869 spin_lock_init(&conn
->collect_lock
);
1870 conn
->max_buffsize
= NETIUCV_BUFSIZE_DEFAULT
;
1873 conn
->rx_buff
= alloc_skb(conn
->max_buffsize
, GFP_KERNEL
| GFP_DMA
);
1876 conn
->tx_buff
= alloc_skb(conn
->max_buffsize
, GFP_KERNEL
| GFP_DMA
);
1879 conn
->fsm
= init_fsm("netiucvconn", conn_state_names
,
1880 conn_event_names
, NR_CONN_STATES
,
1881 NR_CONN_EVENTS
, conn_fsm
, CONN_FSM_LEN
,
1886 fsm_settimer(conn
->fsm
, &conn
->timer
);
1887 fsm_newstate(conn
->fsm
, CONN_STATE_INVALID
);
1890 memcpy(conn
->userdata
, userdata
, 17);
1892 memcpy(conn
->userid
, username
, 9);
1893 fsm_newstate(conn
->fsm
, CONN_STATE_STOPPED
);
1896 write_lock_bh(&iucv_connection_rwlock
);
1897 list_add_tail(&conn
->list
, &iucv_connection_list
);
1898 write_unlock_bh(&iucv_connection_rwlock
);
1902 kfree_skb(conn
->tx_buff
);
1904 kfree_skb(conn
->rx_buff
);
1912 * Release a connection structure and remove it from the
1913 * list of netiucv connections.
1915 static void netiucv_remove_connection(struct iucv_connection
*conn
)
1918 IUCV_DBF_TEXT(trace
, 3, __func__
);
1919 write_lock_bh(&iucv_connection_rwlock
);
1920 list_del_init(&conn
->list
);
1921 write_unlock_bh(&iucv_connection_rwlock
);
1922 fsm_deltimer(&conn
->timer
);
1923 netiucv_purge_skb_queue(&conn
->collect_queue
);
1925 iucv_path_sever(conn
->path
, conn
->userdata
);
1929 netiucv_purge_skb_queue(&conn
->commit_queue
);
1930 kfree_fsm(conn
->fsm
);
1931 kfree_skb(conn
->rx_buff
);
1932 kfree_skb(conn
->tx_buff
);
1936 * Release everything of a net device.
1938 static void netiucv_free_netdevice(struct net_device
*dev
)
1940 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1942 IUCV_DBF_TEXT(trace
, 3, __func__
);
1949 netiucv_remove_connection(privptr
->conn
);
1951 kfree_fsm(privptr
->fsm
);
1952 privptr
->conn
= NULL
; privptr
->fsm
= NULL
;
1953 /* privptr gets freed by free_netdev() */
1958 * Initialize a net device. (Called from kernel in alloc_netdev())
1960 static const struct net_device_ops netiucv_netdev_ops
= {
1961 .ndo_open
= netiucv_open
,
1962 .ndo_stop
= netiucv_close
,
1963 .ndo_get_stats
= netiucv_stats
,
1964 .ndo_start_xmit
= netiucv_tx
,
1967 static void netiucv_setup_netdevice(struct net_device
*dev
)
1969 dev
->mtu
= NETIUCV_MTU_DEFAULT
;
1971 dev
->max_mtu
= NETIUCV_MTU_MAX
;
1972 dev
->needs_free_netdev
= true;
1973 dev
->priv_destructor
= netiucv_free_netdevice
;
1974 dev
->hard_header_len
= NETIUCV_HDRLEN
;
1976 dev
->type
= ARPHRD_SLIP
;
1977 dev
->tx_queue_len
= NETIUCV_QUEUELEN_DEFAULT
;
1978 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
;
1979 dev
->netdev_ops
= &netiucv_netdev_ops
;
1983 * Allocate and initialize everything of a net device.
1985 static struct net_device
*netiucv_init_netdevice(char *username
, char *userdata
)
1987 struct netiucv_priv
*privptr
;
1988 struct net_device
*dev
;
1990 dev
= alloc_netdev(sizeof(struct netiucv_priv
), "iucv%d",
1991 NET_NAME_UNKNOWN
, netiucv_setup_netdevice
);
1995 if (dev_alloc_name(dev
, dev
->name
) < 0)
1998 privptr
= netdev_priv(dev
);
1999 privptr
->fsm
= init_fsm("netiucvdev", dev_state_names
,
2000 dev_event_names
, NR_DEV_STATES
, NR_DEV_EVENTS
,
2001 dev_fsm
, DEV_FSM_LEN
, GFP_KERNEL
);
2005 privptr
->conn
= netiucv_new_connection(dev
, username
, userdata
);
2006 if (!privptr
->conn
) {
2007 IUCV_DBF_TEXT(setup
, 2, "NULL from netiucv_new_connection\n");
2010 fsm_newstate(privptr
->fsm
, DEV_STATE_STOPPED
);
2014 kfree_fsm(privptr
->fsm
);
2021 static ssize_t
connection_store(struct device_driver
*drv
, const char *buf
,
2027 struct net_device
*dev
;
2028 struct netiucv_priv
*priv
;
2029 struct iucv_connection
*cp
;
2031 IUCV_DBF_TEXT(trace
, 3, __func__
);
2032 rc
= netiucv_check_user(buf
, count
, username
, userdata
);
2036 read_lock_bh(&iucv_connection_rwlock
);
2037 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
2038 if (!strncmp(username
, cp
->userid
, 9) &&
2039 !strncmp(userdata
, cp
->userdata
, 17)) {
2040 read_unlock_bh(&iucv_connection_rwlock
);
2041 IUCV_DBF_TEXT_(setup
, 2, "conn_write: Connection to %s "
2042 "already exists\n", netiucv_printuser(cp
));
2046 read_unlock_bh(&iucv_connection_rwlock
);
2048 dev
= netiucv_init_netdevice(username
, userdata
);
2050 IUCV_DBF_TEXT(setup
, 2, "NULL from netiucv_init_netdevice\n");
2054 rc
= netiucv_register_device(dev
);
2057 IUCV_DBF_TEXT_(setup
, 2,
2058 "ret %d from netiucv_register_device\n", rc
);
2063 priv
= netdev_priv(dev
);
2064 SET_NETDEV_DEV(dev
, priv
->dev
);
2066 rc
= register_netdevice(dev
);
2071 dev_info(priv
->dev
, "The IUCV interface to %s has been established "
2073 netiucv_printuser(priv
->conn
));
2078 netiucv_unregister_device(priv
->dev
);
2080 netiucv_free_netdevice(dev
);
2083 static DRIVER_ATTR_WO(connection
);
2085 static ssize_t
remove_store(struct device_driver
*drv
, const char *buf
,
2088 struct iucv_connection
*cp
;
2089 struct net_device
*ndev
;
2090 struct netiucv_priv
*priv
;
2092 char name
[IFNAMSIZ
];
2096 IUCV_DBF_TEXT(trace
, 3, __func__
);
2098 if (count
>= IFNAMSIZ
)
2099 count
= IFNAMSIZ
- 1;
2101 for (i
= 0, p
= buf
; i
< count
&& *p
; i
++, p
++) {
2102 if (*p
== '\n' || *p
== ' ')
2103 /* trailing lf, grr */
2109 read_lock_bh(&iucv_connection_rwlock
);
2110 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
2112 priv
= netdev_priv(ndev
);
2114 if (strncmp(name
, ndev
->name
, count
))
2116 read_unlock_bh(&iucv_connection_rwlock
);
2117 if (ndev
->flags
& (IFF_UP
| IFF_RUNNING
)) {
2118 dev_warn(dev
, "The IUCV device is connected"
2119 " to %s and cannot be removed\n",
2120 priv
->conn
->userid
);
2121 IUCV_DBF_TEXT(data
, 2, "remove_write: still active\n");
2124 unregister_netdev(ndev
);
2125 netiucv_unregister_device(dev
);
2128 read_unlock_bh(&iucv_connection_rwlock
);
2129 IUCV_DBF_TEXT(data
, 2, "remove_write: unknown device\n");
2132 static DRIVER_ATTR_WO(remove
);
2134 static struct attribute
* netiucv_drv_attrs
[] = {
2135 &driver_attr_connection
.attr
,
2136 &driver_attr_remove
.attr
,
2140 static struct attribute_group netiucv_drv_attr_group
= {
2141 .attrs
= netiucv_drv_attrs
,
2144 static const struct attribute_group
*netiucv_drv_attr_groups
[] = {
2145 &netiucv_drv_attr_group
,
2149 static void netiucv_banner(void)
2151 pr_info("driver initialized\n");
2154 static void __exit
netiucv_exit(void)
2156 struct iucv_connection
*cp
;
2157 struct net_device
*ndev
;
2158 struct netiucv_priv
*priv
;
2161 IUCV_DBF_TEXT(trace
, 3, __func__
);
2162 while (!list_empty(&iucv_connection_list
)) {
2163 cp
= list_entry(iucv_connection_list
.next
,
2164 struct iucv_connection
, list
);
2166 priv
= netdev_priv(ndev
);
2169 unregister_netdev(ndev
);
2170 netiucv_unregister_device(dev
);
2173 device_unregister(netiucv_dev
);
2174 driver_unregister(&netiucv_driver
);
2175 iucv_unregister(&netiucv_handler
, 1);
2176 iucv_unregister_dbf_views();
2178 pr_info("driver unloaded\n");
2182 static int __init
netiucv_init(void)
2186 rc
= iucv_register_dbf_views();
2189 rc
= iucv_register(&netiucv_handler
, 1);
2192 IUCV_DBF_TEXT(trace
, 3, __func__
);
2193 netiucv_driver
.groups
= netiucv_drv_attr_groups
;
2194 rc
= driver_register(&netiucv_driver
);
2196 IUCV_DBF_TEXT_(setup
, 2, "ret %d from driver_register\n", rc
);
2199 /* establish dummy device */
2200 netiucv_dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
2205 dev_set_name(netiucv_dev
, "netiucv");
2206 netiucv_dev
->bus
= &iucv_bus
;
2207 netiucv_dev
->parent
= iucv_root
;
2208 netiucv_dev
->release
= (void (*)(struct device
*))kfree
;
2209 netiucv_dev
->driver
= &netiucv_driver
;
2210 rc
= device_register(netiucv_dev
);
2212 put_device(netiucv_dev
);
2219 driver_unregister(&netiucv_driver
);
2221 iucv_unregister(&netiucv_handler
, 1);
2223 iucv_unregister_dbf_views();
2228 module_init(netiucv_init
);
2229 module_exit(netiucv_exit
);
2230 MODULE_LICENSE("GPL");