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