1/*
   2 * IUCV network driver
   3 *
   4 * Copyright IBM Corp. 2001, 2009
   5 *
   6 * Author(s):
   7 *	Original netiucv driver:
   8 *		Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
   9 *	Sysfs integration and all bugs therein:
  10 *		Cornelia Huck (cornelia.huck@de.ibm.com)
  11 *	PM functions:
  12 *		Ursula Braun (ursula.braun@de.ibm.com)
  13 *
  14 * Documentation used:
  15 *  the source of the original IUCV driver by:
  16 *    Stefan Hegewald <hegewald@de.ibm.com>
  17 *    Hartmut Penner <hpenner@de.ibm.com>
  18 *    Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  19 *    Martin Schwidefsky (schwidefsky@de.ibm.com)
  20 *    Alan Altmark (Alan_Altmark@us.ibm.com)  Sept. 2000
  21 *
  22 * This program is free software; you can redistribute it and/or modify
  23 * it under the terms of the GNU General Public License as published by
  24 * the Free Software Foundation; either version 2, or (at your option)
  25 * any later version.
  26 *
  27 * This program is distributed in the hope that it will be useful,
  28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30 * GNU General Public License for more details.
  31 *
  32 * You should have received a copy of the GNU General Public License
  33 * along with this program; if not, write to the Free Software
  34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35 *
  36 */
  37
  38#define KMSG_COMPONENT "netiucv"
  39#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  40
  41#undef DEBUG
  42
  43#include <linux/module.h>
  44#include <linux/init.h>
  45#include <linux/kernel.h>
  46#include <linux/slab.h>
  47#include <linux/errno.h>
  48#include <linux/types.h>
  49#include <linux/interrupt.h>
  50#include <linux/timer.h>
  51#include <linux/bitops.h>
  52
  53#include <linux/signal.h>
  54#include <linux/string.h>
  55#include <linux/device.h>
  56
  57#include <linux/ip.h>
  58#include <linux/if_arp.h>
  59#include <linux/tcp.h>
  60#include <linux/skbuff.h>
  61#include <linux/ctype.h>
  62#include <net/dst.h>
  63
  64#include <asm/io.h>
  65#include <asm/uaccess.h>
 
  66
  67#include <net/iucv/iucv.h>
  68#include "fsm.h"
  69
  70MODULE_AUTHOR
  71    ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
  72MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
  73
  74/**
  75 * Debug Facility stuff
  76 */
  77#define IUCV_DBF_SETUP_NAME "iucv_setup"
  78#define IUCV_DBF_SETUP_LEN 32
  79#define IUCV_DBF_SETUP_PAGES 2
  80#define IUCV_DBF_SETUP_NR_AREAS 1
  81#define IUCV_DBF_SETUP_LEVEL 3
  82
  83#define IUCV_DBF_DATA_NAME "iucv_data"
  84#define IUCV_DBF_DATA_LEN 128
  85#define IUCV_DBF_DATA_PAGES 2
  86#define IUCV_DBF_DATA_NR_AREAS 1
  87#define IUCV_DBF_DATA_LEVEL 2
  88
  89#define IUCV_DBF_TRACE_NAME "iucv_trace"
  90#define IUCV_DBF_TRACE_LEN 16
  91#define IUCV_DBF_TRACE_PAGES 4
  92#define IUCV_DBF_TRACE_NR_AREAS 1
  93#define IUCV_DBF_TRACE_LEVEL 3
  94
  95#define IUCV_DBF_TEXT(name,level,text) \
  96	do { \
  97		debug_text_event(iucv_dbf_##name,level,text); \
  98	} while (0)
  99
 100#define IUCV_DBF_HEX(name,level,addr,len) \
 101	do { \
 102		debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
 103	} while (0)
 104
 105DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf);
 106
 107/* Allow to sort out low debug levels early to avoid wasted sprints */
 108static inline int iucv_dbf_passes(debug_info_t *dbf_grp, int level)
 109{
 110	return (level <= dbf_grp->level);
 111}
 112
 113#define IUCV_DBF_TEXT_(name, level, text...) \
 114	do { \
 115		if (iucv_dbf_passes(iucv_dbf_##name, level)) { \
 116			char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
 117			sprintf(__buf, text); \
 118			debug_text_event(iucv_dbf_##name, level, __buf); \
 119			put_cpu_var(iucv_dbf_txt_buf); \
 120		} \
 121	} while (0)
 122
 123#define IUCV_DBF_SPRINTF(name,level,text...) \
 124	do { \
 125		debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
 126		debug_sprintf_event(iucv_dbf_trace, level, text ); \
 127	} while (0)
 128
 129/**
 130 * some more debug stuff
 131 */
 132#define IUCV_HEXDUMP16(importance,header,ptr) \
 133PRINT_##importance(header "%02x %02x %02x %02x  %02x %02x %02x %02x  " \
 134		   "%02x %02x %02x %02x  %02x %02x %02x %02x\n", \
 135		   *(((char*)ptr)),*(((char*)ptr)+1),*(((char*)ptr)+2), \
 136		   *(((char*)ptr)+3),*(((char*)ptr)+4),*(((char*)ptr)+5), \
 137		   *(((char*)ptr)+6),*(((char*)ptr)+7),*(((char*)ptr)+8), \
 138		   *(((char*)ptr)+9),*(((char*)ptr)+10),*(((char*)ptr)+11), \
 139		   *(((char*)ptr)+12),*(((char*)ptr)+13), \
 140		   *(((char*)ptr)+14),*(((char*)ptr)+15)); \
 141PRINT_##importance(header "%02x %02x %02x %02x  %02x %02x %02x %02x  " \
 142		   "%02x %02x %02x %02x  %02x %02x %02x %02x\n", \
 143		   *(((char*)ptr)+16),*(((char*)ptr)+17), \
 144		   *(((char*)ptr)+18),*(((char*)ptr)+19), \
 145		   *(((char*)ptr)+20),*(((char*)ptr)+21), \
 146		   *(((char*)ptr)+22),*(((char*)ptr)+23), \
 147		   *(((char*)ptr)+24),*(((char*)ptr)+25), \
 148		   *(((char*)ptr)+26),*(((char*)ptr)+27), \
 149		   *(((char*)ptr)+28),*(((char*)ptr)+29), \
 150		   *(((char*)ptr)+30),*(((char*)ptr)+31));
 151
 152#define PRINTK_HEADER " iucv: "       /* for debugging */
 153
 154/* dummy device to make sure netiucv_pm functions are called */
 155static struct device *netiucv_dev;
 156
 157static int netiucv_pm_prepare(struct device *);
 158static void netiucv_pm_complete(struct device *);
 159static int netiucv_pm_freeze(struct device *);
 160static int netiucv_pm_restore_thaw(struct device *);
 161
 162static const struct dev_pm_ops netiucv_pm_ops = {
 163	.prepare = netiucv_pm_prepare,
 164	.complete = netiucv_pm_complete,
 165	.freeze = netiucv_pm_freeze,
 166	.thaw = netiucv_pm_restore_thaw,
 167	.restore = netiucv_pm_restore_thaw,
 168};
 169
 170static struct device_driver netiucv_driver = {
 171	.owner = THIS_MODULE,
 172	.name = "netiucv",
 173	.bus  = &iucv_bus,
 174	.pm = &netiucv_pm_ops,
 175};
 176
 177static int netiucv_callback_connreq(struct iucv_path *,
 178				    u8 ipvmid[8], u8 ipuser[16]);
 179static void netiucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
 180static void netiucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
 181static void netiucv_callback_connsusp(struct iucv_path *, u8 ipuser[16]);
 182static void netiucv_callback_connres(struct iucv_path *, u8 ipuser[16]);
 183static void netiucv_callback_rx(struct iucv_path *, struct iucv_message *);
 184static void netiucv_callback_txdone(struct iucv_path *, struct iucv_message *);
 185
 186static struct iucv_handler netiucv_handler = {
 187	.path_pending	  = netiucv_callback_connreq,
 188	.path_complete	  = netiucv_callback_connack,
 189	.path_severed	  = netiucv_callback_connrej,
 190	.path_quiesced	  = netiucv_callback_connsusp,
 191	.path_resumed	  = netiucv_callback_connres,
 192	.message_pending  = netiucv_callback_rx,
 193	.message_complete = netiucv_callback_txdone
 194};
 195
 196/**
 197 * Per connection profiling data
 198 */
 199struct connection_profile {
 200	unsigned long maxmulti;
 201	unsigned long maxcqueue;
 202	unsigned long doios_single;
 203	unsigned long doios_multi;
 204	unsigned long txlen;
 205	unsigned long tx_time;
 206	struct timespec send_stamp;
 207	unsigned long tx_pending;
 208	unsigned long tx_max_pending;
 209};
 210
 211/**
 212 * Representation of one iucv connection
 213 */
 214struct iucv_connection {
 215	struct list_head	  list;
 216	struct iucv_path	  *path;
 217	struct sk_buff            *rx_buff;
 218	struct sk_buff            *tx_buff;
 219	struct sk_buff_head       collect_queue;
 220	struct sk_buff_head	  commit_queue;
 221	spinlock_t                collect_lock;
 222	int                       collect_len;
 223	int                       max_buffsize;
 224	fsm_timer                 timer;
 225	fsm_instance              *fsm;
 226	struct net_device         *netdev;
 227	struct connection_profile prof;
 228	char                      userid[9];
 
 229};
 230
 231/**
 232 * Linked list of all connection structs.
 233 */
 234static LIST_HEAD(iucv_connection_list);
 235static DEFINE_RWLOCK(iucv_connection_rwlock);
 236
 237/**
 238 * Representation of event-data for the
 239 * connection state machine.
 240 */
 241struct iucv_event {
 242	struct iucv_connection *conn;
 243	void                   *data;
 244};
 245
 246/**
 247 * Private part of the network device structure
 248 */
 249struct netiucv_priv {
 250	struct net_device_stats stats;
 251	unsigned long           tbusy;
 252	fsm_instance            *fsm;
 253        struct iucv_connection  *conn;
 254	struct device           *dev;
 255	int			 pm_state;
 256};
 257
 258/**
 259 * Link level header for a packet.
 260 */
 261struct ll_header {
 262	u16 next;
 263};
 264
 265#define NETIUCV_HDRLEN		 (sizeof(struct ll_header))
 266#define NETIUCV_BUFSIZE_MAX      32768
 267#define NETIUCV_BUFSIZE_DEFAULT  NETIUCV_BUFSIZE_MAX
 268#define NETIUCV_MTU_MAX          (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
 269#define NETIUCV_MTU_DEFAULT      9216
 270#define NETIUCV_QUEUELEN_DEFAULT 50
 271#define NETIUCV_TIMEOUT_5SEC     5000
 272
 273/**
 274 * Compatibility macros for busy handling
 275 * of network devices.
 276 */
 277static inline void netiucv_clear_busy(struct net_device *dev)
 278{
 279	struct netiucv_priv *priv = netdev_priv(dev);
 280	clear_bit(0, &priv->tbusy);
 281	netif_wake_queue(dev);
 282}
 283
 284static inline int netiucv_test_and_set_busy(struct net_device *dev)
 285{
 286	struct netiucv_priv *priv = netdev_priv(dev);
 287	netif_stop_queue(dev);
 288	return test_and_set_bit(0, &priv->tbusy);
 289}
 290
 291static u8 iucvMagic[16] = {
 
 
 
 
 
 292	0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
 293	0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
 294};
 295
 296/**
 297 * Convert an iucv userId to its printable
 298 * form (strip whitespace at end).
 299 *
 300 * @param An iucv userId
 301 *
 302 * @returns The printable string (static data!!)
 303 */
 304static char *netiucv_printname(char *name)
 305{
 306	static char tmp[9];
 307	char *p = tmp;
 308	memcpy(tmp, name, 8);
 309	tmp[8] = '\0';
 310	while (*p && (!isspace(*p)))
 311		p++;
 312	*p = '\0';
 313	return tmp;
 314}
 315
 316/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 317 * States of the interface statemachine.
 318 */
 319enum dev_states {
 320	DEV_STATE_STOPPED,
 321	DEV_STATE_STARTWAIT,
 322	DEV_STATE_STOPWAIT,
 323	DEV_STATE_RUNNING,
 324	/**
 325	 * MUST be always the last element!!
 326	 */
 327	NR_DEV_STATES
 328};
 329
 330static const char *dev_state_names[] = {
 331	"Stopped",
 332	"StartWait",
 333	"StopWait",
 334	"Running",
 335};
 336
 337/**
 338 * Events of the interface statemachine.
 339 */
 340enum dev_events {
 341	DEV_EVENT_START,
 342	DEV_EVENT_STOP,
 343	DEV_EVENT_CONUP,
 344	DEV_EVENT_CONDOWN,
 345	/**
 346	 * MUST be always the last element!!
 347	 */
 348	NR_DEV_EVENTS
 349};
 350
 351static const char *dev_event_names[] = {
 352	"Start",
 353	"Stop",
 354	"Connection up",
 355	"Connection down",
 356};
 357
 358/**
 359 * Events of the connection statemachine
 360 */
 361enum conn_events {
 362	/**
 363	 * Events, representing callbacks from
 364	 * lowlevel iucv layer)
 365	 */
 366	CONN_EVENT_CONN_REQ,
 367	CONN_EVENT_CONN_ACK,
 368	CONN_EVENT_CONN_REJ,
 369	CONN_EVENT_CONN_SUS,
 370	CONN_EVENT_CONN_RES,
 371	CONN_EVENT_RX,
 372	CONN_EVENT_TXDONE,
 373
 374	/**
 375	 * Events, representing errors return codes from
 376	 * calls to lowlevel iucv layer
 377	 */
 378
 379	/**
 380	 * Event, representing timer expiry.
 381	 */
 382	CONN_EVENT_TIMER,
 383
 384	/**
 385	 * Events, representing commands from upper levels.
 386	 */
 387	CONN_EVENT_START,
 388	CONN_EVENT_STOP,
 389
 390	/**
 391	 * MUST be always the last element!!
 392	 */
 393	NR_CONN_EVENTS,
 394};
 395
 396static const char *conn_event_names[] = {
 397	"Remote connection request",
 398	"Remote connection acknowledge",
 399	"Remote connection reject",
 400	"Connection suspended",
 401	"Connection resumed",
 402	"Data received",
 403	"Data sent",
 404
 405	"Timer",
 406
 407	"Start",
 408	"Stop",
 409};
 410
 411/**
 412 * States of the connection statemachine.
 413 */
 414enum conn_states {
 415	/**
 416	 * Connection not assigned to any device,
 417	 * initial state, invalid
 418	 */
 419	CONN_STATE_INVALID,
 420
 421	/**
 422	 * Userid assigned but not operating
 423	 */
 424	CONN_STATE_STOPPED,
 425
 426	/**
 427	 * Connection registered,
 428	 * no connection request sent yet,
 429	 * no connection request received
 430	 */
 431	CONN_STATE_STARTWAIT,
 432
 433	/**
 434	 * Connection registered and connection request sent,
 435	 * no acknowledge and no connection request received yet.
 436	 */
 437	CONN_STATE_SETUPWAIT,
 438
 439	/**
 440	 * Connection up and running idle
 441	 */
 442	CONN_STATE_IDLE,
 443
 444	/**
 445	 * Data sent, awaiting CONN_EVENT_TXDONE
 446	 */
 447	CONN_STATE_TX,
 448
 449	/**
 450	 * Error during registration.
 451	 */
 452	CONN_STATE_REGERR,
 453
 454	/**
 455	 * Error during registration.
 456	 */
 457	CONN_STATE_CONNERR,
 458
 459	/**
 460	 * MUST be always the last element!!
 461	 */
 462	NR_CONN_STATES,
 463};
 464
 465static const char *conn_state_names[] = {
 466	"Invalid",
 467	"Stopped",
 468	"StartWait",
 469	"SetupWait",
 470	"Idle",
 471	"TX",
 472	"Terminating",
 473	"Registration error",
 474	"Connect error",
 475};
 476
 477
 478/**
 479 * Debug Facility Stuff
 480 */
 481static debug_info_t *iucv_dbf_setup = NULL;
 482static debug_info_t *iucv_dbf_data = NULL;
 483static debug_info_t *iucv_dbf_trace = NULL;
 484
 485DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf);
 486
 487static void iucv_unregister_dbf_views(void)
 488{
 489	if (iucv_dbf_setup)
 490		debug_unregister(iucv_dbf_setup);
 491	if (iucv_dbf_data)
 492		debug_unregister(iucv_dbf_data);
 493	if (iucv_dbf_trace)
 494		debug_unregister(iucv_dbf_trace);
 495}
 496static int iucv_register_dbf_views(void)
 497{
 498	iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
 499					IUCV_DBF_SETUP_PAGES,
 500					IUCV_DBF_SETUP_NR_AREAS,
 501					IUCV_DBF_SETUP_LEN);
 502	iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
 503				       IUCV_DBF_DATA_PAGES,
 504				       IUCV_DBF_DATA_NR_AREAS,
 505				       IUCV_DBF_DATA_LEN);
 506	iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
 507					IUCV_DBF_TRACE_PAGES,
 508					IUCV_DBF_TRACE_NR_AREAS,
 509					IUCV_DBF_TRACE_LEN);
 510
 511	if ((iucv_dbf_setup == NULL) || (iucv_dbf_data == NULL) ||
 512	    (iucv_dbf_trace == NULL)) {
 513		iucv_unregister_dbf_views();
 514		return -ENOMEM;
 515	}
 516	debug_register_view(iucv_dbf_setup, &debug_hex_ascii_view);
 517	debug_set_level(iucv_dbf_setup, IUCV_DBF_SETUP_LEVEL);
 518
 519	debug_register_view(iucv_dbf_data, &debug_hex_ascii_view);
 520	debug_set_level(iucv_dbf_data, IUCV_DBF_DATA_LEVEL);
 521
 522	debug_register_view(iucv_dbf_trace, &debug_hex_ascii_view);
 523	debug_set_level(iucv_dbf_trace, IUCV_DBF_TRACE_LEVEL);
 524
 525	return 0;
 526}
 527
 528/*
 529 * Callback-wrappers, called from lowlevel iucv layer.
 530 */
 531
 532static void netiucv_callback_rx(struct iucv_path *path,
 533				struct iucv_message *msg)
 534{
 535	struct iucv_connection *conn = path->private;
 536	struct iucv_event ev;
 537
 538	ev.conn = conn;
 539	ev.data = msg;
 540	fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
 541}
 542
 543static void netiucv_callback_txdone(struct iucv_path *path,
 544				    struct iucv_message *msg)
 545{
 546	struct iucv_connection *conn = path->private;
 547	struct iucv_event ev;
 548
 549	ev.conn = conn;
 550	ev.data = msg;
 551	fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
 552}
 553
 554static void netiucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
 555{
 556	struct iucv_connection *conn = path->private;
 557
 558	fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn);
 559}
 560
 561static int netiucv_callback_connreq(struct iucv_path *path,
 562				    u8 ipvmid[8], u8 ipuser[16])
 563{
 564	struct iucv_connection *conn = path->private;
 565	struct iucv_event ev;
 
 
 566	int rc;
 567
 568	if (memcmp(iucvMagic, ipuser, 16))
 569		/* ipuser must match iucvMagic. */
 570		return -EINVAL;
 571	rc = -EINVAL;
 
 
 
 572	read_lock_bh(&iucv_connection_rwlock);
 573	list_for_each_entry(conn, &iucv_connection_list, list) {
 574		if (strncmp(ipvmid, conn->userid, 8))
 
 575			continue;
 576		/* Found a matching connection for this path. */
 577		conn->path = path;
 578		ev.conn = conn;
 579		ev.data = path;
 580		fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
 581		rc = 0;
 582	}
 
 
 583	read_unlock_bh(&iucv_connection_rwlock);
 584	return rc;
 585}
 586
 587static void netiucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
 588{
 589	struct iucv_connection *conn = path->private;
 590
 591	fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn);
 592}
 593
 594static void netiucv_callback_connsusp(struct iucv_path *path, u8 ipuser[16])
 595{
 596	struct iucv_connection *conn = path->private;
 597
 598	fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn);
 599}
 600
 601static void netiucv_callback_connres(struct iucv_path *path, u8 ipuser[16])
 602{
 603	struct iucv_connection *conn = path->private;
 604
 605	fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn);
 606}
 607
 608/**
 609 * NOP action for statemachines
 610 */
 611static void netiucv_action_nop(fsm_instance *fi, int event, void *arg)
 612{
 613}
 614
 615/*
 616 * Actions of the connection statemachine
 617 */
 618
 619/**
 620 * netiucv_unpack_skb
 621 * @conn: The connection where this skb has been received.
 622 * @pskb: The received skb.
 623 *
 624 * Unpack a just received skb and hand it over to upper layers.
 625 * Helper function for conn_action_rx.
 626 */
 627static void netiucv_unpack_skb(struct iucv_connection *conn,
 628			       struct sk_buff *pskb)
 629{
 630	struct net_device     *dev = conn->netdev;
 631	struct netiucv_priv   *privptr = netdev_priv(dev);
 632	u16 offset = 0;
 633
 634	skb_put(pskb, NETIUCV_HDRLEN);
 635	pskb->dev = dev;
 636	pskb->ip_summed = CHECKSUM_NONE;
 637	pskb->protocol = ntohs(ETH_P_IP);
 638
 639	while (1) {
 640		struct sk_buff *skb;
 641		struct ll_header *header = (struct ll_header *) pskb->data;
 642
 643		if (!header->next)
 644			break;
 645
 646		skb_pull(pskb, NETIUCV_HDRLEN);
 647		header->next -= offset;
 648		offset += header->next;
 649		header->next -= NETIUCV_HDRLEN;
 650		if (skb_tailroom(pskb) < header->next) {
 651			IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n",
 652				header->next, skb_tailroom(pskb));
 653			return;
 654		}
 655		skb_put(pskb, header->next);
 656		skb_reset_mac_header(pskb);
 657		skb = dev_alloc_skb(pskb->len);
 658		if (!skb) {
 659			IUCV_DBF_TEXT(data, 2,
 660				"Out of memory in netiucv_unpack_skb\n");
 661			privptr->stats.rx_dropped++;
 662			return;
 663		}
 664		skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
 665					  pskb->len);
 666		skb_reset_mac_header(skb);
 667		skb->dev = pskb->dev;
 668		skb->protocol = pskb->protocol;
 669		pskb->ip_summed = CHECKSUM_UNNECESSARY;
 670		privptr->stats.rx_packets++;
 671		privptr->stats.rx_bytes += skb->len;
 672		/*
 673		 * Since receiving is always initiated from a tasklet (in iucv.c),
 674		 * we must use netif_rx_ni() instead of netif_rx()
 675		 */
 676		netif_rx_ni(skb);
 677		skb_pull(pskb, header->next);
 678		skb_put(pskb, NETIUCV_HDRLEN);
 679	}
 680}
 681
 682static void conn_action_rx(fsm_instance *fi, int event, void *arg)
 683{
 684	struct iucv_event *ev = arg;
 685	struct iucv_connection *conn = ev->conn;
 686	struct iucv_message *msg = ev->data;
 687	struct netiucv_priv *privptr = netdev_priv(conn->netdev);
 688	int rc;
 689
 690	IUCV_DBF_TEXT(trace, 4, __func__);
 691
 692	if (!conn->netdev) {
 693		iucv_message_reject(conn->path, msg);
 694		IUCV_DBF_TEXT(data, 2,
 695			      "Received data for unlinked connection\n");
 696		return;
 697	}
 698	if (msg->length > conn->max_buffsize) {
 699		iucv_message_reject(conn->path, msg);
 700		privptr->stats.rx_dropped++;
 701		IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n",
 702			       msg->length, conn->max_buffsize);
 703		return;
 704	}
 705	conn->rx_buff->data = conn->rx_buff->head;
 706	skb_reset_tail_pointer(conn->rx_buff);
 707	conn->rx_buff->len = 0;
 708	rc = iucv_message_receive(conn->path, msg, 0, conn->rx_buff->data,
 709				  msg->length, NULL);
 710	if (rc || msg->length < 5) {
 711		privptr->stats.rx_errors++;
 712		IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc);
 713		return;
 714	}
 715	netiucv_unpack_skb(conn, conn->rx_buff);
 716}
 717
 718static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
 719{
 720	struct iucv_event *ev = arg;
 721	struct iucv_connection *conn = ev->conn;
 722	struct iucv_message *msg = ev->data;
 723	struct iucv_message txmsg;
 724	struct netiucv_priv *privptr = NULL;
 725	u32 single_flag = msg->tag;
 726	u32 txbytes = 0;
 727	u32 txpackets = 0;
 728	u32 stat_maxcq = 0;
 729	struct sk_buff *skb;
 730	unsigned long saveflags;
 731	struct ll_header header;
 732	int rc;
 733
 734	IUCV_DBF_TEXT(trace, 4, __func__);
 735
 736	if (conn && conn->netdev)
 737		privptr = netdev_priv(conn->netdev);
 
 
 
 
 738	conn->prof.tx_pending--;
 739	if (single_flag) {
 740		if ((skb = skb_dequeue(&conn->commit_queue))) {
 741			atomic_dec(&skb->users);
 742			if (privptr) {
 743				privptr->stats.tx_packets++;
 744				privptr->stats.tx_bytes +=
 745					(skb->len - NETIUCV_HDRLEN
 746						  - NETIUCV_HDRLEN);
 747			}
 748			dev_kfree_skb_any(skb);
 749		}
 750	}
 751	conn->tx_buff->data = conn->tx_buff->head;
 752	skb_reset_tail_pointer(conn->tx_buff);
 753	conn->tx_buff->len = 0;
 754	spin_lock_irqsave(&conn->collect_lock, saveflags);
 755	while ((skb = skb_dequeue(&conn->collect_queue))) {
 756		header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
 757		memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
 758		       NETIUCV_HDRLEN);
 759		skb_copy_from_linear_data(skb,
 760					  skb_put(conn->tx_buff, skb->len),
 761					  skb->len);
 762		txbytes += skb->len;
 763		txpackets++;
 764		stat_maxcq++;
 765		atomic_dec(&skb->users);
 766		dev_kfree_skb_any(skb);
 767	}
 768	if (conn->collect_len > conn->prof.maxmulti)
 769		conn->prof.maxmulti = conn->collect_len;
 770	conn->collect_len = 0;
 771	spin_unlock_irqrestore(&conn->collect_lock, saveflags);
 772	if (conn->tx_buff->len == 0) {
 773		fsm_newstate(fi, CONN_STATE_IDLE);
 774		return;
 775	}
 776
 777	header.next = 0;
 778	memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
 779	conn->prof.send_stamp = current_kernel_time();
 780	txmsg.class = 0;
 781	txmsg.tag = 0;
 782	rc = iucv_message_send(conn->path, &txmsg, 0, 0,
 783			       conn->tx_buff->data, conn->tx_buff->len);
 784	conn->prof.doios_multi++;
 785	conn->prof.txlen += conn->tx_buff->len;
 786	conn->prof.tx_pending++;
 787	if (conn->prof.tx_pending > conn->prof.tx_max_pending)
 788		conn->prof.tx_max_pending = conn->prof.tx_pending;
 789	if (rc) {
 790		conn->prof.tx_pending--;
 791		fsm_newstate(fi, CONN_STATE_IDLE);
 792		if (privptr)
 793			privptr->stats.tx_errors += txpackets;
 794		IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
 795	} else {
 796		if (privptr) {
 797			privptr->stats.tx_packets += txpackets;
 798			privptr->stats.tx_bytes += txbytes;
 799		}
 800		if (stat_maxcq > conn->prof.maxcqueue)
 801			conn->prof.maxcqueue = stat_maxcq;
 802	}
 803}
 804
 
 
 
 
 
 
 
 
 
 
 805static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
 806{
 807	struct iucv_event *ev = arg;
 808	struct iucv_connection *conn = ev->conn;
 809	struct iucv_path *path = ev->data;
 810	struct net_device *netdev = conn->netdev;
 811	struct netiucv_priv *privptr = netdev_priv(netdev);
 812	int rc;
 813
 814	IUCV_DBF_TEXT(trace, 3, __func__);
 815
 816	conn->path = path;
 817	path->msglim = NETIUCV_QUEUELEN_DEFAULT;
 818	path->flags = 0;
 819	rc = iucv_path_accept(path, &netiucv_handler, NULL, conn);
 820	if (rc) {
 821		IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
 822		return;
 823	}
 824	fsm_newstate(fi, CONN_STATE_IDLE);
 825	netdev->tx_queue_len = conn->path->msglim;
 826	fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 827}
 828
 829static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
 830{
 831	struct iucv_event *ev = arg;
 832	struct iucv_path *path = ev->data;
 833
 834	IUCV_DBF_TEXT(trace, 3, __func__);
 835	iucv_path_sever(path, NULL);
 836}
 837
 838static void conn_action_connack(fsm_instance *fi, int event, void *arg)
 839{
 840	struct iucv_connection *conn = arg;
 841	struct net_device *netdev = conn->netdev;
 842	struct netiucv_priv *privptr = netdev_priv(netdev);
 843
 844	IUCV_DBF_TEXT(trace, 3, __func__);
 845	fsm_deltimer(&conn->timer);
 846	fsm_newstate(fi, CONN_STATE_IDLE);
 847	netdev->tx_queue_len = conn->path->msglim;
 848	fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
 849}
 850
 851static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
 852{
 853	struct iucv_connection *conn = arg;
 854
 855	IUCV_DBF_TEXT(trace, 3, __func__);
 856	fsm_deltimer(&conn->timer);
 857	iucv_path_sever(conn->path, NULL);
 858	fsm_newstate(fi, CONN_STATE_STARTWAIT);
 859}
 860
 861static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
 862{
 863	struct iucv_connection *conn = arg;
 864	struct net_device *netdev = conn->netdev;
 865	struct netiucv_priv *privptr = netdev_priv(netdev);
 866
 867	IUCV_DBF_TEXT(trace, 3, __func__);
 868
 869	fsm_deltimer(&conn->timer);
 870	iucv_path_sever(conn->path, NULL);
 871	dev_info(privptr->dev, "The peer interface of the IUCV device"
 872		" has closed the connection\n");
 873	IUCV_DBF_TEXT(data, 2,
 874		      "conn_action_connsever: Remote dropped connection\n");
 875	fsm_newstate(fi, CONN_STATE_STARTWAIT);
 876	fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 877}
 878
 879static void conn_action_start(fsm_instance *fi, int event, void *arg)
 880{
 881	struct iucv_connection *conn = arg;
 882	struct net_device *netdev = conn->netdev;
 883	struct netiucv_priv *privptr = netdev_priv(netdev);
 884	int rc;
 885
 886	IUCV_DBF_TEXT(trace, 3, __func__);
 887
 888	fsm_newstate(fi, CONN_STATE_STARTWAIT);
 889	IUCV_DBF_TEXT_(setup, 2, "%s('%s'): connecting ...\n",
 890		netdev->name, conn->userid);
 891
 892	/*
 893	 * We must set the state before calling iucv_connect because the
 894	 * callback handler could be called at any point after the connection
 895	 * request is sent
 896	 */
 897
 898	fsm_newstate(fi, CONN_STATE_SETUPWAIT);
 899	conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
 
 
 
 900	rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
 901			       NULL, iucvMagic, conn);
 902	switch (rc) {
 903	case 0:
 904		netdev->tx_queue_len = conn->path->msglim;
 905		fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
 906			     CONN_EVENT_TIMER, conn);
 907		return;
 908	case 11:
 909		dev_warn(privptr->dev,
 910			"The IUCV device failed to connect to z/VM guest %s\n",
 911			netiucv_printname(conn->userid));
 912		fsm_newstate(fi, CONN_STATE_STARTWAIT);
 913		break;
 914	case 12:
 915		dev_warn(privptr->dev,
 916			"The IUCV device failed to connect to the peer on z/VM"
 917			" guest %s\n", netiucv_printname(conn->userid));
 918		fsm_newstate(fi, CONN_STATE_STARTWAIT);
 919		break;
 920	case 13:
 921		dev_err(privptr->dev,
 922			"Connecting the IUCV device would exceed the maximum"
 923			" number of IUCV connections\n");
 924		fsm_newstate(fi, CONN_STATE_CONNERR);
 925		break;
 926	case 14:
 927		dev_err(privptr->dev,
 928			"z/VM guest %s has too many IUCV connections"
 929			" to connect with the IUCV device\n",
 930			netiucv_printname(conn->userid));
 931		fsm_newstate(fi, CONN_STATE_CONNERR);
 932		break;
 933	case 15:
 934		dev_err(privptr->dev,
 935			"The IUCV device cannot connect to a z/VM guest with no"
 936			" IUCV authorization\n");
 937		fsm_newstate(fi, CONN_STATE_CONNERR);
 938		break;
 939	default:
 940		dev_err(privptr->dev,
 941			"Connecting the IUCV device failed with error %d\n",
 942			rc);
 943		fsm_newstate(fi, CONN_STATE_CONNERR);
 944		break;
 945	}
 946	IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
 947	kfree(conn->path);
 948	conn->path = NULL;
 949}
 950
 951static void netiucv_purge_skb_queue(struct sk_buff_head *q)
 952{
 953	struct sk_buff *skb;
 954
 955	while ((skb = skb_dequeue(q))) {
 956		atomic_dec(&skb->users);
 957		dev_kfree_skb_any(skb);
 958	}
 959}
 960
 961static void conn_action_stop(fsm_instance *fi, int event, void *arg)
 962{
 963	struct iucv_event *ev = arg;
 964	struct iucv_connection *conn = ev->conn;
 965	struct net_device *netdev = conn->netdev;
 966	struct netiucv_priv *privptr = netdev_priv(netdev);
 967
 968	IUCV_DBF_TEXT(trace, 3, __func__);
 969
 970	fsm_deltimer(&conn->timer);
 971	fsm_newstate(fi, CONN_STATE_STOPPED);
 972	netiucv_purge_skb_queue(&conn->collect_queue);
 973	if (conn->path) {
 974		IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
 975		iucv_path_sever(conn->path, iucvMagic);
 976		kfree(conn->path);
 977		conn->path = NULL;
 978	}
 979	netiucv_purge_skb_queue(&conn->commit_queue);
 980	fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
 981}
 982
 983static void conn_action_inval(fsm_instance *fi, int event, void *arg)
 984{
 985	struct iucv_connection *conn = arg;
 986	struct net_device *netdev = conn->netdev;
 987
 988	IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
 989		netdev->name, conn->userid);
 990}
 991
 992static const fsm_node conn_fsm[] = {
 993	{ CONN_STATE_INVALID,   CONN_EVENT_START,    conn_action_inval      },
 994	{ CONN_STATE_STOPPED,   CONN_EVENT_START,    conn_action_start      },
 995
 996	{ CONN_STATE_STOPPED,   CONN_EVENT_STOP,     conn_action_stop       },
 997	{ CONN_STATE_STARTWAIT, CONN_EVENT_STOP,     conn_action_stop       },
 998	{ CONN_STATE_SETUPWAIT, CONN_EVENT_STOP,     conn_action_stop       },
 999	{ CONN_STATE_IDLE,      CONN_EVENT_STOP,     conn_action_stop       },
1000	{ CONN_STATE_TX,        CONN_EVENT_STOP,     conn_action_stop       },
1001	{ CONN_STATE_REGERR,    CONN_EVENT_STOP,     conn_action_stop       },
1002	{ CONN_STATE_CONNERR,   CONN_EVENT_STOP,     conn_action_stop       },
1003
1004	{ CONN_STATE_STOPPED,   CONN_EVENT_CONN_REQ, conn_action_connreject },
1005        { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1006	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
1007	{ CONN_STATE_IDLE,      CONN_EVENT_CONN_REQ, conn_action_connreject },
1008	{ CONN_STATE_TX,        CONN_EVENT_CONN_REQ, conn_action_connreject },
1009
1010	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack    },
1011	{ CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER,    conn_action_conntimsev },
1012
1013	{ CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever  },
1014	{ CONN_STATE_IDLE,      CONN_EVENT_CONN_REJ, conn_action_connsever  },
1015	{ CONN_STATE_TX,        CONN_EVENT_CONN_REJ, conn_action_connsever  },
1016
1017	{ CONN_STATE_IDLE,      CONN_EVENT_RX,       conn_action_rx         },
1018	{ CONN_STATE_TX,        CONN_EVENT_RX,       conn_action_rx         },
1019
1020	{ CONN_STATE_TX,        CONN_EVENT_TXDONE,   conn_action_txdone     },
1021	{ CONN_STATE_IDLE,      CONN_EVENT_TXDONE,   conn_action_txdone     },
1022};
1023
1024static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
1025
1026
1027/*
1028 * Actions for interface - statemachine.
1029 */
1030
1031/**
1032 * dev_action_start
1033 * @fi: An instance of an interface statemachine.
1034 * @event: The event, just happened.
1035 * @arg: Generic pointer, casted from struct net_device * upon call.
1036 *
1037 * Startup connection by sending CONN_EVENT_START to it.
1038 */
1039static void dev_action_start(fsm_instance *fi, int event, void *arg)
1040{
1041	struct net_device   *dev = arg;
1042	struct netiucv_priv *privptr = netdev_priv(dev);
1043
1044	IUCV_DBF_TEXT(trace, 3, __func__);
1045
1046	fsm_newstate(fi, DEV_STATE_STARTWAIT);
1047	fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
1048}
1049
1050/**
1051 * Shutdown connection by sending CONN_EVENT_STOP to it.
1052 *
1053 * @param fi    An instance of an interface statemachine.
1054 * @param event The event, just happened.
1055 * @param arg   Generic pointer, casted from struct net_device * upon call.
1056 */
1057static void
1058dev_action_stop(fsm_instance *fi, int event, void *arg)
1059{
1060	struct net_device   *dev = arg;
1061	struct netiucv_priv *privptr = netdev_priv(dev);
1062	struct iucv_event   ev;
1063
1064	IUCV_DBF_TEXT(trace, 3, __func__);
1065
1066	ev.conn = privptr->conn;
1067
1068	fsm_newstate(fi, DEV_STATE_STOPWAIT);
1069	fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
1070}
1071
1072/**
1073 * Called from connection statemachine
1074 * when a connection is up and running.
1075 *
1076 * @param fi    An instance of an interface statemachine.
1077 * @param event The event, just happened.
1078 * @param arg   Generic pointer, casted from struct net_device * upon call.
1079 */
1080static void
1081dev_action_connup(fsm_instance *fi, int event, void *arg)
1082{
1083	struct net_device   *dev = arg;
1084	struct netiucv_priv *privptr = netdev_priv(dev);
1085
1086	IUCV_DBF_TEXT(trace, 3, __func__);
1087
1088	switch (fsm_getstate(fi)) {
1089		case DEV_STATE_STARTWAIT:
1090			fsm_newstate(fi, DEV_STATE_RUNNING);
1091			dev_info(privptr->dev,
1092				"The IUCV device has been connected"
1093				" successfully to %s\n", privptr->conn->userid);
 
1094			IUCV_DBF_TEXT(setup, 3,
1095				"connection is up and running\n");
1096			break;
1097		case DEV_STATE_STOPWAIT:
1098			IUCV_DBF_TEXT(data, 2,
1099				"dev_action_connup: in DEV_STATE_STOPWAIT\n");
1100			break;
1101	}
1102}
1103
1104/**
1105 * Called from connection statemachine
1106 * when a connection has been shutdown.
1107 *
1108 * @param fi    An instance of an interface statemachine.
1109 * @param event The event, just happened.
1110 * @param arg   Generic pointer, casted from struct net_device * upon call.
1111 */
1112static void
1113dev_action_conndown(fsm_instance *fi, int event, void *arg)
1114{
1115	IUCV_DBF_TEXT(trace, 3, __func__);
1116
1117	switch (fsm_getstate(fi)) {
1118		case DEV_STATE_RUNNING:
1119			fsm_newstate(fi, DEV_STATE_STARTWAIT);
1120			break;
1121		case DEV_STATE_STOPWAIT:
1122			fsm_newstate(fi, DEV_STATE_STOPPED);
1123			IUCV_DBF_TEXT(setup, 3, "connection is down\n");
1124			break;
1125	}
1126}
1127
1128static const fsm_node dev_fsm[] = {
1129	{ DEV_STATE_STOPPED,    DEV_EVENT_START,   dev_action_start    },
1130
1131	{ DEV_STATE_STOPWAIT,   DEV_EVENT_START,   dev_action_start    },
1132	{ DEV_STATE_STOPWAIT,   DEV_EVENT_CONDOWN, dev_action_conndown },
1133
1134	{ DEV_STATE_STARTWAIT,  DEV_EVENT_STOP,    dev_action_stop     },
1135	{ DEV_STATE_STARTWAIT,  DEV_EVENT_CONUP,   dev_action_connup   },
1136
1137	{ DEV_STATE_RUNNING,    DEV_EVENT_STOP,    dev_action_stop     },
1138	{ DEV_STATE_RUNNING,    DEV_EVENT_CONDOWN, dev_action_conndown },
1139	{ DEV_STATE_RUNNING,    DEV_EVENT_CONUP,   netiucv_action_nop  },
1140};
1141
1142static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
1143
1144/**
1145 * Transmit a packet.
1146 * This is a helper function for netiucv_tx().
1147 *
1148 * @param conn Connection to be used for sending.
1149 * @param skb Pointer to struct sk_buff of packet to send.
1150 *            The linklevel header has already been set up
1151 *            by netiucv_tx().
1152 *
1153 * @return 0 on success, -ERRNO on failure. (Never fails.)
1154 */
1155static int netiucv_transmit_skb(struct iucv_connection *conn,
1156				struct sk_buff *skb)
1157{
1158	struct iucv_message msg;
1159	unsigned long saveflags;
1160	struct ll_header header;
1161	int rc;
1162
1163	if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
1164		int l = skb->len + NETIUCV_HDRLEN;
1165
1166		spin_lock_irqsave(&conn->collect_lock, saveflags);
1167		if (conn->collect_len + l >
1168		    (conn->max_buffsize - NETIUCV_HDRLEN)) {
1169			rc = -EBUSY;
1170			IUCV_DBF_TEXT(data, 2,
1171				      "EBUSY from netiucv_transmit_skb\n");
1172		} else {
1173			atomic_inc(&skb->users);
1174			skb_queue_tail(&conn->collect_queue, skb);
1175			conn->collect_len += l;
1176			rc = 0;
1177		}
1178		spin_unlock_irqrestore(&conn->collect_lock, saveflags);
1179	} else {
1180		struct sk_buff *nskb = skb;
1181		/**
1182		 * Copy the skb to a new allocated skb in lowmem only if the
1183		 * data is located above 2G in memory or tailroom is < 2.
1184		 */
1185		unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
1186				    NETIUCV_HDRLEN)) >> 31;
1187		int copied = 0;
1188		if (hi || (skb_tailroom(skb) < 2)) {
1189			nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
1190					 NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
1191			if (!nskb) {
1192				IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
1193				rc = -ENOMEM;
1194				return rc;
1195			} else {
1196				skb_reserve(nskb, NETIUCV_HDRLEN);
1197				memcpy(skb_put(nskb, skb->len),
1198				       skb->data, skb->len);
1199			}
1200			copied = 1;
1201		}
1202		/**
1203		 * skb now is below 2G and has enough room. Add headers.
1204		 */
1205		header.next = nskb->len + NETIUCV_HDRLEN;
1206		memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
1207		header.next = 0;
1208		memcpy(skb_put(nskb, NETIUCV_HDRLEN), &header,  NETIUCV_HDRLEN);
1209
1210		fsm_newstate(conn->fsm, CONN_STATE_TX);
1211		conn->prof.send_stamp = current_kernel_time();
1212
1213		msg.tag = 1;
1214		msg.class = 0;
1215		rc = iucv_message_send(conn->path, &msg, 0, 0,
1216				       nskb->data, nskb->len);
1217		conn->prof.doios_single++;
1218		conn->prof.txlen += skb->len;
1219		conn->prof.tx_pending++;
1220		if (conn->prof.tx_pending > conn->prof.tx_max_pending)
1221			conn->prof.tx_max_pending = conn->prof.tx_pending;
1222		if (rc) {
1223			struct netiucv_priv *privptr;
1224			fsm_newstate(conn->fsm, CONN_STATE_IDLE);
1225			conn->prof.tx_pending--;
1226			privptr = netdev_priv(conn->netdev);
1227			if (privptr)
1228				privptr->stats.tx_errors++;
1229			if (copied)
1230				dev_kfree_skb(nskb);
1231			else {
1232				/**
1233				 * Remove our headers. They get added
1234				 * again on retransmit.
1235				 */
1236				skb_pull(skb, NETIUCV_HDRLEN);
1237				skb_trim(skb, skb->len - NETIUCV_HDRLEN);
1238			}
1239			IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
1240		} else {
1241			if (copied)
1242				dev_kfree_skb(skb);
1243			atomic_inc(&nskb->users);
1244			skb_queue_tail(&conn->commit_queue, nskb);
1245		}
1246	}
1247
1248	return rc;
1249}
1250
1251/*
1252 * Interface API for upper network layers
1253 */
1254
1255/**
1256 * Open an interface.
1257 * Called from generic network layer when ifconfig up is run.
1258 *
1259 * @param dev Pointer to interface struct.
1260 *
1261 * @return 0 on success, -ERRNO on failure. (Never fails.)
1262 */
1263static int netiucv_open(struct net_device *dev)
1264{
1265	struct netiucv_priv *priv = netdev_priv(dev);
1266
1267	fsm_event(priv->fsm, DEV_EVENT_START, dev);
1268	return 0;
1269}
1270
1271/**
1272 * Close an interface.
1273 * Called from generic network layer when ifconfig down is run.
1274 *
1275 * @param dev Pointer to interface struct.
1276 *
1277 * @return 0 on success, -ERRNO on failure. (Never fails.)
1278 */
1279static int netiucv_close(struct net_device *dev)
1280{
1281	struct netiucv_priv *priv = netdev_priv(dev);
1282
1283	fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
1284	return 0;
1285}
1286
1287static int netiucv_pm_prepare(struct device *dev)
1288{
1289	IUCV_DBF_TEXT(trace, 3, __func__);
1290	return 0;
1291}
1292
1293static void netiucv_pm_complete(struct device *dev)
1294{
1295	IUCV_DBF_TEXT(trace, 3, __func__);
1296	return;
1297}
1298
1299/**
1300 * netiucv_pm_freeze() - Freeze PM callback
1301 * @dev:	netiucv device
1302 *
1303 * close open netiucv interfaces
1304 */
1305static int netiucv_pm_freeze(struct device *dev)
1306{
1307	struct netiucv_priv *priv = dev_get_drvdata(dev);
1308	struct net_device *ndev = NULL;
1309	int rc = 0;
1310
1311	IUCV_DBF_TEXT(trace, 3, __func__);
1312	if (priv && priv->conn)
1313		ndev = priv->conn->netdev;
1314	if (!ndev)
1315		goto out;
1316	netif_device_detach(ndev);
1317	priv->pm_state = fsm_getstate(priv->fsm);
1318	rc = netiucv_close(ndev);
1319out:
1320	return rc;
1321}
1322
1323/**
1324 * netiucv_pm_restore_thaw() - Thaw and restore PM callback
1325 * @dev:	netiucv device
1326 *
1327 * re-open netiucv interfaces closed during freeze
1328 */
1329static int netiucv_pm_restore_thaw(struct device *dev)
1330{
1331	struct netiucv_priv *priv = dev_get_drvdata(dev);
1332	struct net_device *ndev = NULL;
1333	int rc = 0;
1334
1335	IUCV_DBF_TEXT(trace, 3, __func__);
1336	if (priv && priv->conn)
1337		ndev = priv->conn->netdev;
1338	if (!ndev)
1339		goto out;
1340	switch (priv->pm_state) {
1341	case DEV_STATE_RUNNING:
1342	case DEV_STATE_STARTWAIT:
1343		rc = netiucv_open(ndev);
1344		break;
1345	default:
1346		break;
1347	}
1348	netif_device_attach(ndev);
1349out:
1350	return rc;
1351}
1352
1353/**
1354 * Start transmission of a packet.
1355 * Called from generic network device layer.
1356 *
1357 * @param skb Pointer to buffer containing the packet.
1358 * @param dev Pointer to interface struct.
1359 *
1360 * @return 0 if packet consumed, !0 if packet rejected.
1361 *         Note: If we return !0, then the packet is free'd by
1362 *               the generic network layer.
1363 */
1364static int netiucv_tx(struct sk_buff *skb, struct net_device *dev)
1365{
1366	struct netiucv_priv *privptr = netdev_priv(dev);
1367	int rc;
1368
1369	IUCV_DBF_TEXT(trace, 4, __func__);
1370	/**
1371	 * Some sanity checks ...
1372	 */
1373	if (skb == NULL) {
1374		IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
1375		privptr->stats.tx_dropped++;
1376		return NETDEV_TX_OK;
1377	}
1378	if (skb_headroom(skb) < NETIUCV_HDRLEN) {
1379		IUCV_DBF_TEXT(data, 2,
1380			"netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
1381		dev_kfree_skb(skb);
1382		privptr->stats.tx_dropped++;
1383		return NETDEV_TX_OK;
1384	}
1385
1386	/**
1387	 * If connection is not running, try to restart it
1388	 * and throw away packet.
1389	 */
1390	if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
1391		dev_kfree_skb(skb);
1392		privptr->stats.tx_dropped++;
1393		privptr->stats.tx_errors++;
1394		privptr->stats.tx_carrier_errors++;
1395		return NETDEV_TX_OK;
1396	}
1397
1398	if (netiucv_test_and_set_busy(dev)) {
1399		IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
1400		return NETDEV_TX_BUSY;
1401	}
1402	dev->trans_start = jiffies;
1403	rc = netiucv_transmit_skb(privptr->conn, skb);
1404	netiucv_clear_busy(dev);
1405	return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
1406}
1407
1408/**
1409 * netiucv_stats
1410 * @dev: Pointer to interface struct.
1411 *
1412 * Returns interface statistics of a device.
1413 *
1414 * Returns pointer to stats struct of this interface.
1415 */
1416static struct net_device_stats *netiucv_stats (struct net_device * dev)
1417{
1418	struct netiucv_priv *priv = netdev_priv(dev);
1419
1420	IUCV_DBF_TEXT(trace, 5, __func__);
1421	return &priv->stats;
1422}
1423
1424/**
1425 * netiucv_change_mtu
1426 * @dev: Pointer to interface struct.
1427 * @new_mtu: The new MTU to use for this interface.
1428 *
1429 * Sets MTU of an interface.
1430 *
1431 * Returns 0 on success, -EINVAL if MTU is out of valid range.
1432 *         (valid range is 576 .. NETIUCV_MTU_MAX).
1433 */
1434static int netiucv_change_mtu(struct net_device * dev, int new_mtu)
1435{
1436	IUCV_DBF_TEXT(trace, 3, __func__);
1437	if (new_mtu < 576 || new_mtu > NETIUCV_MTU_MAX) {
1438		IUCV_DBF_TEXT(setup, 2, "given MTU out of valid range\n");
1439		return -EINVAL;
1440	}
1441	dev->mtu = new_mtu;
1442	return 0;
1443}
1444
1445/*
1446 * attributes in sysfs
1447 */
1448
1449static ssize_t user_show(struct device *dev, struct device_attribute *attr,
1450			 char *buf)
1451{
1452	struct netiucv_priv *priv = dev_get_drvdata(dev);
1453
1454	IUCV_DBF_TEXT(trace, 5, __func__);
1455	return sprintf(buf, "%s\n", netiucv_printname(priv->conn->userid));
1456}
1457
1458static ssize_t user_write(struct device *dev, struct device_attribute *attr,
1459			  const char *buf, size_t count)
1460{
1461	struct netiucv_priv *priv = dev_get_drvdata(dev);
1462	struct net_device *ndev = priv->conn->netdev;
1463	char    *p;
1464	char    *tmp;
1465	char 	username[9];
1466	int 	i;
1467	struct iucv_connection *cp;
1468
1469	IUCV_DBF_TEXT(trace, 3, __func__);
1470	if (count > 9) {
1471		IUCV_DBF_TEXT_(setup, 2,
1472			       "%d is length of username\n", (int) count);
 
 
1473		return -EINVAL;
1474	}
1475
1476	tmp = strsep((char **) &buf, "\n");
1477	for (i = 0, p = tmp; i < 8 && *p; i++, p++) {
1478		if (isalnum(*p) || (*p == '$')) {
1479			username[i]= toupper(*p);
1480			continue;
1481		}
1482		if (*p == '\n') {
1483			/* trailing lf, grr */
1484			break;
1485		}
1486		IUCV_DBF_TEXT_(setup, 2,
1487			       "username: invalid character %c\n", *p);
1488		return -EINVAL;
1489	}
1490	while (i < 8)
1491		username[i++] = ' ';
1492	username[8] = '\0';
1493
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1494	if (memcmp(username, priv->conn->userid, 9) &&
1495	    (ndev->flags & (IFF_UP | IFF_RUNNING))) {
1496		/* username changed while the interface is active. */
1497		IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
1498		return -EPERM;
1499	}
1500	read_lock_bh(&iucv_connection_rwlock);
1501	list_for_each_entry(cp, &iucv_connection_list, list) {
1502		if (!strncmp(username, cp->userid, 9) && cp->netdev != ndev) {
 
1503			read_unlock_bh(&iucv_connection_rwlock);
1504			IUCV_DBF_TEXT_(setup, 2, "user_write: Connection "
1505				"to %s already exists\n", username);
1506			return -EEXIST;
1507		}
1508	}
1509	read_unlock_bh(&iucv_connection_rwlock);
1510	memcpy(priv->conn->userid, username, 9);
 
1511	return count;
1512}
1513
1514static DEVICE_ATTR(user, 0644, user_show, user_write);
1515
1516static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
1517			    char *buf)
1518{
1519	struct netiucv_priv *priv = dev_get_drvdata(dev);
1520
1521	IUCV_DBF_TEXT(trace, 5, __func__);
1522	return sprintf(buf, "%d\n", priv->conn->max_buffsize);
1523}
1524
1525static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
1526			     const char *buf, size_t count)
1527{
1528	struct netiucv_priv *priv = dev_get_drvdata(dev);
1529	struct net_device *ndev = priv->conn->netdev;
1530	char         *e;
1531	int          bs1;
1532
1533	IUCV_DBF_TEXT(trace, 3, __func__);
1534	if (count >= 39)
1535		return -EINVAL;
1536
1537	bs1 = simple_strtoul(buf, &e, 0);
1538
1539	if (e && (!isspace(*e))) {
1540		IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %c\n", *e);
 
1541		return -EINVAL;
1542	}
1543	if (bs1 > NETIUCV_BUFSIZE_MAX) {
1544		IUCV_DBF_TEXT_(setup, 2,
1545			"buffer_write: buffer size %d too large\n",
1546			bs1);
1547		return -EINVAL;
1548	}
1549	if ((ndev->flags & IFF_RUNNING) &&
1550	    (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
1551		IUCV_DBF_TEXT_(setup, 2,
1552			"buffer_write: buffer size %d too small\n",
1553			bs1);
1554		return -EINVAL;
1555	}
1556	if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
1557		IUCV_DBF_TEXT_(setup, 2,
1558			"buffer_write: buffer size %d too small\n",
1559			bs1);
1560		return -EINVAL;
1561	}
1562
1563	priv->conn->max_buffsize = bs1;
1564	if (!(ndev->flags & IFF_RUNNING))
1565		ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
1566
1567	return count;
1568
1569}
1570
1571static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1572
1573static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
1574			     char *buf)
1575{
1576	struct netiucv_priv *priv = dev_get_drvdata(dev);
1577
1578	IUCV_DBF_TEXT(trace, 5, __func__);
1579	return sprintf(buf, "%s\n", fsm_getstate_str(priv->fsm));
1580}
1581
1582static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1583
1584static ssize_t conn_fsm_show (struct device *dev,
1585			      struct device_attribute *attr, char *buf)
1586{
1587	struct netiucv_priv *priv = dev_get_drvdata(dev);
1588
1589	IUCV_DBF_TEXT(trace, 5, __func__);
1590	return sprintf(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
1591}
1592
1593static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1594
1595static ssize_t maxmulti_show (struct device *dev,
1596			      struct device_attribute *attr, char *buf)
1597{
1598	struct netiucv_priv *priv = dev_get_drvdata(dev);
1599
1600	IUCV_DBF_TEXT(trace, 5, __func__);
1601	return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
1602}
1603
1604static ssize_t maxmulti_write (struct device *dev,
1605			       struct device_attribute *attr,
1606			       const char *buf, size_t count)
1607{
1608	struct netiucv_priv *priv = dev_get_drvdata(dev);
1609
1610	IUCV_DBF_TEXT(trace, 4, __func__);
1611	priv->conn->prof.maxmulti = 0;
1612	return count;
1613}
1614
1615static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1616
1617static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
1618			   char *buf)
1619{
1620	struct netiucv_priv *priv = dev_get_drvdata(dev);
1621
1622	IUCV_DBF_TEXT(trace, 5, __func__);
1623	return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
1624}
1625
1626static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
1627			    const char *buf, size_t count)
1628{
1629	struct netiucv_priv *priv = dev_get_drvdata(dev);
1630
1631	IUCV_DBF_TEXT(trace, 4, __func__);
1632	priv->conn->prof.maxcqueue = 0;
1633	return count;
1634}
1635
1636static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1637
1638static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
1639			   char *buf)
1640{
1641	struct netiucv_priv *priv = dev_get_drvdata(dev);
1642
1643	IUCV_DBF_TEXT(trace, 5, __func__);
1644	return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
1645}
1646
1647static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
1648			    const char *buf, size_t count)
1649{
1650	struct netiucv_priv *priv = dev_get_drvdata(dev);
1651
1652	IUCV_DBF_TEXT(trace, 4, __func__);
1653	priv->conn->prof.doios_single = 0;
1654	return count;
1655}
1656
1657static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1658
1659static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
1660			   char *buf)
1661{
1662	struct netiucv_priv *priv = dev_get_drvdata(dev);
1663
1664	IUCV_DBF_TEXT(trace, 5, __func__);
1665	return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
1666}
1667
1668static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
1669			    const char *buf, size_t count)
1670{
1671	struct netiucv_priv *priv = dev_get_drvdata(dev);
1672
1673	IUCV_DBF_TEXT(trace, 5, __func__);
1674	priv->conn->prof.doios_multi = 0;
1675	return count;
1676}
1677
1678static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1679
1680static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
1681			   char *buf)
1682{
1683	struct netiucv_priv *priv = dev_get_drvdata(dev);
1684
1685	IUCV_DBF_TEXT(trace, 5, __func__);
1686	return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
1687}
1688
1689static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
1690			    const char *buf, size_t count)
1691{
1692	struct netiucv_priv *priv = dev_get_drvdata(dev);
1693
1694	IUCV_DBF_TEXT(trace, 4, __func__);
1695	priv->conn->prof.txlen = 0;
1696	return count;
1697}
1698
1699static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1700
1701static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
1702			    char *buf)
1703{
1704	struct netiucv_priv *priv = dev_get_drvdata(dev);
1705
1706	IUCV_DBF_TEXT(trace, 5, __func__);
1707	return sprintf(buf, "%ld\n", priv->conn->prof.tx_time);
1708}
1709
1710static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
1711			     const char *buf, size_t count)
1712{
1713	struct netiucv_priv *priv = dev_get_drvdata(dev);
1714
1715	IUCV_DBF_TEXT(trace, 4, __func__);
1716	priv->conn->prof.tx_time = 0;
1717	return count;
1718}
1719
1720static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1721
1722static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
1723			    char *buf)
1724{
1725	struct netiucv_priv *priv = dev_get_drvdata(dev);
1726
1727	IUCV_DBF_TEXT(trace, 5, __func__);
1728	return sprintf(buf, "%ld\n", priv->conn->prof.tx_pending);
1729}
1730
1731static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
1732			     const char *buf, size_t count)
1733{
1734	struct netiucv_priv *priv = dev_get_drvdata(dev);
1735
1736	IUCV_DBF_TEXT(trace, 4, __func__);
1737	priv->conn->prof.tx_pending = 0;
1738	return count;
1739}
1740
1741static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1742
1743static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
1744			    char *buf)
1745{
1746	struct netiucv_priv *priv = dev_get_drvdata(dev);
1747
1748	IUCV_DBF_TEXT(trace, 5, __func__);
1749	return sprintf(buf, "%ld\n", priv->conn->prof.tx_max_pending);
1750}
1751
1752static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
1753			     const char *buf, size_t count)
1754{
1755	struct netiucv_priv *priv = dev_get_drvdata(dev);
1756
1757	IUCV_DBF_TEXT(trace, 4, __func__);
1758	priv->conn->prof.tx_max_pending = 0;
1759	return count;
1760}
1761
1762static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1763
1764static struct attribute *netiucv_attrs[] = {
1765	&dev_attr_buffer.attr,
1766	&dev_attr_user.attr,
1767	NULL,
1768};
1769
1770static struct attribute_group netiucv_attr_group = {
1771	.attrs = netiucv_attrs,
1772};
1773
1774static struct attribute *netiucv_stat_attrs[] = {
1775	&dev_attr_device_fsm_state.attr,
1776	&dev_attr_connection_fsm_state.attr,
1777	&dev_attr_max_tx_buffer_used.attr,
1778	&dev_attr_max_chained_skbs.attr,
1779	&dev_attr_tx_single_write_ops.attr,
1780	&dev_attr_tx_multi_write_ops.attr,
1781	&dev_attr_netto_bytes.attr,
1782	&dev_attr_max_tx_io_time.attr,
1783	&dev_attr_tx_pending.attr,
1784	&dev_attr_tx_max_pending.attr,
1785	NULL,
1786};
1787
1788static struct attribute_group netiucv_stat_attr_group = {
1789	.name  = "stats",
1790	.attrs = netiucv_stat_attrs,
1791};
1792
1793static int netiucv_add_files(struct device *dev)
1794{
1795	int ret;
1796
1797	IUCV_DBF_TEXT(trace, 3, __func__);
1798	ret = sysfs_create_group(&dev->kobj, &netiucv_attr_group);
1799	if (ret)
1800		return ret;
1801	ret = sysfs_create_group(&dev->kobj, &netiucv_stat_attr_group);
1802	if (ret)
1803		sysfs_remove_group(&dev->kobj, &netiucv_attr_group);
1804	return ret;
1805}
1806
1807static void netiucv_remove_files(struct device *dev)
1808{
1809	IUCV_DBF_TEXT(trace, 3, __func__);
1810	sysfs_remove_group(&dev->kobj, &netiucv_stat_attr_group);
1811	sysfs_remove_group(&dev->kobj, &netiucv_attr_group);
1812}
1813
1814static int netiucv_register_device(struct net_device *ndev)
1815{
1816	struct netiucv_priv *priv = netdev_priv(ndev);
1817	struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1818	int ret;
1819
1820	IUCV_DBF_TEXT(trace, 3, __func__);
1821
1822	if (dev) {
1823		dev_set_name(dev, "net%s", ndev->name);
1824		dev->bus = &iucv_bus;
1825		dev->parent = iucv_root;
1826		/*
1827		 * The release function could be called after the
1828		 * module has been unloaded. It's _only_ task is to
1829		 * free the struct. Therefore, we specify kfree()
1830		 * directly here. (Probably a little bit obfuscating
1831		 * but legitime ...).
1832		 */
1833		dev->release = (void (*)(struct device *))kfree;
1834		dev->driver = &netiucv_driver;
1835	} else
1836		return -ENOMEM;
1837
1838	ret = device_register(dev);
1839	if (ret) {
1840		put_device(dev);
1841		return ret;
1842	}
1843	ret = netiucv_add_files(dev);
1844	if (ret)
1845		goto out_unreg;
1846	priv->dev = dev;
1847	dev_set_drvdata(dev, priv);
1848	return 0;
1849
1850out_unreg:
1851	device_unregister(dev);
1852	return ret;
1853}
1854
1855static void netiucv_unregister_device(struct device *dev)
1856{
1857	IUCV_DBF_TEXT(trace, 3, __func__);
1858	netiucv_remove_files(dev);
1859	device_unregister(dev);
1860}
1861
1862/**
1863 * Allocate and initialize a new connection structure.
1864 * Add it to the list of netiucv connections;
1865 */
1866static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
1867						      char *username)
 
