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