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 <asm/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 /* Allow to sort out low debug levels early to avoid wasted sprints */
109 static inline int iucv_dbf_passes(debug_info_t *dbf_grp, int level)
111 return (level <= dbf_grp->level);
114 #define IUCV_DBF_TEXT_(name, level, text...) \
116 if (iucv_dbf_passes(iucv_dbf_##name, level)) { \
117 char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
118 sprintf(__buf, text); \
119 debug_text_event(iucv_dbf_##name, level, __buf); \
120 put_cpu_var(iucv_dbf_txt_buf); \
124 #define IUCV_DBF_SPRINTF(name,level,text...) \
126 debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
127 debug_sprintf_event(iucv_dbf_trace, level, text ); \
131 * some more debug stuff
133 #define IUCV_HEXDUMP16(importance,header,ptr) \
134 PRINT_##importance(header "%02x %02x %02x %02x %02x %02x %02x %02x " \
135 "%02x %02x %02x %02x %02x %02x %02x %02x\n", \
136 *(((char*)ptr)),*(((char*)ptr)+1),*(((char*)ptr)+2), \
137 *(((char*)ptr)+3),*(((char*)ptr)+4),*(((char*)ptr)+5), \
138 *(((char*)ptr)+6),*(((char*)ptr)+7),*(((char*)ptr)+8), \
139 *(((char*)ptr)+9),*(((char*)ptr)+10),*(((char*)ptr)+11), \
140 *(((char*)ptr)+12),*(((char*)ptr)+13), \
141 *(((char*)ptr)+14),*(((char*)ptr)+15)); \
142 PRINT_##importance(header "%02x %02x %02x %02x %02x %02x %02x %02x " \
143 "%02x %02x %02x %02x %02x %02x %02x %02x\n", \
144 *(((char*)ptr)+16),*(((char*)ptr)+17), \
145 *(((char*)ptr)+18),*(((char*)ptr)+19), \
146 *(((char*)ptr)+20),*(((char*)ptr)+21), \
147 *(((char*)ptr)+22),*(((char*)ptr)+23), \
148 *(((char*)ptr)+24),*(((char*)ptr)+25), \
149 *(((char*)ptr)+26),*(((char*)ptr)+27), \
150 *(((char*)ptr)+28),*(((char*)ptr)+29), \
151 *(((char*)ptr)+30),*(((char*)ptr)+31));
153 #define PRINTK_HEADER " iucv: " /* for debugging */
155 /* dummy device to make sure netiucv_pm functions are called */
156 static struct device *netiucv_dev;
158 static int netiucv_pm_prepare(struct device *);
159 static void netiucv_pm_complete(struct device *);
160 static int netiucv_pm_freeze(struct device *);
161 static int netiucv_pm_restore_thaw(struct device *);
163 static const struct dev_pm_ops netiucv_pm_ops = {
164 .prepare = netiucv_pm_prepare,
165 .complete = netiucv_pm_complete,
166 .freeze = netiucv_pm_freeze,
167 .thaw = netiucv_pm_restore_thaw,
168 .restore = netiucv_pm_restore_thaw,
171 static struct device_driver netiucv_driver = {
172 .owner = THIS_MODULE,
175 .pm = &netiucv_pm_ops,
178 static int netiucv_callback_connreq(struct iucv_path *,
179 u8 ipvmid[8], u8 ipuser[16]);
180 static void netiucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
181 static void netiucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
182 static void netiucv_callback_connsusp(struct iucv_path *, u8 ipuser[16]);
183 static void netiucv_callback_connres(struct iucv_path *, u8 ipuser[16]);
184 static void netiucv_callback_rx(struct iucv_path *, struct iucv_message *);
185 static void netiucv_callback_txdone(struct iucv_path *, struct iucv_message *);
187 static struct iucv_handler netiucv_handler = {
188 .path_pending = netiucv_callback_connreq,
189 .path_complete = netiucv_callback_connack,
190 .path_severed = netiucv_callback_connrej,
191 .path_quiesced = netiucv_callback_connsusp,
192 .path_resumed = netiucv_callback_connres,
193 .message_pending = netiucv_callback_rx,
194 .message_complete = netiucv_callback_txdone
198 * Per connection profiling data
200 struct connection_profile {
201 unsigned long maxmulti;
202 unsigned long maxcqueue;
203 unsigned long doios_single;
204 unsigned long doios_multi;
206 unsigned long tx_time;
207 struct timespec send_stamp;
208 unsigned long tx_pending;
209 unsigned long tx_max_pending;
213 * Representation of one iucv connection
215 struct iucv_connection {
216 struct list_head list;
217 struct iucv_path *path;
218 struct sk_buff *rx_buff;
219 struct sk_buff *tx_buff;
220 struct sk_buff_head collect_queue;
221 struct sk_buff_head commit_queue;
222 spinlock_t collect_lock;
227 struct net_device *netdev;
228 struct connection_profile prof;
234 * Linked list of all connection structs.
236 static LIST_HEAD(iucv_connection_list);
237 static DEFINE_RWLOCK(iucv_connection_rwlock);
240 * Representation of event-data for the
241 * connection state machine.
244 struct iucv_connection *conn;
249 * Private part of the network device structure
251 struct netiucv_priv {
252 struct net_device_stats stats;
255 struct iucv_connection *conn;
261 * Link level header for a packet.
267 #define NETIUCV_HDRLEN (sizeof(struct ll_header))
268 #define NETIUCV_BUFSIZE_MAX 65537
269 #define NETIUCV_BUFSIZE_DEFAULT NETIUCV_BUFSIZE_MAX
270 #define NETIUCV_MTU_MAX (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
271 #define NETIUCV_MTU_DEFAULT 9216
272 #define NETIUCV_QUEUELEN_DEFAULT 50
273 #define NETIUCV_TIMEOUT_5SEC 5000
276 * Compatibility macros for busy handling
277 * of network devices.
279 static inline void netiucv_clear_busy(struct net_device *dev)
281 struct netiucv_priv *priv = netdev_priv(dev);
282 clear_bit(0, &priv->tbusy);
283 netif_wake_queue(dev);
286 static inline int netiucv_test_and_set_busy(struct net_device *dev)
288 struct netiucv_priv *priv = netdev_priv(dev);
289 netif_stop_queue(dev);
290 return test_and_set_bit(0, &priv->tbusy);
293 static u8 iucvMagic_ascii[16] = {
294 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
295 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
298 static u8 iucvMagic_ebcdic[16] = {
299 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
300 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
304 * Convert an iucv userId to its printable
305 * form (strip whitespace at end).
307 * @param An iucv userId
309 * @returns The printable string (static data!!)
311 static char *netiucv_printname(char *name, int len)
315 memcpy(tmp, name, len);
317 while (*p && ((p - tmp) < len) && (!isspace(*p)))
323 static char *netiucv_printuser(struct iucv_connection *conn)
325 static char tmp_uid[9];
326 static char tmp_udat[17];
327 static char buf[100];
329 if (memcmp(conn->userdata, iucvMagic_ebcdic, 16)) {
332 memcpy(tmp_uid, conn->userid, 8);
333 memcpy(tmp_uid, netiucv_printname(tmp_uid, 8), 8);
334 memcpy(tmp_udat, conn->userdata, 16);
335 EBCASC(tmp_udat, 16);
336 memcpy(tmp_udat, netiucv_printname(tmp_udat, 16), 16);
337 sprintf(buf, "%s.%s", tmp_uid, tmp_udat);
340 return netiucv_printname(conn->userid, 8);
344 * States of the interface statemachine.
352 * MUST be always the last element!!
357 static const char *dev_state_names[] = {
365 * Events of the interface statemachine.
373 * MUST be always the last element!!
378 static const char *dev_event_names[] = {
386 * Events of the connection statemachine
390 * Events, representing callbacks from
391 * lowlevel iucv layer)
402 * Events, representing errors return codes from
403 * calls to lowlevel iucv layer
407 * Event, representing timer expiry.
412 * Events, representing commands from upper levels.
418 * MUST be always the last element!!
423 static const char *conn_event_names[] = {
424 "Remote connection request",
425 "Remote connection acknowledge",
426 "Remote connection reject",
427 "Connection suspended",
428 "Connection resumed",
439 * States of the connection statemachine.
443 * Connection not assigned to any device,
444 * initial state, invalid
449 * Userid assigned but not operating
454 * Connection registered,
455 * no connection request sent yet,
456 * no connection request received
458 CONN_STATE_STARTWAIT,
461 * Connection registered and connection request sent,
462 * no acknowledge and no connection request received yet.
464 CONN_STATE_SETUPWAIT,
467 * Connection up and running idle
472 * Data sent, awaiting CONN_EVENT_TXDONE
477 * Error during registration.
482 * Error during registration.
487 * MUST be always the last element!!
492 static const char *conn_state_names[] = {
500 "Registration error",
506 * Debug Facility Stuff
508 static debug_info_t *iucv_dbf_setup = NULL;
509 static debug_info_t *iucv_dbf_data = NULL;
510 static debug_info_t *iucv_dbf_trace = NULL;
512 DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf);
514 static void iucv_unregister_dbf_views(void)
517 debug_unregister(iucv_dbf_setup);
519 debug_unregister(iucv_dbf_data);
521 debug_unregister(iucv_dbf_trace);
523 static int iucv_register_dbf_views(void)
525 iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
526 IUCV_DBF_SETUP_PAGES,
527 IUCV_DBF_SETUP_NR_AREAS,
529 iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
531 IUCV_DBF_DATA_NR_AREAS,
533 iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
534 IUCV_DBF_TRACE_PAGES,
535 IUCV_DBF_TRACE_NR_AREAS,
538 if ((iucv_dbf_setup == NULL) || (iucv_dbf_data == NULL) ||
539 (iucv_dbf_trace == NULL)) {
540 iucv_unregister_dbf_views();
543 debug_register_view(iucv_dbf_setup, &debug_hex_ascii_view);
544 debug_set_level(iucv_dbf_setup, IUCV_DBF_SETUP_LEVEL);
546 debug_register_view(iucv_dbf_data, &debug_hex_ascii_view);
547 debug_set_level(iucv_dbf_data, IUCV_DBF_DATA_LEVEL);
549 debug_register_view(iucv_dbf_trace, &debug_hex_ascii_view);
550 debug_set_level(iucv_dbf_trace, IUCV_DBF_TRACE_LEVEL);
556 * Callback-wrappers, called from lowlevel iucv layer.
559 static void netiucv_callback_rx(struct iucv_path *path,
560 struct iucv_message *msg)
562 struct iucv_connection *conn = path->private;
563 struct iucv_event ev;
567 fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
570 static void netiucv_callback_txdone(struct iucv_path *path,
571 struct iucv_message *msg)
573 struct iucv_connection *conn = path->private;
574 struct iucv_event ev;
578 fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
581 static void netiucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
583 struct iucv_connection *conn = path->private;
585 fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn);
588 static int netiucv_callback_connreq(struct iucv_path *path,
589 u8 ipvmid[8], u8 ipuser[16])
591 struct iucv_connection *conn = path->private;
592 struct iucv_event ev;
593 static char tmp_user[9];
594 static char tmp_udat[17];
598 memcpy(tmp_user, netiucv_printname(ipvmid, 8), 8);
599 memcpy(tmp_udat, ipuser, 16);
600 EBCASC(tmp_udat, 16);
601 read_lock_bh(&iucv_connection_rwlock);
602 list_for_each_entry(conn, &iucv_connection_list, list) {
603 if (strncmp(ipvmid, conn->userid, 8) ||
604 strncmp(ipuser, conn->userdata, 16))
606 /* Found a matching connection for this path. */
610 fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
613 IUCV_DBF_TEXT_(setup, 2, "Connection requested for %s.%s\n",
614 tmp_user, netiucv_printname(tmp_udat, 16));
615 read_unlock_bh(&iucv_connection_rwlock);
619 static void netiucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
621 struct iucv_connection *conn = path->private;
623 fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn);
626 static void netiucv_callback_connsusp(struct iucv_path *path, u8 ipuser[16])
628 struct iucv_connection *conn = path->private;
630 fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn);
633 static void netiucv_callback_connres(struct iucv_path *path, u8 ipuser[16])
635 struct iucv_connection *conn = path->private;
637 fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn);
641 * NOP action for statemachines
643 static void netiucv_action_nop(fsm_instance *fi, int event, void *arg)
648 * Actions of the connection statemachine
653 * @conn: The connection where this skb has been received.
654 * @pskb: The received skb.
656 * Unpack a just received skb and hand it over to upper layers.
657 * Helper function for conn_action_rx.
659 static void netiucv_unpack_skb(struct iucv_connection *conn,
660 struct sk_buff *pskb)
662 struct net_device *dev = conn->netdev;
663 struct netiucv_priv *privptr = netdev_priv(dev);
666 skb_put(pskb, NETIUCV_HDRLEN);
668 pskb->ip_summed = CHECKSUM_NONE;
669 pskb->protocol = ntohs(ETH_P_IP);
673 struct ll_header *header = (struct ll_header *) pskb->data;
678 skb_pull(pskb, NETIUCV_HDRLEN);
679 header->next -= offset;
680 offset += header->next;
681 header->next -= NETIUCV_HDRLEN;
682 if (skb_tailroom(pskb) < header->next) {
683 IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n",
684 header->next, skb_tailroom(pskb));
687 skb_put(pskb, header->next);
688 skb_reset_mac_header(pskb);
689 skb = dev_alloc_skb(pskb->len);
691 IUCV_DBF_TEXT(data, 2,
692 "Out of memory in netiucv_unpack_skb\n");
693 privptr->stats.rx_dropped++;
696 skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
698 skb_reset_mac_header(skb);
699 skb->dev = pskb->dev;
700 skb->protocol = pskb->protocol;
701 pskb->ip_summed = CHECKSUM_UNNECESSARY;
702 privptr->stats.rx_packets++;
703 privptr->stats.rx_bytes += skb->len;
705 * Since receiving is always initiated from a tasklet (in iucv.c),
706 * we must use netif_rx_ni() instead of netif_rx()
709 skb_pull(pskb, header->next);
710 skb_put(pskb, NETIUCV_HDRLEN);
714 static void conn_action_rx(fsm_instance *fi, int event, void *arg)
716 struct iucv_event *ev = arg;
717 struct iucv_connection *conn = ev->conn;
718 struct iucv_message *msg = ev->data;
719 struct netiucv_priv *privptr = netdev_priv(conn->netdev);
722 IUCV_DBF_TEXT(trace, 4, __func__);
725 iucv_message_reject(conn->path, msg);
726 IUCV_DBF_TEXT(data, 2,
727 "Received data for unlinked connection\n");
730 if (msg->length > conn->max_buffsize) {
731 iucv_message_reject(conn->path, msg);
732 privptr->stats.rx_dropped++;
733 IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n",
734 msg->length, conn->max_buffsize);
737 conn->rx_buff->data = conn->rx_buff->head;
738 skb_reset_tail_pointer(conn->rx_buff);
739 conn->rx_buff->len = 0;
740 rc = iucv_message_receive(conn->path, msg, 0, conn->rx_buff->data,
742 if (rc || msg->length < 5) {
743 privptr->stats.rx_errors++;
744 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc);
747 netiucv_unpack_skb(conn, conn->rx_buff);
750 static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
752 struct iucv_event *ev = arg;
753 struct iucv_connection *conn = ev->conn;
754 struct iucv_message *msg = ev->data;
755 struct iucv_message txmsg;
756 struct netiucv_priv *privptr = NULL;
757 u32 single_flag = msg->tag;
762 unsigned long saveflags;
763 struct ll_header header;
766 IUCV_DBF_TEXT(trace, 4, __func__);
768 if (conn && conn->netdev)
769 privptr = netdev_priv(conn->netdev);
770 conn->prof.tx_pending--;
772 if ((skb = skb_dequeue(&conn->commit_queue))) {
773 atomic_dec(&skb->users);
775 privptr->stats.tx_packets++;
776 privptr->stats.tx_bytes +=
777 (skb->len - NETIUCV_HDRLEN
780 dev_kfree_skb_any(skb);
783 conn->tx_buff->data = conn->tx_buff->head;
784 skb_reset_tail_pointer(conn->tx_buff);
785 conn->tx_buff->len = 0;
786 spin_lock_irqsave(&conn->collect_lock, saveflags);
787 while ((skb = skb_dequeue(&conn->collect_queue))) {
788 header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
789 memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
791 skb_copy_from_linear_data(skb,
792 skb_put(conn->tx_buff, skb->len),
797 atomic_dec(&skb->users);
798 dev_kfree_skb_any(skb);
800 if (conn->collect_len > conn->prof.maxmulti)
801 conn->prof.maxmulti = conn->collect_len;
802 conn->collect_len = 0;
803 spin_unlock_irqrestore(&conn->collect_lock, saveflags);
804 if (conn->tx_buff->len == 0) {
805 fsm_newstate(fi, CONN_STATE_IDLE);
810 memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
811 conn->prof.send_stamp = current_kernel_time();
814 rc = iucv_message_send(conn->path, &txmsg, 0, 0,
815 conn->tx_buff->data, conn->tx_buff->len);
816 conn->prof.doios_multi++;
817 conn->prof.txlen += conn->tx_buff->len;
818 conn->prof.tx_pending++;
819 if (conn->prof.tx_pending > conn->prof.tx_max_pending)
820 conn->prof.tx_max_pending = conn->prof.tx_pending;
822 conn->prof.tx_pending--;
823 fsm_newstate(fi, CONN_STATE_IDLE);
825 privptr->stats.tx_errors += txpackets;
826 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
829 privptr->stats.tx_packets += txpackets;
830 privptr->stats.tx_bytes += txbytes;
832 if (stat_maxcq > conn->prof.maxcqueue)
833 conn->prof.maxcqueue = stat_maxcq;
837 static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
839 struct iucv_event *ev = arg;
840 struct iucv_connection *conn = ev->conn;
841 struct iucv_path *path = ev->data;
842 struct net_device *netdev = conn->netdev;
843 struct netiucv_priv *privptr = netdev_priv(netdev);
846 IUCV_DBF_TEXT(trace, 3, __func__);
849 path->msglim = NETIUCV_QUEUELEN_DEFAULT;
851 rc = iucv_path_accept(path, &netiucv_handler, conn->userdata , conn);
853 IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
856 fsm_newstate(fi, CONN_STATE_IDLE);
857 netdev->tx_queue_len = conn->path->msglim;
858 fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
861 static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
863 struct iucv_event *ev = arg;
864 struct iucv_path *path = ev->data;
866 IUCV_DBF_TEXT(trace, 3, __func__);
867 iucv_path_sever(path, NULL);
870 static void conn_action_connack(fsm_instance *fi, int event, void *arg)
872 struct iucv_connection *conn = arg;
873 struct net_device *netdev = conn->netdev;
874 struct netiucv_priv *privptr = netdev_priv(netdev);
876 IUCV_DBF_TEXT(trace, 3, __func__);
877 fsm_deltimer(&conn->timer);
878 fsm_newstate(fi, CONN_STATE_IDLE);
879 netdev->tx_queue_len = conn->path->msglim;
880 fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
883 static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
885 struct iucv_connection *conn = arg;
887 IUCV_DBF_TEXT(trace, 3, __func__);
888 fsm_deltimer(&conn->timer);
889 iucv_path_sever(conn->path, conn->userdata);
890 fsm_newstate(fi, CONN_STATE_STARTWAIT);
893 static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
895 struct iucv_connection *conn = arg;
896 struct net_device *netdev = conn->netdev;
897 struct netiucv_priv *privptr = netdev_priv(netdev);
899 IUCV_DBF_TEXT(trace, 3, __func__);
901 fsm_deltimer(&conn->timer);
902 iucv_path_sever(conn->path, conn->userdata);
903 dev_info(privptr->dev, "The peer z/VM guest %s has closed the "
904 "connection\n", netiucv_printuser(conn));
905 IUCV_DBF_TEXT(data, 2,
906 "conn_action_connsever: Remote dropped connection\n");
907 fsm_newstate(fi, CONN_STATE_STARTWAIT);
908 fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
911 static void conn_action_start(fsm_instance *fi, int event, void *arg)
913 struct iucv_connection *conn = arg;
914 struct net_device *netdev = conn->netdev;
915 struct netiucv_priv *privptr = netdev_priv(netdev);
918 IUCV_DBF_TEXT(trace, 3, __func__);
920 fsm_newstate(fi, CONN_STATE_STARTWAIT);
923 * We must set the state before calling iucv_connect because the
924 * callback handler could be called at any point after the connection
928 fsm_newstate(fi, CONN_STATE_SETUPWAIT);
929 conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
930 IUCV_DBF_TEXT_(setup, 2, "%s: connecting to %s ...\n",
931 netdev->name, netiucv_printuser(conn));
933 rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
934 NULL, conn->userdata, conn);
937 netdev->tx_queue_len = conn->path->msglim;
938 fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
939 CONN_EVENT_TIMER, conn);
942 dev_warn(privptr->dev,
943 "The IUCV device failed to connect to z/VM guest %s\n",
944 netiucv_printname(conn->userid, 8));
945 fsm_newstate(fi, CONN_STATE_STARTWAIT);
948 dev_warn(privptr->dev,
949 "The IUCV device failed to connect to the peer on z/VM"
950 " guest %s\n", netiucv_printname(conn->userid, 8));
951 fsm_newstate(fi, CONN_STATE_STARTWAIT);
954 dev_err(privptr->dev,
955 "Connecting the IUCV device would exceed the maximum"
956 " number of IUCV connections\n");
957 fsm_newstate(fi, CONN_STATE_CONNERR);
960 dev_err(privptr->dev,
961 "z/VM guest %s has too many IUCV connections"
962 " to connect with the IUCV device\n",
963 netiucv_printname(conn->userid, 8));
964 fsm_newstate(fi, CONN_STATE_CONNERR);
967 dev_err(privptr->dev,
968 "The IUCV device cannot connect to a z/VM guest with no"
969 " IUCV authorization\n");
970 fsm_newstate(fi, CONN_STATE_CONNERR);
973 dev_err(privptr->dev,
974 "Connecting the IUCV device failed with error %d\n",
976 fsm_newstate(fi, CONN_STATE_CONNERR);
979 IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
984 static void netiucv_purge_skb_queue(struct sk_buff_head *q)
988 while ((skb = skb_dequeue(q))) {
989 atomic_dec(&skb->users);
990 dev_kfree_skb_any(skb);
994 static void conn_action_stop(fsm_instance *fi, int event, void *arg)
996 struct iucv_event *ev = arg;
997 struct iucv_connection *conn = ev->conn;
998 struct net_device *netdev = conn->netdev;
999 struct netiucv_priv *privptr = netdev_priv(netdev);
1001 IUCV_DBF_TEXT(trace, 3, __func__);
1003 fsm_deltimer(&conn->timer);
1004 fsm_newstate(fi, CONN_STATE_STOPPED);
1005 netiucv_purge_skb_queue(&conn->collect_queue);
1007 IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
1008 iucv_path_sever(conn->path, conn->userdata);
1012 netiucv_purge_skb_queue(&conn->commit_queue);
1013 fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
1016 static void conn_action_inval(fsm_instance *fi, int event, void *arg)
1018 struct iucv_connection *conn = arg;
1019 struct net_device *netdev = conn->netdev;
1021 IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
1022 netdev->name, conn->userid);
1025 static const fsm_node conn_fsm[] = {
1026 { CONN_STATE_INVALID, CONN_EVENT_START, conn_action_inval },
1027 { CONN_STATE_STOPPED, CONN_EVENT_START, conn_action_start },
1029 { CONN_STATE_STOPPED, CONN_EVENT_STOP, conn_action_stop },
1030 { CONN_STATE_STARTWAIT, CONN_EVENT_STOP, conn_action_stop },
1031 { CONN_STATE_SETUPWAIT, CONN_EVENT_STOP, conn_action_stop },
1032 { CONN_STATE_IDLE, CONN_EVENT_STOP, conn_action_stop },
1033 { CONN_STATE_TX, CONN_EVENT_STOP, conn_action_stop },
1034 { CONN_STATE_REGERR, CONN_EVENT_STOP, conn_action_stop },
1035 { CONN_STATE_CONNERR, CONN_EVENT_STOP, conn_action_stop },
1037 { CONN_STATE_STOPPED, CONN_EVENT_CONN_REQ, conn_action_connreject },
1038 { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1039 { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1040 { CONN_STATE_IDLE, CONN_EVENT_CONN_REQ, conn_action_connreject },
1041 { CONN_STATE_TX, CONN_EVENT_CONN_REQ, conn_action_connreject },
1043 { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack },
1044 { CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER, conn_action_conntimsev },
1046 { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever },
1047 { CONN_STATE_IDLE, CONN_EVENT_CONN_REJ, conn_action_connsever },
1048 { CONN_STATE_TX, CONN_EVENT_CONN_REJ, conn_action_connsever },
1050 { CONN_STATE_IDLE, CONN_EVENT_RX, conn_action_rx },
1051 { CONN_STATE_TX, CONN_EVENT_RX, conn_action_rx },
1053 { CONN_STATE_TX, CONN_EVENT_TXDONE, conn_action_txdone },
1054 { CONN_STATE_IDLE, CONN_EVENT_TXDONE, conn_action_txdone },
1057 static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
1061 * Actions for interface - statemachine.
1066 * @fi: An instance of an interface statemachine.
1067 * @event: The event, just happened.
1068 * @arg: Generic pointer, casted from struct net_device * upon call.
1070 * Startup connection by sending CONN_EVENT_START to it.
1072 static void dev_action_start(fsm_instance *fi, int event, void *arg)
1074 struct net_device *dev = arg;
1075 struct netiucv_priv *privptr = netdev_priv(dev);
1077 IUCV_DBF_TEXT(trace, 3, __func__);
1079 fsm_newstate(fi, DEV_STATE_STARTWAIT);
1080 fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
1084 * Shutdown connection by sending CONN_EVENT_STOP to it.
1086 * @param fi An instance of an interface statemachine.
1087 * @param event The event, just happened.
1088 * @param arg Generic pointer, casted from struct net_device * upon call.
1091 dev_action_stop(fsm_instance *fi, int event, void *arg)
1093 struct net_device *dev = arg;
1094 struct netiucv_priv *privptr = netdev_priv(dev);
1095 struct iucv_event ev;
1097 IUCV_DBF_TEXT(trace, 3, __func__);
1099 ev.conn = privptr->conn;
1101 fsm_newstate(fi, DEV_STATE_STOPWAIT);
1102 fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
1106 * Called from connection statemachine
1107 * when a connection is up and running.
1109 * @param fi An instance of an interface statemachine.
1110 * @param event The event, just happened.
1111 * @param arg Generic pointer, casted from struct net_device * upon call.
1114 dev_action_connup(fsm_instance *fi, int event, void *arg)
1116 struct net_device *dev = arg;
1117 struct netiucv_priv *privptr = netdev_priv(dev);
1119 IUCV_DBF_TEXT(trace, 3, __func__);
1121 switch (fsm_getstate(fi)) {
1122 case DEV_STATE_STARTWAIT:
1123 fsm_newstate(fi, DEV_STATE_RUNNING);
1124 dev_info(privptr->dev,
1125 "The IUCV device has been connected"
1126 " successfully to %s\n",
1127 netiucv_printuser(privptr->conn));
1128 IUCV_DBF_TEXT(setup, 3,
1129 "connection is up and running\n");
1131 case DEV_STATE_STOPWAIT:
1132 IUCV_DBF_TEXT(data, 2,
1133 "dev_action_connup: in DEV_STATE_STOPWAIT\n");
1139 * Called from connection statemachine
1140 * when a connection has been shutdown.
1142 * @param fi An instance of an interface statemachine.
1143 * @param event The event, just happened.
1144 * @param arg Generic pointer, casted from struct net_device * upon call.
1147 dev_action_conndown(fsm_instance *fi, int event, void *arg)
1149 IUCV_DBF_TEXT(trace, 3, __func__);
1151 switch (fsm_getstate(fi)) {
1152 case DEV_STATE_RUNNING:
1153 fsm_newstate(fi, DEV_STATE_STARTWAIT);
1155 case DEV_STATE_STOPWAIT:
1156 fsm_newstate(fi, DEV_STATE_STOPPED);
1157 IUCV_DBF_TEXT(setup, 3, "connection is down\n");
1162 static const fsm_node dev_fsm[] = {
1163 { DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start },
1165 { DEV_STATE_STOPWAIT, DEV_EVENT_START, dev_action_start },
1166 { DEV_STATE_STOPWAIT, DEV_EVENT_CONDOWN, dev_action_conndown },
1168 { DEV_STATE_STARTWAIT, DEV_EVENT_STOP, dev_action_stop },
1169 { DEV_STATE_STARTWAIT, DEV_EVENT_CONUP, dev_action_connup },
1171 { DEV_STATE_RUNNING, DEV_EVENT_STOP, dev_action_stop },
1172 { DEV_STATE_RUNNING, DEV_EVENT_CONDOWN, dev_action_conndown },
1173 { DEV_STATE_RUNNING, DEV_EVENT_CONUP, netiucv_action_nop },
1176 static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
1179 * Transmit a packet.
1180 * This is a helper function for netiucv_tx().
1182 * @param conn Connection to be used for sending.
1183 * @param skb Pointer to struct sk_buff of packet to send.
1184 * The linklevel header has already been set up
1187 * @return 0 on success, -ERRNO on failure. (Never fails.)
1189 static int netiucv_transmit_skb(struct iucv_connection *conn,
1190 struct sk_buff *skb)
1192 struct iucv_message msg;
1193 unsigned long saveflags;
1194 struct ll_header header;
1197 if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
1198 int l = skb->len + NETIUCV_HDRLEN;
1200 spin_lock_irqsave(&conn->collect_lock, saveflags);
1201 if (conn->collect_len + l >
1202 (conn->max_buffsize - NETIUCV_HDRLEN)) {
1204 IUCV_DBF_TEXT(data, 2,
1205 "EBUSY from netiucv_transmit_skb\n");
1207 atomic_inc(&skb->users);
1208 skb_queue_tail(&conn->collect_queue, skb);
1209 conn->collect_len += l;
1212 spin_unlock_irqrestore(&conn->collect_lock, saveflags);
1214 struct sk_buff *nskb = skb;
1216 * Copy the skb to a new allocated skb in lowmem only if the
1217 * data is located above 2G in memory or tailroom is < 2.
1219 unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
1220 NETIUCV_HDRLEN)) >> 31;
1222 if (hi || (skb_tailroom(skb) < 2)) {
1223 nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
1224 NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
1226 IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
1230 skb_reserve(nskb, NETIUCV_HDRLEN);
1231 memcpy(skb_put(nskb, skb->len),
1232 skb->data, skb->len);
1237 * skb now is below 2G and has enough room. Add headers.
1239 header.next = nskb->len + NETIUCV_HDRLEN;
1240 memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
1242 memcpy(skb_put(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
1244 fsm_newstate(conn->fsm, CONN_STATE_TX);
1245 conn->prof.send_stamp = current_kernel_time();
1249 rc = iucv_message_send(conn->path, &msg, 0, 0,
1250 nskb->data, nskb->len);
1251 conn->prof.doios_single++;
1252 conn->prof.txlen += skb->len;
1253 conn->prof.tx_pending++;
1254 if (conn->prof.tx_pending > conn->prof.tx_max_pending)
1255 conn->prof.tx_max_pending = conn->prof.tx_pending;
1257 struct netiucv_priv *privptr;
1258 fsm_newstate(conn->fsm, CONN_STATE_IDLE);
1259 conn->prof.tx_pending--;
1260 privptr = netdev_priv(conn->netdev);
1262 privptr->stats.tx_errors++;
1264 dev_kfree_skb(nskb);
1267 * Remove our headers. They get added
1268 * again on retransmit.
1270 skb_pull(skb, NETIUCV_HDRLEN);
1271 skb_trim(skb, skb->len - NETIUCV_HDRLEN);
1273 IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
1277 atomic_inc(&nskb->users);
1278 skb_queue_tail(&conn->commit_queue, nskb);
1286 * Interface API for upper network layers
1290 * Open an interface.
1291 * Called from generic network layer when ifconfig up is run.
1293 * @param dev Pointer to interface struct.
1295 * @return 0 on success, -ERRNO on failure. (Never fails.)
1297 static int netiucv_open(struct net_device *dev)
1299 struct netiucv_priv *priv = netdev_priv(dev);
1301 fsm_event(priv->fsm, DEV_EVENT_START, dev);
1306 * Close an interface.
1307 * Called from generic network layer when ifconfig down is run.
1309 * @param dev Pointer to interface struct.
1311 * @return 0 on success, -ERRNO on failure. (Never fails.)
1313 static int netiucv_close(struct net_device *dev)
1315 struct netiucv_priv *priv = netdev_priv(dev);
1317 fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
1321 static int netiucv_pm_prepare(struct device *dev)
1323 IUCV_DBF_TEXT(trace, 3, __func__);
1327 static void netiucv_pm_complete(struct device *dev)
1329 IUCV_DBF_TEXT(trace, 3, __func__);
1334 * netiucv_pm_freeze() - Freeze PM callback
1335 * @dev: netiucv device
1337 * close open netiucv interfaces
1339 static int netiucv_pm_freeze(struct device *dev)
1341 struct netiucv_priv *priv = dev_get_drvdata(dev);
1342 struct net_device *ndev = NULL;
1345 IUCV_DBF_TEXT(trace, 3, __func__);
1346 if (priv && priv->conn)
1347 ndev = priv->conn->netdev;
1350 netif_device_detach(ndev);
1351 priv->pm_state = fsm_getstate(priv->fsm);
1352 rc = netiucv_close(ndev);
1358 * netiucv_pm_restore_thaw() - Thaw and restore PM callback
1359 * @dev: netiucv device
1361 * re-open netiucv interfaces closed during freeze
1363 static int netiucv_pm_restore_thaw(struct device *dev)
1365 struct netiucv_priv *priv = dev_get_drvdata(dev);
1366 struct net_device *ndev = NULL;
1369 IUCV_DBF_TEXT(trace, 3, __func__);
1370 if (priv && priv->conn)
1371 ndev = priv->conn->netdev;
1374 switch (priv->pm_state) {
1375 case DEV_STATE_RUNNING:
1376 case DEV_STATE_STARTWAIT:
1377 rc = netiucv_open(ndev);
1382 netif_device_attach(ndev);
1388 * Start transmission of a packet.
1389 * Called from generic network device layer.
1391 * @param skb Pointer to buffer containing the packet.
1392 * @param dev Pointer to interface struct.
1394 * @return 0 if packet consumed, !0 if packet rejected.
1395 * Note: If we return !0, then the packet is free'd by
1396 * the generic network layer.
1398 static int netiucv_tx(struct sk_buff *skb, struct net_device *dev)
1400 struct netiucv_priv *privptr = netdev_priv(dev);
1403 IUCV_DBF_TEXT(trace, 4, __func__);
1405 * Some sanity checks ...
1408 IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
1409 privptr->stats.tx_dropped++;
1410 return NETDEV_TX_OK;
1412 if (skb_headroom(skb) < NETIUCV_HDRLEN) {
1413 IUCV_DBF_TEXT(data, 2,
1414 "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1416 privptr->stats.tx_dropped++;
1417 return NETDEV_TX_OK;
1421 * If connection is not running, try to restart it
1422 * and throw away packet.
1424 if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
1426 privptr->stats.tx_dropped++;
1427 privptr->stats.tx_errors++;
1428 privptr->stats.tx_carrier_errors++;
1429 return NETDEV_TX_OK;
1432 if (netiucv_test_and_set_busy(dev)) {
1433 IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
1434 return NETDEV_TX_BUSY;
1436 dev->trans_start = jiffies;
1437 rc = netiucv_transmit_skb(privptr->conn, skb);
1438 netiucv_clear_busy(dev);
1439 return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
1444 * @dev: Pointer to interface struct.
1446 * Returns interface statistics of a device.
1448 * Returns pointer to stats struct of this interface.
1450 static struct net_device_stats *netiucv_stats (struct net_device * dev)
1452 struct netiucv_priv *priv = netdev_priv(dev);
1454 IUCV_DBF_TEXT(trace, 5, __func__);
1455 return &priv->stats;
1459 * netiucv_change_mtu
1460 * @dev: Pointer to interface struct.
1461 * @new_mtu: The new MTU to use for this interface.
1463 * Sets MTU of an interface.
1465 * Returns 0 on success, -EINVAL if MTU is out of valid range.
1466 * (valid range is 576 .. NETIUCV_MTU_MAX).
1468 static int netiucv_change_mtu(struct net_device * dev, int new_mtu)
1470 IUCV_DBF_TEXT(trace, 3, __func__);
1471 if (new_mtu < 576 || new_mtu > NETIUCV_MTU_MAX) {
1472 IUCV_DBF_TEXT(setup, 2, "given MTU out of valid range\n");
1480 * attributes in sysfs
1483 static ssize_t user_show(struct device *dev, struct device_attribute *attr,
1486 struct netiucv_priv *priv = dev_get_drvdata(dev);
1488 IUCV_DBF_TEXT(trace, 5, __func__);
1489 return sprintf(buf, "%s\n", netiucv_printuser(priv->conn));
1492 static int netiucv_check_user(const char *buf, size_t count, char *username,
1498 p = strchr(buf, '.');
1499 if ((p && ((count > 26) ||
1501 (buf + count - p > 18))) ||
1502 (!p && (count > 9))) {
1503 IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
1507 for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
1508 if (isalnum(*p) || *p == '$') {
1509 username[i] = toupper(*p);
1513 /* trailing lf, grr */
1515 IUCV_DBF_TEXT_(setup, 2,
1516 "conn_write: invalid character %02x\n", *p);
1520 username[i++] = ' ';
1525 for (i = 0; i < 16 && *p; i++, p++) {
1528 userdata[i] = toupper(*p);
1530 while (i > 0 && i < 16)
1531 userdata[i++] = ' ';
1533 memcpy(userdata, iucvMagic_ascii, 16);
1534 userdata[16] = '\0';
1535 ASCEBC(userdata, 16);
1540 static ssize_t user_write(struct device *dev, struct device_attribute *attr,
1541 const char *buf, size_t count)
1543 struct netiucv_priv *priv = dev_get_drvdata(dev);
1544 struct net_device *ndev = priv->conn->netdev;
1548 struct iucv_connection *cp;
1550 IUCV_DBF_TEXT(trace, 3, __func__);
1551 rc = netiucv_check_user(buf, count, username, userdata);
1555 if (memcmp(username, priv->conn->userid, 9) &&
1556 (ndev->flags & (IFF_UP | IFF_RUNNING))) {
1557 /* username changed while the interface is active. */
1558 IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
1561 read_lock_bh(&iucv_connection_rwlock);
1562 list_for_each_entry(cp, &iucv_connection_list, list) {
1563 if (!strncmp(username, cp->userid, 9) &&
1564 !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
1565 read_unlock_bh(&iucv_connection_rwlock);
1566 IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
1567 "already exists\n", netiucv_printuser(cp));
1571 read_unlock_bh(&iucv_connection_rwlock);
1572 memcpy(priv->conn->userid, username, 9);
1573 memcpy(priv->conn->userdata, userdata, 17);
1577 static DEVICE_ATTR(user, 0644, user_show, user_write);
1579 static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
1582 struct netiucv_priv *priv = dev_get_drvdata(dev);
1584 IUCV_DBF_TEXT(trace, 5, __func__);
1585 return sprintf(buf, "%d\n", priv->conn->max_buffsize);
1588 static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
1589 const char *buf, size_t count)
1591 struct netiucv_priv *priv = dev_get_drvdata(dev);
1592 struct net_device *ndev = priv->conn->netdev;
1596 IUCV_DBF_TEXT(trace, 3, __func__);
1600 bs1 = simple_strtoul(buf, &e, 0);
1602 if (e && (!isspace(*e))) {
1603 IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %02x\n",
1607 if (bs1 > NETIUCV_BUFSIZE_MAX) {
1608 IUCV_DBF_TEXT_(setup, 2,
1609 "buffer_write: buffer size %d too large\n",
1613 if ((ndev->flags & IFF_RUNNING) &&
1614 (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
1615 IUCV_DBF_TEXT_(setup, 2,
1616 "buffer_write: buffer size %d too small\n",
1620 if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
1621 IUCV_DBF_TEXT_(setup, 2,
1622 "buffer_write: buffer size %d too small\n",
1627 priv->conn->max_buffsize = bs1;
1628 if (!(ndev->flags & IFF_RUNNING))
1629 ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
1635 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1637 static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
1640 struct netiucv_priv *priv = dev_get_drvdata(dev);
1642 IUCV_DBF_TEXT(trace, 5, __func__);
1643 return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
1646 static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1648 static ssize_t conn_fsm_show (struct device *dev,
1649 struct device_attribute *attr, char *buf)
1651 struct netiucv_priv *priv = dev_get_drvdata(dev);
1653 IUCV_DBF_TEXT(trace, 5, __func__);
1654 return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
1657 static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1659 static ssize_t maxmulti_show (struct device *dev,
1660 struct device_attribute *attr, char *buf)
1662 struct netiucv_priv *priv = dev_get_drvdata(dev);
1664 IUCV_DBF_TEXT(trace, 5, __func__);
1665 return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
1668 static ssize_t maxmulti_write (struct device *dev,
1669 struct device_attribute *attr,
1670 const char *buf, size_t count)
1672 struct netiucv_priv *priv = dev_get_drvdata(dev);
1674 IUCV_DBF_TEXT(trace, 4, __func__);
1675 priv->conn->prof.maxmulti = 0;
1679 static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1681 static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
1684 struct netiucv_priv *priv = dev_get_drvdata(dev);
1686 IUCV_DBF_TEXT(trace, 5, __func__);
1687 return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
1690 static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
1691 const char *buf, size_t count)
1693 struct netiucv_priv *priv = dev_get_drvdata(dev);
1695 IUCV_DBF_TEXT(trace, 4, __func__);
1696 priv->conn->prof.maxcqueue = 0;
1700 static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1702 static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
1705 struct netiucv_priv *priv = dev_get_drvdata(dev);
1707 IUCV_DBF_TEXT(trace, 5, __func__);
1708 return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
1711 static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
1712 const char *buf, size_t count)
1714 struct netiucv_priv *priv = dev_get_drvdata(dev);
1716 IUCV_DBF_TEXT(trace, 4, __func__);
1717 priv->conn->prof.doios_single = 0;
1721 static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1723 static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
1726 struct netiucv_priv *priv = dev_get_drvdata(dev);
1728 IUCV_DBF_TEXT(trace, 5, __func__);
1729 return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
1732 static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
1733 const char *buf, size_t count)
1735 struct netiucv_priv *priv = dev_get_drvdata(dev);
1737 IUCV_DBF_TEXT(trace, 5, __func__);
1738 priv->conn->prof.doios_multi = 0;
1742 static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1744 static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
1747 struct netiucv_priv *priv = dev_get_drvdata(dev);
1749 IUCV_DBF_TEXT(trace, 5, __func__);
1750 return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
1753 static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
1754 const char *buf, size_t count)
1756 struct netiucv_priv *priv = dev_get_drvdata(dev);
1758 IUCV_DBF_TEXT(trace, 4, __func__);
1759 priv->conn->prof.txlen = 0;
1763 static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1765 static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
1768 struct netiucv_priv *priv = dev_get_drvdata(dev);
1770 IUCV_DBF_TEXT(trace, 5, __func__);
1771 return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
1774 static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
1775 const char *buf, size_t count)
1777 struct netiucv_priv *priv = dev_get_drvdata(dev);
1779 IUCV_DBF_TEXT(trace, 4, __func__);
1780 priv->conn->prof.tx_time = 0;
1784 static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1786 static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
1789 struct netiucv_priv *priv = dev_get_drvdata(dev);
1791 IUCV_DBF_TEXT(trace, 5, __func__);
1792 return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
1795 static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
1796 const char *buf, size_t count)
1798 struct netiucv_priv *priv = dev_get_drvdata(dev);
1800 IUCV_DBF_TEXT(trace, 4, __func__);
1801 priv->conn->prof.tx_pending = 0;
1805 static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1807 static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
1810 struct netiucv_priv *priv = dev_get_drvdata(dev);
1812 IUCV_DBF_TEXT(trace, 5, __func__);
1813 return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
1816 static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
1817 const char *buf, size_t count)
1819 struct netiucv_priv *priv = dev_get_drvdata(dev);
1821 IUCV_DBF_TEXT(trace, 4, __func__);
1822 priv->conn->prof.tx_max_pending = 0;
1826 static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1828 static struct attribute *netiucv_attrs[] = {
1829 &dev_attr_buffer.attr,
1830 &dev_attr_user.attr,
1834 static struct attribute_group netiucv_attr_group = {
1835 .attrs = netiucv_attrs,
1838 static struct attribute *netiucv_stat_attrs[] = {
1839 &dev_attr_device_fsm_state.attr,
1840 &dev_attr_connection_fsm_state.attr,
1841 &dev_attr_max_tx_buffer_used.attr,
1842 &dev_attr_max_chained_skbs.attr,
1843 &dev_attr_tx_single_write_ops.attr,
1844 &dev_attr_tx_multi_write_ops.attr,
1845 &dev_attr_netto_bytes.attr,
1846 &dev_attr_max_tx_io_time.attr,
1847 &dev_attr_tx_pending.attr,
1848 &dev_attr_tx_max_pending.attr,
1852 static struct attribute_group netiucv_stat_attr_group = {
1854 .attrs = netiucv_stat_attrs,
1857 static const struct attribute_group *netiucv_attr_groups[] = {
1858 &netiucv_stat_attr_group,
1859 &netiucv_attr_group,
1863 static int netiucv_register_device(struct net_device *ndev)
1865 struct netiucv_priv *priv = netdev_priv(ndev);
1866 struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1869 IUCV_DBF_TEXT(trace, 3, __func__);
1872 dev_set_name(dev, "net%s", ndev->name);
1873 dev->bus = &iucv_bus;
1874 dev->parent = iucv_root;
1875 dev->groups = netiucv_attr_groups;
1877 * The release function could be called after the
1878 * module has been unloaded. It's _only_ task is to
1879 * free the struct. Therefore, we specify kfree()
1880 * directly here. (Probably a little bit obfuscating
1881 * but legitime ...).
1883 dev->release = (void (*)(struct device *))kfree;
1884 dev->driver = &netiucv_driver;
1888 ret = device_register(dev);
1894 dev_set_drvdata(dev, priv);
1898 static void netiucv_unregister_device(struct device *dev)
1900 IUCV_DBF_TEXT(trace, 3, __func__);
1901 device_unregister(dev);
1905 * Allocate and initialize a new connection structure.
1906 * Add it to the list of netiucv connections;
1908 static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
1912 struct iucv_connection *conn;
1914 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1917 skb_queue_head_init(&conn->collect_queue);
1918 skb_queue_head_init(&conn->commit_queue);
1919 spin_lock_init(&conn->collect_lock);
1920 conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1923 conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1926 conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1929 conn->fsm = init_fsm("netiucvconn", conn_state_names,
1930 conn_event_names, NR_CONN_STATES,
1931 NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1936 fsm_settimer(conn->fsm, &conn->timer);
1937 fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1940 memcpy(conn->userdata, userdata, 17);
1942 memcpy(conn->userid, username, 9);
1943 fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1946 write_lock_bh(&iucv_connection_rwlock);
1947 list_add_tail(&conn->list, &iucv_connection_list);
1948 write_unlock_bh(&iucv_connection_rwlock);
1952 kfree_skb(conn->tx_buff);
1954 kfree_skb(conn->rx_buff);
1962 * Release a connection structure and remove it from the
1963 * list of netiucv connections.
1965 static void netiucv_remove_connection(struct iucv_connection *conn)
1968 IUCV_DBF_TEXT(trace, 3, __func__);
1969 write_lock_bh(&iucv_connection_rwlock);
1970 list_del_init(&conn->list);
1971 write_unlock_bh(&iucv_connection_rwlock);
1972 fsm_deltimer(&conn->timer);
1973 netiucv_purge_skb_queue(&conn->collect_queue);
1975 iucv_path_sever(conn->path, conn->userdata);
1979 netiucv_purge_skb_queue(&conn->commit_queue);
1980 kfree_fsm(conn->fsm);
1981 kfree_skb(conn->rx_buff);
1982 kfree_skb(conn->tx_buff);
1986 * Release everything of a net device.
1988 static void netiucv_free_netdevice(struct net_device *dev)
1990 struct netiucv_priv *privptr = netdev_priv(dev);
1992 IUCV_DBF_TEXT(trace, 3, __func__);
1999 netiucv_remove_connection(privptr->conn);
2001 kfree_fsm(privptr->fsm);
2002 privptr->conn = NULL; privptr->fsm = NULL;
2003 /* privptr gets freed by free_netdev() */
2009 * Initialize a net device. (Called from kernel in alloc_netdev())
2011 static const struct net_device_ops netiucv_netdev_ops = {
2012 .ndo_open = netiucv_open,
2013 .ndo_stop = netiucv_close,
2014 .ndo_get_stats = netiucv_stats,
2015 .ndo_start_xmit = netiucv_tx,
2016 .ndo_change_mtu = netiucv_change_mtu,
2019 static void netiucv_setup_netdevice(struct net_device *dev)
2021 dev->mtu = NETIUCV_MTU_DEFAULT;
2022 dev->destructor = netiucv_free_netdevice;
2023 dev->hard_header_len = NETIUCV_HDRLEN;
2025 dev->type = ARPHRD_SLIP;
2026 dev->tx_queue_len = NETIUCV_QUEUELEN_DEFAULT;
2027 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2028 dev->netdev_ops = &netiucv_netdev_ops;
2032 * Allocate and initialize everything of a net device.
2034 static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
2036 struct netiucv_priv *privptr;
2037 struct net_device *dev;
2039 dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
2040 netiucv_setup_netdevice);
2044 if (dev_alloc_name(dev, dev->name) < 0)
2047 privptr = netdev_priv(dev);
2048 privptr->fsm = init_fsm("netiucvdev", dev_state_names,
2049 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
2050 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2054 privptr->conn = netiucv_new_connection(dev, username, userdata);
2055 if (!privptr->conn) {
2056 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
2059 fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2063 kfree_fsm(privptr->fsm);
2070 static ssize_t conn_write(struct device_driver *drv,
2071 const char *buf, size_t count)
2076 struct net_device *dev;
2077 struct netiucv_priv *priv;
2078 struct iucv_connection *cp;
2080 IUCV_DBF_TEXT(trace, 3, __func__);
2081 rc = netiucv_check_user(buf, count, username, userdata);
2085 read_lock_bh(&iucv_connection_rwlock);
2086 list_for_each_entry(cp, &iucv_connection_list, list) {
2087 if (!strncmp(username, cp->userid, 9) &&
2088 !strncmp(userdata, cp->userdata, 17)) {
2089 read_unlock_bh(&iucv_connection_rwlock);
2090 IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
2091 "already exists\n", netiucv_printuser(cp));
2095 read_unlock_bh(&iucv_connection_rwlock);
2097 dev = netiucv_init_netdevice(username, userdata);
2099 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
2103 rc = netiucv_register_device(dev);
2106 IUCV_DBF_TEXT_(setup, 2,
2107 "ret %d from netiucv_register_device\n", rc);
2112 priv = netdev_priv(dev);
2113 SET_NETDEV_DEV(dev, priv->dev);
2115 rc = register_netdevice(dev);
2120 dev_info(priv->dev, "The IUCV interface to %s has been established "
2122 netiucv_printuser(priv->conn));
2127 netiucv_unregister_device(priv->dev);
2129 netiucv_free_netdevice(dev);
2133 static DRIVER_ATTR(connection, 0200, NULL, conn_write);
2135 static ssize_t remove_write (struct device_driver *drv,
2136 const char *buf, size_t count)
2138 struct iucv_connection *cp;
2139 struct net_device *ndev;
2140 struct netiucv_priv *priv;
2142 char name[IFNAMSIZ];
2146 IUCV_DBF_TEXT(trace, 3, __func__);
2148 if (count >= IFNAMSIZ)
2149 count = IFNAMSIZ - 1;
2151 for (i = 0, p = buf; i < count && *p; i++, p++) {
2152 if (*p == '\n' || *p == ' ')
2153 /* trailing lf, grr */
2159 read_lock_bh(&iucv_connection_rwlock);
2160 list_for_each_entry(cp, &iucv_connection_list, list) {
2162 priv = netdev_priv(ndev);
2164 if (strncmp(name, ndev->name, count))
2166 read_unlock_bh(&iucv_connection_rwlock);
2167 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2168 dev_warn(dev, "The IUCV device is connected"
2169 " to %s and cannot be removed\n",
2170 priv->conn->userid);
2171 IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2174 unregister_netdev(ndev);
2175 netiucv_unregister_device(dev);
2178 read_unlock_bh(&iucv_connection_rwlock);
2179 IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2183 static DRIVER_ATTR(remove, 0200, NULL, remove_write);
2185 static struct attribute * netiucv_drv_attrs[] = {
2186 &driver_attr_connection.attr,
2187 &driver_attr_remove.attr,
2191 static struct attribute_group netiucv_drv_attr_group = {
2192 .attrs = netiucv_drv_attrs,
2195 static const struct attribute_group *netiucv_drv_attr_groups[] = {
2196 &netiucv_drv_attr_group,
2200 static void netiucv_banner(void)
2202 pr_info("driver initialized\n");
2205 static void __exit netiucv_exit(void)
2207 struct iucv_connection *cp;
2208 struct net_device *ndev;
2209 struct netiucv_priv *priv;
2212 IUCV_DBF_TEXT(trace, 3, __func__);
2213 while (!list_empty(&iucv_connection_list)) {
2214 cp = list_entry(iucv_connection_list.next,
2215 struct iucv_connection, list);
2217 priv = netdev_priv(ndev);
2220 unregister_netdev(ndev);
2221 netiucv_unregister_device(dev);
2224 device_unregister(netiucv_dev);
2225 driver_unregister(&netiucv_driver);
2226 iucv_unregister(&netiucv_handler, 1);
2227 iucv_unregister_dbf_views();
2229 pr_info("driver unloaded\n");
2233 static int __init netiucv_init(void)
2237 rc = iucv_register_dbf_views();
2240 rc = iucv_register(&netiucv_handler, 1);
2243 IUCV_DBF_TEXT(trace, 3, __func__);
2244 netiucv_driver.groups = netiucv_drv_attr_groups;
2245 rc = driver_register(&netiucv_driver);
2247 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2250 /* establish dummy device */
2251 netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
2256 dev_set_name(netiucv_dev, "netiucv");
2257 netiucv_dev->bus = &iucv_bus;
2258 netiucv_dev->parent = iucv_root;
2259 netiucv_dev->release = (void (*)(struct device *))kfree;
2260 netiucv_dev->driver = &netiucv_driver;
2261 rc = device_register(netiucv_dev);
2263 put_device(netiucv_dev);
2270 driver_unregister(&netiucv_driver);
2272 iucv_unregister(&netiucv_handler, 1);
2274 iucv_unregister_dbf_views();
2279 module_init(netiucv_init);
2280 module_exit(netiucv_exit);
2281 MODULE_LICENSE("GPL");