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