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