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