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 inline 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 inline 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 atomic_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 atomic_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 atomic_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 atomic_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 atomic_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 conn_write(struct device_driver *drv,
2022 const char *buf, size_t count)
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);
2084 static DRIVER_ATTR(connection, 0200, NULL, conn_write);
2086 static ssize_t remove_write (struct device_driver *drv,
2087 const char *buf, size_t count)
2089 struct iucv_connection *cp;
2090 struct net_device *ndev;
2091 struct netiucv_priv *priv;
2093 char name[IFNAMSIZ];
2097 IUCV_DBF_TEXT(trace, 3, __func__);
2099 if (count >= IFNAMSIZ)
2100 count = IFNAMSIZ - 1;
2102 for (i = 0, p = buf; i < count && *p; i++, p++) {
2103 if (*p == '\n' || *p == ' ')
2104 /* trailing lf, grr */
2110 read_lock_bh(&iucv_connection_rwlock);
2111 list_for_each_entry(cp, &iucv_connection_list, list) {
2113 priv = netdev_priv(ndev);
2115 if (strncmp(name, ndev->name, count))
2117 read_unlock_bh(&iucv_connection_rwlock);
2118 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2119 dev_warn(dev, "The IUCV device is connected"
2120 " to %s and cannot be removed\n",
2121 priv->conn->userid);
2122 IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2125 unregister_netdev(ndev);
2126 netiucv_unregister_device(dev);
2129 read_unlock_bh(&iucv_connection_rwlock);
2130 IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2134 static DRIVER_ATTR(remove, 0200, NULL, remove_write);
2136 static struct attribute * netiucv_drv_attrs[] = {
2137 &driver_attr_connection.attr,
2138 &driver_attr_remove.attr,
2142 static struct attribute_group netiucv_drv_attr_group = {
2143 .attrs = netiucv_drv_attrs,
2146 static const struct attribute_group *netiucv_drv_attr_groups[] = {
2147 &netiucv_drv_attr_group,
2151 static void netiucv_banner(void)
2153 pr_info("driver initialized\n");
2156 static void __exit netiucv_exit(void)
2158 struct iucv_connection *cp;
2159 struct net_device *ndev;
2160 struct netiucv_priv *priv;
2163 IUCV_DBF_TEXT(trace, 3, __func__);
2164 while (!list_empty(&iucv_connection_list)) {
2165 cp = list_entry(iucv_connection_list.next,
2166 struct iucv_connection, list);
2168 priv = netdev_priv(ndev);
2171 unregister_netdev(ndev);
2172 netiucv_unregister_device(dev);
2175 device_unregister(netiucv_dev);
2176 driver_unregister(&netiucv_driver);
2177 iucv_unregister(&netiucv_handler, 1);
2178 iucv_unregister_dbf_views();
2180 pr_info("driver unloaded\n");
2184 static int __init netiucv_init(void)
2188 rc = iucv_register_dbf_views();
2191 rc = iucv_register(&netiucv_handler, 1);
2194 IUCV_DBF_TEXT(trace, 3, __func__);
2195 netiucv_driver.groups = netiucv_drv_attr_groups;
2196 rc = driver_register(&netiucv_driver);
2198 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2201 /* establish dummy device */
2202 netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
2207 dev_set_name(netiucv_dev, "netiucv");
2208 netiucv_dev->bus = &iucv_bus;
2209 netiucv_dev->parent = iucv_root;
2210 netiucv_dev->release = (void (*)(struct device *))kfree;
2211 netiucv_dev->driver = &netiucv_driver;
2212 rc = device_register(netiucv_dev);
2214 put_device(netiucv_dev);
2221 driver_unregister(&netiucv_driver);
2223 iucv_unregister(&netiucv_handler, 1);
2225 iucv_unregister_dbf_views();
2230 module_init(netiucv_init);
2231 module_exit(netiucv_exit);
2232 MODULE_LICENSE("GPL");