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