1868{
1869	struct iucv_connection *conn;
1870
1871	conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1872	if (!conn)
1873		goto out;
1874	skb_queue_head_init(&conn->collect_queue);
1875	skb_queue_head_init(&conn->commit_queue);
1876	spin_lock_init(&conn->collect_lock);
1877	conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1878	conn->netdev = dev;
1879
1880	conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1881	if (!conn->rx_buff)
1882		goto out_conn;
1883	conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
1884	if (!conn->tx_buff)
1885		goto out_rx;
1886	conn->fsm = init_fsm("netiucvconn", conn_state_names,
1887			     conn_event_names, NR_CONN_STATES,
1888			     NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1889			     GFP_KERNEL);
1890	if (!conn->fsm)
1891		goto out_tx;
1892
1893	fsm_settimer(conn->fsm, &conn->timer);
1894	fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1895
 
 
1896	if (username) {
1897		memcpy(conn->userid, username, 9);
1898		fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1899	}
1900
1901	write_lock_bh(&iucv_connection_rwlock);
1902	list_add_tail(&conn->list, &iucv_connection_list);
1903	write_unlock_bh(&iucv_connection_rwlock);
1904	return conn;
1905
1906out_tx:
1907	kfree_skb(conn->tx_buff);
1908out_rx:
1909	kfree_skb(conn->rx_buff);
1910out_conn:
1911	kfree(conn);
1912out:
1913	return NULL;
1914}
1915
1916/**
1917 * Release a connection structure and remove it from the
1918 * list of netiucv connections.
1919 */
1920static void netiucv_remove_connection(struct iucv_connection *conn)
1921{
 
1922	IUCV_DBF_TEXT(trace, 3, __func__);
1923	write_lock_bh(&iucv_connection_rwlock);
1924	list_del_init(&conn->list);
1925	write_unlock_bh(&iucv_connection_rwlock);
1926	fsm_deltimer(&conn->timer);
1927	netiucv_purge_skb_queue(&conn->collect_queue);
1928	if (conn->path) {
1929		iucv_path_sever(conn->path, iucvMagic);
1930		kfree(conn->path);
1931		conn->path = NULL;
1932	}
1933	netiucv_purge_skb_queue(&conn->commit_queue);
1934	kfree_fsm(conn->fsm);
1935	kfree_skb(conn->rx_buff);
1936	kfree_skb(conn->tx_buff);
1937}
1938
1939/**
1940 * Release everything of a net device.
1941 */
1942static void netiucv_free_netdevice(struct net_device *dev)
1943{
1944	struct netiucv_priv *privptr = netdev_priv(dev);
1945
1946	IUCV_DBF_TEXT(trace, 3, __func__);
1947
1948	if (!dev)
1949		return;
1950
1951	if (privptr) {
1952		if (privptr->conn)
1953			netiucv_remove_connection(privptr->conn);
1954		if (privptr->fsm)
1955			kfree_fsm(privptr->fsm);
1956		privptr->conn = NULL; privptr->fsm = NULL;
1957		/* privptr gets freed by free_netdev() */
1958	}
1959	free_netdev(dev);
1960}
1961
1962/**
1963 * Initialize a net device. (Called from kernel in alloc_netdev())
1964 */
1965static const struct net_device_ops netiucv_netdev_ops = {
1966	.ndo_open		= netiucv_open,
1967	.ndo_stop		= netiucv_close,
1968	.ndo_get_stats		= netiucv_stats,
1969	.ndo_start_xmit		= netiucv_tx,
1970	.ndo_change_mtu	   	= netiucv_change_mtu,
1971};
1972
1973static void netiucv_setup_netdevice(struct net_device *dev)
1974{
1975	dev->mtu	         = NETIUCV_MTU_DEFAULT;
1976	dev->destructor          = netiucv_free_netdevice;
 
 
 
1977	dev->hard_header_len     = NETIUCV_HDRLEN;
1978	dev->addr_len            = 0;
1979	dev->type                = ARPHRD_SLIP;
1980	dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
1981	dev->flags	         = IFF_POINTOPOINT | IFF_NOARP;
1982	dev->netdev_ops		 = &netiucv_netdev_ops;
1983}
1984
1985/**
1986 * Allocate and initialize everything of a net device.
1987 */
1988static struct net_device *netiucv_init_netdevice(char *username)
1989{
1990	struct netiucv_priv *privptr;
1991	struct net_device *dev;
1992
1993	dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
1994			   netiucv_setup_netdevice);
1995	if (!dev)
1996		return NULL;
 
 
 
