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