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