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