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