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