X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Fs390%2Fnet%2Fnetiucv.c;h=16e8e69afb10b2d3395657bb2a0db1f4b298b05f;hb=6a77f38946aaee1cd85eeec6cf4229b204c15071;hp=13354dfee73c49c6d3889a8b59699a2d0bb07a9b;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c index 13354dfee..16e8e69af 100644 --- a/drivers/s390/net/netiucv.c +++ b/drivers/s390/net/netiucv.c @@ -1,5 +1,5 @@ /* - * $Id: netiucv.c,v 1.51 2004/04/23 08:11:21 mschwide Exp $ + * $Id: netiucv.c,v 1.63 2004/07/27 13:36:05 mschwide Exp $ * * IUCV network driver * @@ -30,7 +30,7 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * - * RELEASE-TAG: IUCV network driver $Revision: 1.51 $ + * RELEASE-TAG: IUCV network driver $Revision: 1.63 $ * */ @@ -45,6 +45,7 @@ #include #include #include +#include #include #include @@ -58,7 +59,6 @@ #include #include -#include #include #include "iucv.h" @@ -69,6 +69,13 @@ MODULE_AUTHOR MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver"); +#define PRINTK_HEADER " iucv: " /* for debugging */ + +static struct device_driver netiucv_driver = { + .name = "netiucv", + .bus = &iucv_bus, +}; + /** * Per connection profiling data */ @@ -98,7 +105,6 @@ struct iucv_connection { spinlock_t collect_lock; int collect_len; int max_buffsize; - int flags; fsm_timer timer; fsm_instance *fsm; struct net_device *netdev; @@ -106,15 +112,10 @@ struct iucv_connection { char userid[9]; }; -#define CONN_FLAGS_BUFSIZE_CHANGED 1 - /** * Linked list of all connection structs. */ -static struct iucv_connection *connections; - -/* Keep track of interfaces. */ -static int ifno; +static struct iucv_connection *iucv_connections; /** * Representation of event-data for the @@ -134,7 +135,6 @@ struct netiucv_priv { fsm_instance *fsm; struct iucv_connection *conn; struct device *dev; - fsm_timer timer; }; /** @@ -169,17 +169,17 @@ static __inline__ int netiucv_test_and_set_busy(struct net_device *dev) } static __u8 iucv_host[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -//static __u8 iucvMagic[16] = { -// 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, -// 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 -//}; +static __u8 iucvMagic[16] = { + 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 +}; /** * This mask means the 16-byte IUCV "magic" and the origin userid must * match exactly as specified in order to give connection_pending() * control. */ -static __u8 mask[] = { +static __u8 netiucv_mask[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff @@ -235,7 +235,6 @@ enum dev_events { DEV_EVENT_STOP, DEV_EVENT_CONUP, DEV_EVENT_CONDOWN, - DEV_EVENT_TIMER, /** * MUST be always the last element!! */ @@ -247,7 +246,6 @@ static const char *dev_event_names[] = { "Stop", "Connection up", "Connection down", - "Timer", }; /** @@ -370,6 +368,58 @@ static const char *conn_state_names[] = { }; +/** + * Debug Facility Stuff + */ +static debug_info_t *iucv_dbf_setup = NULL; +static debug_info_t *iucv_dbf_data = NULL; +static debug_info_t *iucv_dbf_trace = NULL; + +DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf); + +static void +iucv_unregister_dbf_views(void) +{ + if (iucv_dbf_setup) + debug_unregister(iucv_dbf_setup); + if (iucv_dbf_data) + debug_unregister(iucv_dbf_data); + if (iucv_dbf_trace) + debug_unregister(iucv_dbf_trace); +} +static int +iucv_register_dbf_views(void) +{ + iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME, + IUCV_DBF_SETUP_INDEX, + IUCV_DBF_SETUP_NR_AREAS, + IUCV_DBF_SETUP_LEN); + iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME, + IUCV_DBF_DATA_INDEX, + IUCV_DBF_DATA_NR_AREAS, + IUCV_DBF_DATA_LEN); + iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME, + IUCV_DBF_TRACE_INDEX, + IUCV_DBF_TRACE_NR_AREAS, + IUCV_DBF_TRACE_LEN); + + if ((iucv_dbf_setup == NULL) || (iucv_dbf_data == NULL) || + (iucv_dbf_trace == NULL)) { + iucv_unregister_dbf_views(); + return -ENOMEM; + } + debug_register_view(iucv_dbf_setup, &debug_hex_ascii_view); + debug_set_level(iucv_dbf_setup, IUCV_DBF_SETUP_LEVEL); + + debug_register_view(iucv_dbf_data, &debug_hex_ascii_view); + debug_set_level(iucv_dbf_data, IUCV_DBF_DATA_LEVEL); + + debug_register_view(iucv_dbf_trace, &debug_hex_ascii_view); + debug_set_level(iucv_dbf_trace, IUCV_DBF_TRACE_LEVEL); + + return 0; +} + /** * Callback-wrappers, called from lowlevel iucv layer. *****************************************************************************/ @@ -499,7 +549,7 @@ netiucv_unpack_skb(struct iucv_connection *conn, struct sk_buff *pskb) struct sk_buff *skb; ll_header *header = (ll_header *)pskb->data; - if (header->next == 0) + if (!header->next) break; skb_pull(pskb, NETIUCV_HDRLEN); @@ -507,19 +557,21 @@ netiucv_unpack_skb(struct iucv_connection *conn, struct sk_buff *pskb) offset += header->next; header->next -= NETIUCV_HDRLEN; if (skb_tailroom(pskb) < header->next) { - printk(KERN_WARNING - "%s: Illegal next field in iucv header: " + PRINT_WARN("%s: Illegal next field in iucv header: " "%d > %d\n", dev->name, header->next, skb_tailroom(pskb)); + IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n", + header->next, skb_tailroom(pskb)); return; } skb_put(pskb, header->next); pskb->mac.raw = pskb->data; skb = dev_alloc_skb(pskb->len); if (!skb) { - printk(KERN_WARNING - "%s Out of memory in netiucv_unpack_skb\n", + PRINT_WARN("%s Out of memory in netiucv_unpack_skb\n", dev->name); + IUCV_DBF_TEXT(data, 2, + "Out of memory in netiucv_unpack_skb\n"); privptr->stats.rx_dropped++; return; } @@ -547,30 +599,37 @@ conn_action_rx(fsm_instance *fi, int event, void *arg) struct iucv_event *ev = (struct iucv_event *)arg; struct iucv_connection *conn = ev->conn; iucv_MessagePending *eib = (iucv_MessagePending *)ev->data; - struct netiucv_priv *privptr = (struct netiucv_priv *)conn->netdev->priv; + struct netiucv_priv *privptr =(struct netiucv_priv *)conn->netdev->priv; - __u16 msglen = eib->ln1msg2.ipbfln1f; + __u32 msglen = eib->ln1msg2.ipbfln1f; int rc; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); if (!conn->netdev) { /* FRITZ: How to tell iucv LL to drop the msg? */ - printk(KERN_WARNING - "Received data for unlinked connection\n"); + PRINT_WARN("Received data for unlinked connection\n"); + IUCV_DBF_TEXT(data, 2, + "Received data for unlinked connection\n"); return; } if (msglen > conn->max_buffsize) { /* FRITZ: How to tell iucv LL to drop the msg? */ privptr->stats.rx_dropped++; + PRINT_WARN("msglen %d > max_buffsize %d\n", + msglen, conn->max_buffsize); + IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n", + msglen, conn->max_buffsize); return; } conn->rx_buff->data = conn->rx_buff->tail = conn->rx_buff->head; conn->rx_buff->len = 0; rc = iucv_receive(conn->pathid, eib->ipmsgid, eib->iptrgcls, conn->rx_buff->data, msglen, NULL, NULL, NULL); - if (rc != 0 || msglen < 5) { + if (rc || msglen < 5) { privptr->stats.rx_errors++; + PRINT_WARN("iucv_receive returned %08x\n", rc); + IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc); return; } netiucv_unpack_skb(conn, conn->rx_buff); @@ -592,7 +651,7 @@ conn_action_txdone(fsm_instance *fi, int event, void *arg) unsigned long saveflags; ll_header header; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); if (conn && conn->netdev && conn->netdev->priv) privptr = (struct netiucv_priv *)conn->netdev->priv; @@ -642,13 +701,13 @@ conn_action_txdone(fsm_instance *fi, int event, void *arg) conn->prof.tx_pending++; if (conn->prof.tx_pending > conn->prof.tx_max_pending) conn->prof.tx_max_pending = conn->prof.tx_pending; - if (rc != 0) { + if (rc) { conn->prof.tx_pending--; fsm_newstate(fi, CONN_STATE_IDLE); if (privptr) privptr->stats.tx_errors += txpackets; - printk(KERN_DEBUG "iucv_send returned %08x\n", - rc); + PRINT_WARN("iucv_send returned %08x\n", rc); + IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc); } else { if (privptr) { privptr->stats.tx_packets += txpackets; @@ -673,14 +732,14 @@ conn_action_connaccept(fsm_instance *fi, int event, void *arg) __u16 msglimit; __u8 udata[16]; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); rc = iucv_accept(eib->ippathid, NETIUCV_QUEUELEN_DEFAULT, udata, 0, conn->handle, conn, NULL, &msglimit); - if (rc != 0) { - printk(KERN_WARNING - "%s: IUCV accept failed with error %d\n", + if (rc) { + PRINT_WARN("%s: IUCV accept failed with error %d\n", netdev->name, rc); + IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc); return; } fsm_newstate(fi, CONN_STATE_IDLE); @@ -698,13 +757,16 @@ conn_action_connreject(fsm_instance *fi, int event, void *arg) iucv_ConnectionPending *eib = (iucv_ConnectionPending *)ev->data; __u8 udata[16]; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); iucv_sever(eib->ippathid, udata); if (eib->ippathid != conn->pathid) { - printk(KERN_INFO - "%s: IR pathid %d does not match original pathid %d\n", + PRINT_INFO("%s: IR Connection Pending; " + "pathid %d does not match original pathid %d\n", netdev->name, eib->ippathid, conn->pathid); + IUCV_DBF_TEXT_(data, 2, + "connreject: IR pathid %d, conn. pathid %d\n", + eib->ippathid, conn->pathid); iucv_sever(conn->pathid, udata); } } @@ -718,14 +780,17 @@ conn_action_connack(fsm_instance *fi, int event, void *arg) struct net_device *netdev = conn->netdev; struct netiucv_priv *privptr = (struct netiucv_priv *)netdev->priv; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); fsm_deltimer(&conn->timer); fsm_newstate(fi, CONN_STATE_IDLE); if (eib->ippathid != conn->pathid) { - printk(KERN_INFO - "%s: IR pathid %d does not match original pathid %d\n", + PRINT_INFO("%s: IR Connection Complete; " + "pathid %d does not match original pathid %d\n", netdev->name, eib->ippathid, conn->pathid); + IUCV_DBF_TEXT_(data, 2, + "connack: IR pathid %d, conn. pathid %d\n", + eib->ippathid, conn->pathid); conn->pathid = eib->ippathid; } netdev->tx_queue_len = eib->ipmsglim; @@ -738,7 +803,7 @@ conn_action_conntimsev(fsm_instance *fi, int event, void *arg) struct iucv_connection *conn = (struct iucv_connection *)arg; __u8 udata[16]; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); fsm_deltimer(&conn->timer); iucv_sever(conn->pathid, udata); @@ -754,12 +819,13 @@ conn_action_connsever(fsm_instance *fi, int event, void *arg) struct netiucv_priv *privptr = (struct netiucv_priv *)netdev->priv; __u8 udata[16]; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); fsm_deltimer(&conn->timer); iucv_sever(conn->pathid, udata); - printk(KERN_INFO "%s: Remote dropped connection\n", - netdev->name); + PRINT_INFO("%s: Remote dropped connection\n", netdev->name); + IUCV_DBF_TEXT(data, 2, + "conn_action_connsever: Remote dropped connection\n"); fsm_newstate(fi, CONN_STATE_STARTWAIT); fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev); } @@ -771,30 +837,29 @@ conn_action_start(fsm_instance *fi, int event, void *arg) struct iucv_connection *conn = ev->conn; __u16 msglimit; int rc; - __u8 iucvMagic[16] = { - 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, - 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 - }; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); - memcpy(iucvMagic, conn->netdev->name, IFNAMSIZ); - if (conn->handle == 0) { + if (!conn->handle) { + IUCV_DBF_TEXT(trace, 5, "calling iucv_register_program\n"); conn->handle = - iucv_register_program(iucvMagic, conn->userid, mask, + iucv_register_program(iucvMagic, conn->userid, + netiucv_mask, &netiucv_ops, conn); fsm_newstate(fi, CONN_STATE_STARTWAIT); - if (conn->handle <= 0) { + if (!conn->handle) { fsm_newstate(fi, CONN_STATE_REGERR); - conn->handle = 0; + conn->handle = NULL; + IUCV_DBF_TEXT(setup, 2, + "NULL from iucv_register_program\n"); return; } - pr_debug("%s('%s'): registered successfully\n", + PRINT_DEBUG("%s('%s'): registered successfully\n", conn->netdev->name, conn->userid); } - pr_debug("%s('%s'): connecting ...\n", + PRINT_DEBUG("%s('%s'): connecting ...\n", conn->netdev->name, conn->userid); /* We must set the state before calling iucv_connect because the callback @@ -803,8 +868,8 @@ conn_action_start(fsm_instance *fi, int event, void *arg) fsm_newstate(fi, CONN_STATE_SETUPWAIT); rc = iucv_connect(&(conn->pathid), NETIUCV_QUEUELEN_DEFAULT, iucvMagic, - conn->userid, iucv_host, 0, NULL, &msglimit, conn->handle, - conn); + conn->userid, iucv_host, 0, NULL, &msglimit, + conn->handle, conn); switch (rc) { case 0: conn->netdev->tx_queue_len = msglimit; @@ -812,47 +877,45 @@ conn_action_start(fsm_instance *fi, int event, void *arg) CONN_EVENT_TIMER, conn); return; case 11: - printk(KERN_NOTICE - "%s: User %s is currently not available.\n", + PRINT_INFO("%s: User %s is currently not available.\n", conn->netdev->name, netiucv_printname(conn->userid)); fsm_newstate(fi, CONN_STATE_STARTWAIT); return; case 12: - printk(KERN_NOTICE - "%s: User %s is currently not ready.\n", + PRINT_INFO("%s: User %s is currently not ready.\n", conn->netdev->name, netiucv_printname(conn->userid)); fsm_newstate(fi, CONN_STATE_STARTWAIT); return; case 13: - printk(KERN_WARNING - "%s: Too many IUCV connections.\n", + PRINT_WARN("%s: Too many IUCV connections.\n", conn->netdev->name); fsm_newstate(fi, CONN_STATE_CONNERR); break; case 14: - printk(KERN_WARNING + PRINT_WARN( "%s: User %s has too many IUCV connections.\n", conn->netdev->name, netiucv_printname(conn->userid)); fsm_newstate(fi, CONN_STATE_CONNERR); break; case 15: - printk(KERN_WARNING + PRINT_WARN( "%s: No IUCV authorization in CP directory.\n", conn->netdev->name); fsm_newstate(fi, CONN_STATE_CONNERR); break; default: - printk(KERN_WARNING - "%s: iucv_connect returned error %d\n", + PRINT_WARN("%s: iucv_connect returned error %d\n", conn->netdev->name, rc); fsm_newstate(fi, CONN_STATE_CONNERR); break; } + IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc); + IUCV_DBF_TEXT(trace, 5, "calling iucv_unregister_program\n"); iucv_unregister_program(conn->handle); - conn->handle = 0; + conn->handle = NULL; } static void @@ -874,14 +937,15 @@ conn_action_stop(fsm_instance *fi, int event, void *arg) struct net_device *netdev = conn->netdev; struct netiucv_priv *privptr = (struct netiucv_priv *)netdev->priv; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); fsm_deltimer(&conn->timer); fsm_newstate(fi, CONN_STATE_STOPPED); netiucv_purge_skb_queue(&conn->collect_queue); if (conn->handle) + IUCV_DBF_TEXT(trace, 5, "calling iucv_unregister_program\n"); iucv_unregister_program(conn->handle); - conn->handle = 0; + conn->handle = NULL; netiucv_purge_skb_queue(&conn->commit_queue); fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev); } @@ -893,9 +957,9 @@ conn_action_inval(fsm_instance *fi, int event, void *arg) struct iucv_connection *conn = ev->conn; struct net_device *netdev = conn->netdev; - printk(KERN_WARNING - "%s: Cannot connect without username\n", + PRINT_WARN("%s: Cannot connect without username\n", netdev->name); + IUCV_DBF_TEXT(data, 2, "conn_action_inval called\n"); } static const fsm_node conn_fsm[] = { @@ -951,7 +1015,7 @@ dev_action_start(fsm_instance *fi, int event, void *arg) struct netiucv_priv *privptr = dev->priv; struct iucv_event ev; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); ev.conn = privptr->conn; fsm_newstate(fi, DEV_STATE_STARTWAIT); @@ -972,7 +1036,7 @@ dev_action_stop(fsm_instance *fi, int event, void *arg) struct netiucv_priv *privptr = dev->priv; struct iucv_event ev; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); ev.conn = privptr->conn; @@ -992,20 +1056,24 @@ static void dev_action_connup(fsm_instance *fi, int event, void *arg) { struct net_device *dev = (struct net_device *)arg; + struct netiucv_priv *privptr = dev->priv; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); switch (fsm_getstate(fi)) { case DEV_STATE_STARTWAIT: fsm_newstate(fi, DEV_STATE_RUNNING); - printk(KERN_INFO - "%s: connected with remote side\n", - dev->name); + PRINT_INFO("%s: connected with remote side %s\n", + dev->name, privptr->conn->userid); + IUCV_DBF_TEXT(setup, 3, + "connection is up and running\n"); break; case DEV_STATE_STOPWAIT: - printk(KERN_INFO - "%s: got connection UP event during shutdown!!\n", + PRINT_INFO( + "%s: got connection UP event during shutdown!\n", dev->name); + IUCV_DBF_TEXT(data, 2, + "dev_action_connup: in DEV_STATE_STOPWAIT\n"); break; } } @@ -1021,7 +1089,7 @@ dev_action_connup(fsm_instance *fi, int event, void *arg) static void dev_action_conndown(fsm_instance *fi, int event, void *arg) { - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); switch (fsm_getstate(fi)) { case DEV_STATE_RUNNING: @@ -1029,6 +1097,7 @@ dev_action_conndown(fsm_instance *fi, int event, void *arg) break; case DEV_STATE_STOPWAIT: fsm_newstate(fi, DEV_STATE_STOPPED); + IUCV_DBF_TEXT(setup, 3, "connection is down\n"); break; } } @@ -1071,9 +1140,11 @@ netiucv_transmit_skb(struct iucv_connection *conn, struct sk_buff *skb) { spin_lock_irqsave(&conn->collect_lock, saveflags); if (conn->collect_len + l > - (conn->max_buffsize - NETIUCV_HDRLEN)) + (conn->max_buffsize - NETIUCV_HDRLEN)) { rc = -EBUSY; - else { + IUCV_DBF_TEXT(data, 2, + "EBUSY from netiucv_transmit_skb\n"); + } else { atomic_inc(&skb->users); skb_queue_tail(&conn->collect_queue, skb); conn->collect_len += l; @@ -1092,9 +1163,9 @@ netiucv_transmit_skb(struct iucv_connection *conn, struct sk_buff *skb) { nskb = alloc_skb(skb->len + NETIUCV_HDRLEN + NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA); if (!nskb) { - printk(KERN_WARNING - "%s: Could not allocate tx_skb\n", + PRINT_WARN("%s: Could not allocate tx_skb\n", conn->netdev->name); + IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n"); rc = -ENOMEM; return rc; } else { @@ -1123,7 +1194,7 @@ netiucv_transmit_skb(struct iucv_connection *conn, struct sk_buff *skb) { conn->prof.tx_pending++; if (conn->prof.tx_pending > conn->prof.tx_max_pending) conn->prof.tx_max_pending = conn->prof.tx_pending; - if (rc != 0) { + if (rc) { struct netiucv_priv *privptr; fsm_newstate(conn->fsm, CONN_STATE_IDLE); conn->prof.tx_pending--; @@ -1140,8 +1211,8 @@ netiucv_transmit_skb(struct iucv_connection *conn, struct sk_buff *skb) { skb_pull(skb, NETIUCV_HDRLEN); skb_trim(skb, skb->len - NETIUCV_HDRLEN); } - printk(KERN_DEBUG "iucv_send returned %08x\n", - rc); + PRINT_WARN("iucv_send returned %08x\n", rc); + IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc); } else { if (copied) dev_kfree_skb(skb); @@ -1167,7 +1238,7 @@ netiucv_transmit_skb(struct iucv_connection *conn, struct sk_buff *skb) { */ static int netiucv_open(struct net_device *dev) { - fsm_event(((struct netiucv_priv *)dev->priv)->fsm, DEV_EVENT_START, dev); + fsm_event(((struct netiucv_priv *)dev->priv)->fsm, DEV_EVENT_START,dev); return 0; } @@ -1201,18 +1272,21 @@ static int netiucv_tx(struct sk_buff *skb, struct net_device *dev) int rc = 0; struct netiucv_priv *privptr = dev->priv; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); /** * Some sanity checks ... */ if (skb == NULL) { - printk(KERN_WARNING "%s: NULL sk_buff passed\n", dev->name); + PRINT_WARN("%s: NULL sk_buff passed\n", dev->name); + IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n"); privptr->stats.tx_dropped++; return 0; } - if (skb_headroom(skb) < (NETIUCV_HDRLEN)) { - printk(KERN_WARNING - "%s: Got sk_buff with head room < %ld bytes\n", + if (skb_headroom(skb) < NETIUCV_HDRLEN) { + PRINT_WARN("%s: Got sk_buff with head room < %ld bytes\n", dev->name, NETIUCV_HDRLEN); + IUCV_DBF_TEXT(data, 2, + "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n"); dev_kfree_skb(skb); privptr->stats.tx_dropped++; return 0; @@ -1231,11 +1305,12 @@ static int netiucv_tx(struct sk_buff *skb, struct net_device *dev) return 0; } - if (netiucv_test_and_set_busy(dev)) + if (netiucv_test_and_set_busy(dev)) { + IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n"); return -EBUSY; - + } dev->trans_start = jiffies; - if (netiucv_transmit_skb(privptr->conn, skb) != 0) + if (netiucv_transmit_skb(privptr->conn, skb)) rc = 1; netiucv_clear_busy(dev); return rc; @@ -1251,6 +1326,7 @@ static int netiucv_tx(struct sk_buff *skb, struct net_device *dev) static struct net_device_stats * netiucv_stats (struct net_device * dev) { + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return &((struct netiucv_priv *)dev->priv)->stats; } @@ -1266,8 +1342,11 @@ netiucv_stats (struct net_device * dev) static int netiucv_change_mtu (struct net_device * dev, int new_mtu) { - if ((new_mtu < 576) || (new_mtu > NETIUCV_MTU_MAX)) + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); + if ((new_mtu < 576) || (new_mtu > NETIUCV_MTU_MAX)) { + IUCV_DBF_TEXT(setup, 2, "given MTU out of valid range\n"); return -EINVAL; + } dev->mtu = new_mtu; return 0; } @@ -1281,6 +1360,7 @@ user_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%s\n", netiucv_printname(priv->conn->userid)); } @@ -1294,9 +1374,11 @@ user_write (struct device *dev, const char *buf, size_t count) char username[10]; int i; + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (count>9) { - printk(KERN_WARNING - "netiucv: username too long (%d)!\n", (int)count); + PRINT_WARN("netiucv: username too long (%d)!\n", (int)count); + IUCV_DBF_TEXT_(setup, 2, + "%d is length of username\n", (int)count); return -EINVAL; } @@ -1308,8 +1390,11 @@ user_write (struct device *dev, const char *buf, size_t count) /* trailing lf, grr */ break; } else { - printk(KERN_WARNING - "netiucv: Invalid character in username!\n"); + PRINT_WARN("netiucv: Invalid char %c in username!\n", + *p); + IUCV_DBF_TEXT_(setup, 2, + "username: invalid character %c\n", + *p); return -EINVAL; } } @@ -1317,14 +1402,14 @@ user_write (struct device *dev, const char *buf, size_t count) username[i++] = ' '; username[9] = '\0'; - if (memcmp(username, priv->conn->userid, 8) != 0) { + if (memcmp(username, priv->conn->userid, 8)) { /* username changed */ if (ndev->flags & (IFF_UP | IFF_RUNNING)) { - printk(KERN_WARNING + PRINT_WARN( "netiucv: device %s active, connected to %s\n", dev->bus_id, priv->conn->userid); - printk(KERN_WARNING - "netiucv: user cannot be updated\n"); + PRINT_WARN("netiucv: user cannot be updated\n"); + IUCV_DBF_TEXT(setup, 2, "user_write: device active\n"); return -EBUSY; } } @@ -1341,6 +1426,7 @@ buffer_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%d\n", priv->conn->max_buffsize); } @@ -1352,33 +1438,46 @@ buffer_write (struct device *dev, const char *buf, size_t count) char *e; int bs1; + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (count >= 39) return -EINVAL; bs1 = simple_strtoul(buf, &e, 0); if (e && (!isspace(*e))) { - printk(KERN_WARNING - "netiucv: Invalid character in buffer!\n"); + PRINT_WARN("netiucv: Invalid character in buffer!\n"); + IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %c\n", *e); return -EINVAL; } if (bs1 > NETIUCV_BUFSIZE_MAX) { - printk(KERN_WARNING - "netiucv: Given buffer size %d too large.\n", + PRINT_WARN("netiucv: Given buffer size %d too large.\n", + bs1); + IUCV_DBF_TEXT_(setup, 2, + "buffer_write: buffer size %d too large\n", bs1); - return -EINVAL; } if ((ndev->flags & IFF_RUNNING) && - (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) + (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) { + PRINT_WARN("netiucv: Given buffer size %d too small.\n", + bs1); + IUCV_DBF_TEXT_(setup, 2, + "buffer_write: buffer size %d too small\n", + bs1); return -EINVAL; - if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) + } + if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) { + PRINT_WARN("netiucv: Given buffer size %d too small.\n", + bs1); + IUCV_DBF_TEXT_(setup, 2, + "buffer_write: buffer size %d too small\n", + bs1); return -EINVAL; + } priv->conn->max_buffsize = bs1; if (!(ndev->flags & IFF_RUNNING)) ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN; - priv->conn->flags |= CONN_FLAGS_BUFSIZE_CHANGED; return count; @@ -1390,7 +1489,8 @@ static ssize_t dev_fsm_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm)); } @@ -1400,7 +1500,8 @@ static ssize_t conn_fsm_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm)); } @@ -1410,7 +1511,8 @@ static ssize_t maxmulti_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti); } @@ -1418,7 +1520,8 @@ static ssize_t maxmulti_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.maxmulti = 0; return count; } @@ -1429,7 +1532,8 @@ static ssize_t maxcq_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue); } @@ -1438,6 +1542,7 @@ maxcq_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.maxcqueue = 0; return count; } @@ -1448,7 +1553,8 @@ static ssize_t sdoio_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.doios_single); } @@ -1457,6 +1563,7 @@ sdoio_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.doios_single = 0; return count; } @@ -1467,7 +1574,8 @@ static ssize_t mdoio_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi); } @@ -1476,6 +1584,7 @@ mdoio_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); priv->conn->prof.doios_multi = 0; return count; } @@ -1486,7 +1595,8 @@ static ssize_t txlen_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.txlen); } @@ -1495,6 +1605,7 @@ txlen_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.txlen = 0; return count; } @@ -1505,7 +1616,8 @@ static ssize_t txtime_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; - + + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.tx_time); } @@ -1514,6 +1626,7 @@ txtime_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.tx_time = 0; return count; } @@ -1525,6 +1638,7 @@ txpend_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending); } @@ -1533,6 +1647,7 @@ txpend_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.tx_pending = 0; return count; } @@ -1544,6 +1659,7 @@ txmpnd_show (struct device *dev, char *buf) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 5, __FUNCTION__); return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending); } @@ -1552,6 +1668,7 @@ txmpnd_write (struct device *dev, const char *buf, size_t count) { struct netiucv_priv *priv = dev->driver_data; + IUCV_DBF_TEXT(trace, 4, __FUNCTION__); priv->conn->prof.tx_max_pending = 0; return count; } @@ -1592,8 +1709,7 @@ netiucv_add_files(struct device *dev) { int ret; - pr_debug("%s() called\n", __FUNCTION__); - + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); ret = sysfs_create_group(&dev->kobj, &netiucv_attr_group); if (ret) return ret; @@ -1606,24 +1722,24 @@ netiucv_add_files(struct device *dev) static inline void netiucv_remove_files(struct device *dev) { - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); sysfs_remove_group(&dev->kobj, &netiucv_stat_attr_group); sysfs_remove_group(&dev->kobj, &netiucv_attr_group); } static int -netiucv_register_device(struct net_device *ndev, int ifno) +netiucv_register_device(struct net_device *ndev) { struct netiucv_priv *priv = ndev->priv; struct device *dev = kmalloc(sizeof(struct device), GFP_KERNEL); int ret; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (dev) { memset(dev, 0, sizeof(struct device)); - snprintf(dev->bus_id, BUS_ID_SIZE, "netiucv%x", ifno); + snprintf(dev->bus_id, BUS_ID_SIZE, "net%s", ndev->name); dev->bus = &iucv_bus; dev->parent = iucv_root; /* @@ -1634,6 +1750,7 @@ netiucv_register_device(struct net_device *ndev, int ifno) * but legitime ...). */ dev->release = (void (*)(struct device *))kfree; + dev->driver = &netiucv_driver; } else return -ENOMEM; @@ -1644,8 +1761,8 @@ netiucv_register_device(struct net_device *ndev, int ifno) ret = netiucv_add_files(dev); if (ret) goto out_unreg; - dev->driver_data = priv; priv->dev = dev; + dev->driver_data = priv; return 0; out_unreg: @@ -1656,19 +1773,19 @@ out_unreg: static void netiucv_unregister_device(struct device *dev) { - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); netiucv_remove_files(dev); device_unregister(dev); } /** * Allocate and initialize a new connection structure. - * Add it to the list of connections; + * Add it to the list of netiucv connections; */ static struct iucv_connection * netiucv_new_connection(struct net_device *dev, char *username) { - struct iucv_connection **clist = &connections; + struct iucv_connection **clist = &iucv_connections; struct iucv_connection *conn = (struct iucv_connection *) kmalloc(sizeof(struct iucv_connection), GFP_KERNEL); @@ -1719,23 +1836,22 @@ netiucv_new_connection(struct net_device *dev, char *username) /** * Release a connection structure and remove it from the - * list of connections. + * list of netiucv connections. */ static void netiucv_remove_connection(struct iucv_connection *conn) { - struct iucv_connection **clist = &connections; - - pr_debug("%s() called\n", __FUNCTION__); + struct iucv_connection **clist = &iucv_connections; + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (conn == NULL) return; while (*clist) { if (*clist == conn) { *clist = conn->next; - if (conn->handle != 0) { + if (conn->handle) { iucv_unregister_program(conn->handle); - conn->handle = 0; + conn->handle = NULL; } fsm_deltimer(&conn->timer); kfree_fsm(conn->fsm); @@ -1755,20 +1871,18 @@ netiucv_free_netdevice(struct net_device *dev) { struct netiucv_priv *privptr; - pr_debug("%s() called\n", __FUNCTION__); + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (!dev) return; privptr = (struct netiucv_priv *)dev->priv; if (privptr) { - if (privptr->fsm) - fsm_deltimer(&privptr->timer); if (privptr->conn) netiucv_remove_connection(privptr->conn); if (privptr->fsm) kfree_fsm(privptr->fsm); - privptr->conn = 0; privptr->fsm = 0; + privptr->conn = NULL; privptr->fsm = NULL; /* privptr gets freed by free_netdev() */ } free_netdev(dev); @@ -1801,22 +1915,25 @@ netiucv_setup_netdevice(struct net_device *dev) * Allocate and initialize everything of a net device. */ static struct net_device * -netiucv_init_netdevice(int ifno, char *username) +netiucv_init_netdevice(char *username) { struct netiucv_priv *privptr; struct net_device *dev; - dev = alloc_netdev(sizeof(struct netiucv_priv), "", + dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d", netiucv_setup_netdevice); if (!dev) return NULL; - sprintf(dev->name, "iucv%d", ifno); + if (dev_alloc_name(dev, dev->name) < 0) { + free_netdev(dev); + return NULL; + } - privptr = (struct netiucv_priv *)dev->priv; + privptr = (struct netiucv_priv *)dev->priv; privptr->fsm = init_fsm("netiucvdev", dev_state_names, dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS, dev_fsm, DEV_FSM_LEN, GFP_KERNEL); - if (privptr->fsm == NULL) { + if (!privptr->fsm) { free_netdev(dev); return NULL; } @@ -1824,9 +1941,9 @@ netiucv_init_netdevice(int ifno, char *username) if (!privptr->conn) { kfree_fsm(privptr->fsm); free_netdev(dev); + IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n"); return NULL; } - fsm_settimer(privptr->fsm, &privptr->timer); fsm_newstate(privptr->fsm, DEV_STATE_STOPPED); return dev; @@ -1840,9 +1957,10 @@ conn_write(struct device_driver *drv, const char *buf, size_t count) int i, ret; struct net_device *dev; + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); if (count>9) { - printk(KERN_WARNING - "netiucv: username too long (%d)!\n", (int)count); + PRINT_WARN("netiucv: username too long (%d)!\n", (int)count); + IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n"); return -EINVAL; } @@ -1853,53 +1971,112 @@ conn_write(struct device_driver *drv, const char *buf, size_t count) /* trailing lf, grr */ break; } else { - printk(KERN_WARNING - "netiucv: Invalid character in username!\n"); + PRINT_WARN("netiucv: Invalid character in username!\n"); + IUCV_DBF_TEXT_(setup, 2, + "conn_write: invalid character %c\n", *p); return -EINVAL; } } while (i<9) username[i++] = ' '; username[9] = '\0'; - dev = netiucv_init_netdevice(ifno, username); + dev = netiucv_init_netdevice(username); if (!dev) { - printk(KERN_WARNING + PRINT_WARN( "netiucv: Could not allocate network device structure " "for user '%s'\n", netiucv_printname(username)); + IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n"); return -ENODEV; } - - if ((ret = netiucv_register_device(dev, ifno))) + + if ((ret = netiucv_register_device(dev))) { + IUCV_DBF_TEXT_(setup, 2, + "ret %d from netiucv_register_device\n", ret); goto out_free_ndev; + } + /* sysfs magic */ - SET_NETDEV_DEV(dev, (struct device*)((struct netiucv_priv*)dev->priv)->dev); + SET_NETDEV_DEV(dev, + (struct device*)((struct netiucv_priv*)dev->priv)->dev); + if ((ret = register_netdev(dev))) { - netiucv_unregister_device((struct device*)((struct netiucv_priv*)dev->priv)->dev); + netiucv_unregister_device((struct device*) + ((struct netiucv_priv*)dev->priv)->dev); goto out_free_ndev; } - printk(KERN_INFO "%s: '%s'\n", dev->name, netiucv_printname(username)); - ifno++; + + PRINT_INFO("%s: '%s'\n", dev->name, netiucv_printname(username)); return count; out_free_ndev: - printk(KERN_WARNING - "netiucv: Could not register '%s'\n", dev->name); + PRINT_WARN("netiucv: Could not register '%s'\n", dev->name); + IUCV_DBF_TEXT(setup, 2, "conn_write: could not register\n"); netiucv_free_netdevice(dev); return ret; } DRIVER_ATTR(connection, 0200, NULL, conn_write); -static struct device_driver netiucv_driver = { - .name = "netiucv", - .bus = &iucv_bus, -}; +static ssize_t +remove_write (struct device_driver *drv, const char *buf, size_t count) +{ + struct iucv_connection **clist = &iucv_connections; + struct net_device *ndev; + struct netiucv_priv *priv; + struct device *dev; + char name[IFNAMSIZ]; + char *p; + int i; + + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); + + if (count >= IFNAMSIZ) + count = IFNAMSIZ-1; + + for (i=0, p=(char *)buf; inetdev; + priv = (struct netiucv_priv*)ndev->priv; + dev = priv->dev; + + if (strncmp(name, ndev->name, count)) { + clist = &((*clist)->next); + continue; + } + if (ndev->flags & (IFF_UP | IFF_RUNNING)) { + PRINT_WARN( + "netiucv: net device %s active with peer %s\n", + ndev->name, priv->conn->userid); + PRINT_WARN("netiucv: %s cannot be removed\n", + ndev->name); + IUCV_DBF_TEXT(data, 2, "remove_write: still active\n"); + return -EBUSY; + } + unregister_netdev(ndev); + netiucv_unregister_device(dev); + return count; + } + PRINT_WARN("netiucv: net device %s unknown\n", name); + IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n"); + return -EINVAL; +} + +DRIVER_ATTR(remove, 0200, NULL, remove_write); static void netiucv_banner(void) { - char vbuf[] = "$Revision: 1.51 $"; + char vbuf[] = "$Revision: 1.63 $"; char *version = vbuf; if ((version = strchr(version, ':'))) { @@ -1908,14 +2085,15 @@ netiucv_banner(void) *p = '\0'; } else version = " ??? "; - printk(KERN_INFO "NETIUCV driver Version%s initialized\n", version); + PRINT_INFO("NETIUCV driver Version%s initialized\n", version); } static void __exit netiucv_exit(void) { - while (connections) { - struct net_device *ndev = connections->netdev; + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); + while (iucv_connections) { + struct net_device *ndev = iucv_connections->netdev; struct netiucv_priv *priv = (struct netiucv_priv*)ndev->priv; struct device *dev = priv->dev; @@ -1924,9 +2102,11 @@ netiucv_exit(void) } driver_remove_file(&netiucv_driver, &driver_attr_connection); + driver_remove_file(&netiucv_driver, &driver_attr_remove); driver_unregister(&netiucv_driver); + iucv_unregister_dbf_views(); - printk(KERN_INFO "NETIUCV driver unloaded\n"); + PRINT_INFO("NETIUCV driver unloaded\n"); return; } @@ -1935,20 +2115,31 @@ netiucv_init(void) { int ret; + ret = iucv_register_dbf_views(); + if (ret) { + PRINT_WARN("netiucv_init failed, " + "iucv_register_dbf_views rc = %d\n", ret); + return ret; + } + IUCV_DBF_TEXT(trace, 3, __FUNCTION__); ret = driver_register(&netiucv_driver); - if (ret != 0) { - printk(KERN_ERR "NETIUCV: failed to register driver.\n"); + if (ret) { + PRINT_ERR("NETIUCV: failed to register driver.\n"); + IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", ret); + iucv_unregister_dbf_views(); return ret; } /* Add entry for specifying connections. */ ret = driver_create_file(&netiucv_driver, &driver_attr_connection); - - if (ret == 0) + if (!ret) { + ret = driver_create_file(&netiucv_driver, &driver_attr_remove); netiucv_banner(); - else { - printk(KERN_ERR "NETIUCV: failed to add driver attribute.\n"); + } else { + PRINT_ERR("NETIUCV: failed to add driver attribute.\n"); + IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_create_file\n", ret); driver_unregister(&netiucv_driver); + iucv_unregister_dbf_views(); } return ret; }