Release 4.11 drivers/s390/net/netiucv.c

/*
 * IUCV network driver
 *
 * Copyright IBM Corp. 2001, 2009
 *
 * Author(s):
 *      Original netiucv driver:
 *              Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
 *      Sysfs integration and all bugs therein:
 *              Cornelia Huck (cornelia.huck@de.ibm.com)
 *      PM functions:
 *              Ursula Braun (ursula.braun@de.ibm.com)
 *
 * Documentation used:
 *  the source of the original IUCV driver by:
 *    Stefan Hegewald <hegewald@de.ibm.com>
 *    Hartmut Penner <hpenner@de.ibm.com>
 *    Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *    Martin Schwidefsky (schwidefsky@de.ibm.com)
 *    Alan Altmark (Alan_Altmark@us.ibm.com)  Sept. 2000
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */


#define KMSG_COMPONENT "netiucv"

#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt


#undef DEBUG

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/bitops.h>

#include <linux/signal.h>
#include <linux/string.h>
#include <linux/device.h>

#include <linux/ip.h>
#include <linux/if_arp.h>
#include <linux/tcp.h>
#include <linux/skbuff.h>
#include <linux/ctype.h>
#include <net/dst.h>

#include <asm/io.h>
#include <linux/uaccess.h>
#include <asm/ebcdic.h>

#include <net/iucv/iucv.h>
#include "fsm.h"

MODULE_AUTHOR
    ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");

/**
 * Debug Facility stuff
 */

#define IUCV_DBF_SETUP_NAME "iucv_setup"

#define IUCV_DBF_SETUP_LEN 64

#define IUCV_DBF_SETUP_PAGES 2

#define IUCV_DBF_SETUP_NR_AREAS 1

#define IUCV_DBF_SETUP_LEVEL 3


#define IUCV_DBF_DATA_NAME "iucv_data"

#define IUCV_DBF_DATA_LEN 128

#define IUCV_DBF_DATA_PAGES 2

#define IUCV_DBF_DATA_NR_AREAS 1

#define IUCV_DBF_DATA_LEVEL 2


#define IUCV_DBF_TRACE_NAME "iucv_trace"

#define IUCV_DBF_TRACE_LEN 16

#define IUCV_DBF_TRACE_PAGES 4

#define IUCV_DBF_TRACE_NR_AREAS 1

#define IUCV_DBF_TRACE_LEVEL 3


#define IUCV_DBF_TEXT(name,level,text) \
	do { \
                debug_text_event(iucv_dbf_##name,level,text); \
        } while (0)


#define IUCV_DBF_HEX(name,level,addr,len) \
	do { \
                debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
        } while (0)

DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf);


