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