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