1997
1998	privptr = netdev_priv(dev);
1999	privptr->fsm = init_fsm("netiucvdev", dev_state_names,
2000				dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
2001				dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
2002	if (!privptr->fsm)
2003		goto out_netdev;
2004
2005	privptr->conn = netiucv_new_connection(dev, username);
2006	if (!privptr->conn) {
2007		IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
2008		goto out_fsm;
2009	}
2010	fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
2011	return dev;
2012
2013out_fsm:
2014	kfree_fsm(privptr->fsm);
2015out_netdev:
 
2016	free_netdev(dev);
2017	return NULL;
2018}
2019
2020static ssize_t conn_write(struct device_driver *drv,
2021			  const char *buf, size_t count)
2022{
2023	const char *p;
2024	char username[9];
2025	int i, rc;
 
2026	struct net_device *dev;
2027	struct netiucv_priv *priv;
2028	struct iucv_connection *cp;
2029
2030	IUCV_DBF_TEXT(trace, 3, __func__);
2031	if (count>9) {
2032		IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
2033		return -EINVAL;
2034	}
2035
2036	for (i = 0, p = buf; i < 8 && *p; i++, p++) {
2037		if (isalnum(*p) || *p == '$') {
2038			username[i] = toupper(*p);
2039			continue;
2040		}
2041		if (*p == '\n')
2042			/* trailing lf, grr */
2043			break;
2044		IUCV_DBF_TEXT_(setup, 2,
2045			       "conn_write: invalid character %c\n", *p);
2046		return -EINVAL;
2047	}
2048	while (i < 8)
2049		username[i++] = ' ';
2050	username[8] = '\0';
2051
2052	read_lock_bh(&iucv_connection_rwlock);
2053	list_for_each_entry(cp, &iucv_connection_list, list) {
2054		if (!strncmp(username, cp->userid, 9)) {
 
2055			read_unlock_bh(&iucv_connection_rwlock);
2056			IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection "
2057				"to %s already exists\n", username);
2058			return -EEXIST;
2059		}
2060	}
2061	read_unlock_bh(&iucv_connection_rwlock);
2062
2063	dev = netiucv_init_netdevice(username);
2064	if (!dev) {
2065		IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
2066		return -ENODEV;
2067	}
2068
2069	rc = netiucv_register_device(dev);
2070	if (rc) {
 
2071		IUCV_DBF_TEXT_(setup, 2,
2072			"ret %d from netiucv_register_device\n", rc);
2073		goto out_free_ndev;
2074	}
2075
2076	/* sysfs magic */
2077	priv = netdev_priv(dev);
2078	SET_NETDEV_DEV(dev, priv->dev);
2079
2080	rc = register_netdev(dev);
 
