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