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