2081	if (rc)
2082		goto out_unreg;
2083
2084	dev_info(priv->dev, "The IUCV interface to %s has been"
2085		" established successfully\n", netiucv_printname(username));
 
2086
2087	return count;
2088
2089out_unreg:
2090	netiucv_unregister_device(priv->dev);
2091out_free_ndev:
2092	netiucv_free_netdevice(dev);
2093	return rc;
2094}
 
2095
2096static DRIVER_ATTR(connection, 0200, NULL, conn_write);
2097
2098static ssize_t remove_write (struct device_driver *drv,
2099			     const char *buf, size_t count)
2100{
2101	struct iucv_connection *cp;
2102        struct net_device *ndev;
2103        struct netiucv_priv *priv;
2104        struct device *dev;
2105        char name[IFNAMSIZ];
2106	const char *p;
2107        int i;
2108
2109	IUCV_DBF_TEXT(trace, 3, __func__);
2110
2111        if (count >= IFNAMSIZ)
2112                count = IFNAMSIZ - 1;
2113
2114	for (i = 0, p = buf; i < count && *p; i++, p++) {
2115		if (*p == '\n' || *p == ' ')
2116                        /* trailing lf, grr */
2117                        break;
2118		name[i] = *p;
2119        }
2120        name[i] = '\0';
2121
2122	read_lock_bh(&iucv_connection_rwlock);
2123	list_for_each_entry(cp, &iucv_connection_list, list) {
2124		ndev = cp->netdev;
2125		priv = netdev_priv(ndev);
2126                dev = priv->dev;
2127		if (strncmp(name, ndev->name, count))
2128			continue;
2129		read_unlock_bh(&iucv_connection_rwlock);
2130                if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2131			dev_warn(dev, "The IUCV device is connected"
2132				" to %s and cannot be removed\n",
2133				priv->conn->userid);
2134			IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2135			return -EPERM;
2136                }
2137                unregister_netdev(ndev);
2138                netiucv_unregister_device(dev);
2139                return count;
2140        }
2141	read_unlock_bh(&iucv_connection_rwlock);
2142	IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2143        return -EINVAL;
2144}
2145
2146static DRIVER_ATTR(remove, 0200, NULL, remove_write);
2147
2148static struct attribute * netiucv_drv_attrs[] = {
2149	&driver_attr_connection.attr,
2150	&driver_attr_remove.attr,
2151	NULL,
2152};
2153
2154static struct attribute_group netiucv_drv_attr_group = {
2155	.attrs = netiucv_drv_attrs,
2156};
2157
2158static const struct attribute_group *netiucv_drv_attr_groups[] = {
2159	&netiucv_drv_attr_group,
2160	NULL,
2161};
2162
2163static void netiucv_banner(void)
2164{
2165	pr_info("driver initialized\n");
2166}
2167
2168static void __exit netiucv_exit(void)
2169{
2170	struct iucv_connection *cp;
2171	struct net_device *ndev;
2172	struct netiucv_priv *priv;
2173	struct device *dev;
2174
2175	IUCV_DBF_TEXT(trace, 3, __func__);
2176	while (!list_empty(&iucv_connection_list)) {
2177		cp = list_entry(iucv_connection_list.next,
2178				struct iucv_connection, list);
2179		ndev = cp->netdev;
2180		priv = netdev_priv(ndev);
2181		dev = priv->dev;
2182
2183		unregister_netdev(ndev);
2184		netiucv_unregister_device(dev);
2185	}
2186
2187	device_unregister(netiucv_dev);
2188	driver_unregister(&netiucv_driver);
2189	iucv_unregister(&netiucv_handler, 1);
2190	iucv_unregister_dbf_views();
2191
2192	pr_info("driver unloaded\n");
2193	return;
2194}
2195
2196static int __init netiucv_init(void)
2197{
2198	int rc;
2199
2200	rc = iucv_register_dbf_views();
2201	if (rc)
2202		goto out;
2203	rc = iucv_register(&netiucv_handler, 1);
2204	if (rc)
2205		goto out_dbf;
2206	IUCV_DBF_TEXT(trace, 3, __func__);
2207	netiucv_driver.groups = netiucv_drv_attr_groups;
2208	rc = driver_register(&netiucv_driver);
2209	if (rc) {
2210		IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
2211		goto out_iucv;
2212	}
2213	/* establish dummy device */
2214	netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
2215	if (!netiucv_dev) {
2216		rc = -ENOMEM;
2217		goto out_driver;
2218	}
2219	dev_set_name(netiucv_dev, "netiucv");
2220	netiucv_dev->bus = &iucv_bus;
2221	netiucv_dev->parent = iucv_root;
2222	netiucv_dev->release = (void (*)(struct device *))kfree;
2223	netiucv_dev->driver = &netiucv_driver;
2224	rc = device_register(netiucv_dev);
2225	if (rc) {
2226		put_device(netiucv_dev);
2227		goto out_driver;
2228	}
2229	netiucv_banner();
2230	return rc;
2231
2232out_driver:
2233	driver_unregister(&netiucv_driver);
2234out_iucv:
2235	iucv_unregister(&netiucv_handler, 1);
2236out_dbf:
2237	iucv_unregister_dbf_views();
2238out:
2239	return rc;
2240}
2241
2242module_init(netiucv_init);
2243module_exit(netiucv_exit);
2244MODULE_LICENSE("GPL");