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