]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/s390/net/netiucv.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] s390: Remove CVS generated information
[mirror_ubuntu-zesty-kernel.git] / drivers / s390 / net / netiucv.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 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 *
4ce3b30c
CH		 7 * Sysfs integration and all bugs therein by Cornelia Huck
8 * (cornelia.huck@de.ibm.com)
1da177e4
LT		 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 *
1da177e4
LT		 32 */
33\f
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
64MODULE_AUTHOR
65 ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
66MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
67
68\f
69#define PRINTK_HEADER " iucv: " /* for debugging */
70
71static struct device_driver netiucv_driver = {
72 .name = "netiucv",
73 .bus = &iucv_bus,
74};
75
76/**
77 * Per connection profiling data
78 */
79struct 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 */
94struct 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 */
115static struct iucv_connection *iucv_connections;
116
117/**
118 * Representation of event-data for the
119 * connection state machine.
120 */
121struct iucv_event {
122 struct iucv_connection *conn;
123 void *data;
124};
125
126/**
127 * Private part of the network device structure
128 */
129struct 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 */
140typedef 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 */
156static __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
162static __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
168static __u8 iucv_host[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
169static __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 */
179static __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 */
193static __inline__ char *
194netiucv_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\f
206/**
207 * States of the interface statemachine.
208 */
209enum 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
220static const char *dev_state_names[] = {
221 "Stopped",
222 "StartWait",
223 "StopWait",
224 "Running",
225};
226
227/**
228 * Events of the interface statemachine.
229 */
230enum 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
241static const char *dev_event_names[] = {
242 "Start",
243 "Stop",
244 "Connection up",
245 "Connection down",
246};
247\f
248/**
249 * Events of the connection statemachine
250 */
251enum 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
286static 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 */
304enum 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
355static 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\f
368/**
369 * Debug Facility Stuff
370 */
371static debug_info_t *iucv_dbf_setup = NULL;
372static debug_info_t *iucv_dbf_data = NULL;
373static debug_info_t *iucv_dbf_trace = NULL;
374
375DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf);
376
377static void
378iucv_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}
387static int
388iucv_register_dbf_views(void)
389{
390 iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
66a464db 391 IUCV_DBF_SETUP_PAGES,
1da177e4
LT		 392 IUCV_DBF_SETUP_NR_AREAS,
393 IUCV_DBF_SETUP_LEN);
394 iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
66a464db 395 IUCV_DBF_DATA_PAGES,
1da177e4
LT		 396 IUCV_DBF_DATA_NR_AREAS,
397 IUCV_DBF_DATA_LEN);
398 iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
66a464db 399 IUCV_DBF_TRACE_PAGES,
1da177e4
LT		 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
424static void
425netiucv_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
436static void
437netiucv_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
447static void
448netiucv_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
458static void
459netiucv_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
469static void
470netiucv_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
480static void
481netiucv_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
491static void
492netiucv_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
502static 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 */
515static void
516fsm_action_nop(fsm_instance *fi, int event, void *arg)
517{
518}
519\f
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
533static void
534netiucv_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
593static void
594conn_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
635static void
636conn_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
720static void
721conn_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
748static void
749conn_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
771static void
772conn_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
797static void
798conn_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
810static void
811conn_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
830static void
831conn_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
918static void
919netiucv_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
929static void
930conn_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
950static void
951conn_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
962static 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
994static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
995
996\f
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 */
1008static void
1009dev_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 */
1029static void
1030dev_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 */
1052static void
1053dev_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 */
1086static void
1087dev_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
1102static 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
1116static 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 */
1129static int
1130netiucv_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\f
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 */
1236static int
1237netiucv_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 */
1250static int
1251netiucv_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 */
1267static 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 */
1323static struct net_device_stats *
1324netiucv_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 */
1339static int
1340netiucv_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
1355static ssize_t
3fd3c0a5 1356user_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1364static ssize_t
3fd3c0a5 1365user_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1419static DEVICE_ATTR(user, 0644, user_show, user_write);
1420
1421static ssize_t
3fd3c0a5 1422buffer_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1430static ssize_t
3fd3c0a5 1431buffer_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1483static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
1484
1485static ssize_t
3fd3c0a5 1486dev_fsm_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1494static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
1495
1496static ssize_t
3fd3c0a5 1497conn_fsm_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1505static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
1506
1507static ssize_t
3fd3c0a5 1508maxmulti_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1516static ssize_t
3fd3c0a5 1517maxmulti_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1526static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
1527
1528static ssize_t
3fd3c0a5 1529maxcq_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1537static ssize_t
3fd3c0a5 1538maxcq_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1547static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
1548
1549static ssize_t
3fd3c0a5 1550sdoio_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1558static ssize_t
3fd3c0a5 1559sdoio_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1568static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
1569
1570static ssize_t
3fd3c0a5 1571mdoio_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1579static ssize_t
3fd3c0a5 1580mdoio_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1589static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
1590
1591static ssize_t
3fd3c0a5 1592txlen_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1600static ssize_t
3fd3c0a5 1601txlen_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1610static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
1611
1612static ssize_t
3fd3c0a5 1613txtime_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1621static ssize_t
3fd3c0a5 1622txtime_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1631static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
1632
1633static ssize_t
3fd3c0a5 1634txpend_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1642static ssize_t
3fd3c0a5 1643txpend_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1652static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
1653
1654static ssize_t
3fd3c0a5 1655txmpnd_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 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
1663static ssize_t
3fd3c0a5 1664txmpnd_write (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 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
1673static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
1674
1675static struct attribute *netiucv_attrs[] = {
1676 &dev_attr_buffer.attr,
1677 &dev_attr_user.attr,
1678 NULL,
1679};
1680
1681static struct attribute_group netiucv_attr_group = {
1682 .attrs = netiucv_attrs,
1683};
1684
1685static 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
1699static struct attribute_group netiucv_stat_attr_group = {
1700 .name = "stats",
1701 .attrs = netiucv_stat_attrs,
1702};
1703
1704static inline int
1705netiucv_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
1719static inline void
1720netiucv_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
1727static int
1728netiucv_register_device(struct net_device *ndev)
1729{
1730 struct netiucv_priv *priv = ndev->priv;
1731 struct device *dev = kmalloc(sizeof(struct device), GFP_KERNEL);
1732 int ret;
1733
1734
1735 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
1736
1737 if (dev) {
1738 memset(dev, 0, sizeof(struct device));
1739 snprintf(dev->bus_id, BUS_ID_SIZE, "net%s", ndev->name);
1740 dev->bus = &iucv_bus;
1741 dev->parent = iucv_root;
1742 /*
1743 * The release function could be called after the
1744 * module has been unloaded. It's _only_ task is to
1745 * free the struct. Therefore, we specify kfree()
1746 * directly here. (Probably a little bit obfuscating
1747 * but legitime ...).
1748 */
1749 dev->release = (void (*)(struct device *))kfree;
1750 dev->driver = &netiucv_driver;
1751 } else
1752 return -ENOMEM;
1753
1754 ret = device_register(dev);
1755
1756 if (ret)
1757 return ret;
1758 ret = netiucv_add_files(dev);
1759 if (ret)
1760 goto out_unreg;
1761 priv->dev = dev;
1762 dev->driver_data = priv;
1763 return 0;
1764
1765out_unreg:
1766 device_unregister(dev);
1767 return ret;
1768}
1769
1770static void
1771netiucv_unregister_device(struct device *dev)
1772{
1773 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
1774 netiucv_remove_files(dev);
1775 device_unregister(dev);
1776}
1777
1778/**
1779 * Allocate and initialize a new connection structure.
1780 * Add it to the list of netiucv connections;
1781 */
1782static struct iucv_connection *
1783netiucv_new_connection(struct net_device *dev, char *username)
1784{
1785 struct iucv_connection **clist = &iucv_connections;
1786 struct iucv_connection *conn =
1787 (struct iucv_connection *)
1788 kmalloc(sizeof(struct iucv_connection), GFP_KERNEL);
1789
1790 if (conn) {
1791 memset(conn, 0, sizeof(struct iucv_connection));
1792 skb_queue_head_init(&conn->collect_queue);
1793 skb_queue_head_init(&conn->commit_queue);
1794 conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
1795 conn->netdev = dev;
1796
1797 conn->rx_buff = alloc_skb(NETIUCV_BUFSIZE_DEFAULT,
1798 GFP_KERNEL | GFP_DMA);
1799 if (!conn->rx_buff) {
1800 kfree(conn);
1801 return NULL;
1802 }
1803 conn->tx_buff = alloc_skb(NETIUCV_BUFSIZE_DEFAULT,
1804 GFP_KERNEL | GFP_DMA);
1805 if (!conn->tx_buff) {
1806 kfree_skb(conn->rx_buff);
1807 kfree(conn);
1808 return NULL;
1809 }
1810 conn->fsm = init_fsm("netiucvconn", conn_state_names,
1811 conn_event_names, NR_CONN_STATES,
1812 NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
1813 GFP_KERNEL);
1814 if (!conn->fsm) {
1815 kfree_skb(conn->tx_buff);
1816 kfree_skb(conn->rx_buff);
1817 kfree(conn);
1818 return NULL;
1819 }
1820 fsm_settimer(conn->fsm, &conn->timer);
1821 fsm_newstate(conn->fsm, CONN_STATE_INVALID);
1822
1823 if (username) {
1824 memcpy(conn->userid, username, 9);
1825 fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
1826 }
1827
1828 conn->next = *clist;
1829 *clist = conn;
1830 }
1831 return conn;
1832}
1833
1834/**
1835 * Release a connection structure and remove it from the
1836 * list of netiucv connections.
1837 */
1838static void
1839netiucv_remove_connection(struct iucv_connection *conn)
1840{
1841 struct iucv_connection **clist = &iucv_connections;
1842
1843 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
1844 if (conn == NULL)
1845 return;
1846 while (*clist) {
1847 if (*clist == conn) {
1848 *clist = conn->next;
1849 if (conn->handle) {
1850 iucv_unregister_program(conn->handle);
1851 conn->handle = NULL;
1852 }
1853 fsm_deltimer(&conn->timer);
1854 kfree_fsm(conn->fsm);
1855 kfree_skb(conn->rx_buff);
1856 kfree_skb(conn->tx_buff);
1857 return;
1858 }
1859 clist = &((*clist)->next);
1860 }
1861}
1862
1863/**
1864 * Release everything of a net device.
1865 */
1866static void
1867netiucv_free_netdevice(struct net_device *dev)
1868{
1869 struct netiucv_priv *privptr;
1870
1871 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
1872
1873 if (!dev)
1874 return;
1875
1876 privptr = (struct netiucv_priv *)dev->priv;
1877 if (privptr) {
1878 if (privptr->conn)
1879 netiucv_remove_connection(privptr->conn);
1880 if (privptr->fsm)
1881 kfree_fsm(privptr->fsm);
1882 privptr->conn = NULL; privptr->fsm = NULL;
1883 /* privptr gets freed by free_netdev() */
1884 }
1885 free_netdev(dev);
1886}
1887
1888/**
1889 * Initialize a net device. (Called from kernel in alloc_netdev())
1890 */
1891static void
1892netiucv_setup_netdevice(struct net_device *dev)
1893{
1894 memset(dev->priv, 0, sizeof(struct netiucv_priv));
1895
1896 dev->mtu = NETIUCV_MTU_DEFAULT;
1897 dev->hard_start_xmit = netiucv_tx;
1898 dev->open = netiucv_open;
1899 dev->stop = netiucv_close;
1900 dev->get_stats = netiucv_stats;
1901 dev->change_mtu = netiucv_change_mtu;
1902 dev->destructor = netiucv_free_netdevice;
1903 dev->hard_header_len = NETIUCV_HDRLEN;
1904 dev->addr_len = 0;
1905 dev->type = ARPHRD_SLIP;
1906 dev->tx_queue_len = NETIUCV_QUEUELEN_DEFAULT;
1907 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
1908 SET_MODULE_OWNER(dev);
1909}
1910
1911/**
1912 * Allocate and initialize everything of a net device.
1913 */
1914static struct net_device *
1915netiucv_init_netdevice(char *username)
1916{
1917 struct netiucv_priv *privptr;
1918 struct net_device *dev;
1919
1920 dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
1921 netiucv_setup_netdevice);
1922 if (!dev)
1923 return NULL;
1924 if (dev_alloc_name(dev, dev->name) < 0) {
1925 free_netdev(dev);
1926 return NULL;
1927 }
1928
1929 privptr = (struct netiucv_priv *)dev->priv;
1930 privptr->fsm = init_fsm("netiucvdev", dev_state_names,
1931 dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
1932 dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
1933 if (!privptr->fsm) {
1934 free_netdev(dev);
1935 return NULL;
1936 }
1937 privptr->conn = netiucv_new_connection(dev, username);
1938 if (!privptr->conn) {
1939 kfree_fsm(privptr->fsm);
1940 free_netdev(dev);
1941 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
1942 return NULL;
1943 }
1944 fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
1945
1946 return dev;
1947}
1948
1949static ssize_t
1950conn_write(struct device_driver *drv, const char *buf, size_t count)
1951{
1952 char *p;
1953 char username[10];
1954 int i, ret;
1955 struct net_device *dev;
1956
1957 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
1958 if (count>9) {
1959 PRINT_WARN("netiucv: username too long (%d)!\n", (int)count);
1960 IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
1961 return -EINVAL;
1962 }
1963
1964 for (i=0, p=(char *)buf; i<8 && *p; i++, p++) {
1965 if (isalnum(*p) || (*p == '$'))
1966 username[i]= *p;
1967 else if (*p == '\n') {
1968 /* trailing lf, grr */
1969 break;
1970 } else {
1971 PRINT_WARN("netiucv: Invalid character in username!\n");
1972 IUCV_DBF_TEXT_(setup, 2,
1973 "conn_write: invalid character %c\n", *p);
1974 return -EINVAL;
1975 }
1976 }
1977 while (i<9)
1978 username[i++] = ' ';
1979 username[9] = '\0';
1980 dev = netiucv_init_netdevice(username);
1981 if (!dev) {
1982 PRINT_WARN(
1983 "netiucv: Could not allocate network device structure "
1984 "for user '%s'\n", netiucv_printname(username));
1985 IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
1986 return -ENODEV;
1987 }
1988
1989 if ((ret = netiucv_register_device(dev))) {
1990 IUCV_DBF_TEXT_(setup, 2,
1991 "ret %d from netiucv_register_device\n", ret);
1992 goto out_free_ndev;
1993 }
1994
1995 /* sysfs magic */
1996 SET_NETDEV_DEV(dev,
1997 (struct device*)((struct netiucv_priv*)dev->priv)->dev);
1998
1999 if ((ret = register_netdev(dev))) {
2000 netiucv_unregister_device((struct device*)
2001 ((struct netiucv_priv*)dev->priv)->dev);
2002 goto out_free_ndev;
2003 }
2004
2005 PRINT_INFO("%s: '%s'\n", dev->name, netiucv_printname(username));
2006
2007 return count;
2008
2009out_free_ndev:
2010 PRINT_WARN("netiucv: Could not register '%s'\n", dev->name);
2011 IUCV_DBF_TEXT(setup, 2, "conn_write: could not register\n");
2012 netiucv_free_netdevice(dev);
2013 return ret;
2014}
2015
2016DRIVER_ATTR(connection, 0200, NULL, conn_write);
2017
2018static ssize_t
2019remove_write (struct device_driver *drv, const char *buf, size_t count)
2020{
2021 struct iucv_connection **clist = &iucv_connections;
2022 struct net_device *ndev;
2023 struct netiucv_priv *priv;
2024 struct device *dev;
2025 char name[IFNAMSIZ];
2026 char *p;
2027 int i;
2028
2029 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
2030
2031 if (count >= IFNAMSIZ)
2032 count = IFNAMSIZ-1;
2033
2034 for (i=0, p=(char *)buf; i<count && *p; i++, p++) {
2035 if ((*p == '\n') | (*p == ' ')) {
2036 /* trailing lf, grr */
2037 break;
2038 } else {
2039 name[i]=*p;
2040 }
2041 }
2042 name[i] = '\0';
2043
2044 while (*clist) {
2045 ndev = (*clist)->netdev;
2046 priv = (struct netiucv_priv*)ndev->priv;
2047 dev = priv->dev;
2048
2049 if (strncmp(name, ndev->name, count)) {
2050 clist = &((*clist)->next);
2051 continue;
2052 }
2053 if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
2054 PRINT_WARN(
2055 "netiucv: net device %s active with peer %s\n",
2056 ndev->name, priv->conn->userid);
2057 PRINT_WARN("netiucv: %s cannot be removed\n",
2058 ndev->name);
2059 IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
2060 return -EBUSY;
2061 }
2062 unregister_netdev(ndev);
2063 netiucv_unregister_device(dev);
2064 return count;
2065 }
2066 PRINT_WARN("netiucv: net device %s unknown\n", name);
2067 IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
2068 return -EINVAL;
2069}
2070
2071DRIVER_ATTR(remove, 0200, NULL, remove_write);
2072
2073static void
2074netiucv_banner(void)
2075{
e018ba1f 2076 PRINT_INFO("NETIUCV driver initialized\n");
1da177e4
LT		 2077}
2078
2079static void __exit
2080netiucv_exit(void)
2081{
2082 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
2083 while (iucv_connections) {
2084 struct net_device *ndev = iucv_connections->netdev;
2085 struct netiucv_priv *priv = (struct netiucv_priv*)ndev->priv;
2086 struct device *dev = priv->dev;
2087
2088 unregister_netdev(ndev);
2089 netiucv_unregister_device(dev);
2090 }
2091
2092 driver_remove_file(&netiucv_driver, &driver_attr_connection);
2093 driver_remove_file(&netiucv_driver, &driver_attr_remove);
2094 driver_unregister(&netiucv_driver);
2095 iucv_unregister_dbf_views();
2096
2097 PRINT_INFO("NETIUCV driver unloaded\n");
2098 return;
2099}
2100
2101static int __init
2102netiucv_init(void)
2103{
2104 int ret;
2105
2106 ret = iucv_register_dbf_views();
2107 if (ret) {
2108 PRINT_WARN("netiucv_init failed, "
2109 "iucv_register_dbf_views rc = %d\n", ret);
2110 return ret;
2111 }
2112 IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
2113 ret = driver_register(&netiucv_driver);
2114 if (ret) {
2115 PRINT_ERR("NETIUCV: failed to register driver.\n");
2116 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", ret);
2117 iucv_unregister_dbf_views();
2118 return ret;
2119 }
2120
2121 /* Add entry for specifying connections. */
2122 ret = driver_create_file(&netiucv_driver, &driver_attr_connection);
2123 if (!ret) {
2124 ret = driver_create_file(&netiucv_driver, &driver_attr_remove);
2125 netiucv_banner();
2126 } else {
2127 PRINT_ERR("NETIUCV: failed to add driver attribute.\n");
2128 IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_create_file\n", ret);
2129 driver_unregister(&netiucv_driver);
2130 iucv_unregister_dbf_views();
2131 }
2132 return ret;
2133}
2134
2135module_init(netiucv_init);
2136module_exit(netiucv_exit);
2137MODULE_LICENSE("GPL");
ubuntu-zesty-kernel mirror