4 * Copyright 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
5 * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
7 * Sysfs integration and all bugs therein by Cornelia Huck
8 * (cornelia.huck@de.ibm.com)
11 * the source of the original IUCV driver by:
12 * Stefan Hegewald <hegewald@de.ibm.com>
13 * Hartmut Penner <hpenner@de.ibm.com>
14 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
15 * Martin Schwidefsky (schwidefsky@de.ibm.com)
16 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2, or (at your option)
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39 #include <linux/slab.h>
40 #include <linux/errno.h>
41 #include <linux/types.h>
42 #include <linux/interrupt.h>
43 #include <linux/timer.h>
44 #include <linux/bitops.h>
46 #include <linux/signal.h>
47 #include <linux/string.h>
48 #include <linux/device.h>
51 #include <linux/if_arp.h>
52 #include <linux/tcp.h>
53 #include <linux/skbuff.h>
54 #include <linux/ctype.h>
58 #include <asm/uaccess.h>
60 #include <net/iucv/iucv.h>
64 ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
65 MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
68 * Debug Facility stuff
70 #define IUCV_DBF_SETUP_NAME "iucv_setup"
71 #define IUCV_DBF_SETUP_LEN 32
72 #define IUCV_DBF_SETUP_PAGES 2
73 #define IUCV_DBF_SETUP_NR_AREAS 1
74 #define IUCV_DBF_SETUP_LEVEL 3
76 #define IUCV_DBF_DATA_NAME "iucv_data"
77 #define IUCV_DBF_DATA_LEN 128
78 #define IUCV_DBF_DATA_PAGES 2
79 #define IUCV_DBF_DATA_NR_AREAS 1
80 #define IUCV_DBF_DATA_LEVEL 2
82 #define IUCV_DBF_TRACE_NAME "iucv_trace"
83 #define IUCV_DBF_TRACE_LEN 16
84 #define IUCV_DBF_TRACE_PAGES 4
85 #define IUCV_DBF_TRACE_NR_AREAS 1
86 #define IUCV_DBF_TRACE_LEVEL 3
88 #define IUCV_DBF_TEXT(name,level,text) \
90 debug_text_event(iucv_dbf_##name,level,text); \
93 #define IUCV_DBF_HEX(name,level,addr,len) \
95 debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
98 DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf
);
100 /* Allow to sort out low debug levels early to avoid wasted sprints */
101 static inline int iucv_dbf_passes(debug_info_t
*dbf_grp
, int level
)
103 return (level
<= dbf_grp
->level
);
106 #define IUCV_DBF_TEXT_(name, level, text...) \
108 if (iucv_dbf_passes(iucv_dbf_##name, level)) { \
109 char* iucv_dbf_txt_buf = \
110 get_cpu_var(iucv_dbf_txt_buf); \
111 sprintf(iucv_dbf_txt_buf, text); \
112 debug_text_event(iucv_dbf_##name, level, \
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 IUCV_HEXDUMP16(importance,header,ptr) \
128 PRINT_##importance(header "%02x %02x %02x %02x %02x %02x %02x %02x " \
129 "%02x %02x %02x %02x %02x %02x %02x %02x\n", \
130 *(((char*)ptr)),*(((char*)ptr)+1),*(((char*)ptr)+2), \
131 *(((char*)ptr)+3),*(((char*)ptr)+4),*(((char*)ptr)+5), \
132 *(((char*)ptr)+6),*(((char*)ptr)+7),*(((char*)ptr)+8), \
133 *(((char*)ptr)+9),*(((char*)ptr)+10),*(((char*)ptr)+11), \
134 *(((char*)ptr)+12),*(((char*)ptr)+13), \
135 *(((char*)ptr)+14),*(((char*)ptr)+15)); \
136 PRINT_##importance(header "%02x %02x %02x %02x %02x %02x %02x %02x " \
137 "%02x %02x %02x %02x %02x %02x %02x %02x\n", \
138 *(((char*)ptr)+16),*(((char*)ptr)+17), \
139 *(((char*)ptr)+18),*(((char*)ptr)+19), \
140 *(((char*)ptr)+20),*(((char*)ptr)+21), \
141 *(((char*)ptr)+22),*(((char*)ptr)+23), \
142 *(((char*)ptr)+24),*(((char*)ptr)+25), \
143 *(((char*)ptr)+26),*(((char*)ptr)+27), \
144 *(((char*)ptr)+28),*(((char*)ptr)+29), \
145 *(((char*)ptr)+30),*(((char*)ptr)+31));
147 #define PRINTK_HEADER " iucv: " /* for debugging */
149 static struct device_driver netiucv_driver
= {
150 .owner
= THIS_MODULE
,
155 static int netiucv_callback_connreq(struct iucv_path
*,
156 u8 ipvmid
[8], u8 ipuser
[16]);
157 static void netiucv_callback_connack(struct iucv_path
*, u8 ipuser
[16]);
158 static void netiucv_callback_connrej(struct iucv_path
*, u8 ipuser
[16]);
159 static void netiucv_callback_connsusp(struct iucv_path
*, u8 ipuser
[16]);
160 static void netiucv_callback_connres(struct iucv_path
*, u8 ipuser
[16]);
161 static void netiucv_callback_rx(struct iucv_path
*, struct iucv_message
*);
162 static void netiucv_callback_txdone(struct iucv_path
*, struct iucv_message
*);
164 static struct iucv_handler netiucv_handler
= {
165 .path_pending
= netiucv_callback_connreq
,
166 .path_complete
= netiucv_callback_connack
,
167 .path_severed
= netiucv_callback_connrej
,
168 .path_quiesced
= netiucv_callback_connsusp
,
169 .path_resumed
= netiucv_callback_connres
,
170 .message_pending
= netiucv_callback_rx
,
171 .message_complete
= netiucv_callback_txdone
175 * Per connection profiling data
177 struct connection_profile
{
178 unsigned long maxmulti
;
179 unsigned long maxcqueue
;
180 unsigned long doios_single
;
181 unsigned long doios_multi
;
183 unsigned long tx_time
;
184 struct timespec send_stamp
;
185 unsigned long tx_pending
;
186 unsigned long tx_max_pending
;
190 * Representation of one iucv connection
192 struct iucv_connection
{
193 struct list_head list
;
194 struct iucv_path
*path
;
195 struct sk_buff
*rx_buff
;
196 struct sk_buff
*tx_buff
;
197 struct sk_buff_head collect_queue
;
198 struct sk_buff_head commit_queue
;
199 spinlock_t collect_lock
;
204 struct net_device
*netdev
;
205 struct connection_profile prof
;
210 * Linked list of all connection structs.
212 static LIST_HEAD(iucv_connection_list
);
213 static DEFINE_RWLOCK(iucv_connection_rwlock
);
216 * Representation of event-data for the
217 * connection state machine.
220 struct iucv_connection
*conn
;
225 * Private part of the network device structure
227 struct netiucv_priv
{
228 struct net_device_stats stats
;
231 struct iucv_connection
*conn
;
236 * Link level header for a packet.
242 #define NETIUCV_HDRLEN (sizeof(struct ll_header))
243 #define NETIUCV_BUFSIZE_MAX 32768
244 #define NETIUCV_BUFSIZE_DEFAULT NETIUCV_BUFSIZE_MAX
245 #define NETIUCV_MTU_MAX (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
246 #define NETIUCV_MTU_DEFAULT 9216
247 #define NETIUCV_QUEUELEN_DEFAULT 50
248 #define NETIUCV_TIMEOUT_5SEC 5000
251 * Compatibility macros for busy handling
252 * of network devices.
254 static inline void netiucv_clear_busy(struct net_device
*dev
)
256 struct netiucv_priv
*priv
= netdev_priv(dev
);
257 clear_bit(0, &priv
->tbusy
);
258 netif_wake_queue(dev
);
261 static inline int netiucv_test_and_set_busy(struct net_device
*dev
)
263 struct netiucv_priv
*priv
= netdev_priv(dev
);
264 netif_stop_queue(dev
);
265 return test_and_set_bit(0, &priv
->tbusy
);
268 static u8 iucvMagic
[16] = {
269 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
270 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
274 * Convert an iucv userId to its printable
275 * form (strip whitespace at end).
277 * @param An iucv userId
279 * @returns The printable string (static data!!)
281 static char *netiucv_printname(char *name
)
285 memcpy(tmp
, name
, 8);
287 while (*p
&& (!isspace(*p
)))
294 * States of the interface statemachine.
302 * MUST be always the last element!!
307 static const char *dev_state_names
[] = {
315 * Events of the interface statemachine.
323 * MUST be always the last element!!
328 static const char *dev_event_names
[] = {
336 * Events of the connection statemachine
340 * Events, representing callbacks from
341 * lowlevel iucv layer)
352 * Events, representing errors return codes from
353 * calls to lowlevel iucv layer
357 * Event, representing timer expiry.
362 * Events, representing commands from upper levels.
368 * MUST be always the last element!!
373 static const char *conn_event_names
[] = {
374 "Remote connection request",
375 "Remote connection acknowledge",
376 "Remote connection reject",
377 "Connection suspended",
378 "Connection resumed",
389 * States of the connection statemachine.
393 * Connection not assigned to any device,
394 * initial state, invalid
399 * Userid assigned but not operating
404 * Connection registered,
405 * no connection request sent yet,
406 * no connection request received
408 CONN_STATE_STARTWAIT
,
411 * Connection registered and connection request sent,
412 * no acknowledge and no connection request received yet.
414 CONN_STATE_SETUPWAIT
,
417 * Connection up and running idle
422 * Data sent, awaiting CONN_EVENT_TXDONE
427 * Error during registration.
432 * Error during registration.
437 * MUST be always the last element!!
442 static const char *conn_state_names
[] = {
450 "Registration error",
456 * Debug Facility Stuff
458 static debug_info_t
*iucv_dbf_setup
= NULL
;
459 static debug_info_t
*iucv_dbf_data
= NULL
;
460 static debug_info_t
*iucv_dbf_trace
= NULL
;
462 DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf
);
464 static void iucv_unregister_dbf_views(void)
467 debug_unregister(iucv_dbf_setup
);
469 debug_unregister(iucv_dbf_data
);
471 debug_unregister(iucv_dbf_trace
);
473 static int iucv_register_dbf_views(void)
475 iucv_dbf_setup
= debug_register(IUCV_DBF_SETUP_NAME
,
476 IUCV_DBF_SETUP_PAGES
,
477 IUCV_DBF_SETUP_NR_AREAS
,
479 iucv_dbf_data
= debug_register(IUCV_DBF_DATA_NAME
,
481 IUCV_DBF_DATA_NR_AREAS
,
483 iucv_dbf_trace
= debug_register(IUCV_DBF_TRACE_NAME
,
484 IUCV_DBF_TRACE_PAGES
,
485 IUCV_DBF_TRACE_NR_AREAS
,
488 if ((iucv_dbf_setup
== NULL
) || (iucv_dbf_data
== NULL
) ||
489 (iucv_dbf_trace
== NULL
)) {
490 iucv_unregister_dbf_views();
493 debug_register_view(iucv_dbf_setup
, &debug_hex_ascii_view
);
494 debug_set_level(iucv_dbf_setup
, IUCV_DBF_SETUP_LEVEL
);
496 debug_register_view(iucv_dbf_data
, &debug_hex_ascii_view
);
497 debug_set_level(iucv_dbf_data
, IUCV_DBF_DATA_LEVEL
);
499 debug_register_view(iucv_dbf_trace
, &debug_hex_ascii_view
);
500 debug_set_level(iucv_dbf_trace
, IUCV_DBF_TRACE_LEVEL
);
506 * Callback-wrappers, called from lowlevel iucv layer.
509 static void netiucv_callback_rx(struct iucv_path
*path
,
510 struct iucv_message
*msg
)
512 struct iucv_connection
*conn
= path
->private;
513 struct iucv_event ev
;
517 fsm_event(conn
->fsm
, CONN_EVENT_RX
, &ev
);
520 static void netiucv_callback_txdone(struct iucv_path
*path
,
521 struct iucv_message
*msg
)
523 struct iucv_connection
*conn
= path
->private;
524 struct iucv_event ev
;
528 fsm_event(conn
->fsm
, CONN_EVENT_TXDONE
, &ev
);
531 static void netiucv_callback_connack(struct iucv_path
*path
, u8 ipuser
[16])
533 struct iucv_connection
*conn
= path
->private;
535 fsm_event(conn
->fsm
, CONN_EVENT_CONN_ACK
, conn
);
538 static int netiucv_callback_connreq(struct iucv_path
*path
,
539 u8 ipvmid
[8], u8 ipuser
[16])
541 struct iucv_connection
*conn
= path
->private;
542 struct iucv_event ev
;
545 if (memcmp(iucvMagic
, ipuser
, sizeof(ipuser
)))
546 /* ipuser must match iucvMagic. */
549 read_lock_bh(&iucv_connection_rwlock
);
550 list_for_each_entry(conn
, &iucv_connection_list
, list
) {
551 if (strncmp(ipvmid
, conn
->userid
, 8))
553 /* Found a matching connection for this path. */
557 fsm_event(conn
->fsm
, CONN_EVENT_CONN_REQ
, &ev
);
560 read_unlock_bh(&iucv_connection_rwlock
);
564 static void netiucv_callback_connrej(struct iucv_path
*path
, u8 ipuser
[16])
566 struct iucv_connection
*conn
= path
->private;
568 fsm_event(conn
->fsm
, CONN_EVENT_CONN_REJ
, conn
);
571 static void netiucv_callback_connsusp(struct iucv_path
*path
, u8 ipuser
[16])
573 struct iucv_connection
*conn
= path
->private;
575 fsm_event(conn
->fsm
, CONN_EVENT_CONN_SUS
, conn
);
578 static void netiucv_callback_connres(struct iucv_path
*path
, u8 ipuser
[16])
580 struct iucv_connection
*conn
= path
->private;
582 fsm_event(conn
->fsm
, CONN_EVENT_CONN_RES
, conn
);
586 * NOP action for statemachines
588 static void netiucv_action_nop(fsm_instance
*fi
, int event
, void *arg
)
593 * Actions of the connection statemachine
598 * @conn: The connection where this skb has been received.
599 * @pskb: The received skb.
601 * Unpack a just received skb and hand it over to upper layers.
602 * Helper function for conn_action_rx.
604 static void netiucv_unpack_skb(struct iucv_connection
*conn
,
605 struct sk_buff
*pskb
)
607 struct net_device
*dev
= conn
->netdev
;
608 struct netiucv_priv
*privptr
= netdev_priv(dev
);
611 skb_put(pskb
, NETIUCV_HDRLEN
);
613 pskb
->ip_summed
= CHECKSUM_NONE
;
614 pskb
->protocol
= ntohs(ETH_P_IP
);
618 struct ll_header
*header
= (struct ll_header
*) pskb
->data
;
623 skb_pull(pskb
, NETIUCV_HDRLEN
);
624 header
->next
-= offset
;
625 offset
+= header
->next
;
626 header
->next
-= NETIUCV_HDRLEN
;
627 if (skb_tailroom(pskb
) < header
->next
) {
628 IUCV_DBF_TEXT_(data
, 2, "Illegal next field: %d > %d\n",
629 header
->next
, skb_tailroom(pskb
));
632 skb_put(pskb
, header
->next
);
633 skb_reset_mac_header(pskb
);
634 skb
= dev_alloc_skb(pskb
->len
);
636 IUCV_DBF_TEXT(data
, 2,
637 "Out of memory in netiucv_unpack_skb\n");
638 privptr
->stats
.rx_dropped
++;
641 skb_copy_from_linear_data(pskb
, skb_put(skb
, pskb
->len
),
643 skb_reset_mac_header(skb
);
644 skb
->dev
= pskb
->dev
;
645 skb
->protocol
= pskb
->protocol
;
646 pskb
->ip_summed
= CHECKSUM_UNNECESSARY
;
647 privptr
->stats
.rx_packets
++;
648 privptr
->stats
.rx_bytes
+= skb
->len
;
650 * Since receiving is always initiated from a tasklet (in iucv.c),
651 * we must use netif_rx_ni() instead of netif_rx()
654 dev
->last_rx
= jiffies
;
655 skb_pull(pskb
, header
->next
);
656 skb_put(pskb
, NETIUCV_HDRLEN
);
660 static void conn_action_rx(fsm_instance
*fi
, int event
, void *arg
)
662 struct iucv_event
*ev
= arg
;
663 struct iucv_connection
*conn
= ev
->conn
;
664 struct iucv_message
*msg
= ev
->data
;
665 struct netiucv_priv
*privptr
= netdev_priv(conn
->netdev
);
668 IUCV_DBF_TEXT(trace
, 4, __func__
);
671 iucv_message_reject(conn
->path
, msg
);
672 IUCV_DBF_TEXT(data
, 2,
673 "Received data for unlinked connection\n");
676 if (msg
->length
> conn
->max_buffsize
) {
677 iucv_message_reject(conn
->path
, msg
);
678 privptr
->stats
.rx_dropped
++;
679 IUCV_DBF_TEXT_(data
, 2, "msglen %d > max_buffsize %d\n",
680 msg
->length
, conn
->max_buffsize
);
683 conn
->rx_buff
->data
= conn
->rx_buff
->head
;
684 skb_reset_tail_pointer(conn
->rx_buff
);
685 conn
->rx_buff
->len
= 0;
686 rc
= iucv_message_receive(conn
->path
, msg
, 0, conn
->rx_buff
->data
,
688 if (rc
|| msg
->length
< 5) {
689 privptr
->stats
.rx_errors
++;
690 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_receive\n", rc
);
693 netiucv_unpack_skb(conn
, conn
->rx_buff
);
696 static void conn_action_txdone(fsm_instance
*fi
, int event
, void *arg
)
698 struct iucv_event
*ev
= arg
;
699 struct iucv_connection
*conn
= ev
->conn
;
700 struct iucv_message
*msg
= ev
->data
;
701 struct iucv_message txmsg
;
702 struct netiucv_priv
*privptr
= NULL
;
703 u32 single_flag
= msg
->tag
;
708 unsigned long saveflags
;
709 struct ll_header header
;
712 IUCV_DBF_TEXT(trace
, 4, __func__
);
714 if (conn
&& conn
->netdev
)
715 privptr
= netdev_priv(conn
->netdev
);
716 conn
->prof
.tx_pending
--;
718 if ((skb
= skb_dequeue(&conn
->commit_queue
))) {
719 atomic_dec(&skb
->users
);
720 dev_kfree_skb_any(skb
);
722 privptr
->stats
.tx_packets
++;
723 privptr
->stats
.tx_bytes
+=
724 (skb
->len
- NETIUCV_HDRLEN
729 conn
->tx_buff
->data
= conn
->tx_buff
->head
;
730 skb_reset_tail_pointer(conn
->tx_buff
);
731 conn
->tx_buff
->len
= 0;
732 spin_lock_irqsave(&conn
->collect_lock
, saveflags
);
733 while ((skb
= skb_dequeue(&conn
->collect_queue
))) {
734 header
.next
= conn
->tx_buff
->len
+ skb
->len
+ NETIUCV_HDRLEN
;
735 memcpy(skb_put(conn
->tx_buff
, NETIUCV_HDRLEN
), &header
,
737 skb_copy_from_linear_data(skb
,
738 skb_put(conn
->tx_buff
, skb
->len
),
743 atomic_dec(&skb
->users
);
744 dev_kfree_skb_any(skb
);
746 if (conn
->collect_len
> conn
->prof
.maxmulti
)
747 conn
->prof
.maxmulti
= conn
->collect_len
;
748 conn
->collect_len
= 0;
749 spin_unlock_irqrestore(&conn
->collect_lock
, saveflags
);
750 if (conn
->tx_buff
->len
== 0) {
751 fsm_newstate(fi
, CONN_STATE_IDLE
);
756 memcpy(skb_put(conn
->tx_buff
, NETIUCV_HDRLEN
), &header
, NETIUCV_HDRLEN
);
757 conn
->prof
.send_stamp
= current_kernel_time();
760 rc
= iucv_message_send(conn
->path
, &txmsg
, 0, 0,
761 conn
->tx_buff
->data
, conn
->tx_buff
->len
);
762 conn
->prof
.doios_multi
++;
763 conn
->prof
.txlen
+= conn
->tx_buff
->len
;
764 conn
->prof
.tx_pending
++;
765 if (conn
->prof
.tx_pending
> conn
->prof
.tx_max_pending
)
766 conn
->prof
.tx_max_pending
= conn
->prof
.tx_pending
;
768 conn
->prof
.tx_pending
--;
769 fsm_newstate(fi
, CONN_STATE_IDLE
);
771 privptr
->stats
.tx_errors
+= txpackets
;
772 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_send\n", rc
);
775 privptr
->stats
.tx_packets
+= txpackets
;
776 privptr
->stats
.tx_bytes
+= txbytes
;
778 if (stat_maxcq
> conn
->prof
.maxcqueue
)
779 conn
->prof
.maxcqueue
= stat_maxcq
;
783 static void conn_action_connaccept(fsm_instance
*fi
, int event
, void *arg
)
785 struct iucv_event
*ev
= arg
;
786 struct iucv_connection
*conn
= ev
->conn
;
787 struct iucv_path
*path
= ev
->data
;
788 struct net_device
*netdev
= conn
->netdev
;
789 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
792 IUCV_DBF_TEXT(trace
, 3, __func__
);
795 path
->msglim
= NETIUCV_QUEUELEN_DEFAULT
;
797 rc
= iucv_path_accept(path
, &netiucv_handler
, NULL
, conn
);
799 IUCV_DBF_TEXT_(setup
, 2, "rc %d from iucv_accept", rc
);
802 fsm_newstate(fi
, CONN_STATE_IDLE
);
803 netdev
->tx_queue_len
= conn
->path
->msglim
;
804 fsm_event(privptr
->fsm
, DEV_EVENT_CONUP
, netdev
);
807 static void conn_action_connreject(fsm_instance
*fi
, int event
, void *arg
)
809 struct iucv_event
*ev
= arg
;
810 struct iucv_path
*path
= ev
->data
;
812 IUCV_DBF_TEXT(trace
, 3, __func__
);
813 iucv_path_sever(path
, NULL
);
816 static void conn_action_connack(fsm_instance
*fi
, int event
, void *arg
)
818 struct iucv_connection
*conn
= arg
;
819 struct net_device
*netdev
= conn
->netdev
;
820 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
822 IUCV_DBF_TEXT(trace
, 3, __func__
);
823 fsm_deltimer(&conn
->timer
);
824 fsm_newstate(fi
, CONN_STATE_IDLE
);
825 netdev
->tx_queue_len
= conn
->path
->msglim
;
826 fsm_event(privptr
->fsm
, DEV_EVENT_CONUP
, netdev
);
829 static void conn_action_conntimsev(fsm_instance
*fi
, int event
, void *arg
)
831 struct iucv_connection
*conn
= arg
;
833 IUCV_DBF_TEXT(trace
, 3, __func__
);
834 fsm_deltimer(&conn
->timer
);
835 iucv_path_sever(conn
->path
, NULL
);
836 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
839 static void conn_action_connsever(fsm_instance
*fi
, int event
, void *arg
)
841 struct iucv_connection
*conn
= arg
;
842 struct net_device
*netdev
= conn
->netdev
;
843 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
845 IUCV_DBF_TEXT(trace
, 3, __func__
);
847 fsm_deltimer(&conn
->timer
);
848 iucv_path_sever(conn
->path
, NULL
);
849 PRINT_INFO("%s: Remote dropped connection\n", netdev
->name
);
850 IUCV_DBF_TEXT(data
, 2,
851 "conn_action_connsever: Remote dropped connection\n");
852 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
853 fsm_event(privptr
->fsm
, DEV_EVENT_CONDOWN
, netdev
);
856 static void conn_action_start(fsm_instance
*fi
, int event
, void *arg
)
858 struct iucv_connection
*conn
= arg
;
861 IUCV_DBF_TEXT(trace
, 3, __func__
);
863 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
864 IUCV_DBF_TEXT_(setup
, 2, "%s('%s'): connecting ...\n",
865 conn
->netdev
->name
, conn
->userid
);
868 * We must set the state before calling iucv_connect because the
869 * callback handler could be called at any point after the connection
873 fsm_newstate(fi
, CONN_STATE_SETUPWAIT
);
874 conn
->path
= iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT
, 0, GFP_KERNEL
);
875 rc
= iucv_path_connect(conn
->path
, &netiucv_handler
, conn
->userid
,
876 NULL
, iucvMagic
, conn
);
879 conn
->netdev
->tx_queue_len
= conn
->path
->msglim
;
880 fsm_addtimer(&conn
->timer
, NETIUCV_TIMEOUT_5SEC
,
881 CONN_EVENT_TIMER
, conn
);
884 PRINT_INFO("%s: User %s is currently not available.\n",
886 netiucv_printname(conn
->userid
));
887 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
890 PRINT_INFO("%s: User %s is currently not ready.\n",
892 netiucv_printname(conn
->userid
));
893 fsm_newstate(fi
, CONN_STATE_STARTWAIT
);
896 PRINT_WARN("%s: Too many IUCV connections.\n",
898 fsm_newstate(fi
, CONN_STATE_CONNERR
);
901 PRINT_WARN("%s: User %s has too many IUCV connections.\n",
903 netiucv_printname(conn
->userid
));
904 fsm_newstate(fi
, CONN_STATE_CONNERR
);
907 PRINT_WARN("%s: No IUCV authorization in CP directory.\n",
909 fsm_newstate(fi
, CONN_STATE_CONNERR
);
912 PRINT_WARN("%s: iucv_connect returned error %d\n",
913 conn
->netdev
->name
, rc
);
914 fsm_newstate(fi
, CONN_STATE_CONNERR
);
917 IUCV_DBF_TEXT_(setup
, 5, "iucv_connect rc is %d\n", rc
);
922 static void netiucv_purge_skb_queue(struct sk_buff_head
*q
)
926 while ((skb
= skb_dequeue(q
))) {
927 atomic_dec(&skb
->users
);
928 dev_kfree_skb_any(skb
);
932 static void conn_action_stop(fsm_instance
*fi
, int event
, void *arg
)
934 struct iucv_event
*ev
= arg
;
935 struct iucv_connection
*conn
= ev
->conn
;
936 struct net_device
*netdev
= conn
->netdev
;
937 struct netiucv_priv
*privptr
= netdev_priv(netdev
);
939 IUCV_DBF_TEXT(trace
, 3, __func__
);
941 fsm_deltimer(&conn
->timer
);
942 fsm_newstate(fi
, CONN_STATE_STOPPED
);
943 netiucv_purge_skb_queue(&conn
->collect_queue
);
945 IUCV_DBF_TEXT(trace
, 5, "calling iucv_path_sever\n");
946 iucv_path_sever(conn
->path
, iucvMagic
);
950 netiucv_purge_skb_queue(&conn
->commit_queue
);
951 fsm_event(privptr
->fsm
, DEV_EVENT_CONDOWN
, netdev
);
954 static void conn_action_inval(fsm_instance
*fi
, int event
, void *arg
)
956 struct iucv_connection
*conn
= arg
;
957 struct net_device
*netdev
= conn
->netdev
;
959 IUCV_DBF_TEXT_(data
, 2, "%s('%s'): conn_action_inval called\n",
960 netdev
->name
, conn
->userid
);
963 static const fsm_node conn_fsm
[] = {
964 { CONN_STATE_INVALID
, CONN_EVENT_START
, conn_action_inval
},
965 { CONN_STATE_STOPPED
, CONN_EVENT_START
, conn_action_start
},
967 { CONN_STATE_STOPPED
, CONN_EVENT_STOP
, conn_action_stop
},
968 { CONN_STATE_STARTWAIT
, CONN_EVENT_STOP
, conn_action_stop
},
969 { CONN_STATE_SETUPWAIT
, CONN_EVENT_STOP
, conn_action_stop
},
970 { CONN_STATE_IDLE
, CONN_EVENT_STOP
, conn_action_stop
},
971 { CONN_STATE_TX
, CONN_EVENT_STOP
, conn_action_stop
},
972 { CONN_STATE_REGERR
, CONN_EVENT_STOP
, conn_action_stop
},
973 { CONN_STATE_CONNERR
, CONN_EVENT_STOP
, conn_action_stop
},
975 { CONN_STATE_STOPPED
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
976 { CONN_STATE_STARTWAIT
, CONN_EVENT_CONN_REQ
, conn_action_connaccept
},
977 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_REQ
, conn_action_connaccept
},
978 { CONN_STATE_IDLE
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
979 { CONN_STATE_TX
, CONN_EVENT_CONN_REQ
, conn_action_connreject
},
981 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_ACK
, conn_action_connack
},
982 { CONN_STATE_SETUPWAIT
, CONN_EVENT_TIMER
, conn_action_conntimsev
},
984 { CONN_STATE_SETUPWAIT
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
985 { CONN_STATE_IDLE
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
986 { CONN_STATE_TX
, CONN_EVENT_CONN_REJ
, conn_action_connsever
},
988 { CONN_STATE_IDLE
, CONN_EVENT_RX
, conn_action_rx
},
989 { CONN_STATE_TX
, CONN_EVENT_RX
, conn_action_rx
},
991 { CONN_STATE_TX
, CONN_EVENT_TXDONE
, conn_action_txdone
},
992 { CONN_STATE_IDLE
, CONN_EVENT_TXDONE
, conn_action_txdone
},
995 static const int CONN_FSM_LEN
= sizeof(conn_fsm
) / sizeof(fsm_node
);
999 * Actions for interface - statemachine.
1004 * @fi: An instance of an interface statemachine.
1005 * @event: The event, just happened.
1006 * @arg: Generic pointer, casted from struct net_device * upon call.
1008 * Startup connection by sending CONN_EVENT_START to it.
1010 static void dev_action_start(fsm_instance
*fi
, int event
, void *arg
)
1012 struct net_device
*dev
= arg
;
1013 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1015 IUCV_DBF_TEXT(trace
, 3, __func__
);
1017 fsm_newstate(fi
, DEV_STATE_STARTWAIT
);
1018 fsm_event(privptr
->conn
->fsm
, CONN_EVENT_START
, privptr
->conn
);
1022 * Shutdown connection by sending CONN_EVENT_STOP to it.
1024 * @param fi An instance of an interface statemachine.
1025 * @param event The event, just happened.
1026 * @param arg Generic pointer, casted from struct net_device * upon call.
1029 dev_action_stop(fsm_instance
*fi
, int event
, void *arg
)
1031 struct net_device
*dev
= arg
;
1032 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1033 struct iucv_event ev
;
1035 IUCV_DBF_TEXT(trace
, 3, __func__
);
1037 ev
.conn
= privptr
->conn
;
1039 fsm_newstate(fi
, DEV_STATE_STOPWAIT
);
1040 fsm_event(privptr
->conn
->fsm
, CONN_EVENT_STOP
, &ev
);
1044 * Called from connection statemachine
1045 * when a connection is up and running.
1047 * @param fi An instance of an interface statemachine.
1048 * @param event The event, just happened.
1049 * @param arg Generic pointer, casted from struct net_device * upon call.
1052 dev_action_connup(fsm_instance
*fi
, int event
, void *arg
)
1054 struct net_device
*dev
= arg
;
1055 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1057 IUCV_DBF_TEXT(trace
, 3, __func__
);
1059 switch (fsm_getstate(fi
)) {
1060 case DEV_STATE_STARTWAIT
:
1061 fsm_newstate(fi
, DEV_STATE_RUNNING
);
1062 PRINT_INFO("%s: connected with remote side %s\n",
1063 dev
->name
, privptr
->conn
->userid
);
1064 IUCV_DBF_TEXT(setup
, 3,
1065 "connection is up and running\n");
1067 case DEV_STATE_STOPWAIT
:
1068 IUCV_DBF_TEXT(data
, 2,
1069 "dev_action_connup: in DEV_STATE_STOPWAIT\n");
1075 * Called from connection statemachine
1076 * when a connection has been shutdown.
1078 * @param fi An instance of an interface statemachine.
1079 * @param event The event, just happened.
1080 * @param arg Generic pointer, casted from struct net_device * upon call.
1083 dev_action_conndown(fsm_instance
*fi
, int event
, void *arg
)
1085 IUCV_DBF_TEXT(trace
, 3, __func__
);
1087 switch (fsm_getstate(fi
)) {
1088 case DEV_STATE_RUNNING
:
1089 fsm_newstate(fi
, DEV_STATE_STARTWAIT
);
1091 case DEV_STATE_STOPWAIT
:
1092 fsm_newstate(fi
, DEV_STATE_STOPPED
);
1093 IUCV_DBF_TEXT(setup
, 3, "connection is down\n");
1098 static const fsm_node dev_fsm
[] = {
1099 { DEV_STATE_STOPPED
, DEV_EVENT_START
, dev_action_start
},
1101 { DEV_STATE_STOPWAIT
, DEV_EVENT_START
, dev_action_start
},
1102 { DEV_STATE_STOPWAIT
, DEV_EVENT_CONDOWN
, dev_action_conndown
},
1104 { DEV_STATE_STARTWAIT
, DEV_EVENT_STOP
, dev_action_stop
},
1105 { DEV_STATE_STARTWAIT
, DEV_EVENT_CONUP
, dev_action_connup
},
1107 { DEV_STATE_RUNNING
, DEV_EVENT_STOP
, dev_action_stop
},
1108 { DEV_STATE_RUNNING
, DEV_EVENT_CONDOWN
, dev_action_conndown
},
1109 { DEV_STATE_RUNNING
, DEV_EVENT_CONUP
, netiucv_action_nop
},
1112 static const int DEV_FSM_LEN
= sizeof(dev_fsm
) / sizeof(fsm_node
);
1115 * Transmit a packet.
1116 * This is a helper function for netiucv_tx().
1118 * @param conn Connection to be used for sending.
1119 * @param skb Pointer to struct sk_buff of packet to send.
1120 * The linklevel header has already been set up
1123 * @return 0 on success, -ERRNO on failure. (Never fails.)
1125 static int netiucv_transmit_skb(struct iucv_connection
*conn
,
1126 struct sk_buff
*skb
)
1128 struct iucv_message msg
;
1129 unsigned long saveflags
;
1130 struct ll_header header
;
1133 if (fsm_getstate(conn
->fsm
) != CONN_STATE_IDLE
) {
1134 int l
= skb
->len
+ NETIUCV_HDRLEN
;
1136 spin_lock_irqsave(&conn
->collect_lock
, saveflags
);
1137 if (conn
->collect_len
+ l
>
1138 (conn
->max_buffsize
- NETIUCV_HDRLEN
)) {
1140 IUCV_DBF_TEXT(data
, 2,
1141 "EBUSY from netiucv_transmit_skb\n");
1143 atomic_inc(&skb
->users
);
1144 skb_queue_tail(&conn
->collect_queue
, skb
);
1145 conn
->collect_len
+= l
;
1148 spin_unlock_irqrestore(&conn
->collect_lock
, saveflags
);
1150 struct sk_buff
*nskb
= skb
;
1152 * Copy the skb to a new allocated skb in lowmem only if the
1153 * data is located above 2G in memory or tailroom is < 2.
1155 unsigned long hi
= ((unsigned long)(skb_tail_pointer(skb
) +
1156 NETIUCV_HDRLEN
)) >> 31;
1158 if (hi
|| (skb_tailroom(skb
) < 2)) {
1159 nskb
= alloc_skb(skb
->len
+ NETIUCV_HDRLEN
+
1160 NETIUCV_HDRLEN
, GFP_ATOMIC
| GFP_DMA
);
1162 IUCV_DBF_TEXT(data
, 2, "alloc_skb failed\n");
1166 skb_reserve(nskb
, NETIUCV_HDRLEN
);
1167 memcpy(skb_put(nskb
, skb
->len
),
1168 skb
->data
, skb
->len
);
1173 * skb now is below 2G and has enough room. Add headers.
1175 header
.next
= nskb
->len
+ NETIUCV_HDRLEN
;
1176 memcpy(skb_push(nskb
, NETIUCV_HDRLEN
), &header
, NETIUCV_HDRLEN
);
1178 memcpy(skb_put(nskb
, NETIUCV_HDRLEN
), &header
, NETIUCV_HDRLEN
);
1180 fsm_newstate(conn
->fsm
, CONN_STATE_TX
);
1181 conn
->prof
.send_stamp
= current_kernel_time();
1185 rc
= iucv_message_send(conn
->path
, &msg
, 0, 0,
1186 nskb
->data
, nskb
->len
);
1187 conn
->prof
.doios_single
++;
1188 conn
->prof
.txlen
+= skb
->len
;
1189 conn
->prof
.tx_pending
++;
1190 if (conn
->prof
.tx_pending
> conn
->prof
.tx_max_pending
)
1191 conn
->prof
.tx_max_pending
= conn
->prof
.tx_pending
;
1193 struct netiucv_priv
*privptr
;
1194 fsm_newstate(conn
->fsm
, CONN_STATE_IDLE
);
1195 conn
->prof
.tx_pending
--;
1196 privptr
= netdev_priv(conn
->netdev
);
1198 privptr
->stats
.tx_errors
++;
1200 dev_kfree_skb(nskb
);
1203 * Remove our headers. They get added
1204 * again on retransmit.
1206 skb_pull(skb
, NETIUCV_HDRLEN
);
1207 skb_trim(skb
, skb
->len
- NETIUCV_HDRLEN
);
1209 IUCV_DBF_TEXT_(data
, 2, "rc %d from iucv_send\n", rc
);
1213 atomic_inc(&nskb
->users
);
1214 skb_queue_tail(&conn
->commit_queue
, nskb
);
1222 * Interface API for upper network layers
1226 * Open an interface.
1227 * Called from generic network layer when ifconfig up is run.
1229 * @param dev Pointer to interface struct.
1231 * @return 0 on success, -ERRNO on failure. (Never fails.)
1233 static int netiucv_open(struct net_device
*dev
)
1235 struct netiucv_priv
*priv
= netdev_priv(dev
);
1237 fsm_event(priv
->fsm
, DEV_EVENT_START
, dev
);
1242 * Close an interface.
1243 * Called from generic network layer when ifconfig down is run.
1245 * @param dev Pointer to interface struct.
1247 * @return 0 on success, -ERRNO on failure. (Never fails.)
1249 static int netiucv_close(struct net_device
*dev
)
1251 struct netiucv_priv
*priv
= netdev_priv(dev
);
1253 fsm_event(priv
->fsm
, DEV_EVENT_STOP
, dev
);
1258 * Start transmission of a packet.
1259 * Called from generic network device layer.
1261 * @param skb Pointer to buffer containing the packet.
1262 * @param dev Pointer to interface struct.
1264 * @return 0 if packet consumed, !0 if packet rejected.
1265 * Note: If we return !0, then the packet is free'd by
1266 * the generic network layer.
1268 static int netiucv_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1270 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1273 IUCV_DBF_TEXT(trace
, 4, __func__
);
1275 * Some sanity checks ...
1278 IUCV_DBF_TEXT(data
, 2, "netiucv_tx: skb is NULL\n");
1279 privptr
->stats
.tx_dropped
++;
1282 if (skb_headroom(skb
) < NETIUCV_HDRLEN
) {
1283 IUCV_DBF_TEXT(data
, 2,
1284 "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1286 privptr
->stats
.tx_dropped
++;
1291 * If connection is not running, try to restart it
1292 * and throw away packet.
1294 if (fsm_getstate(privptr
->fsm
) != DEV_STATE_RUNNING
) {
1296 privptr
->stats
.tx_dropped
++;
1297 privptr
->stats
.tx_errors
++;
1298 privptr
->stats
.tx_carrier_errors
++;
1302 if (netiucv_test_and_set_busy(dev
)) {
1303 IUCV_DBF_TEXT(data
, 2, "EBUSY from netiucv_tx\n");
1306 dev
->trans_start
= jiffies
;
1307 rc
= netiucv_transmit_skb(privptr
->conn
, skb
) != 0;
1308 netiucv_clear_busy(dev
);
1314 * @dev: Pointer to interface struct.
1316 * Returns interface statistics of a device.
1318 * Returns pointer to stats struct of this interface.
1320 static struct net_device_stats
*netiucv_stats (struct net_device
* dev
)
1322 struct netiucv_priv
*priv
= netdev_priv(dev
);
1324 IUCV_DBF_TEXT(trace
, 5, __func__
);
1325 return &priv
->stats
;
1329 * netiucv_change_mtu
1330 * @dev: Pointer to interface struct.
1331 * @new_mtu: The new MTU to use for this interface.
1333 * Sets MTU of an interface.
1335 * Returns 0 on success, -EINVAL if MTU is out of valid range.
1336 * (valid range is 576 .. NETIUCV_MTU_MAX).
1338 static int netiucv_change_mtu(struct net_device
* dev
, int new_mtu
)
1340 IUCV_DBF_TEXT(trace
, 3, __func__
);
1341 if (new_mtu
< 576 || new_mtu
> NETIUCV_MTU_MAX
) {
1342 IUCV_DBF_TEXT(setup
, 2, "given MTU out of valid range\n");
1350 * attributes in sysfs
1353 static ssize_t
user_show(struct device
*dev
, struct device_attribute
*attr
,
1356 struct netiucv_priv
*priv
= dev
->driver_data
;
1358 IUCV_DBF_TEXT(trace
, 5, __func__
);
1359 return sprintf(buf
, "%s\n", netiucv_printname(priv
->conn
->userid
));
1362 static ssize_t
user_write(struct device
*dev
, struct device_attribute
*attr
,
1363 const char *buf
, size_t count
)
1365 struct netiucv_priv
*priv
= dev
->driver_data
;
1366 struct net_device
*ndev
= priv
->conn
->netdev
;
1371 struct iucv_connection
*cp
;
1373 IUCV_DBF_TEXT(trace
, 3, __func__
);
1375 IUCV_DBF_TEXT_(setup
, 2,
1376 "%d is length of username\n", (int) count
);
1380 tmp
= strsep((char **) &buf
, "\n");
1381 for (i
= 0, p
= tmp
; i
< 8 && *p
; i
++, p
++) {
1382 if (isalnum(*p
) || (*p
== '$')) {
1383 username
[i
]= toupper(*p
);
1387 /* trailing lf, grr */
1390 IUCV_DBF_TEXT_(setup
, 2,
1391 "username: invalid character %c\n", *p
);
1395 username
[i
++] = ' ';
1398 if (memcmp(username
, priv
->conn
->userid
, 9) &&
1399 (ndev
->flags
& (IFF_UP
| IFF_RUNNING
))) {
1400 /* username changed while the interface is active. */
1401 IUCV_DBF_TEXT(setup
, 2, "user_write: device active\n");
1404 read_lock_bh(&iucv_connection_rwlock
);
1405 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
1406 if (!strncmp(username
, cp
->userid
, 9) && cp
->netdev
!= ndev
) {
1407 read_unlock_bh(&iucv_connection_rwlock
);
1408 IUCV_DBF_TEXT_(setup
, 2, "user_write: Connection "
1409 "to %s already exists\n", username
);
1413 read_unlock_bh(&iucv_connection_rwlock
);
1414 memcpy(priv
->conn
->userid
, username
, 9);
1418 static DEVICE_ATTR(user
, 0644, user_show
, user_write
);
1420 static ssize_t
buffer_show (struct device
*dev
, struct device_attribute
*attr
,
1422 { struct netiucv_priv
*priv
= dev
->driver_data
;
1424 IUCV_DBF_TEXT(trace
, 5, __func__
);
1425 return sprintf(buf
, "%d\n", priv
->conn
->max_buffsize
);
1428 static ssize_t
buffer_write (struct device
*dev
, struct device_attribute
*attr
,
1429 const char *buf
, size_t count
)
1431 struct netiucv_priv
*priv
= dev
->driver_data
;
1432 struct net_device
*ndev
= priv
->conn
->netdev
;
1436 IUCV_DBF_TEXT(trace
, 3, __func__
);
1440 bs1
= simple_strtoul(buf
, &e
, 0);
1442 if (e
&& (!isspace(*e
))) {
1443 IUCV_DBF_TEXT_(setup
, 2, "buffer_write: invalid char %c\n", *e
);
1446 if (bs1
> NETIUCV_BUFSIZE_MAX
) {
1447 IUCV_DBF_TEXT_(setup
, 2,
1448 "buffer_write: buffer size %d too large\n",
1452 if ((ndev
->flags
& IFF_RUNNING
) &&
1453 (bs1
< (ndev
->mtu
+ NETIUCV_HDRLEN
+ 2))) {
1454 IUCV_DBF_TEXT_(setup
, 2,
1455 "buffer_write: buffer size %d too small\n",
1459 if (bs1
< (576 + NETIUCV_HDRLEN
+ NETIUCV_HDRLEN
)) {
1460 IUCV_DBF_TEXT_(setup
, 2,
1461 "buffer_write: buffer size %d too small\n",
1466 priv
->conn
->max_buffsize
= bs1
;
1467 if (!(ndev
->flags
& IFF_RUNNING
))
1468 ndev
->mtu
= bs1
- NETIUCV_HDRLEN
- NETIUCV_HDRLEN
;
1474 static DEVICE_ATTR(buffer
, 0644, buffer_show
, buffer_write
);
1476 static ssize_t
dev_fsm_show (struct device
*dev
, struct device_attribute
*attr
,
1479 struct netiucv_priv
*priv
= dev
->driver_data
;
1481 IUCV_DBF_TEXT(trace
, 5, __func__
);
1482 return sprintf(buf
, "%s\n", fsm_getstate_str(priv
->fsm
));
1485 static DEVICE_ATTR(device_fsm_state
, 0444, dev_fsm_show
, NULL
);
1487 static ssize_t
conn_fsm_show (struct device
*dev
,
1488 struct device_attribute
*attr
, char *buf
)
1490 struct netiucv_priv
*priv
= dev
->driver_data
;
1492 IUCV_DBF_TEXT(trace
, 5, __func__
);
1493 return sprintf(buf
, "%s\n", fsm_getstate_str(priv
->conn
->fsm
));
1496 static DEVICE_ATTR(connection_fsm_state
, 0444, conn_fsm_show
, NULL
);
1498 static ssize_t
maxmulti_show (struct device
*dev
,
1499 struct device_attribute
*attr
, char *buf
)
1501 struct netiucv_priv
*priv
= dev
->driver_data
;
1503 IUCV_DBF_TEXT(trace
, 5, __func__
);
1504 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.maxmulti
);
1507 static ssize_t
maxmulti_write (struct device
*dev
,
1508 struct device_attribute
*attr
,
1509 const char *buf
, size_t count
)
1511 struct netiucv_priv
*priv
= dev
->driver_data
;
1513 IUCV_DBF_TEXT(trace
, 4, __func__
);
1514 priv
->conn
->prof
.maxmulti
= 0;
1518 static DEVICE_ATTR(max_tx_buffer_used
, 0644, maxmulti_show
, maxmulti_write
);
1520 static ssize_t
maxcq_show (struct device
*dev
, struct device_attribute
*attr
,
1523 struct netiucv_priv
*priv
= dev
->driver_data
;
1525 IUCV_DBF_TEXT(trace
, 5, __func__
);
1526 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.maxcqueue
);
1529 static ssize_t
maxcq_write (struct device
*dev
, struct device_attribute
*attr
,
1530 const char *buf
, size_t count
)
1532 struct netiucv_priv
*priv
= dev
->driver_data
;
1534 IUCV_DBF_TEXT(trace
, 4, __func__
);
1535 priv
->conn
->prof
.maxcqueue
= 0;
1539 static DEVICE_ATTR(max_chained_skbs
, 0644, maxcq_show
, maxcq_write
);
1541 static ssize_t
sdoio_show (struct device
*dev
, struct device_attribute
*attr
,
1544 struct netiucv_priv
*priv
= dev
->driver_data
;
1546 IUCV_DBF_TEXT(trace
, 5, __func__
);
1547 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.doios_single
);
1550 static ssize_t
sdoio_write (struct device
*dev
, struct device_attribute
*attr
,
1551 const char *buf
, size_t count
)
1553 struct netiucv_priv
*priv
= dev
->driver_data
;
1555 IUCV_DBF_TEXT(trace
, 4, __func__
);
1556 priv
->conn
->prof
.doios_single
= 0;
1560 static DEVICE_ATTR(tx_single_write_ops
, 0644, sdoio_show
, sdoio_write
);
1562 static ssize_t
mdoio_show (struct device
*dev
, struct device_attribute
*attr
,
1565 struct netiucv_priv
*priv
= dev
->driver_data
;
1567 IUCV_DBF_TEXT(trace
, 5, __func__
);
1568 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.doios_multi
);
1571 static ssize_t
mdoio_write (struct device
*dev
, struct device_attribute
*attr
,
1572 const char *buf
, size_t count
)
1574 struct netiucv_priv
*priv
= dev
->driver_data
;
1576 IUCV_DBF_TEXT(trace
, 5, __func__
);
1577 priv
->conn
->prof
.doios_multi
= 0;
1581 static DEVICE_ATTR(tx_multi_write_ops
, 0644, mdoio_show
, mdoio_write
);
1583 static ssize_t
txlen_show (struct device
*dev
, struct device_attribute
*attr
,
1586 struct netiucv_priv
*priv
= dev
->driver_data
;
1588 IUCV_DBF_TEXT(trace
, 5, __func__
);
1589 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.txlen
);
1592 static ssize_t
txlen_write (struct device
*dev
, struct device_attribute
*attr
,
1593 const char *buf
, size_t count
)
1595 struct netiucv_priv
*priv
= dev
->driver_data
;
1597 IUCV_DBF_TEXT(trace
, 4, __func__
);
1598 priv
->conn
->prof
.txlen
= 0;
1602 static DEVICE_ATTR(netto_bytes
, 0644, txlen_show
, txlen_write
);
1604 static ssize_t
txtime_show (struct device
*dev
, struct device_attribute
*attr
,
1607 struct netiucv_priv
*priv
= dev
->driver_data
;
1609 IUCV_DBF_TEXT(trace
, 5, __func__
);
1610 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_time
);
1613 static ssize_t
txtime_write (struct device
*dev
, struct device_attribute
*attr
,
1614 const char *buf
, size_t count
)
1616 struct netiucv_priv
*priv
= dev
->driver_data
;
1618 IUCV_DBF_TEXT(trace
, 4, __func__
);
1619 priv
->conn
->prof
.tx_time
= 0;
1623 static DEVICE_ATTR(max_tx_io_time
, 0644, txtime_show
, txtime_write
);
1625 static ssize_t
txpend_show (struct device
*dev
, struct device_attribute
*attr
,
1628 struct netiucv_priv
*priv
= dev
->driver_data
;
1630 IUCV_DBF_TEXT(trace
, 5, __func__
);
1631 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_pending
);
1634 static ssize_t
txpend_write (struct device
*dev
, struct device_attribute
*attr
,
1635 const char *buf
, size_t count
)
1637 struct netiucv_priv
*priv
= dev
->driver_data
;
1639 IUCV_DBF_TEXT(trace
, 4, __func__
);
1640 priv
->conn
->prof
.tx_pending
= 0;
1644 static DEVICE_ATTR(tx_pending
, 0644, txpend_show
, txpend_write
);
1646 static ssize_t
txmpnd_show (struct device
*dev
, struct device_attribute
*attr
,
1649 struct netiucv_priv
*priv
= dev
->driver_data
;
1651 IUCV_DBF_TEXT(trace
, 5, __func__
);
1652 return sprintf(buf
, "%ld\n", priv
->conn
->prof
.tx_max_pending
);
1655 static ssize_t
txmpnd_write (struct device
*dev
, struct device_attribute
*attr
,
1656 const char *buf
, size_t count
)
1658 struct netiucv_priv
*priv
= dev
->driver_data
;
1660 IUCV_DBF_TEXT(trace
, 4, __func__
);
1661 priv
->conn
->prof
.tx_max_pending
= 0;
1665 static DEVICE_ATTR(tx_max_pending
, 0644, txmpnd_show
, txmpnd_write
);
1667 static struct attribute
*netiucv_attrs
[] = {
1668 &dev_attr_buffer
.attr
,
1669 &dev_attr_user
.attr
,
1673 static struct attribute_group netiucv_attr_group
= {
1674 .attrs
= netiucv_attrs
,
1677 static struct attribute
*netiucv_stat_attrs
[] = {
1678 &dev_attr_device_fsm_state
.attr
,
1679 &dev_attr_connection_fsm_state
.attr
,
1680 &dev_attr_max_tx_buffer_used
.attr
,
1681 &dev_attr_max_chained_skbs
.attr
,
1682 &dev_attr_tx_single_write_ops
.attr
,
1683 &dev_attr_tx_multi_write_ops
.attr
,
1684 &dev_attr_netto_bytes
.attr
,
1685 &dev_attr_max_tx_io_time
.attr
,
1686 &dev_attr_tx_pending
.attr
,
1687 &dev_attr_tx_max_pending
.attr
,
1691 static struct attribute_group netiucv_stat_attr_group
= {
1693 .attrs
= netiucv_stat_attrs
,
1696 static int netiucv_add_files(struct device
*dev
)
1700 IUCV_DBF_TEXT(trace
, 3, __func__
);
1701 ret
= sysfs_create_group(&dev
->kobj
, &netiucv_attr_group
);
1704 ret
= sysfs_create_group(&dev
->kobj
, &netiucv_stat_attr_group
);
1706 sysfs_remove_group(&dev
->kobj
, &netiucv_attr_group
);
1710 static void netiucv_remove_files(struct device
*dev
)
1712 IUCV_DBF_TEXT(trace
, 3, __func__
);
1713 sysfs_remove_group(&dev
->kobj
, &netiucv_stat_attr_group
);
1714 sysfs_remove_group(&dev
->kobj
, &netiucv_attr_group
);
1717 static int netiucv_register_device(struct net_device
*ndev
)
1719 struct netiucv_priv
*priv
= netdev_priv(ndev
);
1720 struct device
*dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1724 IUCV_DBF_TEXT(trace
, 3, __func__
);
1727 snprintf(dev
->bus_id
, BUS_ID_SIZE
, "net%s", ndev
->name
);
1728 dev
->bus
= &iucv_bus
;
1729 dev
->parent
= iucv_root
;
1731 * The release function could be called after the
1732 * module has been unloaded. It's _only_ task is to
1733 * free the struct. Therefore, we specify kfree()
1734 * directly here. (Probably a little bit obfuscating
1735 * but legitime ...).
1737 dev
->release
= (void (*)(struct device
*))kfree
;
1738 dev
->driver
= &netiucv_driver
;
1742 ret
= device_register(dev
);
1746 ret
= netiucv_add_files(dev
);
1750 dev
->driver_data
= priv
;
1754 device_unregister(dev
);
1758 static void netiucv_unregister_device(struct device
*dev
)
1760 IUCV_DBF_TEXT(trace
, 3, __func__
);
1761 netiucv_remove_files(dev
);
1762 device_unregister(dev
);
1766 * Allocate and initialize a new connection structure.
1767 * Add it to the list of netiucv connections;
1769 static struct iucv_connection
*netiucv_new_connection(struct net_device
*dev
,
1772 struct iucv_connection
*conn
;
1774 conn
= kzalloc(sizeof(*conn
), GFP_KERNEL
);
1777 skb_queue_head_init(&conn
->collect_queue
);
1778 skb_queue_head_init(&conn
->commit_queue
);
1779 spin_lock_init(&conn
->collect_lock
);
1780 conn
->max_buffsize
= NETIUCV_BUFSIZE_DEFAULT
;
1783 conn
->rx_buff
= alloc_skb(conn
->max_buffsize
, GFP_KERNEL
| GFP_DMA
);
1786 conn
->tx_buff
= alloc_skb(conn
->max_buffsize
, GFP_KERNEL
| GFP_DMA
);
1789 conn
->fsm
= init_fsm("netiucvconn", conn_state_names
,
1790 conn_event_names
, NR_CONN_STATES
,
1791 NR_CONN_EVENTS
, conn_fsm
, CONN_FSM_LEN
,
1796 fsm_settimer(conn
->fsm
, &conn
->timer
);
1797 fsm_newstate(conn
->fsm
, CONN_STATE_INVALID
);
1800 memcpy(conn
->userid
, username
, 9);
1801 fsm_newstate(conn
->fsm
, CONN_STATE_STOPPED
);
1804 write_lock_bh(&iucv_connection_rwlock
);
1805 list_add_tail(&conn
->list
, &iucv_connection_list
);
1806 write_unlock_bh(&iucv_connection_rwlock
);
1810 kfree_skb(conn
->tx_buff
);
1812 kfree_skb(conn
->rx_buff
);
1820 * Release a connection structure and remove it from the
1821 * list of netiucv connections.
1823 static void netiucv_remove_connection(struct iucv_connection
*conn
)
1825 IUCV_DBF_TEXT(trace
, 3, __func__
);
1826 write_lock_bh(&iucv_connection_rwlock
);
1827 list_del_init(&conn
->list
);
1828 write_unlock_bh(&iucv_connection_rwlock
);
1829 fsm_deltimer(&conn
->timer
);
1830 netiucv_purge_skb_queue(&conn
->collect_queue
);
1832 iucv_path_sever(conn
->path
, iucvMagic
);
1836 netiucv_purge_skb_queue(&conn
->commit_queue
);
1837 kfree_fsm(conn
->fsm
);
1838 kfree_skb(conn
->rx_buff
);
1839 kfree_skb(conn
->tx_buff
);
1843 * Release everything of a net device.
1845 static void netiucv_free_netdevice(struct net_device
*dev
)
1847 struct netiucv_priv
*privptr
= netdev_priv(dev
);
1849 IUCV_DBF_TEXT(trace
, 3, __func__
);
1856 netiucv_remove_connection(privptr
->conn
);
1858 kfree_fsm(privptr
->fsm
);
1859 privptr
->conn
= NULL
; privptr
->fsm
= NULL
;
1860 /* privptr gets freed by free_netdev() */
1866 * Initialize a net device. (Called from kernel in alloc_netdev())
1868 static void netiucv_setup_netdevice(struct net_device
*dev
)
1870 dev
->mtu
= NETIUCV_MTU_DEFAULT
;
1871 dev
->hard_start_xmit
= netiucv_tx
;
1872 dev
->open
= netiucv_open
;
1873 dev
->stop
= netiucv_close
;
1874 dev
->get_stats
= netiucv_stats
;
1875 dev
->change_mtu
= netiucv_change_mtu
;
1876 dev
->destructor
= netiucv_free_netdevice
;
1877 dev
->hard_header_len
= NETIUCV_HDRLEN
;
1879 dev
->type
= ARPHRD_SLIP
;
1880 dev
->tx_queue_len
= NETIUCV_QUEUELEN_DEFAULT
;
1881 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
;
1885 * Allocate and initialize everything of a net device.
1887 static struct net_device
*netiucv_init_netdevice(char *username
)
1889 struct netiucv_priv
*privptr
;
1890 struct net_device
*dev
;
1892 dev
= alloc_netdev(sizeof(struct netiucv_priv
), "iucv%d",
1893 netiucv_setup_netdevice
);
1896 if (dev_alloc_name(dev
, dev
->name
) < 0)
1899 privptr
= netdev_priv(dev
);
1900 privptr
->fsm
= init_fsm("netiucvdev", dev_state_names
,
1901 dev_event_names
, NR_DEV_STATES
, NR_DEV_EVENTS
,
1902 dev_fsm
, DEV_FSM_LEN
, GFP_KERNEL
);
1906 privptr
->conn
= netiucv_new_connection(dev
, username
);
1907 if (!privptr
->conn
) {
1908 IUCV_DBF_TEXT(setup
, 2, "NULL from netiucv_new_connection\n");
1911 fsm_newstate(privptr
->fsm
, DEV_STATE_STOPPED
);
1915 kfree_fsm(privptr
->fsm
);
1921 static ssize_t
conn_write(struct device_driver
*drv
,
1922 const char *buf
, size_t count
)
1927 struct net_device
*dev
;
1928 struct netiucv_priv
*priv
;
1929 struct iucv_connection
*cp
;
1931 IUCV_DBF_TEXT(trace
, 3, __func__
);
1933 IUCV_DBF_TEXT(setup
, 2, "conn_write: too long\n");
1937 for (i
= 0, p
= buf
; i
< 8 && *p
; i
++, p
++) {
1938 if (isalnum(*p
) || *p
== '$') {
1939 username
[i
] = toupper(*p
);
1943 /* trailing lf, grr */
1945 IUCV_DBF_TEXT_(setup
, 2,
1946 "conn_write: invalid character %c\n", *p
);
1950 username
[i
++] = ' ';
1953 read_lock_bh(&iucv_connection_rwlock
);
1954 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
1955 if (!strncmp(username
, cp
->userid
, 9)) {
1956 read_unlock_bh(&iucv_connection_rwlock
);
1957 IUCV_DBF_TEXT_(setup
, 2, "conn_write: Connection "
1958 "to %s already exists\n", username
);
1962 read_unlock_bh(&iucv_connection_rwlock
);
1964 dev
= netiucv_init_netdevice(username
);
1966 IUCV_DBF_TEXT(setup
, 2, "NULL from netiucv_init_netdevice\n");
1970 rc
= netiucv_register_device(dev
);
1972 IUCV_DBF_TEXT_(setup
, 2,
1973 "ret %d from netiucv_register_device\n", rc
);
1978 priv
= netdev_priv(dev
);
1979 SET_NETDEV_DEV(dev
, priv
->dev
);
1981 rc
= register_netdev(dev
);
1989 netiucv_unregister_device(priv
->dev
);
1991 netiucv_free_netdevice(dev
);
1995 static DRIVER_ATTR(connection
, 0200, NULL
, conn_write
);
1997 static ssize_t
remove_write (struct device_driver
*drv
,
1998 const char *buf
, size_t count
)
2000 struct iucv_connection
*cp
;
2001 struct net_device
*ndev
;
2002 struct netiucv_priv
*priv
;
2004 char name
[IFNAMSIZ
];
2008 IUCV_DBF_TEXT(trace
, 3, __func__
);
2010 if (count
>= IFNAMSIZ
)
2011 count
= IFNAMSIZ
- 1;;
2013 for (i
= 0, p
= buf
; i
< count
&& *p
; i
++, p
++) {
2014 if (*p
== '\n' || *p
== ' ')
2015 /* trailing lf, grr */
2021 read_lock_bh(&iucv_connection_rwlock
);
2022 list_for_each_entry(cp
, &iucv_connection_list
, list
) {
2024 priv
= netdev_priv(ndev
);
2026 if (strncmp(name
, ndev
->name
, count
))
2028 read_unlock_bh(&iucv_connection_rwlock
);
2029 if (ndev
->flags
& (IFF_UP
| IFF_RUNNING
)) {
2030 PRINT_WARN("netiucv: net device %s active with peer "
2031 "%s\n", ndev
->name
, priv
->conn
->userid
);
2032 PRINT_WARN("netiucv: %s cannot be removed\n",
2034 IUCV_DBF_TEXT(data
, 2, "remove_write: still active\n");
2037 unregister_netdev(ndev
);
2038 netiucv_unregister_device(dev
);
2041 read_unlock_bh(&iucv_connection_rwlock
);
2042 IUCV_DBF_TEXT(data
, 2, "remove_write: unknown device\n");
2046 static DRIVER_ATTR(remove
, 0200, NULL
, remove_write
);
2048 static struct attribute
* netiucv_drv_attrs
[] = {
2049 &driver_attr_connection
.attr
,
2050 &driver_attr_remove
.attr
,
2054 static struct attribute_group netiucv_drv_attr_group
= {
2055 .attrs
= netiucv_drv_attrs
,
2058 static struct attribute_group
*netiucv_drv_attr_groups
[] = {
2059 &netiucv_drv_attr_group
,
2063 static void netiucv_banner(void)
2065 PRINT_INFO("NETIUCV driver initialized\n");
2068 static void __exit
netiucv_exit(void)
2070 struct iucv_connection
*cp
;
2071 struct net_device
*ndev
;
2072 struct netiucv_priv
*priv
;
2075 IUCV_DBF_TEXT(trace
, 3, __func__
);
2076 while (!list_empty(&iucv_connection_list
)) {
2077 cp
= list_entry(iucv_connection_list
.next
,
2078 struct iucv_connection
, list
);
2080 priv
= netdev_priv(ndev
);
2083 unregister_netdev(ndev
);
2084 netiucv_unregister_device(dev
);
2087 driver_unregister(&netiucv_driver
);
2088 iucv_unregister(&netiucv_handler
, 1);
2089 iucv_unregister_dbf_views();
2091 PRINT_INFO("NETIUCV driver unloaded\n");
2095 static int __init
netiucv_init(void)
2099 rc
= iucv_register_dbf_views();
2102 rc
= iucv_register(&netiucv_handler
, 1);
2105 IUCV_DBF_TEXT(trace
, 3, __func__
);
2106 netiucv_driver
.groups
= netiucv_drv_attr_groups
;
2107 rc
= driver_register(&netiucv_driver
);
2109 IUCV_DBF_TEXT_(setup
, 2, "ret %d from driver_register\n", rc
);
2117 iucv_unregister(&netiucv_handler
, 1);
2119 iucv_unregister_dbf_views();
2124 module_init(netiucv_init
);
2125 module_exit(netiucv_exit
);
2126 MODULE_LICENSE("GPL");