#define IUCV_DBF_TEXT_(name, level, text...) \
	do { \
                if (debug_level_enabled(iucv_dbf_##name, level)) { \
                        char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
                        sprintf(__buf, text); \
                        debug_text_event(iucv_dbf_##name, level, __buf); \
                        put_cpu_var(iucv_dbf_txt_buf); \
                } \
        } while (0)


#define IUCV_DBF_SPRINTF(name,level,text...) \
	do { \
                debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
                debug_sprintf_event(iucv_dbf_trace, level, text ); \
        } while (0)

/**
 * some more debug stuff
 */

#define PRINTK_HEADER " iucv: "       
/* for debugging */

/* dummy device to make sure netiucv_pm functions are called */

static struct device *netiucv_dev;

static int netiucv_pm_prepare(struct device *);
static void netiucv_pm_complete(struct device *);
static int netiucv_pm_freeze(struct device *);
static int netiucv_pm_restore_thaw(struct device *);


static const struct dev_pm_ops netiucv_pm_ops = {
	.prepare = netiucv_pm_prepare,
	.complete = netiucv_pm_complete,
	.freeze = netiucv_pm_freeze,
	.thaw = netiucv_pm_restore_thaw,
	.restore = netiucv_pm_restore_thaw,
};


static struct device_driver netiucv_driver = {
	.owner = THIS_MODULE,
	.name = "netiucv",
	.bus  = &iucv_bus,
	.pm = &netiucv_pm_ops,
};

static int netiucv_callback_connreq(struct iucv_path *, u8 *, u8 *);
static void netiucv_callback_connack(struct iucv_path *, u8 *);
static void netiucv_callback_connrej(struct iucv_path *, u8 *);
static void netiucv_callback_connsusp(struct iucv_path *, u8 *);
static void netiucv_callback_connres(struct iucv_path *, u8 *);
static void netiucv_callback_rx(struct iucv_path *, struct iucv_message *);
static void netiucv_callback_txdone(struct iucv_path *, struct iucv_message *);


static struct iucv_handler netiucv_handler = {
	.path_pending	  = netiucv_callback_connreq,
	.path_complete	  = netiucv_callback_connack,
	.path_severed	  = netiucv_callback_connrej,
	.path_quiesced	  = netiucv_callback_connsusp,
	.path_resumed	  = netiucv_callback_connres,
	.message_pending  = netiucv_callback_rx,
	.message_complete = netiucv_callback_txdone
};

/**
 * Per connection profiling data
 */

struct connection_profile {
	
unsigned long maxmulti;
	
unsigned long maxcqueue;
	
unsigned long doios_single;
	
unsigned long doios_multi;
	
unsigned long txlen;
	
unsigned long tx_time;
	
unsigned long send_stamp;
	
unsigned long tx_pending;
	
unsigned long tx_max_pending;
};

/**
 * Representation of one iucv connection
 */

struct iucv_connection {
	
struct list_head	  list;
	
struct iucv_path	  *path;
	
struct sk_buff            *rx_buff;
	
struct sk_buff            *tx_buff;
	
struct sk_buff_head       collect_queue;
	
struct sk_buff_head	  commit_queue;
	
spinlock_t                collect_lock;
	
int                       collect_len;
	
int                       max_buffsize;
	
fsm_timer                 timer;
	
fsm_instance              *fsm;
	
struct net_device         *netdev;
	
struct connection_profile prof;
	
char                      userid[9];
	
char			  userdata[17];
};

/**
 * Linked list of all connection structs.
 */
static LIST_HEAD(iucv_connection_list);
static DEFINE_RWLOCK(iucv_connection_rwlock);

/**
 * Representation of event-data for the
 * connection state machine.
 */

struct iucv_event {
	
struct iucv_connection *conn;
	
void                   *data;
};

/**
 * Private part of the network device structure
 */

struct netiucv_priv {
	
struct net_device_stats stats;
	
unsigned long           tbusy;
	
fsm_instance            *fsm;
        
struct iucv_connection  *conn;
	
struct device           *dev;
	
int			 pm_state;
};

/**
 * Link level header for a packet.
 */

struct ll_header {
	
u16 next;
};


#define NETIUCV_HDRLEN		 (sizeof(struct ll_header))

#define NETIUCV_BUFSIZE_MAX	 65537

#define NETIUCV_BUFSIZE_DEFAULT  NETIUCV_BUFSIZE_MAX

#define NETIUCV_MTU_MAX          (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)

#define NETIUCV_MTU_DEFAULT      9216

#define NETIUCV_QUEUELEN_DEFAULT 50

#define NETIUCV_TIMEOUT_5SEC     5000

/**
 * Compatibility macros for busy handling
 * of network devices.
 */


static inline void netiucv_clear_busy(struct net_device *dev)
{
	struct netiucv_priv *priv = netdev_priv(dev);
	clear_bit(0, &priv->tbusy);
	netif_wake_queue(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
64.86%
2
40.00%
Martin Schwidefsky
13
35.14%
3
60.00%
Total
37
100.00%
5
100.00%



static inline int netiucv_test_and_set_busy(struct net_device *dev)
{
	struct netiucv_priv *priv = netdev_priv(dev);
	netif_stop_queue(dev);
	return test_and_set_bit(0, &priv->tbusy);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
26
68.42%
2
50.00%
Martin Schwidefsky
12
31.58%
2
50.00%
Total
38
100.00%
4
100.00%


static u8 iucvMagic_ascii[16] = {
	0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
};


static u8 iucvMagic_ebcdic[16] = {
	0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
	0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
};

/**
 * Convert an iucv userId to its printable
 * form (strip whitespace at end).
 *
 * @param An iucv userId
 *
 * @returns The printable string (static data!!)
 */


static char *netiucv_printname(char *name, int len)
{
	static char tmp[17];
	char *p = tmp;
	memcpy(tmp, name, len);
	tmp[len] = '\0';
	while (*p && ((p - tmp) < len) && (!isspace(*p)))
		p++;
	*p = '\0';
	return tmp;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
62
79.49%
2
66.67%
Ursula Braun
16
20.51%
1
33.33%
Total
78
100.00%
3
100.00%



static char *netiucv_printuser(struct iucv_connection *conn)
{
	static char tmp_uid[9];
	static char tmp_udat[17];
	static char buf[100];

	if (memcmp(conn->userdata, iucvMagic_ebcdic, 16)) {
		tmp_uid[8] = '\0';
		tmp_udat[16] = '\0';
		memcpy(tmp_uid, netiucv_printname(conn->userid, 8), 8);
		memcpy(tmp_udat, conn->userdata, 16);
		EBCASC(tmp_udat, 16);
		memcpy(tmp_udat, netiucv_printname(tmp_udat, 16), 16);
		sprintf(buf, "%s.%s", tmp_uid, tmp_udat);
		return buf;
	} else
		return netiucv_printname(conn->userid, 8);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
135
100.00%
2
100.00%
Total
135
100.00%
2
100.00%

/**
 * States of the interface statemachine.
 */

enum dev_states {
	
DEV_STATE_STOPPED,
	
DEV_STATE_STARTWAIT,
	
DEV_STATE_STOPWAIT,
	
DEV_STATE_RUNNING,
	/**
         * MUST be always the last element!!
         */
	
NR_DEV_STATES
};


static const char *dev_state_names[] = {
	"Stopped",
	"StartWait",
	"StopWait",
	"Running",
};

/**
 * Events of the interface statemachine.
 */

enum dev_events {
	
DEV_EVENT_START,
	
DEV_EVENT_STOP,
	
DEV_EVENT_CONUP,
	
DEV_EVENT_CONDOWN,
	/**
         * MUST be always the last element!!
         */
	
NR_DEV_EVENTS
};


static const char *dev_event_names[] = {
	"Start",
	"Stop",
	"Connection up",
	"Connection down",
};

/**
 * Events of the connection statemachine
 */

enum conn_events {
	/**
         * Events, representing callbacks from
         * lowlevel iucv layer)
         */
	
CONN_EVENT_CONN_REQ,
	
CONN_EVENT_CONN_ACK,
	
CONN_EVENT_CONN_REJ,
	
CONN_EVENT_CONN_SUS,
	
CONN_EVENT_CONN_RES,
	
CONN_EVENT_RX,
	
CONN_EVENT_TXDONE,

	/**
         * Events, representing errors return codes from
         * calls to lowlevel iucv layer
         */

	/**
         * Event, representing timer expiry.
         */
	
CONN_EVENT_TIMER,

	/**
         * Events, representing commands from upper levels.
         */
	
CONN_EVENT_START,
	
CONN_EVENT_STOP,

	/**
         * MUST be always the last element!!
         */
	
NR_CONN_EVENTS,
};


static const char *conn_event_names[] = {
	"Remote connection request",
	"Remote connection acknowledge",
	"Remote connection reject",
	"Connection suspended",
	"Connection resumed",
	"Data received",
	"Data sent",

	"Timer",

	"Start",
	"Stop",
};

/**
 * States of the connection statemachine.
 */

enum conn_states {
	/**
         * Connection not assigned to any device,
         * initial state, invalid
         */
	
CONN_STATE_INVALID,

	/**
         * Userid assigned but not operating
         */
	
CONN_STATE_STOPPED,

	/**
         * Connection registered,
         * no connection request sent yet,
         * no connection request received
         */
	
CONN_STATE_STARTWAIT,

	/**
         * Connection registered and connection request sent,
         * no acknowledge and no connection request received yet.
         */
	
CONN_STATE_SETUPWAIT,

	/**
         * Connection up and running idle
         */
	
CONN_STATE_IDLE,

	/**
         * Data sent, awaiting CONN_EVENT_TXDONE
         */
	
CONN_STATE_TX,

	/**
         * Error during registration.
         */
	
CONN_STATE_REGERR,

	/**
         * Error during registration.
         */
	
CONN_STATE_CONNERR,

	/**
         * MUST be always the last element!!
         */
	
NR_CONN_STATES,
};


static const char *conn_state_names[] = {
	"Invalid",
	"Stopped",
	"StartWait",
	"SetupWait",
	"Idle",
	"TX",
	"Terminating",
	"Registration error",
	"Connect error",
};


/**
 * 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)
{
	debug_unregister(iucv_dbf_setup);
	debug_unregister(iucv_dbf_data);
	debug_unregister(iucv_dbf_trace);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%



static int iucv_register_dbf_views(void)
{
	iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
					IUCV_DBF_SETUP_PAGES,
					IUCV_DBF_SETUP_NR_AREAS,
					IUCV_DBF_SETUP_LEN);
	iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
				       IUCV_DBF_DATA_PAGES,
				       IUCV_DBF_DATA_NR_AREAS,
				       IUCV_DBF_DATA_LEN);
	iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
					IUCV_DBF_TRACE_PAGES,
					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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
121
97.58%
1
50.00%
Michael Holzheu
3
2.42%
1
50.00%
Total
124
100.00%
2
100.00%

/*
 * Callback-wrappers, called from lowlevel iucv layer.
 */



static void netiucv_callback_rx(struct iucv_path *path,
				struct iucv_message *msg)
{
	struct iucv_connection *conn = path->private;
	struct iucv_event ev;

	ev.conn = conn;
	ev.data = msg;
	fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
41
77.36%
2
50.00%
Martin Schwidefsky
12
22.64%
2
50.00%
Total
53
100.00%
4
100.00%



static void netiucv_callback_txdone(struct iucv_path *path,
				    struct iucv_message *msg)
{
	struct iucv_connection *conn = path->private;
	struct iucv_event ev;

	ev.conn = conn;
	ev.data = msg;
	fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
41
77.36%
2
50.00%
Martin Schwidefsky
12
22.64%
2
50.00%
Total
53
100.00%
4
100.00%



static void netiucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
{
	struct iucv_connection *conn = path->private;

	fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
64.86%
2
50.00%
Martin Schwidefsky
13
35.14%
2
50.00%
Total
37
100.00%
4
100.00%



static int netiucv_callback_connreq(struct iucv_path *path, u8 *ipvmid,
				    u8 *ipuser)
{
	struct iucv_connection *conn = path->private;
	struct iucv_event ev;
	static char tmp_user[9];
	static char tmp_udat[17];
	int rc;

	rc = -EINVAL;
	memcpy(tmp_user, netiucv_printname(ipvmid, 8), 8);
	memcpy(tmp_udat, ipuser, 16);
	EBCASC(tmp_udat, 16);
	read_lock_bh(&iucv_connection_rwlock);
	list_for_each_entry(conn, &iucv_connection_list, list) {
		if (strncmp(ipvmid, conn->userid, 8) ||
		    strncmp(ipuser, conn->userdata, 16))
			continue;
		/* Found a matching connection for this path. */
		conn->path = path;
		ev.conn = conn;
		ev.data = path;
		fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
		rc = 0;
	}
	IUCV_DBF_TEXT_(setup, 2, "Connection requested for %s.%s\n",
		       tmp_user, netiucv_printname(tmp_udat, 16));
	read_unlock_bh(&iucv_connection_rwlock);
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
75
40.11%
2
28.57%
Ursula Braun
73
39.04%
2
28.57%
Linus Torvalds
38
20.32%
2
28.57%
Stefan Weil
1
0.53%
1
14.29%
Total
187
100.00%
7
100.00%



static void netiucv_callback_connrej(struct iucv_path *path, u8 *ipuser)
{
	struct iucv_connection *conn = path->private;

	fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
68.57%
2
40.00%
Martin Schwidefsky
10
28.57%
2
40.00%
Ursula Braun
1
2.86%
1
20.00%
Total
35
100.00%
5
100.00%



static void netiucv_callback_connsusp(struct iucv_path *path, u8 *ipuser)
{
	struct iucv_connection *conn = path->private;

	fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
68.57%
2
40.00%
Martin Schwidefsky
10
28.57%
2
40.00%
Ursula Braun
1
2.86%
1
20.00%
Total
35
100.00%
5
100.00%



static void netiucv_callback_connres(struct iucv_path *path, u8 *ipuser)
{
	struct iucv_connection *conn = path->private;

	fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
68.57%
2
40.00%
Martin Schwidefsky
10
28.57%
2
40.00%
Ursula Braun
1
2.86%
1
20.00%
Total
35
100.00%
5
100.00%

/**
 * NOP action for statemachines
 */


static void netiucv_action_nop(fsm_instance *fi, int event, void *arg)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
15
93.75%
1
50.00%
Ursula Braun-Krahl
1
6.25%
1
50.00%
Total
16
100.00%
2
100.00%

/*
 * Actions of the connection statemachine
 */

/**
 * netiucv_unpack_skb
 * @conn: The connection where this skb has been received.
 * @pskb: The received skb.
 *
 * Unpack a just received skb and hand it over to upper layers.
 * Helper function for conn_action_rx.
 */


static void netiucv_unpack_skb(struct iucv_connection *conn,
			       struct sk_buff *pskb)
{
	struct net_device     *dev = conn->netdev;
	struct netiucv_priv   *privptr = netdev_priv(dev);
	u16 offset = 0;

	skb_put(pskb, NETIUCV_HDRLEN);
	pskb->dev = dev;
	pskb->ip_summed = CHECKSUM_NONE;
	pskb->protocol = ntohs(ETH_P_IP);

	while (1) {
		struct sk_buff *skb;
		struct ll_header *header = (struct ll_header *) pskb->data;

		if (!header->next)
			break;

		skb_pull(pskb, NETIUCV_HDRLEN);
		header->next -= offset;
		offset += header->next;
		header->next -= NETIUCV_HDRLEN;
		if (skb_tailroom(pskb) < header->next) {
			IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n",
				header->next, skb_tailroom(pskb));
			return;
		}
		skb_put(pskb, header->next);
		skb_reset_mac_header(pskb);
		skb = dev_alloc_skb(pskb->len);
		if (!skb) {
			IUCV_DBF_TEXT(data, 2,
				"Out of memory in netiucv_unpack_skb\n");
			privptr->stats.rx_dropped++;
			return;
		}
		skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
					  pskb->len);
		skb_reset_mac_header(skb);
		skb->dev = pskb->dev;
		skb->protocol = pskb->protocol;
		pskb->ip_summed = CHECKSUM_UNNECESSARY;
		privptr->stats.rx_packets++;
		privptr->stats.rx_bytes += skb->len;
		/*
                 * Since receiving is always initiated from a tasklet (in iucv.c),
                 * we must use netif_rx_ni() instead of netif_rx()
                 */
		netif_rx_ni(skb);
		skb_pull(pskb, header->next);
		skb_put(pskb, NETIUCV_HDRLEN);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
237
82.01%
2
25.00%
Martin Schwidefsky
37
12.80%
3
37.50%
Arnaldo Carvalho de Melo
9
3.11%
2
25.00%
Julia Lawall
6
2.08%
1
12.50%
Total
289
100.00%
8
100.00%



static void conn_action_rx(fsm_instance *fi, int event, void *arg)
{
	struct iucv_event *ev = arg;
	struct iucv_connection *conn = ev->conn;
	struct iucv_message *msg = ev->data;
	struct netiucv_priv *privptr = netdev_priv(conn->netdev);
	int rc;

	IUCV_DBF_TEXT(trace, 4, __func__);

	if (!conn->netdev) {
		iucv_message_reject(conn->path, msg);
		IUCV_DBF_TEXT(data, 2,
			      "Received data for unlinked connection\n");
		return;
	}
	if (msg->length > conn->max_buffsize) {
		iucv_message_reject(conn->path, msg);
		privptr->stats.rx_dropped++;
		IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n",
			       msg->length, conn->max_buffsize);
		return;
	}
	conn->rx_buff->data = conn->rx_buff->head;
	skb_reset_tail_pointer(conn->rx_buff);
	conn->rx_buff->len = 0;
	rc = iucv_message_receive(conn->path, msg, 0, conn->rx_buff->data,
				  msg->length, NULL);
	if (rc || msg->length < 5) {
		privptr->stats.rx_errors++;
		IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc);
		return;
	}
	netiucv_unpack_skb(conn, conn->rx_buff);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
149
64.22%
3
37.50%
Martin Schwidefsky
77
33.19%
3
37.50%
Arnaldo Carvalho de Melo
5
2.16%
1
12.50%
Harvey Harrison
1
0.43%
1
12.50%
Total
232
100.00%
8
100.00%



static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
{
	struct iucv_event *ev = arg;
	struct iucv_connection *conn = ev->conn;
	struct iucv_message *msg = ev->data;
	struct iucv_message txmsg;
	struct netiucv_priv *privptr = NULL;
	u32 single_flag = msg->tag;
	u32 txbytes = 0;
	u32 txpackets = 0;
	u32 stat_maxcq = 0;
	struct sk_buff *skb;
	unsigned long saveflags;
	struct ll_header header;
	int rc;

	IUCV_DBF_TEXT(trace, 4, __func__);

	if (!conn || !conn->netdev) {
		IUCV_DBF_TEXT(data, 2,
			      "Send confirmation for unlinked connection\n");
		return;
	}
	privptr = netdev_priv(conn->netdev);
	conn->prof.tx_pending--;
	if (single_flag) {
		if ((skb = skb_dequeue(&conn->commit_queue))) {
			atomic_dec(&skb->users);
			if (privptr) {
				privptr->stats.tx_packets++;
				privptr->stats.tx_bytes +=
					(skb->len - NETIUCV_HDRLEN
						  - NETIUCV_HDRLEN);
			}
			dev_kfree_skb_any(skb);
		}
	}
	conn->tx_buff->data = conn->tx_buff->head;
	skb_reset_tail_pointer(conn->tx_buff);
	conn->tx_buff->len = 0;
	spin_lock_irqsave(&conn->collect_lock, saveflags);
	while ((skb = skb_dequeue(&conn->collect_queue))) {
		header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
		memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
		       NETIUCV_HDRLEN);
		skb_copy_from_linear_data(skb,
					  skb_put(conn->tx_buff, skb->len),
					  skb->len);
		txbytes += skb->len;
		txpackets++;
		stat_maxcq++;
		atomic_dec(&skb->users);
		dev_kfree_skb_any(skb);
	}
	if (conn->collect_len > conn->prof.maxmulti)
		conn->prof.maxmulti = conn->collect_len;
	conn->collect_len = 0;
	spin_unlock_irqrestore(&conn->collect_lock, saveflags);
	if (conn->tx_buff->len == 0) {
		fsm_newstate(fi, CONN_STATE_IDLE);
		return;
	}

	header.next = 0;
	memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
	conn->prof.send_stamp = jiffies;
	txmsg.class = 0;
	txmsg.tag = 0;
	rc = iucv_message_send(conn->path, &txmsg, 0, 0,
			       conn->tx_buff->data, conn->tx_buff->len);
	conn->prof.doios_multi++;
	conn->prof.txlen += conn->tx_buff->len;
	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) {
		conn->prof.tx_pending--;
		fsm_newstate(fi, CONN_STATE_IDLE);
		if (privptr)
			privptr->stats.tx_errors += txpackets;
		IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
	} else {
		if (privptr) {
			privptr->stats.tx_packets += txpackets;
			privptr->stats.tx_bytes += txbytes;
		}
		if (stat_maxcq > conn->prof.maxcqueue)
			conn->prof.maxcqueue = stat_maxcq;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
428
71.33%
3
21.43%
Andrew Morton
77
12.83%
2
14.29%
Martin Schwidefsky
65
10.83%
3
21.43%
Ursula Braun
20
3.33%
2
14.29%
Arnaldo Carvalho de Melo
8
1.33%
2
14.29%
Harvey Harrison
1
0.17%
1
7.14%
Aya Mahfouz
1
0.17%
1
7.14%
Total
600
100.00%
14
100.00%



static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
{
	struct iucv_event *ev = arg;
	struct iucv_connection *conn = ev->conn;
	struct iucv_path *path = ev->data;
	struct net_device *netdev = conn->netdev;
	struct netiucv_priv *privptr = netdev_priv(netdev);
	int rc;

	IUCV_DBF_TEXT(trace, 3, __func__);

	conn->path = path;
	path->msglim = NETIUCV_QUEUELEN_DEFAULT;
	path->flags = 0;
	rc = iucv_path_accept(path, &netiucv_handler, conn->userdata , conn);
	if (rc) {
		IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
		return;
	}
	fsm_newstate(fi, CONN_STATE_IDLE);
	netdev->tx_queue_len = conn->path->msglim;
	fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
95
62.09%
3
37.50%
Martin Schwidefsky
54
35.29%
3
37.50%
Ursula Braun
3
1.96%
1
12.50%
Harvey Harrison
1
0.65%
1
12.50%
Total
153
100.00%
8
100.00%



static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
{
	struct iucv_event *ev = arg;
	struct iucv_path *path = ev->data;

	IUCV_DBF_TEXT(trace, 3, __func__);
	iucv_path_sever(path, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
33
67.35%
2
28.57%
Martin Schwidefsky
10
20.41%
3
42.86%
Andrew Morton
5
10.20%
1
14.29%
Harvey Harrison
1
2.04%
1
14.29%
Total
49
100.00%
7
100.00%



static void conn_action_connack(fsm_instance *fi, int event, void *arg)
{
	struct iucv_connection *conn = arg;
	struct net_device *netdev = conn->netdev;
	struct netiucv_priv *privptr = netdev_priv(netdev);

	IUCV_DBF_TEXT(trace, 3, __func__);
	fsm_deltimer(&conn->timer);
	fsm_newstate(fi, CONN_STATE_IDLE);
	netdev->tx_queue_len = conn->path->msglim;
	fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
64
72.73%
2
28.57%
Martin Schwidefsky
15
17.05%
3
42.86%
Andrew Morton
8
9.09%
1
14.29%
Harvey Harrison
1
1.14%
1
14.29%
Total
88
100.00%
7
100.00%



static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
{
	struct iucv_connection *conn = arg;

	IUCV_DBF_TEXT(trace, 3, __func__);
	fsm_deltimer(&conn->timer);
	iucv_path_sever(conn->path, conn->userdata);
	fsm_newstate(fi, CONN_STATE_STARTWAIT);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
47
79.66%
1
14.29%
Martin Schwidefsky
6
10.17%
2
28.57%
Ursula Braun
3
5.08%
1
14.29%
Linus Torvalds
2
3.39%
2
28.57%
Harvey Harrison
1
1.69%
1
14.29%
Total
59
100.00%
7
100.00%



static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
{
	struct iucv_connection *conn = arg;
	struct net_device *netdev = conn->netdev;
	struct netiucv_priv *privptr = netdev_priv(netdev);

	IUCV_DBF_TEXT(trace, 3, __func__);

	fsm_deltimer(&conn->timer);
	iucv_path_sever(conn->path, conn->userdata);
	dev_info(privptr->dev, "The peer z/VM guest %s has closed the "
			       "connection\n", netiucv_printuser(conn));
	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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
59
52.21%
3
27.27%
Martin Schwidefsky
22
19.47%
3
27.27%
Andrew Morton
17
15.04%
2
18.18%
Ursula Braun
10
8.85%
1
9.09%
Ursula Braun-Krahl
4
3.54%
1
9.09%
Harvey Harrison
1
0.88%
1
9.09%
Total
113
100.00%
11
100.00%



static void conn_action_start(fsm_instance *fi, int event, void *arg)
{
	struct iucv_connection *conn = arg;
	struct net_device *netdev = conn->netdev;
	struct netiucv_priv *privptr = netdev_priv(netdev);
	int rc;

	IUCV_DBF_TEXT(trace, 3, __func__);

	fsm_newstate(fi, CONN_STATE_STARTWAIT);

	/*
         * We must set the state before calling iucv_connect because the
         * callback handler could be called at any point after the connection
         * request is sent
         */

	fsm_newstate(fi, CONN_STATE_SETUPWAIT);
	conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
	IUCV_DBF_TEXT_(setup, 2, "%s: connecting to %s ...\n",
		netdev->name, netiucv_printuser(conn));

	rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
			       NULL, conn->userdata, conn);
	switch (rc) {
	case 0:
		netdev->tx_queue_len = conn->path->msglim;
		fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
			     CONN_EVENT_TIMER, conn);
		return;
	case 11:
		dev_warn(privptr->dev,
			"The IUCV device failed to connect to z/VM guest %s\n",
			netiucv_printname(conn->userid, 8));
		fsm_newstate(fi, CONN_STATE_STARTWAIT);
		break;
	case 12:
		dev_warn(privptr->dev,
			"The IUCV device failed to connect to the peer on z/VM"
			" guest %s\n", netiucv_printname(conn->userid, 8));
		fsm_newstate(fi, CONN_STATE_STARTWAIT);
		break;
	case 13:
		dev_err(privptr->dev,
			"Connecting the IUCV device would exceed the maximum"
			" number of IUCV connections\n");
		fsm_newstate(fi, CONN_STATE_CONNERR);
		break;
	case 14:
		dev_err(privptr->dev,
			"z/VM guest %s has too many IUCV connections"
			" to connect with the IUCV device\n",
			netiucv_printname(conn->userid, 8));
		fsm_newstate(fi, CONN_STATE_CONNERR);
		break;
	case 15:
		dev_err(privptr->dev,
			"The IUCV device cannot connect to a z/VM guest with no"
			" IUCV authorization\n");
		fsm_newstate(fi, CONN_STATE_CONNERR);
		break;
	default:
		dev_err(privptr->dev,
			"Connecting the IUCV device failed with error %d\n",
			rc);
		fsm_newstate(fi, CONN_STATE_CONNERR);
		break;
	}
	IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
	kfree(conn->path);
	conn->path = NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
179
53.59%
3
23.08%
Ursula Braun-Krahl
53
15.87%
1
7.69%
Martin Schwidefsky
46
13.77%
3
23.08%
Andrew Morton
28
8.38%
4
30.77%
Ursula Braun
27
8.08%
1
7.69%
Harvey Harrison
1
0.30%
1
7.69%
Total
334
100.00%
13
100.00%



static void netiucv_purge_skb_queue(struct sk_buff_head *q)
{
	struct sk_buff *skb;

	while ((skb = skb_dequeue(q))) {
		atomic_dec(&skb->users);
		dev_kfree_skb_any(skb);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
42
100.00%
2
100.00%
Total
42
100.00%
2
100.00%



static void conn_action_stop(fsm_instance *fi, int event, void *arg)
{
	struct iucv_event *ev = arg;
	struct iucv_connection *conn = ev->conn;
	struct net_device *netdev = conn->netdev;
	struct netiucv_priv *privptr = netdev_priv(netdev);

	IUCV_DBF_TEXT(trace, 3, __func__);

	fsm_deltimer(&conn->timer);
	fsm_newstate(fi, CONN_STATE_STOPPED);
	netiucv_purge_skb_queue(&conn->collect_queue);
	if (conn->path) {
		IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
		iucv_path_sever(conn->path, conn->userdata);
		kfree(conn->path);
		conn->path = NULL;
	}
	netiucv_purge_skb_queue(&conn->commit_queue);
	fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
84
58.33%
3
27.27%
Martin Schwidefsky
40
27.78%
4
36.36%
Andrew Morton
16
11.11%
2
18.18%
Ursula Braun
3
2.08%
1
9.09%
Harvey Harrison
1
0.69%
1
9.09%
Total
144
100.00%
11
100.00%



static void conn_action_inval(fsm_instance *fi, int event, void *arg)
{
	struct iucv_connection *conn = arg;
	struct net_device *netdev = conn->netdev;

	IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
		netdev->name, conn->userid);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
35
70.00%
2
33.33%
Ursula Braun-Krahl
9
18.00%
1
16.67%
Martin Schwidefsky
6
12.00%
3
50.00%
Total
50
100.00%
6
100.00%


static const fsm_node conn_fsm[] = {
	{ CONN_STATE_INVALID,   CONN_EVENT_START,    conn_action_inval      },
	{ CONN_STATE_STOPPED,   CONN_EVENT_START,    conn_action_start      },

	{ CONN_STATE_STOPPED,   CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_STARTWAIT, CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_SETUPWAIT, CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_IDLE,      CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_TX,        CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_REGERR,    CONN_EVENT_STOP,     conn_action_stop       },
	{ CONN_STATE_CONNERR,   CONN_EVENT_STOP,     conn_action_stop       },

	{ CONN_STATE_STOPPED,   CONN_EVENT_CONN_REQ, conn_action_connreject },
        { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
	{ CONN_STATE_IDLE,      CONN_EVENT_CONN_REQ, conn_action_connreject },
	{ CONN_STATE_TX,        CONN_EVENT_CONN_REQ, conn_action_connreject },

	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack    },
	{ CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER,    conn_action_conntimsev },

	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever  },
	{ CONN_STATE_IDLE,      CONN_EVENT_CONN_REJ, conn_action_connsever  },
	{ CONN_STATE_TX,        CONN_EVENT_CONN_REJ, conn_action_connsever  },

	{ CONN_STATE_IDLE,      CONN_EVENT_RX,       conn_action_rx         },
	{ CONN_STATE_TX,        CONN_EVENT_RX,       conn_action_rx         },

	{ CONN_STATE_TX,        CONN_EVENT_TXDONE,   conn_action_txdone     },
	{ CONN_STATE_IDLE,      CONN_EVENT_TXDONE,   conn_action_txdone     },
};


static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);


/*
 * Actions for interface - statemachine.
 */

/**
 * dev_action_start
 * @fi: An instance of an interface statemachine.
 * @event: The event, just happened.
 * @arg: Generic pointer, casted from struct net_device * upon call.
 *
 * Startup connection by sending CONN_EVENT_START to it.
 */


static void dev_action_start(fsm_instance *fi, int event, void *arg)
{
	struct net_device   *dev = arg;
	struct netiucv_priv *privptr = netdev_priv(dev);

	IUCV_DBF_TEXT(trace, 3, __func__);

	fsm_newstate(fi, DEV_STATE_STARTWAIT);
	fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
52
80.00%
2
33.33%
Martin Schwidefsky
12
18.46%
3
50.00%
Harvey Harrison
1
1.54%
1
16.67%
Total
65
100.00%
6
100.00%

/**
 * Shutdown connection by sending CONN_EVENT_STOP to it.
 *
 * @param fi    An instance of an interface statemachine.
 * @param event The event, just happened.
 * @param arg   Generic pointer, casted from struct net_device * upon call.
 */

static void

dev_action_stop(fsm_instance *fi, int event, void *arg)
{
	struct net_device   *dev = arg;
	struct netiucv_priv *privptr = netdev_priv(dev);
	struct iucv_event   ev;

	IUCV_DBF_TEXT(trace, 3, __func__);

	ev.conn = privptr->conn;

	fsm_newstate(fi, DEV_STATE_STOPWAIT);
	fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
61
80.26%
2
33.33%
Martin Schwidefsky
14
18.42%
3
50.00%
Harvey Harrison
1
1.32%
1
16.67%
Total
76
100.00%
6
100.00%

/**
 * Called from connection statemachine
 * when a connection is up and running.
 *
 * @param fi    An instance of an interface statemachine.
 * @param event The event, just happened.
 * @param arg   Generic pointer, casted from struct net_device * upon call.
 */

static void

dev_action_connup(fsm_instance *fi, int event, void *arg)
{
	struct net_device   *dev = arg;
	struct netiucv_priv *privptr = netdev_priv(dev);

	IUCV_DBF_TEXT(trace, 3, __func__);

	switch (fsm_getstate(fi)) {
		case DEV_STATE_STARTWAIT:
			fsm_newstate(fi, DEV_STATE_RUNNING);
			dev_info(privptr->dev,
				"The IUCV device has been connected"
				" successfully to %s\n",
				netiucv_printuser(privptr->conn));
			IUCV_DBF_TEXT(setup, 3,
				"connection is up and running\n");
			break;
		case DEV_STATE_STOPWAIT:
			IUCV_DBF_TEXT(data, 2,
				"dev_action_connup: in DEV_STATE_STOPWAIT\n");
			break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
55
53.92%
3
30.00%
Martin Schwidefsky
26
25.49%
3
30.00%
Andrew Morton
11
10.78%
1
10.00%
Ursula Braun-Krahl
6
5.88%
1
10.00%
Ursula Braun
3
2.94%
1
10.00%
Harvey Harrison
1
0.98%
1
10.00%
Total
102
100.00%
10
100.00%

/**
 * Called from connection statemachine
 * when a connection has been shutdown.
 *
 * @param fi    An instance of an interface statemachine.
 * @param event The event, just happened.
 * @param arg   Generic pointer, casted from struct net_device * upon call.
 */

static void

dev_action_conndown(fsm_instance *fi, int event, void *arg)
{
	IUCV_DBF_TEXT(trace, 3, __func__);

	switch (fsm_getstate(fi)) {
		case DEV_STATE_RUNNING:
			fsm_newstate(fi, DEV_STATE_STARTWAIT);
			break;
		case DEV_STATE_STOPWAIT:
			fsm_newstate(fi, DEV_STATE_STOPPED);
			IUCV_DBF_TEXT(setup, 3, "connection is down\n");
			break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
52
78.79%
3
60.00%
Martin Schwidefsky
13
19.70%
1
20.00%
Harvey Harrison
1
1.52%
1
20.00%
Total
66
100.00%
5
100.00%


static const fsm_node dev_fsm[] = {
	{ DEV_STATE_STOPPED,    DEV_EVENT_START,   dev_action_start    },

	{ DEV_STATE_STOPWAIT,   DEV_EVENT_START,   dev_action_start    },
	{ DEV_STATE_STOPWAIT,   DEV_EVENT_CONDOWN, dev_action_conndown },

	{ DEV_STATE_STARTWAIT,  DEV_EVENT_STOP,    dev_action_stop     },
	{ DEV_STATE_STARTWAIT,  DEV_EVENT_CONUP,   dev_action_connup   },

	{ DEV_STATE_RUNNING,    DEV_EVENT_STOP,    dev_action_stop     },
	{ DEV_STATE_RUNNING,    DEV_EVENT_CONDOWN, dev_action_conndown },
	{ DEV_STATE_RUNNING,    DEV_EVENT_CONUP,   netiucv_action_nop  },
};


static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);

/**
 * Transmit a packet.
 * This is a helper function for netiucv_tx().
 *
 * @param conn Connection to be used for sending.
 * @param skb Pointer to struct sk_buff of packet to send.
 *            The linklevel header has already been set up
 *            by netiucv_tx().
 *
 * @return 0 on success, -ERRNO on failure. (Never fails.)
 */


static int netiucv_transmit_skb(struct iucv_connection *conn,
				struct sk_buff *skb)
{
	struct iucv_message msg;
	unsigned long saveflags;
	struct ll_header header;
	int rc;

	if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
		int l = skb->len + NETIUCV_HDRLEN;

		spin_lock_irqsave(&conn->collect_lock, saveflags);
		if (conn->collect_len + l >
		    (conn->max_buffsize - NETIUCV_HDRLEN)) {
			rc = -EBUSY;
			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;
			rc = 0;
		}
		spin_unlock_irqrestore(&conn->collect_lock, saveflags);
	} else {
		struct sk_buff *nskb = skb;
		/**
                 * Copy the skb to a new allocated skb in lowmem only if the
                 * data is located above 2G in memory or tailroom is < 2.
                 */
		unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
				    NETIUCV_HDRLEN)) >> 31;
		int copied = 0;
		if (hi || (skb_tailroom(skb) < 2)) {
			nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
					 NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
			if (!nskb) {
				IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
				rc = -ENOMEM;
				return rc;
			} else {
				skb_reserve(nskb, NETIUCV_HDRLEN);
				memcpy(skb_put(nskb, skb->len),
				       skb->data, skb->len);
			}
			copied = 1;
		}
		/**
                 * skb now is below 2G and has enough room. Add headers.
                 */
		header.next = nskb->len + NETIUCV_HDRLEN;
		memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
		header.next = 0;
		memcpy(skb_put(nskb, NETIUCV_HDRLEN), &header,  NETIUCV_HDRLEN);

		fsm_newstate(conn->fsm, CONN_STATE_TX);
		conn->prof.send_stamp = jiffies;

		msg.tag = 1;
		msg.class = 0;
		rc = iucv_message_send(conn->path, &msg, 0, 0,
				       nskb->data, nskb->len);
		conn->prof.doios_single++;
		conn->prof.txlen += skb->len;
		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) {
			struct netiucv_priv *privptr;
			fsm_newstate(conn->fsm, CONN_STATE_IDLE);
			conn->prof.tx_pending--;
			privptr = netdev_priv(conn->netdev);
			if (privptr)
				privptr->stats.tx_errors++;
			if (copied)
				dev_kfree_skb(nskb);
			else {
				/**
                                 * Remove our headers. They get added
                                 * again on retransmit.
                                 */
				skb_pull(skb, NETIUCV_HDRLEN);
				skb_trim(skb, skb->len - NETIUCV_HDRLEN);
			}
			IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
		} else {
			if (copied)
				dev_kfree_skb(skb);
			atomic_inc(&nskb->users);
			skb_queue_tail(&conn->commit_queue, nskb);
		}
	}

	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
379
70.84%
3
30.00%
Andrew Morton
92
17.20%
2
20.00%
Martin Schwidefsky
60
11.21%
3
30.00%
Arnaldo Carvalho de Melo
3
0.56%
1
10.00%
Aya Mahfouz
1
0.19%
1
10.00%
Total
535
100.00%
10
100.00%

/*
 * Interface API for upper network layers
 */

/**
 * Open an interface.
 * Called from generic network layer when ifconfig up is run.
 *
 * @param dev Pointer to interface struct.
 *
 * @return 0 on success, -ERRNO on failure. (Never fails.)
 */


static int netiucv_open(struct net_device *dev)
{
	struct netiucv_priv *priv = netdev_priv(dev);

	fsm_event(priv->fsm, DEV_EVENT_START, dev);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
68.57%
2
50.00%
Martin Schwidefsky
11
31.43%
2
50.00%
Total
35
100.00%
4
100.00%

/**
 * Close an interface.
 * Called from generic network layer when ifconfig down is run.
 *
 * @param dev Pointer to interface struct.
 *
 * @return 0 on success, -ERRNO on failure. (Never fails.)
 */


static int netiucv_close(struct net_device *dev)
{
	struct netiucv_priv *priv = netdev_priv(dev);

	fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
24
68.57%
2
50.00%
Martin Schwidefsky
11
31.43%
2
50.00%
Total
35
100.00%
4
100.00%



static int netiucv_pm_prepare(struct device *dev)
{
	IUCV_DBF_TEXT(trace, 3, __func__);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%



static void netiucv_pm_complete(struct device *dev)
{
	IUCV_DBF_TEXT(trace, 3, __func__);
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%

/**
 * netiucv_pm_freeze() - Freeze PM callback
 * @dev:        netiucv device
 *
 * close open netiucv interfaces
 */


static int netiucv_pm_freeze(struct device *dev)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);
	struct net_device *ndev = NULL;
	int rc = 0;

	IUCV_DBF_TEXT(trace, 3, __func__);
	if (priv && priv->conn)
		ndev = priv->conn->netdev;
	if (!ndev)
		goto out;
	netif_device_detach(ndev);
	priv->pm_state = fsm_getstate(priv->fsm);
	rc = netiucv_close(ndev);
out:
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
91
96.81%
1
50.00%
Martin Schwidefsky
3
3.19%
1
50.00%
Total
94
100.00%
2
100.00%

/**
 * netiucv_pm_restore_thaw() - Thaw and restore PM callback
 * @dev:        netiucv device
 *
 * re-open netiucv interfaces closed during freeze
 */


static int netiucv_pm_restore_thaw(struct device *dev)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);
	struct net_device *ndev = NULL;
	int rc = 0;

	IUCV_DBF_TEXT(trace, 3, __func__);
	if (priv && priv->conn)
		ndev = priv->conn->netdev;
	if (!ndev)
		goto out;
	switch (priv->pm_state) {
	case DEV_STATE_RUNNING:
	case DEV_STATE_STARTWAIT:
		rc = netiucv_open(ndev);
		break;
	default:
		break;
	}
	netif_device_attach(ndev);
out:
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
97
97.00%
1
50.00%
Martin Schwidefsky
3
3.00%
1
50.00%
Total
100
100.00%
2
100.00%

/**
 * Start transmission of a packet.
 * Called from generic network device layer.
 *
 * @param skb Pointer to buffer containing the packet.
 * @param dev Pointer to interface struct.
 *
 * @return 0 if packet consumed, !0 if packet rejected.
 *         Note: If we return !0, then the packet is free'd by
 *               the generic network layer.
 */


static int netiucv_tx(struct sk_buff *skb, struct net_device *dev)
{
	struct netiucv_priv *privptr = netdev_priv(dev);
	int rc;

	IUCV_DBF_TEXT(trace, 4, __func__);
	/**
         * Some sanity checks ...
         */
	if (skb == NULL) {
		IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
		privptr->stats.tx_dropped++;
		return NETDEV_TX_OK;
	}
	if (skb_headroom(skb) < NETIUCV_HDRLEN) {
		IUCV_DBF_TEXT(data, 2,
			"netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
		dev_kfree_skb(skb);
		privptr->stats.tx_dropped++;
		return NETDEV_TX_OK;
	}

	/**
         * If connection is not running, try to restart it
         * and throw away packet.
         */
	if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
		dev_kfree_skb(skb);
		privptr->stats.tx_dropped++;
		privptr->stats.tx_errors++;
		privptr->stats.tx_carrier_errors++;
		return NETDEV_TX_OK;
	}

	if (netiucv_test_and_set_busy(dev)) {
		IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
		return NETDEV_TX_BUSY;
	}
	netif_trans_update(dev);
	rc = netiucv_transmit_skb(privptr->conn, skb);
	netiucv_clear_busy(dev);
	return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
133
68.91%
2
18.18%
Martin Schwidefsky
47
24.35%
3
27.27%
Patrick McHardy
7
3.63%
2
18.18%
Florian Westphal
3
1.55%
1
9.09%
Jeff Garzik
1
0.52%
1
9.09%
Ursula Braun
1
0.52%
1
9.09%
Harvey Harrison
1
0.52%
1
9.09%
Total
193
100.00%
11
100.00%

/**
 * netiucv_stats
 * @dev: Pointer to interface struct.
 *
 * Returns interface statistics of a device.
 *
 * Returns pointer to stats struct of this interface.
 */


static struct net_device_stats *netiucv_stats (struct net_device * dev)
{
	struct netiucv_priv *priv = netdev_priv(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return &priv->stats;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
19
50.00%
3
60.00%
Linus Torvalds
18
47.37%
1
20.00%
Harvey Harrison
1
2.63%
1
20.00%
Total
38
100.00%
5
100.00%

/*
 * attributes in sysfs
 */



static ssize_t user_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%s\n", netiucv_printuser(priv->conn));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
43
79.63%
3
37.50%
Yani Ioannou
5
9.26%
1
12.50%
Greg Kroah-Hartman
3
5.56%
1
12.50%
Linus Torvalds
1
1.85%
1
12.50%
Harvey Harrison
1
1.85%
1
12.50%
Ursula Braun
1
1.85%
1
12.50%
Total
54
100.00%
8
100.00%



static int netiucv_check_user(const char *buf, size_t count, char *username,
			      char *userdata)
{
	const char *p;
	int i;

	p = strchr(buf, '.');
	if ((p && ((count > 26) ||
		   ((p - buf) > 8) ||
		   (buf + count - p > 18))) ||
	    (!p && (count > 9))) {
		IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
		return -EINVAL;
	}

	for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
		if (isalnum(*p) || *p == '$') {
			username[i] = toupper(*p);
			continue;
		}
		if (*p == '\n')
			/* trailing lf, grr */
			break;
		IUCV_DBF_TEXT_(setup, 2,
			       "conn_write: invalid character %02x\n", *p);
		return -EINVAL;
	}
	while (i < 8)
		username[i++] = ' ';
	username[8] = '\0';

	if (*p == '.') {
		p++;
		for (i = 0; i < 16 && *p; i++, p++) {
			if (*p == '\n')
				break;
			userdata[i] = toupper(*p);
		}
		while (i > 0 && i < 16)
			userdata[i++] = ' ';
	} else
		memcpy(userdata, iucvMagic_ascii, 16);
	userdata[16] = '\0';
	ASCEBC(userdata, 16);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
214
71.57%
1
14.29%
Andrew Morton
45
15.05%
1
14.29%
Martin Schwidefsky
24
8.03%
3
42.86%
Linus Torvalds
14
4.68%
1
14.29%
Frank Pavlic
2
0.67%
1
14.29%
Total
299
100.00%
7
100.00%



static ssize_t user_write(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);
	struct net_device *ndev = priv->conn->netdev;
	char	username[9];
	char	userdata[17];
	int	rc;
	struct iucv_connection *cp;

	IUCV_DBF_TEXT(trace, 3, __func__);
	rc = netiucv_check_user(buf, count, username, userdata);
	if (rc)
		return rc;

	if (memcmp(username, priv->conn->userid, 9) &&
	    (ndev->flags & (IFF_UP | IFF_RUNNING))) {
		/* username changed while the interface is active. */
		IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
		return -EPERM;
	}
	read_lock_bh(&iucv_connection_rwlock);
	list_for_each_entry(cp, &iucv_connection_list, list) {
		if (!strncmp(username, cp->userid, 9) &&
		   !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
			read_unlock_bh(&iucv_connection_rwlock);
			IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
				"already exists\n", netiucv_printuser(cp));
			return -EEXIST;
		}
	}
	read_unlock_bh(&iucv_connection_rwlock);
	memcpy(priv->conn->userid, username, 9);
	memcpy(priv->conn->userdata, userdata, 17);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ursula Braun
114
46.15%
1
12.50%
Andrew Morton
44
17.81%
1
12.50%
Martin Schwidefsky
41
16.60%
3
37.50%
Frank Pavlic
37
14.98%
1
12.50%
Ursula Braun-Krahl
6
2.43%
1
12.50%
Linus Torvalds
5
2.02%
1
12.50%
Total
247
100.00%
8
100.00%

static DEVICE_ATTR(user, 0644, user_show, user_write);



static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%d\n", priv->conn->max_buffsize);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
31
58.49%
1
20.00%
Martin Schwidefsky
13
24.53%
1
20.00%
Yani Ioannou
5
9.43%
1
20.00%
Greg Kroah-Hartman
3
5.66%
1
20.00%
Harvey Harrison
1
1.89%
1
20.00%
Total
53
100.00%
5
100.00%



static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);
	struct net_device *ndev = priv->conn->netdev;
	unsigned int bs1;
	int rc;

	IUCV_DBF_TEXT(trace, 3, __func__);
	if (count >= 39)
		return -EINVAL;

	rc = kstrtouint(buf, 0, &bs1);

	if (rc == -EINVAL) {
		IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %s\n",
			buf);
		return -EINVAL;
	}
	if ((rc == -ERANGE) || (bs1 > NETIUCV_BUFSIZE_MAX)) {
		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))) {
		IUCV_DBF_TEXT_(setup, 2,
			"buffer_write: buffer size %d too small\n",
			bs1);
		return -EINVAL;
	}
	if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
		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;

	return count;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
93
38.59%
1
12.50%
Linus Torvalds
58
24.07%
1
12.50%
Martin Schwidefsky
57
23.65%
2
25.00%
Ursula Braun
24
9.96%
1
12.50%
Yani Ioannou
5
2.07%
1
12.50%
Greg Kroah-Hartman
3
1.24%
1
12.50%
Harvey Harrison
1
0.41%
1
12.50%
Total
241
100.00%
8
100.00%

static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);



static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
24
44.44%
3
42.86%
Linus Torvalds
21
38.89%
1
14.29%
Yani Ioannou
5
9.26%
1
14.29%
Greg Kroah-Hartman
3
5.56%
1
14.29%
Harvey Harrison
1
1.85%
1
14.29%
Total
54
100.00%
7
100.00%

static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);



static ssize_t conn_fsm_show (struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
34
60.71%
3
42.86%
Linus Torvalds
13
23.21%
1
14.29%
Yani Ioannou
5
8.93%
1
14.29%
Greg Kroah-Hartman
3
5.36%
1
14.29%
Harvey Harrison
1
1.79%
1
14.29%
Total
56
100.00%
7
100.00%

static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);



static ssize_t maxmulti_show (struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
23
41.82%
1
11.11%
Martin Schwidefsky
21
38.18%
3
33.33%
Yani Ioannou
5
9.09%
1
11.11%
Greg Kroah-Hartman
3
5.45%
1
11.11%
Harvey Harrison
1
1.82%
1
11.11%
Al Viro
1
1.82%
1
11.11%
Patrick Mochel
1
1.82%
1
11.11%
Total
55
100.00%
9
100.00%



static ssize_t maxmulti_write (struct device *dev,
			       struct device_attribute *attr,
			       const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.maxmulti = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
37
66.07%
3
42.86%
Linus Torvalds
10
17.86%
1
14.29%
Yani Ioannou
5
8.93%
1
14.29%
Greg Kroah-Hartman
3
5.36%
1
14.29%
Harvey Harrison
1
1.79%
1
14.29%
Total
56
100.00%
7
100.00%

static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);



static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
28
50.91%
3
33.33%
Linus Torvalds
14
25.45%
1
11.11%
Yani Ioannou
5
9.09%
1
11.11%
Greg Kroah-Hartman
3
5.45%
1
11.11%
Al Viro
3
5.45%
1
11.11%
Patrick Mochel
1
1.82%
1
11.11%
Harvey Harrison
1
1.82%
1
11.11%
Total
55
100.00%
9
100.00%



static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.maxcqueue = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
32
57.14%
3
42.86%
Linus Torvalds
15
26.79%
1
14.29%
Yani Ioannou
5
8.93%
1
14.29%
Greg Kroah-Hartman
3
5.36%
1
14.29%
Harvey Harrison
1
1.79%
1
14.29%
Total
56
100.00%
7
100.00%

static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);



static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
34
61.82%
3
37.50%
Linus Torvalds
11
20.00%
1
12.50%
Yani Ioannou
5
9.09%
1
12.50%
Greg Kroah-Hartman
3
5.45%
1
12.50%
Harvey Harrison
1
1.82%
1
12.50%
Patrick Mochel
1
1.82%
1
12.50%
Total
55
100.00%
8
100.00%



static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.doios_single = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
27
48.21%
1
12.50%
Martin Schwidefsky
19
33.93%
3
37.50%
Yani Ioannou
5
8.93%
1
12.50%
Greg Kroah-Hartman
3
5.36%
1
12.50%
Harvey Harrison
1
1.79%
1
12.50%
Al Viro
1
1.79%
1
12.50%
Total
56
100.00%
8
100.00%

static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);



static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
40
72.73%
3
37.50%
Linus Torvalds
5
9.09%
1
12.50%
Yani Ioannou
5
9.09%
1
12.50%
Greg Kroah-Hartman
3
5.45%
1
12.50%
Harvey Harrison
1
1.82%
1
12.50%
Patrick Mochel
1
1.82%
1
12.50%
Total
55
100.00%
8
100.00%



static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	priv->conn->prof.doios_multi = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
38
67.86%
3
42.86%
Linus Torvalds
9
16.07%
1
14.29%
Yani Ioannou
5
8.93%
1
14.29%
Greg Kroah-Hartman
3
5.36%
1
14.29%
Harvey Harrison
1
1.79%
1
14.29%
Total
56
100.00%
7
100.00%

static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);



static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
39
70.91%
3
37.50%
Linus Torvalds
6
10.91%
1
12.50%
Yani Ioannou
5
9.09%
1
12.50%
Greg Kroah-Hartman
3
5.45%
1
12.50%
Patrick Mochel
1
1.82%
1
12.50%
Harvey Harrison
1
1.82%
1
12.50%
Total
55
100.00%
8
100.00%



static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.txlen = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
35
62.50%
3
42.86%
Linus Torvalds
12
21.43%
1
14.29%
Yani Ioannou
5
8.93%
1
14.29%
Greg Kroah-Hartman
3
5.36%
1
14.29%
Harvey Harrison
1
1.79%
1
14.29%
Total
56
100.00%
7
100.00%

static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);



static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
28
50.91%
3
33.33%
Linus Torvalds
14
25.45%
1
11.11%
Yani Ioannou
5
9.09%
1
11.11%
Greg Kroah-Hartman
3
5.45%
1
11.11%
Al Viro
3
5.45%
1
11.11%
Patrick Mochel
1
1.82%
1
11.11%
Harvey Harrison
1
1.82%
1
11.11%
Total
55
100.00%
9
100.00%



static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.tx_time = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
34
60.71%
3
37.50%
Linus Torvalds
10
17.86%
1
12.50%
Yani Ioannou
5
8.93%
1
12.50%
Patrick Mochel
3
5.36%
1
12.50%
Greg Kroah-Hartman
3
5.36%
1
12.50%
Harvey Harrison
1
1.79%
1
12.50%
Total
56
100.00%
8
100.00%

static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);



static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
31
56.36%
1
16.67%
Martin Schwidefsky
15
27.27%
2
33.33%
Yani Ioannou
5
9.09%
1
16.67%
Greg Kroah-Hartman
3
5.45%
1
16.67%
Harvey Harrison
1
1.82%
1
16.67%
Total
55
100.00%
6
100.00%



static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.tx_pending = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
34
60.71%
1
16.67%
Martin Schwidefsky
13
23.21%
2
33.33%
Yani Ioannou
5
8.93%
1
16.67%
Greg Kroah-Hartman
3
5.36%
1
16.67%
Harvey Harrison
1
1.79%
1
16.67%
Total
56
100.00%
6
100.00%

static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);



static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 5, __func__);
	return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
38
69.09%
1
20.00%
Martin Schwidefsky
8
14.55%
1
20.00%
Yani Ioannou
5
9.09%
1
20.00%
Greg Kroah-Hartman
3
5.45%
1
20.00%
Harvey Harrison
1
1.82%
1
20.00%
Total
55
100.00%
5
100.00%



static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct netiucv_priv *priv = dev_get_drvdata(dev);

	IUCV_DBF_TEXT(trace, 4, __func__);
	priv->conn->prof.tx_max_pending = 0;
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
39
69.64%
1
20.00%
Martin Schwidefsky
8
14.29%
1
20.00%
Yani Ioannou
5
8.93%
1
20.00%
Greg Kroah-Hartman
3
5.36%
1
20.00%
Harvey Harrison
1
1.79%
1
20.00%
Total
56
100.00%
5
100.00%

static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);


static struct attribute *netiucv_attrs[] = {
	&dev_attr_buffer.attr,
	&dev_attr_user.attr,
	NULL,
};


static struct attribute_group netiucv_attr_group = {
	.attrs = netiucv_attrs,
};


static struct attribute *netiucv_stat_attrs[] = {
	&dev_attr_device_fsm_state.attr,
	&dev_attr_connection_fsm_state.attr,
	&dev_attr_max_tx_buffer_used.attr,
	&dev_attr_max_chained_skbs.attr,
	&dev_attr_tx_single_write_ops.attr,
	&dev_attr_tx_multi_write_ops.attr,
	&dev_attr_netto_bytes.attr,
	&dev_attr_max_tx_io_time.attr,
	&dev_attr_tx_pending.attr,
	&dev_attr_tx_max_pending.attr,
	NULL,
};


static struct attribute_group netiucv_stat_attr_group = {
	.name  = "stats",
	.attrs = netiucv_stat_attrs,
};


static const struct attribute_group *netiucv_attr_groups[] = {
	&netiucv_stat_attr_group,
	&netiucv_attr_group,
	NULL,
};



static int netiucv_register_device(struct net_device *ndev)
{
	struct netiucv_priv *priv = netdev_priv(ndev);
	struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
	int ret;

	IUCV_DBF_TEXT(trace, 3, __func__);

	if (dev) {
		dev_set_name(dev, "net%s", ndev->name);
		dev->bus = &iucv_bus;
		dev->parent = iucv_root;
		dev->groups = netiucv_attr_groups;
		/*
                 * The release function could be called after the
                 * module has been unloaded. It's _only_ task is to
                 * free the struct. Therefore, we specify kfree()
                 * directly here. (Probably a little bit obfuscating
                 * but legitime ...).
                 */
		dev->release = (void (*)(struct device *))kfree;
		dev->driver = &netiucv_driver;
	} else
		return -ENOMEM;

	ret = device_register(dev);
	if (ret) {
		put_device(dev);
		return ret;
	}
	priv->dev = dev;
	dev_set_drvdata(dev, priv);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
55
36.18%
2
15.38%
Martin Schwidefsky
55
36.18%
4
30.77%
Linus Torvalds
22
14.47%
1
7.69%
Sebastian Ott
7
4.61%
1
7.69%
Frank Blaschka
6
3.95%
1
7.69%
Greg Kroah-Hartman
4
2.63%
1
7.69%
Cornelia Huck
1
0.66%
1
7.69%
Eric Sesterhenn / Snakebyte
1
0.66%
1
7.69%
Harvey Harrison
1
0.66%
1
7.69%
Total
152
100.00%
13
100.00%



static void netiucv_unregister_device(struct device *dev)
{
	IUCV_DBF_TEXT(trace, 3, __func__);
	device_unregister(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
10
40.00%
1
16.67%
Martin Schwidefsky
8
32.00%
3
50.00%
Andrew Morton
6
24.00%
1
16.67%
Harvey Harrison
1
4.00%
1
16.67%
Total
25
100.00%
6
100.00%

/**
 * Allocate and initialize a new connection structure.
 * Add it to the list of netiucv connections;
 */


static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
						      char *username,
						      char *userdata)
{
	struct iucv_connection *conn;

	conn = kzalloc(sizeof(*conn), GFP_KERNEL);
	if (!conn)
		goto out;
	skb_queue_head_init(&conn->collect_queue);
	skb_queue_head_init(&conn->commit_queue);
	spin_lock_init(&conn->collect_lock);
	conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
	conn->netdev = dev;

	conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
	if (!conn->rx_buff)
		goto out_conn;
	conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
	if (!conn->tx_buff)
		goto out_rx;
	conn->fsm = init_fsm("netiucvconn", conn_state_names,
			     conn_event_names, NR_CONN_STATES,
			     NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
			     GFP_KERNEL);
	if (!conn->fsm)
		goto out_tx;

	fsm_settimer(conn->fsm, &conn->timer);
	fsm_newstate(conn->fsm, CONN_STATE_INVALID);

	if (userdata)
		memcpy(conn->userdata, userdata, 17);
	if (username) {
		memcpy(conn->userid, username, 9);
		fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
	}

	write_lock_bh(&iucv_connection_rwlock);
	list_add_tail(&conn->list, &iucv_connection_list);
	write_unlock_bh(&iucv_connection_rwlock);
	return conn;

out_tx:
	kfree_skb(conn->tx_buff);
out_rx:
	kfree_skb(conn->rx_buff);
out_conn:
	kfree(conn);
out:
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
168
59.15%
1
12.50%
Martin Schwidefsky
72
25.35%
3
37.50%
Ursula Braun
19
6.69%
1
12.50%
Frank Pavlic
16
5.63%
1
12.50%
Andrew Morton
8
2.82%
1
12.50%
Eric Sesterhenn / Snakebyte
1
0.35%
1
12.50%
Total
284
100.00%
8
100.00%

/**
 * Release a connection structure and remove it from the
 * list of netiucv connections.
 */


static void netiucv_remove_connection(struct iucv_connection *conn)
{

	IUCV_DBF_TEXT(trace, 3, __func__);
	write_lock_bh(&iucv_connection_rwlock);
	list_del_init(&conn->list);
	write_unlock_bh(&iucv_connection_rwlock);
	fsm_deltimer(&conn->timer);
	netiucv_purge_skb_queue(&conn->collect_queue);
	if (conn->path) {
		iucv_path_sever(conn->path, conn->userdata);
		kfree(conn->path);
		conn->path = NULL;
	}
	netiucv_purge_skb_queue(&conn->commit_queue);
	kfree_fsm(conn->fsm);
	kfree_skb(conn->rx_buff);
	kfree_skb(conn->tx_buff);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
43
36.75%
1
11.11%
Martin Schwidefsky
27
23.08%
3
33.33%
Ursula Braun-Krahl
18
15.38%
1
11.11%
Andrew Morton
17
14.53%
1
11.11%
Frank Pavlic
8
6.84%
1
11.11%
Ursula Braun
3
2.56%
1
11.11%
Harvey Harrison
1
0.85%
1
11.11%
Total
117
100.00%
9
100.00%

/**
 * Release everything of a net device.
 */


static void netiucv_free_netdevice(struct net_device *dev)
{
	struct netiucv_priv *privptr = netdev_priv(dev);

	IUCV_DBF_TEXT(trace, 3, __func__);

	if (!dev)
		return;

	if (privptr) {
		if (privptr->conn)
			netiucv_remove_connection(privptr->conn);
		if (privptr->fsm)
			kfree_fsm(privptr->fsm);
		privptr->conn = NULL; privptr->fsm = NULL;
		/* privptr gets freed by free_netdev() */
	}
	free_netdev(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
62
72.09%
1
20.00%
Linus Torvalds
12
13.95%
1
20.00%
Martin Schwidefsky
11
12.79%
2
40.00%
Harvey Harrison
1
1.16%
1
20.00%
Total
86
100.00%
5
100.00%

/**
 * Initialize a net device. (Called from kernel in alloc_netdev())
 */

static const struct net_device_ops netiucv_netdev_ops = {
	.ndo_open		= netiucv_open,
	.ndo_stop		= netiucv_close,
	.ndo_get_stats		= netiucv_stats,
	.ndo_start_xmit		= netiucv_tx,
};



static void netiucv_setup_netdevice(struct net_device *dev)
{
	dev->mtu	         = NETIUCV_MTU_DEFAULT;
	dev->min_mtu		 = 576;
	dev->max_mtu		 = NETIUCV_MTU_MAX;
	dev->destructor          = netiucv_free_netdevice;
	dev->hard_header_len     = NETIUCV_HDRLEN;
	dev->addr_len            = 0;
	dev->type                = ARPHRD_SLIP;
	dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
	dev->flags	         = IFF_POINTOPOINT | IFF_NOARP;
	dev->netdev_ops		 = &netiucv_netdev_ops;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Al Viro
39
52.70%
1
20.00%
Jarod Wilson
12
16.22%
1
20.00%
Martin Schwidefsky
10
13.51%
1
20.00%
Frank Blaschka
7
9.46%
1
20.00%
Andrew Morton
6
8.11%
1
20.00%
Total
74
100.00%
5
100.00%

/**
 * Allocate and initialize everything of a net device.
 */


static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
{
	struct netiucv_priv *privptr;
	struct net_device *dev;

	dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
			   NET_NAME_UNKNOWN, netiucv_setup_netdevice);
	if (!dev)
		return NULL;
	rtnl_lock();
	if (dev_alloc_name(dev, dev->name) < 0)
		goto out_netdev;

	privptr = netdev_priv(dev);
	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)
		goto out_netdev;

	privptr->conn = netiucv_new_connection(dev, username, userdata);
	if (!privptr->conn) {
		IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
		goto out_fsm;
	}
	fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
	return dev;

out_fsm:
	kfree_fsm(privptr->fsm);
out_netdev:
	rtnl_unlock();
	free_netdev(dev);
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
95
53.37%
2
18.18%
Martin Schwidefsky
42
23.60%
3
27.27%
Ursula Braun
22
12.36%
2
18.18%
Andrew Morton
11
6.18%
2
18.18%
Benjamin Poirier
6
3.37%
1
9.09%
Tom Gundersen
2
1.12%
1
9.09%
Total
178
100.00%
11
100.00%



static ssize_t conn_write(struct device_driver *drv,
			  const char *buf, size_t count)
{
	char username[9];
	char userdata[17];
	int rc;
	struct net_device *dev;
	struct netiucv_priv *priv;
	struct iucv_connection *cp;

	IUCV_DBF_TEXT(trace, 3, __func__);
	rc = netiucv_check_user(buf, count, username, userdata);
	if (rc)
		return rc;

	read_lock_bh(&iucv_connection_rwlock);
	list_for_each_entry(cp, &iucv_connection_list, list) {
		if (!strncmp(username, cp->userid, 9) &&
		    !strncmp(userdata, cp->userdata, 17)) {
			read_unlock_bh(&iucv_connection_rwlock);
			IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
				"already exists\n", netiucv_printuser(cp));
			return -EEXIST;
		}
	}
	read_unlock_bh(&iucv_connection_rwlock);

	dev = netiucv_init_netdevice(username, userdata);
	if (!dev) {
		IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
		return -ENODEV;
	}

	rc = netiucv_register_device(dev);
	if (rc) {
		rtnl_unlock();
		IUCV_DBF_TEXT_(setup, 2,
			"ret %d from netiucv_register_device\n", rc);
		goto out_free_ndev;
	}

	/* sysfs magic */
	priv = netdev_priv(dev);
	SET_NETDEV_DEV(dev, priv->dev);

	rc = register_netdevice(dev);
	rtnl_unlock();
	if (rc)
		goto out_unreg;

	dev_info(priv->dev, "The IUCV interface to %s has been established "
			    "successfully\n",
		netiucv_printuser(priv->conn));

	return count;

out_unreg:
	netiucv_unregister_device(priv->dev);
out_free_ndev:
	netiucv_free_netdevice(dev);
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
151
52.98%
5
33.33%
Ursula Braun
41
14.39%
1
6.67%
Frank Pavlic
37
12.98%
1
6.67%
Andrew Morton
16
5.61%
2
13.33%
Ursula Braun-Krahl
16
5.61%
2
13.33%
Linus Torvalds
16
5.61%
2
13.33%
Benjamin Poirier
7
2.46%
1
6.67%
Harvey Harrison
1
0.35%
1
6.67%
Total
285
100.00%
15
100.00%

static DRIVER_ATTR(connection, 0200, NULL, conn_write);



static ssize_t remove_write (struct device_driver *drv,
			     const char *buf, size_t count)
{
	struct iucv_connection *cp;
        struct net_device *ndev;
        struct netiucv_priv *priv;
        struct device *dev;
        char name[IFNAMSIZ];
	const char *p;
        int i;

	IUCV_DBF_TEXT(trace, 3, __func__);

        if (count >= IFNAMSIZ)
                count = IFNAMSIZ - 1;

	for (i = 0, p = buf; i < count && *p; i++, p++) {
		if (*p == '\n' || *p == ' ')
                        /* trailing lf, grr */
                        break;
		name[i] = *p;
        }
        name[i] = '\0';

	read_lock_bh(&iucv_connection_rwlock);
	list_for_each_entry(cp, &iucv_connection_list, list) {
		ndev = cp->netdev;
		priv = netdev_priv(ndev);
                dev = priv->dev;
		if (strncmp(name, ndev->name, count))
			continue;
		read_unlock_bh(&iucv_connection_rwlock);
                if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
			dev_warn(dev, "The IUCV device is connected"
				" to %s and cannot be removed\n",
				priv->conn->userid);
			IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
			return -EPERM;
                }
                unregister_netdev(ndev);
                netiucv_unregister_device(dev);
                return count;
        }
	read_unlock_bh(&iucv_connection_rwlock);
	IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
        return -EINVAL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Morton
194
75.78%
1
12.50%
Martin Schwidefsky
43
16.80%
2
25.00%
Frank Pavlic
12
4.69%
1
12.50%
Ursula Braun-Krahl
5
1.95%
2
25.00%
Harvey Harrison
1
0.39%
1
12.50%
Dave Jones
1
0.39%
1
12.50%
Total
256
100.00%
8
100.00%

static DRIVER_ATTR(remove, 0200, NULL, remove_write);


static struct attribute * netiucv_drv_attrs[] = {
	&driver_attr_connection.attr,
	&driver_attr_remove.attr,
	NULL,
};


static struct attribute_group netiucv_drv_attr_group = {
	.attrs = netiucv_drv_attrs,
};


static const struct attribute_group *netiucv_drv_attr_groups[] = {
	&netiucv_drv_attr_group,
	NULL,
};



static void netiucv_banner(void)
{
	pr_info("driver initialized\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
9
69.23%
2
50.00%
Martin Schwidefsky
2
15.38%
1
25.00%
Ursula Braun-Krahl
2
15.38%
1
25.00%
Total
13
100.00%
4
100.00%



static void __exit netiucv_exit(void)
{
	struct iucv_connection *cp;
	struct net_device *ndev;
	struct netiucv_priv *priv;
	struct device *dev;

	IUCV_DBF_TEXT(trace, 3, __func__);
	while (!list_empty(&iucv_connection_list)) {
		cp = list_entry(iucv_connection_list.next,
				struct iucv_connection, list);
		ndev = cp->netdev;
		priv = netdev_priv(ndev);
		dev = priv->dev;

		unregister_netdev(ndev);
		netiucv_unregister_device(dev);
	}

	device_unregister(netiucv_dev);
	driver_unregister(&netiucv_driver);
	iucv_unregister(&netiucv_handler, 1);
	iucv_unregister_dbf_views();

	pr_info("driver unloaded\n");
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
88
73.33%
3
27.27%
Andrew Morton
14
11.67%
2
18.18%
Linus Torvalds
9
7.50%
2
18.18%
Ursula Braun
5
4.17%
1
9.09%
Ursula Braun-Krahl
2
1.67%
1
9.09%
Harvey Harrison
1
0.83%
1
9.09%
Frank Pavlic
1
0.83%
1
9.09%
Total
120
100.00%
11
100.00%



static int __init netiucv_init(void)
{
	int rc;

	rc = iucv_register_dbf_views();
	if (rc)
		goto out;
	rc = iucv_register(&netiucv_handler, 1);
	if (rc)
		goto out_dbf;
	IUCV_DBF_TEXT(trace, 3, __func__);
	netiucv_driver.groups = netiucv_drv_attr_groups;
	rc = driver_register(&netiucv_driver);
	if (rc) {
		IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
		goto out_iucv;
	}
	/* establish dummy device */
	netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
	if (!netiucv_dev) {
		rc = -ENOMEM;
		goto out_driver;
	}
	dev_set_name(netiucv_dev, "netiucv");
	netiucv_dev->bus = &iucv_bus;
	netiucv_dev->parent = iucv_root;
	netiucv_dev->release = (void (*)(struct device *))kfree;
	netiucv_dev->driver = &netiucv_driver;
	rc = device_register(netiucv_dev);
	if (rc) {
		put_device(netiucv_dev);
		goto out_driver;
	}
	netiucv_banner();
	return rc;

out_driver:
	driver_unregister(&netiucv_driver);
out_iucv:
	iucv_unregister(&netiucv_handler, 1);
out_dbf:
	iucv_unregister_dbf_views();
out:
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
96
45.28%
3
33.33%
Ursula Braun
95
44.81%
1
11.11%
Sebastian Ott
7
3.30%
1
11.11%
Linus Torvalds
7
3.30%
2
22.22%
Cornelia Huck
6
2.83%
1
11.11%
Harvey Harrison
1
0.47%
1
11.11%
Total
212
100.00%
9
100.00%


module_init(netiucv_init);

module_exit(netiucv_exit);
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
3899
39.83%
6
8.00%
Martin Schwidefsky
2721
27.79%
9
12.00%
Andrew Morton
1251
12.78%
9
12.00%
Ursula Braun
1213
12.39%
9
12.00%
Ursula Braun-Krahl
135
1.38%
4
5.33%
Frank Pavlic
114
1.16%
1
1.33%
Yani Ioannou
105
1.07%
1
1.33%
Greg Kroah-Hartman
67
0.68%
1
1.33%
Frank Blaschka
51
0.52%
2
2.67%
Al Viro
47
0.48%
2
2.67%
Harvey Harrison
44
0.45%
1
1.33%
Cornelia Huck
26
0.27%
4
5.33%
Arnaldo Carvalho de Melo
25
0.26%
3
4.00%
Sebastian Ott
14
0.14%
1
1.33%
Benjamin Poirier
13
0.13%
1
1.33%
Jarod Wilson
12
0.12%
1
1.33%
Patrick Mochel
9
0.09%
2
2.67%
Patrick McHardy
7
0.07%
2
2.67%
Julia Lawall
6
0.06%
1
1.33%
Aya Mahfouz
4
0.04%
1
1.33%
Thomas Gleixner
4
0.04%
1
1.33%
Florian Westphal
3
0.03%
1
1.33%
Adrian Bunk
3
0.03%
1
1.33%
Michael Holzheu
3
0.03%
1
1.33%
Heiko Carstens
2
0.02%
1
1.33%
Cheng Renquan
2
0.02%
1
1.33%
Tom Gundersen
2
0.02%
1
1.33%
Eric Sesterhenn / Snakebyte
2
0.02%
1
1.33%
Stefan Weil
1
0.01%
1
1.33%
Hendrik Brueckner
1
0.01%
1
1.33%
Jeff Garzik
1
0.01%
1
1.33%
David Brownell
1
0.01%
1
1.33%
Dave Jones
1
0.01%
1
1.33%
Alexey Dobriyan
1
0.01%
1
1.33%
Total
9790
100.00%
75
100.00%
Directory: drivers/s390/net

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.