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