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