开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
netiucv.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：53k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

netiucv.c：源码内容
  1. /*
  2.  * $Id: netiucv.c,v 1.17 2002/02/12 21:52:20 felfert Exp $
  3.  *
  4.  * IUCV network driver
  5.  *
  6.  * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
  7.  * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
  8.  *
  9.  * Documentation used:
  10.  *  the source of the original IUCV driver by:
  11.  *    Stefan Hegewald <hegewald@de.ibm.com>
  12.  *    Hartmut Penner <hpenner@de.ibm.com>
  13.  *    Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  14.  *    Martin Schwidefsky (schwidefsky@de.ibm.com)
  15.  *    Alan Altmark (Alan_Altmark@us.ibm.com)  Sept. 2000
  16.  *
  17.  * This program is free software; you can redistribute it and/or modify
  18.  * it under the terms of the GNU General Public License as published by
  19.  * the Free Software Foundation; either version 2, or (at your option)
  20.  * any later version.
  21.  *
  22.  * This program is distributed in the hope that it will be useful,
  23.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.  * GNU General Public License for more details.
  26.  *
  27.  * You should have received a copy of the GNU General Public License
  28.  * along with this program; if not, write to the Free Software
  29.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30.  *
  31.  * RELEASE-TAG: IUCV network driver $Revision: 1.17 $
  32.  *
  33.  */
  35. #include <linux/version.h>
  36. #include <linux/module.h>
  37. #include <linux/init.h>
  38. #include <linux/kernel.h>
  39. #include <linux/slab.h>
  40. #include <linux/errno.h>
  41. #include <linux/types.h>
  42. #include <linux/interrupt.h>
  43. #include <linux/timer.h>
  44. #include <linux/sched.h>
  46. #include <linux/signal.h>
  47. #include <linux/string.h>
  48. #include <linux/proc_fs.h>
  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>
  57. #include <asm/io.h>
  58. #include <asm/bitops.h>
  59. #include <asm/uaccess.h>
  61. #include "iucv.h"
  62. #include "fsm.h"
  64. #undef DEBUG
  66. #ifdef MODULE
  67. MODULE_AUTHOR
  68.     ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
  69. MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
  70. MODULE_PARM (iucv, "1s");
  71. MODULE_PARM_DESC (iucv,
  72.   "Specify the initial remote userids for iucv0 .. iucvn:n"
  73.   "iucv=userid0:userid1:...:useridN");
  74. #endif
  76. static char *iucv = "";
  78. /**
  79.  * compatibility stuff
  80.  */
  81. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0))
  82. typedef struct net_device net_device;
  83. #else
  84. typedef struct device net_device;
  85. #endif
  88. /**
  89.  * Per connection profiling data
  90.  */
  91. typedef struct connection_profile_t {
  92. unsigned long maxmulti;
  93. unsigned long maxcqueue;
  94. unsigned long doios_single;
  95. unsigned long doios_multi;
  96. unsigned long txlen;
  97. unsigned long tx_time;
  98. struct timeval send_stamp;
  99. } connection_profile;
  101. /**
  102.  * Representation of one iucv connection
  103.  */
  104. typedef struct iucv_connection_t {
  105. struct iucv_connection_t *next;
  106. iucv_handle_t            handle;
  107. __u16                    pathid;
  108. struct sk_buff           *rx_buff;
  109. struct sk_buff           *tx_buff;
  110. struct sk_buff_head      collect_queue;
  111. spinlock_t               collect_lock;
  112. int                      collect_len;
  113. int                      max_buffsize;
  114. int                      flags;
  115. fsm_timer                timer;
  116. int                      retry;
  117. fsm_instance             *fsm;
  118. net_device               *netdev;
  119. connection_profile       prof;
  120. char                     userid[9];
  121. } iucv_connection;
  123. #define CONN_FLAGS_BUFSIZE_CHANGED 1
  125. /**
  126.  * Linked list of all connection structs.
  127.  */
  128. iucv_connection *connections;
  130. /**
  131.  * Representation of event-data for the
  132.  * connection state machine.
  133.  */
  134. typedef struct iucv_event_t {
  135. iucv_connection *conn;
  136. void            *data;
  137. } iucv_event;
  139. /**
  140.  * Private part of the network device structure
  141.  */
  142. typedef struct netiucv_priv_t {
  143. struct net_device_stats stats;
  144. #if LINUX_VERSION_CODE >= 0x02032D
  145. unsigned long           tbusy;
  146. #endif
  147. fsm_instance            *fsm;
  148.         iucv_connection         *conn;
  149. struct proc_dir_entry   *proc_dentry;
  150. struct proc_dir_entry   *proc_stat_entry;
  151. struct proc_dir_entry   *proc_buffer_entry;
  152. struct proc_dir_entry   *proc_user_entry;
  153. int                     proc_registered;
  154. } netiucv_priv;
  156. /**
  157.  * Link level header for a packet.
  158.  */
  159. typedef struct ll_header_t {
  160. __u16 next;
  161. } ll_header;
  163. #define NETIUCV_HDRLEN           (sizeof(ll_header))
  164. #define NETIUCV_BUFSIZE_MAX      32768
  165. #define NETIUCV_BUFSIZE_DEFAULT  NETIUCV_BUFSIZE_MAX
  166. #define NETIUCV_MTU_MAX          (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
  167. #define NETIUCV_MTU_DEFAULT      9216
  168. #define NETIUCV_QUEUELEN_DEFAULT 50
  169. #define NETIUCV_TIMEOUT_5SEC     5000
  171. /**
  172.  * Compatibility macros for busy handling
  173.  * of network devices.
  174.  */
  175. #if LINUX_VERSION_CODE < 0x02032D
  176. static __inline__ void netiucv_clear_busy(net_device *dev)
  177. {
  178. clear_bit(0 ,(void *)&dev->tbusy);
  179. mark_bh(NET_BH);
  180. }
  182. static __inline__ int netiucv_test_and_set_busy(net_device *dev)
  183. {
  184. return(test_and_set_bit(0, (void *)&dev->tbusy));
  185. }
  187. #define SET_DEVICE_START(device, value) dev->start = value
  188. #else
  189. static __inline__ void netiucv_clear_busy(net_device *dev)
  190. {
  191. clear_bit(0, &(((netiucv_priv *)dev->priv)->tbusy));
  192. netif_wake_queue(dev);
  193. }
  195. static __inline__ int netiucv_test_and_set_busy(net_device *dev)
  196. {
  197. netif_stop_queue(dev);
  198. return test_and_set_bit(0, &((netiucv_priv *)dev->priv)->tbusy);
  199. }
  201. #define SET_DEVICE_START(device, value)
  202. #endif
  204. #if LINUX_VERSION_CODE < 0x020400
  205. #  define dev_kfree_skb_irq(a) dev_kfree_skb(a)
  206. #endif
  208. __u8 iucv_host[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  209. __u8 iucvMagic[16] = {
  210. 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
  211. 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
  212. };
  214. /**
  215.  * This mask means the 16-byte IUCV "magic" and the origin userid must
  216.  * match exactly as specified in order to give connection_pending()
  217.  * control.
  218.  */
  219. __u8 mask[] = {
  220. 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  221. 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  222. 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  223. };
  225. /**
  226.  * Convert an iucv userId to its printable
  227.  * form (strip whitespace at end).
  228.  *
  229.  * @param An iucv userId
  230.  *
  231.  * @returns The printable string (static data!!)
  232.  */
  233. static __inline__ char *
  234. netiucv_printname(char *name)
  235. {
  236. static char tmp[9];
  237. char *p = tmp;
  238. memcpy(tmp, name, 8);
  239. tmp[8] = '';
  240. while (*p && (!isspace(*p)))
  241. p++;
  242. *p = '';
  243. return tmp;
  244. }
  246. /**
  247.  * States of the interface statemachine.
  248.  */
  249. enum dev_states {
  250. DEV_STATE_STOPPED,
  251. DEV_STATE_STARTWAIT,
  252. DEV_STATE_STOPWAIT,
  253. DEV_STATE_RUNNING,
  254. /**
  255.  * MUST be always the last element!!
  256.  */
  257. NR_DEV_STATES
  258. };
  260. static const char *dev_state_names[] = {
  261. "Stopped",
  262. "StartWait",
  263. "StopWait",
  264. "Running",
  265. };
  267. /**
  268.  * Events of the interface statemachine.
  269.  */
  270. enum dev_events {
  271. DEV_EVENT_START,
  272. DEV_EVENT_STOP,
  273. DEV_EVENT_CONUP,
  274. DEV_EVENT_CONDOWN,
  275. /**
  276.  * MUST be always the last element!!
  277.  */
  278. NR_DEV_EVENTS
  279. };
  281. static const char *dev_event_names[] = {
  282. "Start",
  283. "Stop",
  284. "Connection up",
  285. "Connection down",
  286. };
  288. /**
  289.  * Events of the connection statemachine
  290.  */
  291. enum conn_events {
  292. /**
  293.  * Events, representing callbacks from
  294.  * lowlevel iucv layer)
  295.  */
  296. CONN_EVENT_CONN_REQ,
  297. CONN_EVENT_CONN_ACK,
  298. CONN_EVENT_CONN_REJ,
  299. CONN_EVENT_CONN_SUS,
  300. CONN_EVENT_CONN_RES,
  301. CONN_EVENT_RX,
  302. CONN_EVENT_TXDONE,
  304. /**
  305.  * Events, representing errors return codes from
  306.  * calls to lowlevel iucv layer
  307.  */
  309. /**
  310.  * Event, representing timer expiry.
  311.  */
  312. CONN_EVENT_TIMER,
  314. /**
  315.  * Events, representing commands from upper levels.
  316.  */
  317. CONN_EVENT_START,
  318. CONN_EVENT_STOP,
  320. /**
  321.  * MUST be always the last element!!
  322.  */
  323. NR_CONN_EVENTS,
  324. };
  326. static const char *conn_event_names[] = {
  327. "Remote connection request",
  328. "Remote connection acknowledge",
  329. "Remote connection reject",
  330. "Connection suspended",
  331. "Connection resumed",
  332. "Data received",
  333. "Data sent",
  335. "Timer",
  337. "Start",
  338. "Stop",
  339. };
  341. /**
  342.  * States of the connection statemachine.
  343.  */
  344. enum conn_states {
  345. /**
  346.  * Connection not assigned to any device,
  347.  * initial state, invalid
  348.  */
  349. CONN_STATE_INVALID,
  351. /**
  352.  * Userid assigned but not operating
  353.  */
  354. CONN_STATE_STOPPED,
  356. /**
  357.  * Connection registered,
  358.  * no connection request sent yet,
  359.  * no connection request received
  360.  */
  361. CONN_STATE_STARTWAIT,
  363. /**
  364.  * Connection registered and connection request sent,
  365.  * no acknowledge and no connection request received yet.
  366.  */
  367. CONN_STATE_SETUPWAIT,
  369. /**
  370.  * Connection up and running idle
  371.  */
  372. CONN_STATE_IDLE,
  374. /**
  375.  * Data sent, awaiting CONN_EVENT_TXDONE
  376.  */
  377. CONN_STATE_TX,
  379. /**
  380.  * Terminating
  381.  */
  382. CONN_STATE_TERM,
  384. /**
  385.  * Error during registration.
  386.  */
  387. CONN_STATE_REGERR,
  389. /**
  390.  * Error during registration.
  391.  */
  392. CONN_STATE_CONNERR,
  394. /**
  395.  * MUST be always the last element!!
  396.  */
  397. NR_CONN_STATES,
  398. };
  400. static const char *conn_state_names[] = {
  401. "Invalid",
  402. "Stopped",
  403. "StartWait",
  404. "SetupWait",
  405. "Idle",
  406. "TX",
  407. "Terminating",
  408. "Registration error",
  409. "Connect error",
  410. };
  413. /**
  414.  * Callback-wrappers, called from lowlevel iucv layer.
  415.  *****************************************************************************/
  417. static void
  418. netiucv_callback_rx(iucv_MessagePending *eib, void *pgm_data)
  419. {
  420. iucv_connection *conn = (iucv_connection *)pgm_data;
  421. iucv_event ev;
  423. ev.conn = conn;
  424. ev.data = (void *)eib;
  426. fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
  427. }
  429. static void
  430. netiucv_callback_txdone(iucv_MessageComplete *eib, void *pgm_data)
  431. {
  432. iucv_connection *conn = (iucv_connection *)pgm_data;
  433. iucv_event ev;
  435. ev.conn = conn;
  436. ev.data = (void *)eib;
  437. fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
  438. }
  440. static void
  441. netiucv_callback_connack(iucv_ConnectionComplete *eib, void *pgm_data)
  442. {
  443. iucv_connection *conn = (iucv_connection *)pgm_data;
  444. iucv_event ev;
  446. ev.conn = conn;
  447. ev.data = (void *)eib;
  448. fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, &ev);
  449. }
  451. static void
  452. netiucv_callback_connreq(iucv_ConnectionPending *eib, void *pgm_data)
  453. {
  454. iucv_connection *conn = (iucv_connection *)pgm_data;
  455. iucv_event ev;
  457. ev.conn = conn;
  458. ev.data = (void *)eib;
  459. fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
  460. }
  462. static void
  463. netiucv_callback_connrej(iucv_ConnectionSevered *eib, void *pgm_data)
  464. {
  465. iucv_connection *conn = (iucv_connection *)pgm_data;
  466. iucv_event ev;
  468. ev.conn = conn;
  469. ev.data = (void *)eib;
  470. fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, &ev);
  471. }
  473. static void
  474. netiucv_callback_connsusp(iucv_ConnectionQuiesced *eib, void *pgm_data)
  475. {
  476. iucv_connection *conn = (iucv_connection *)pgm_data;
  477. iucv_event ev;
  479. ev.conn = conn;
  480. ev.data = (void *)eib;
  481. fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, &ev);
  482. }
  484. static void
  485. netiucv_callback_connres(iucv_ConnectionResumed *eib, void *pgm_data)
  486. {
  487. iucv_connection *conn = (iucv_connection *)pgm_data;
  488. iucv_event ev;
  490. ev.conn = conn;
  491. ev.data = (void *)eib;
  492. fsm_event(conn->fsm, CONN_EVENT_CONN_RES, &ev);
  493. }
  495. static iucv_interrupt_ops_t netiucv_ops = {
  496. ConnectionPending:  netiucv_callback_connreq,
  497. ConnectionComplete: netiucv_callback_connack,
  498. ConnectionSevered:  netiucv_callback_connrej,
  499. ConnectionQuiesced: netiucv_callback_connsusp,
  500. ConnectionResumed:  netiucv_callback_connres,
  501. MessagePending:     netiucv_callback_rx,
  502. MessageComplete:    netiucv_callback_txdone
  503. };
  505. /**
  506.  * Dummy NOP action for all statemachines
  507.  */
  508. static void
  509. fsm_action_nop(fsm_instance *fi, int event, void *arg)
  510. {
  511. }
  513. /**
  514.  * Actions of the connection statemachine
  515.  *****************************************************************************/
  517. /**
  518.  * Helper function for conn_action_rx()
  519.  * Unpack a just received skb and hand it over to
  520.  * upper layers.
  521.  *
  522.  * @param conn The connection where this skb has been received.
  523.  * @param pskb The received skb.
  524.  */
  525. //static __inline__ void
  526. static void
  527. netiucv_unpack_skb(iucv_connection *conn, struct sk_buff *pskb)
  528. {
  529. net_device     *dev = conn->netdev;
  530. netiucv_priv   *privptr = (netiucv_priv *)dev->priv;
  531. __u16          offset = 0;
  533. skb_put(pskb, NETIUCV_HDRLEN);
  534. pskb->dev = dev;
  535. pskb->ip_summed = CHECKSUM_NONE;
  536. pskb->protocol = ntohs(ETH_P_IP);
  538. while (1) {
  539. struct sk_buff *skb;
  540. ll_header *header = (ll_header *)pskb->data;
  542. if (header->next == 0)
  543. break;
  545. skb_pull(pskb, NETIUCV_HDRLEN);
  546. header->next -= offset;
  547. offset += header->next;
  548. header->next -= NETIUCV_HDRLEN;
  549. if (skb_tailroom(pskb) < header->next) {
  550. printk(KERN_WARNING
  551.        "%s: Illegal next field in iucv header: %d > %dn",
  552.        dev->name, header->next, skb_tailroom(pskb));
  553. return;
  554. }
  555. skb_put(pskb, header->next);
  556. pskb->mac.raw = pskb->data;
  557. skb = dev_alloc_skb(pskb->len);
  558. if (!skb) {
  559. printk(KERN_WARNING
  560.        "%s Out of memory in netiucv_unpack_skbn",
  561.        dev->name);
  562. privptr->stats.rx_dropped++;
  563. return;
  564. }
  565. memcpy(skb_put(skb, pskb->len), pskb->data, pskb->len);
  566. skb->mac.raw = skb->data;
  567. skb->dev = pskb->dev;
  568. skb->protocol = pskb->protocol;
  569. pskb->ip_summed = CHECKSUM_UNNECESSARY;
  570. netif_rx(skb);
  571. privptr->stats.rx_packets++;
  572. privptr->stats.rx_bytes += skb->len;
  573. skb_pull(pskb, header->next);
  574. skb_put(pskb, NETIUCV_HDRLEN);
  575. }
  576. }
  578. static void
  579. conn_action_rx(fsm_instance *fi, int event, void *arg)
  580. {
  581. iucv_event *ev = (iucv_event *)arg;
  582. iucv_connection *conn = ev->conn;
  583. iucv_MessagePending *eib = (iucv_MessagePending *)ev->data;
  584. netiucv_priv *privptr = (netiucv_priv *)conn->netdev->priv;
  586. __u16 msglen = eib->ln1msg2.ipbfln1f;
  587. int rc;
  589. #ifdef DEBUG
  590. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  591. #endif
  592. if (!conn->netdev) {
  593. /* FRITZ: How to tell iucv LL to drop the msg? */
  594. printk(KERN_WARNING
  595.        "Received data for unlinked connectionn"); 
  596. return;
  597. }
  598. if (msglen > conn->max_buffsize) {
  599. /* FRITZ: How to tell iucv LL to drop the msg? */
  600. privptr->stats.rx_dropped++;
  601. return;
  602. }
  603. conn->rx_buff->data = conn->rx_buff->tail = conn->rx_buff->head;
  604. conn->rx_buff->len = 0;
  605. rc = iucv_receive(conn->pathid, eib->ipmsgid, eib->iptrgcls,
  606.   conn->rx_buff->data, msglen, NULL, NULL, NULL);
  607. if (rc != 0 || msglen < 5) {
  608. privptr->stats.rx_errors++;
  609. return;
  610. }
  611. netiucv_unpack_skb(conn, conn->rx_buff);
  612. }
  614. static void
  615. conn_action_txdone(fsm_instance *fi, int event, void *arg)
  616. {
  617. iucv_event *ev = (iucv_event *)arg;
  618. iucv_connection *conn = ev->conn;
  619. iucv_MessageComplete *eib = (iucv_MessageComplete *)ev->data;
  620. netiucv_priv *privptr = NULL;
  621.          /* Shut up, gcc! skb is always below 2G. */
  622. struct sk_buff *skb = (struct sk_buff *)(unsigned long)eib->ipmsgtag;
  623. __u32 txbytes = 0;
  624. __u32 txpackets = 0;
  625. __u32 stat_maxcq = 0;
  626. unsigned long saveflags;
  627. ll_header header;
  629. #ifdef DEBUG
  630. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  631. #endif
  632. fsm_deltimer(&conn->timer);
  633. if (conn && conn->netdev && conn->netdev->priv)
  634. privptr = (netiucv_priv *)conn->netdev->priv;
  635. if (skb) {
  636. if (privptr) {
  637. privptr->stats.tx_packets++;
  638. privptr->stats.tx_bytes +=
  639. (skb->len - NETIUCV_HDRLEN - NETIUCV_HDRLEN);
  640. }
  641. dev_kfree_skb_any(skb);
  642. }
  643. conn->tx_buff->data = conn->tx_buff->tail = conn->tx_buff->head;
  644. conn->tx_buff->len = 0;
  645. spin_lock_irqsave(&conn->collect_lock, saveflags);
  646. while ((skb = skb_dequeue(&conn->collect_queue))) {
  647. header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
  648. memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
  649.        NETIUCV_HDRLEN);
  650. memcpy(skb_put(conn->tx_buff, skb->len), skb->data, skb->len);
  651. txbytes += skb->len;
  652. txpackets++;
  653. stat_maxcq++;
  654. atomic_dec(&skb->users);
  655. dev_kfree_skb_any(skb);
  656. }
  657. if (conn->collect_len > conn->prof.maxmulti)
  658. conn->prof.maxmulti = conn->collect_len;
  659. conn->collect_len = 0;
  660. spin_unlock_irqrestore(&conn->collect_lock, saveflags);
  661. if (conn->tx_buff->len) {
  662. int rc;
  664. header.next = 0;
  665. memcpy(skb_put(conn->tx_buff, NETIUCV_HDRLEN), &header,
  666.        NETIUCV_HDRLEN);
  668. fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
  669.      CONN_EVENT_TIMER, conn);
  670. conn->prof.send_stamp = xtime;
  671. rc = iucv_send(conn->pathid, NULL, 0, 0, 0, 0,
  672.        conn->tx_buff->data, conn->tx_buff->len);
  673. conn->prof.doios_multi++;
  674. conn->prof.txlen += conn->tx_buff->len;
  675. if (rc != 0) {
  676. fsm_deltimer(&conn->timer);
  677. fsm_newstate(fi, CONN_STATE_IDLE);
  678. if (privptr)
  679. privptr->stats.tx_errors += txpackets;
  680. } else {
  681. if (privptr) {
  682. privptr->stats.tx_packets += txpackets;
  683. privptr->stats.tx_bytes += txbytes;
  684. }
  685. if (stat_maxcq > conn->prof.maxcqueue)
  686. conn->prof.maxcqueue = stat_maxcq;
  687. }
  688. } else
  689. fsm_newstate(fi, CONN_STATE_IDLE);
  690. }
  692. static void
  693. conn_action_connaccept(fsm_instance *fi, int event, void *arg)
  694. {
  695. iucv_event *ev = (iucv_event *)arg;
  696. iucv_connection *conn = ev->conn;
  697. iucv_ConnectionPending *eib = (iucv_ConnectionPending *)ev->data;
  698. net_device *netdev = conn->netdev;
  699. netiucv_priv *privptr = (netiucv_priv *)netdev->priv;
  700. int rc;
  701. __u16 msglimit;
  702. __u8 udata[16];
  704. #ifdef DEBUG
  705. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  706. #endif
  707. rc = iucv_accept(eib->ippathid, NETIUCV_QUEUELEN_DEFAULT, udata, 0,
  708.  conn->handle, conn, NULL, &msglimit);
  709. if (rc != 0) {
  710. printk(KERN_WARNING
  711.        "%s: IUCV accept failed with error %dn",
  712.        netdev->name, rc);
  713. return;
  714. }
  715. fsm_newstate(fi, CONN_STATE_IDLE);
  716. conn->pathid = eib->ippathid;
  717. netdev->tx_queue_len = msglimit;
  718. fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
  719. }
  721. static void
  722. conn_action_connreject(fsm_instance *fi, int event, void *arg)
  723. {
  724. iucv_event *ev = (iucv_event *)arg;
  725. // iucv_connection *conn = ev->conn;
  726. iucv_ConnectionPending *eib = (iucv_ConnectionPending *)ev->data;
  727. __u8 udata[16];
  729. #ifdef DEBUG
  730. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  731. #endif
  732. iucv_sever(eib->ippathid, udata);
  733. }
  735. static void
  736. conn_action_connack(fsm_instance *fi, int event, void *arg)
  737. {
  738. iucv_event *ev = (iucv_event *)arg;
  739. iucv_connection *conn = ev->conn;
  740. iucv_ConnectionComplete *eib = (iucv_ConnectionComplete *)ev->data;
  741. net_device *netdev = conn->netdev;
  742. netiucv_priv *privptr = (netiucv_priv *)netdev->priv;
  744. #ifdef DEBUG
  745. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  746. #endif
  747. fsm_newstate(fi, CONN_STATE_IDLE);
  748. conn->pathid = eib->ippathid;
  749. netdev->tx_queue_len = eib->ipmsglim;
  750. fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
  751. }
  753. static void
  754. conn_action_connsever(fsm_instance *fi, int event, void *arg)
  755. {
  756. iucv_event *ev = (iucv_event *)arg;
  757. iucv_connection *conn = ev->conn;
  758. // iucv_ConnectionSevered *eib = (iucv_ConnectionSevered *)ev->data;
  759. net_device *netdev = conn->netdev;
  760. netiucv_priv *privptr = (netiucv_priv *)netdev->priv;
  761. int state = fsm_getstate(fi);
  763. #ifdef DEBUG
  764. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  765. #endif
  766. switch (state) {
  767. case CONN_STATE_IDLE:
  768. case CONN_STATE_TX:
  769. printk(KERN_INFO "%s: Remote dropped connectionn",
  770.        netdev->name);
  771. if (conn->handle)
  772. iucv_unregister_program(conn->handle);
  773. conn->handle = 0;
  774. fsm_newstate(fi, CONN_STATE_STOPPED);
  775. fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
  776. break;
  777. }
  778. }
  780. static void
  781. conn_action_start(fsm_instance *fi, int event, void *arg)
  782. {
  783. iucv_event *ev = (iucv_event *)arg;
  784. iucv_connection *conn = ev->conn;
  786. int rc;
  788. #ifdef DEBUG
  789. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  790. #endif
  791. if (conn->handle == 0) {
  792. conn->handle =
  793. iucv_register_program(iucvMagic, conn->userid, mask,
  794.       &netiucv_ops, conn);
  795. fsm_newstate(fi, CONN_STATE_STARTWAIT);
  796. if (conn->handle <= 0) {
  797. fsm_newstate(fi, CONN_STATE_REGERR);
  798. conn->handle = 0;
  799. return;
  800. }
  801. #ifdef DEBUG
  802. printk(KERN_DEBUG "%s('%s'): registered successfullyn",
  803.        conn->netdev->name, conn->userid);
  804. #endif
  805. }
  806. #ifdef DEBUG
  807. printk(KERN_DEBUG "%s('%s'): connecting ...n",
  808.        conn->netdev->name, conn->userid);
  809. #endif
  810. rc = iucv_connect(&(conn->pathid), NETIUCV_QUEUELEN_DEFAULT, iucvMagic,
  811.   conn->userid, iucv_host, 0, NULL, NULL, conn->handle,
  812.   conn);
  813. fsm_newstate(fi, CONN_STATE_SETUPWAIT);
  814. switch (rc) {
  815. case 0:
  816. return;
  817. case 11:
  818. printk(KERN_NOTICE
  819.        "%s: User %s is currently not available.n",
  820.        conn->netdev->name,
  821.        netiucv_printname(conn->userid));
  822. fsm_newstate(fi, CONN_STATE_STARTWAIT);
  823. return;
  824. case 12:
  825. printk(KERN_NOTICE
  826.        "%s: User %s is currently not ready.n",
  827.        conn->netdev->name,
  828.        netiucv_printname(conn->userid));
  829. fsm_newstate(fi, CONN_STATE_STARTWAIT);
  830. return;
  831. case 13:
  832. printk(KERN_WARNING
  833.        "%s: Too many IUCV connections.n",
  834.        conn->netdev->name);
  835. fsm_newstate(fi, CONN_STATE_CONNERR);
  836. break;
  837. case 14:
  838. printk(KERN_WARNING
  839.        "%s: User %s has too many IUCV connections.n",
  840.        conn->netdev->name,
  841.        netiucv_printname(conn->userid));
  842. fsm_newstate(fi, CONN_STATE_CONNERR);
  843. break;
  844. case 15:
  845. printk(KERN_WARNING
  846.        "%s: No IUCV authorization in CP directory.n",
  847.        conn->netdev->name);
  848. fsm_newstate(fi, CONN_STATE_CONNERR);
  849. break;
  850. default:
  851. printk(KERN_WARNING
  852.        "%s: iucv_connect returned error %dn",
  853.        conn->netdev->name, rc);
  854. fsm_newstate(fi, CONN_STATE_CONNERR);
  855. break;
  856. }
  857. iucv_unregister_program(conn->handle);
  858. conn->handle = 0;
  859. }
  861. static void
  862. netiucv_purge_skb_queue(struct sk_buff_head *q)
  863. {
  864. struct sk_buff *skb;
  866. while ((skb = skb_dequeue(q))) {
  867. atomic_dec(&skb->users);
  868. dev_kfree_skb_any(skb);
  869. }
  870. }
  872. static void
  873. conn_action_stop(fsm_instance *fi, int event, void *arg)
  874. {
  875. iucv_event *ev = (iucv_event *)arg;
  876. iucv_connection *conn = ev->conn;
  877. net_device *netdev = conn->netdev;
  878. netiucv_priv *privptr = (netiucv_priv *)netdev->priv;
  880. #ifdef DEBUG
  881. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  882. #endif
  883. fsm_newstate(fi, CONN_STATE_STOPPED);
  884. netiucv_purge_skb_queue(&conn->collect_queue);
  885. if (conn->handle)
  886. iucv_unregister_program(conn->handle);
  887. conn->handle = 0;
  888. fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
  889. }
  891. static void
  892. conn_action_inval(fsm_instance *fi, int event, void *arg)
  893. {
  894. iucv_event *ev = (iucv_event *)arg;
  895. iucv_connection *conn = ev->conn;
  896. net_device *netdev = conn->netdev;
  898. printk(KERN_WARNING
  899.        "%s: Cannot connect without usernamen",
  900.        netdev->name);
  901. }
  903. static const fsm_node conn_fsm[] = {
  904. { CONN_STATE_INVALID,   CONN_EVENT_START,    conn_action_inval      },
  905. { CONN_STATE_STOPPED,   CONN_EVENT_START,    conn_action_start      },
  906. { CONN_STATE_STARTWAIT, CONN_EVENT_START,    conn_action_start      },
  908. { CONN_STATE_STARTWAIT, CONN_EVENT_STOP,     conn_action_stop       },
  909. { CONN_STATE_SETUPWAIT, CONN_EVENT_STOP,     conn_action_stop       },
  910. { CONN_STATE_IDLE,      CONN_EVENT_STOP,     conn_action_stop       },
  911. { CONN_STATE_TX,        CONN_EVENT_STOP,     conn_action_stop       },
  912. { CONN_STATE_REGERR,    CONN_EVENT_STOP,     conn_action_stop       },
  913. { CONN_STATE_CONNERR,   CONN_EVENT_STOP,     conn_action_stop       },
  915. { CONN_STATE_STOPPED,   CONN_EVENT_CONN_REQ, conn_action_connreject },
  916.         { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
  917. { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
  918. { CONN_STATE_IDLE,      CONN_EVENT_CONN_REQ, conn_action_connreject },
  919. { CONN_STATE_TX,        CONN_EVENT_CONN_REQ, conn_action_connreject },
  921. { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack    },
  923. { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever  },
  924. { CONN_STATE_IDLE,      CONN_EVENT_CONN_REJ, conn_action_connsever  },
  925. { CONN_STATE_TX,        CONN_EVENT_CONN_REJ, conn_action_connsever  },
  927. { CONN_STATE_IDLE,      CONN_EVENT_RX,       conn_action_rx         },
  928. { CONN_STATE_TX,        CONN_EVENT_RX,       conn_action_rx         },
  930. { CONN_STATE_TX,        CONN_EVENT_TXDONE,   conn_action_txdone     },
  931. };
  933. static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
  936. /**
  937.  * Actions for interface - statemachine.
  938.  *****************************************************************************/
  940. /**
  941.  * Startup connection by sending CONN_EVENT_START to it.
  942.  *
  943.  * @param fi    An instance of an interface statemachine.
  944.  * @param event The event, just happened.
  945.  * @param arg   Generic pointer, casted from net_device * upon call.
  946.  */
  947. static void
  948. dev_action_start(fsm_instance *fi, int event, void *arg)
  949. {
  950. net_device   *dev = (net_device *)arg;
  951. netiucv_priv *privptr = dev->priv;
  952. iucv_event   ev;
  954. #ifdef DEBUG
  955. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  956. #endif
  957. ev.conn = privptr->conn;
  958. fsm_newstate(fi, DEV_STATE_STARTWAIT);
  959. fsm_event(privptr->conn->fsm, CONN_EVENT_START, &ev);
  960. }
  962. /**
  963.  * Shutdown connection by sending CONN_EVENT_STOP to it.
  964.  *
  965.  * @param fi    An instance of an interface statemachine.
  966.  * @param event The event, just happened.
  967.  * @param arg   Generic pointer, casted from net_device * upon call.
  968.  */
  969. static void
  970. dev_action_stop(fsm_instance *fi, int event, void *arg)
  971. {
  972. net_device   *dev = (net_device *)arg;
  973. netiucv_priv *privptr = dev->priv;
  974. iucv_event   ev;
  976. #ifdef DEBUG
  977. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  978. #endif
  979. ev.conn = privptr->conn;
  981. fsm_newstate(fi, DEV_STATE_STOPWAIT);
  982. fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
  983. }
  985. /**
  986.  * Called from connection statemachine
  987.  * when a connection is up and running.
  988.  *
  989.  * @param fi    An instance of an interface statemachine.
  990.  * @param event The event, just happened.
  991.  * @param arg   Generic pointer, casted from net_device * upon call.
  992.  */
  993. static void
  994. dev_action_connup(fsm_instance *fi, int event, void *arg)
  995. {
  996. net_device   *dev = (net_device *)arg;
  998. #ifdef DEBUG
  999. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  1000. #endif
  1001. switch (fsm_getstate(fi)) {
  1002. case DEV_STATE_STARTWAIT:
  1003. fsm_newstate(fi, DEV_STATE_RUNNING);
  1004. printk(KERN_INFO
  1005.        "%s: connected with remote siden",
  1006.        dev->name);
  1007. break;
  1008. case DEV_STATE_STOPWAIT:
  1009. printk(KERN_INFO
  1010.        "%s: got connection UP event during shutdown!!n",
  1011.        dev->name);
  1012. break;
  1013. }
  1014. }
  1016. /**
  1017.  * Called from connection statemachine
  1018.  * when a connection has been shutdown.
  1019.  *
  1020.  * @param fi    An instance of an interface statemachine.
  1021.  * @param event The event, just happened.
  1022.  * @param arg   Generic pointer, casted from net_device * upon call.
  1023.  */
  1024. static void
  1025. dev_action_conndown(fsm_instance *fi, int event, void *arg)
  1026. {
  1027. net_device   *dev = (net_device *)arg;
  1028. netiucv_priv *privptr = dev->priv;
  1029. iucv_event   ev;
  1031. #ifdef DEBUG
  1032. printk(KERN_DEBUG "%s() calledn", __FUNCTION__);
  1033. #endif
  1034. switch (fsm_getstate(fi)) {
  1035. case DEV_STATE_RUNNING:
  1036. fsm_newstate(fi, DEV_STATE_STARTWAIT);
  1037. ev.conn = privptr->conn;
  1038. fsm_event(privptr->conn->fsm, CONN_EVENT_START, &ev);
  1039. break;
  1040. case DEV_STATE_STARTWAIT:
  1041. break;
  1042. case DEV_STATE_STOPWAIT:
  1043. fsm_newstate(fi, DEV_STATE_STOPPED);
  1044. break;
  1045. }
  1046. }
  1048. static const fsm_node dev_fsm[] = {
  1049. { DEV_STATE_STOPPED,   DEV_EVENT_START,   dev_action_start    },
  1051. { DEV_STATE_STOPWAIT,  DEV_EVENT_START,   dev_action_start    },
  1052. { DEV_STATE_STOPWAIT,  DEV_EVENT_CONDOWN, dev_action_conndown },
  1054. { DEV_STATE_STARTWAIT, DEV_EVENT_STOP,    dev_action_stop     },
  1055. { DEV_STATE_STARTWAIT, DEV_EVENT_CONUP,   dev_action_connup   },
  1056. { DEV_STATE_STARTWAIT, DEV_EVENT_CONDOWN, dev_action_conndown },
  1058. { DEV_STATE_RUNNING,   DEV_EVENT_STOP,    dev_action_stop     },
  1059. { DEV_STATE_RUNNING,   DEV_EVENT_CONDOWN, dev_action_conndown },
  1060. { DEV_STATE_RUNNING,   DEV_EVENT_CONUP,   fsm_action_nop      },
  1061. };
  1063. static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
  1065. /**
  1066.  * Transmit a packet.
  1067.  * This is a helper function for netiucv_tx().
  1068.  *
  1069.  * @param conn Connection to be used for sending.
  1070.  * @param skb Pointer to struct sk_buff of packet to send.
  1071.  *            The linklevel header has already been set up
  1072.  *            by netiucv_tx().
  1073.  *
  1074.  * @return 0 on success, -ERRNO on failure. (Never fails.)
  1075.  */
  1076. static int
  1077. netiucv_transmit_skb(iucv_connection *conn, struct sk_buff *skb) {
  1078. unsigned long saveflags;
  1079. ll_header header;
  1080. int       rc = 0;
  1082. if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
  1083. int l = skb->len + NETIUCV_HDRLEN;
  1085. spin_lock_irqsave(&conn->collect_lock, saveflags);
  1086. if (conn->collect_len + l >
  1087.     (conn->max_buffsize - NETIUCV_HDRLEN))
  1088. rc = -EBUSY;
  1089. else {
  1090. atomic_inc(&skb->users);
  1091. skb_queue_tail(&conn->collect_queue, skb);
  1092. conn->collect_len += l;
  1093. }
  1094. spin_unlock_irqrestore(&conn->collect_lock, saveflags);
  1095. } else {
  1096. struct sk_buff *nskb = skb;
  1097. /**
  1098.  * Copy the skb to a new allocated skb in lowmem only if the
  1099.  * data is located above 2G in memory or tailroom is < 2.
  1100.  */
  1101. unsigned long hi =
  1102. ((unsigned long)(skb->tail + NETIUCV_HDRLEN)) >> 31;
  1103. int copied = 0;
  1104. if (hi || (skb_tailroom(skb) < 2)) {
  1105. nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
  1106.  NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
  1107. if (!nskb) {
  1108. printk(KERN_WARNING
  1109.        "%s: Could not allocate tx_skbn",
  1110.        conn->netdev->name);
  1111. rc = -ENOMEM;
  1112. } else {
  1113. skb_reserve(nskb, NETIUCV_HDRLEN);
  1114. memcpy(skb_put(nskb, skb->len),
  1115.        skb->data, skb->len);
  1116. }
  1117. copied = 1;
  1118. }
  1119. /**
  1120.  * skb now is below 2G and has enough room. Add headers.
  1121.  */
  1122. header.next = nskb->len + NETIUCV_HDRLEN;
  1123. memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
  1124. header.next = 0;
  1125. memcpy(skb_put(nskb, NETIUCV_HDRLEN), &header,  NETIUCV_HDRLEN);
  1127. conn->retry = 0;
  1128. fsm_newstate(conn->fsm, CONN_STATE_TX);
  1129. fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
  1130.      CONN_EVENT_TIMER, conn);
  1131. conn->prof.send_stamp = xtime;
  1133. rc = iucv_send(conn->pathid, NULL, 0, 0,
  1134.        /* Shut up, gcc! nskb is always below 2G. */
  1135.        (__u32)(((unsigned long)nskb)&0xffffffff), 0,
  1136.        nskb->data, nskb->len);
  1137. conn->prof.doios_single++;
  1138. conn->prof.txlen += skb->len;
  1139. if (rc != 0) {
  1140. fsm_deltimer(&conn->timer);
  1141. if (copied)
  1142. dev_kfree_skb(nskb);
  1143. else {
  1144. /**
  1145.  * Remove our headers. They get added
  1146.  * again on retransmit.
  1147.  */
  1148. skb_pull(skb, NETIUCV_HDRLEN);
  1149. skb_trim(skb, skb->len - NETIUCV_HDRLEN);
  1150. }
  1151. } else {
  1152. if (copied)
  1153. dev_kfree_skb(skb);
  1154. }
  1155. }
  1157. return rc;
  1158. }
  1160. /**
  1161.  * Interface API for upper network layers
  1162.  *****************************************************************************/
  1164. /**
  1165.  * Open an interface.
  1166.  * Called from generic network layer when ifconfig up is run.
  1167.  *
  1168.  * @param dev Pointer to interface struct.
  1169.  *
  1170.  * @return 0 on success, -ERRNO on failure. (Never fails.)
  1171.  */
  1172. static int
  1173. netiucv_open(net_device *dev) {
  1174. MOD_INC_USE_COUNT;
  1175. SET_DEVICE_START(dev, 1);
  1176. fsm_event(((netiucv_priv *)dev->priv)->fsm, DEV_EVENT_START, dev);
  1177. return 0;
  1178. }
  1180. /**
  1181.  * Close an interface.
  1182.  * Called from generic network layer when ifconfig down is run.
  1183.  *
  1184.  * @param dev Pointer to interface struct.
  1185.  *
  1186.  * @return 0 on success, -ERRNO on failure. (Never fails.)
  1187.  */
  1188. static int
  1189. netiucv_close(net_device *dev) {
  1190. SET_DEVICE_START(dev, 0);
  1191. fsm_event(((netiucv_priv *)dev->priv)->fsm, DEV_EVENT_STOP, dev);
  1192. MOD_DEC_USE_COUNT;
  1193. return 0;
  1194. }
  1196. /**
  1197.  * Start transmission of a packet.
  1198.  * Called from generic network device layer.
  1199.  *
  1200.  * @param skb Pointer to buffer containing the packet.
  1201.  * @param dev Pointer to interface struct.
  1202.  *
  1203.  * @return 0 if packet consumed, !0 if packet rejected.
  1204.  *         Note: If we return !0, then the packet is free'd by
  1205.  *               the generic network layer.
  1206.  */
  1207. static int netiucv_tx(struct sk_buff *skb, net_device *dev)
  1208. {
  1209. int          rc = 0;
  1210. netiucv_priv *privptr = (netiucv_priv *)dev->priv;
  1212. /**
  1213.  * Some sanity checks ...
  1214.  */
  1215. if (skb == NULL) {
  1216. printk(KERN_WARNING "%s: NULL sk_buff passedn", dev->name);
  1217. privptr->stats.tx_dropped++;
  1218. return 0;
  1219. }
  1220. if (skb_headroom(skb) < (NETIUCV_HDRLEN)) {
  1221. printk(KERN_WARNING
  1222.        "%s: Got sk_buff with head room < %ld bytesn",
  1223.        dev->name, NETIUCV_HDRLEN);
  1224. dev_kfree_skb(skb);
  1225. privptr->stats.tx_dropped++;
  1226. return 0;
  1227. }
  1229. /**
  1230.  * If connection is not running, try to restart it
  1231.  * notify anybody about a link failure and throw
  1232.  * away packet. 
  1233.  */
  1234. if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
  1235. fsm_event(privptr->fsm, DEV_EVENT_START, dev);
  1236. dst_link_failure(skb);
  1237. dev_kfree_skb(skb);
  1238. privptr->stats.tx_dropped++;
  1239. privptr->stats.tx_errors++;
  1240. privptr->stats.tx_carrier_errors++;
  1241. return 0;
  1242. }
  1244. if (netiucv_test_and_set_busy(dev))
  1245. return -EBUSY;
  1247. dev->trans_start = jiffies;
  1248. if (netiucv_transmit_skb(privptr->conn, skb) != 0)
  1249. rc = 1;
  1250. netiucv_clear_busy(dev);
  1251. return rc;
  1252. }
  1254. /**
  1255.  * Returns interface statistics of a device.
  1256.  *
  1257.  * @param dev Pointer to interface struct.
  1258.  *
  1259.  * @return Pointer to stats struct of this interface.
  1260.  */
  1261. static struct net_device_stats *
  1262. netiucv_stats (net_device * dev)
  1263. {
  1264. return &((netiucv_priv *)dev->priv)->stats;
  1265. }
  1267. /**
  1268.  * Sets MTU of an interface.
  1269.  *
  1270.  * @param dev     Pointer to interface struct.
  1271.  * @param new_mtu The new MTU to use for this interface.
  1272.  *
  1273.  * @return 0 on success, -EINVAL if MTU is out of valid range.
  1274.  *         (valid range is 576 .. NETIUCV_MTU_MAX).
  1275.  */
  1276. static int
  1277. netiucv_change_mtu (net_device * dev, int new_mtu)
  1278. {
  1279. if ((new_mtu < 576) || (new_mtu > NETIUCV_MTU_MAX))
  1280. return -EINVAL;
  1281. dev->mtu = new_mtu;
  1282. return 0;
  1283. }
  1286. /**
  1287.  * procfs related structures and routines
  1288.  *****************************************************************************/
  1290. static net_device *
  1291. find_netdev_by_ino(unsigned long ino)
  1292. {
  1293. iucv_connection *conn = connections;
  1294. net_device *dev = NULL;
  1295. netiucv_priv *privptr;
  1297. while (conn) {
  1298. if (conn->netdev != dev) {
  1299. dev = conn->netdev;
  1300. privptr = (netiucv_priv *)dev->priv;
  1302. if ((privptr->proc_buffer_entry->low_ino == ino) ||
  1303.     (privptr->proc_user_entry->low_ino == ino)   ||
  1304.     (privptr->proc_stat_entry->low_ino == ino)     )
  1305. return dev;
  1306. }
  1307. conn = conn->next;
  1308. }
  1309. return NULL;
  1310. }
  1312. #if LINUX_VERSION_CODE < 0x020363
  1313. /**
  1314.  * Lock the module, if someone changes into
  1315.  * our proc directory.
  1316.  */
  1317. static void
  1318. netiucv_fill_inode(struct inode *inode, int fill)
  1319. {
  1320. if (fill) {
  1321. MOD_INC_USE_COUNT;
  1322. } else
  1323. MOD_DEC_USE_COUNT;
  1324. }
  1325. #endif
  1327. #define CTRL_BUFSIZE 40
  1329. static int
  1330. netiucv_buffer_open(struct inode *inode, struct file *file)
  1331. {
  1332. file->private_data = kmalloc(CTRL_BUFSIZE, GFP_KERNEL);
  1333. if (file->private_data == NULL)
  1334. return -ENOMEM;
  1335. MOD_INC_USE_COUNT;
  1336. return 0;
  1337. }
  1339. static int
  1340. netiucv_buffer_close(struct inode *inode, struct file *file)
  1341. {
  1342. kfree(file->private_data);
  1343. MOD_DEC_USE_COUNT;
  1344. return 0;
  1345. }
  1347. static ssize_t
  1348. netiucv_buffer_write(struct file *file, const char *buf, size_t count,
  1349.    loff_t *off)
  1350. {
  1351. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1352. net_device   *dev;
  1353. netiucv_priv *privptr;
  1354. char         *e;
  1355. int          bs1;
  1356. char         tmp[CTRL_BUFSIZE];
  1358. if (!(dev = find_netdev_by_ino(ino)))
  1359. return -ENODEV;
  1360. if (off != &file->f_pos)
  1361. return -ESPIPE;
  1363. privptr = (netiucv_priv *)dev->priv;
  1365. if (count >= CTRL_BUFSIZE-1)
  1366. return -EINVAL;
  1368. if (copy_from_user(tmp, buf, count))
  1369. return -EFAULT;
  1370. tmp[count+1] = '';
  1371. bs1 = simple_strtoul(tmp, &e, 0);
  1373. if ((bs1 > NETIUCV_BUFSIZE_MAX) ||
  1374.     (e && (!isspace(*e))))
  1375. return -EINVAL;
  1376. if ((dev->flags & IFF_RUNNING) &&
  1377.     (bs1 < (dev->mtu + NETIUCV_HDRLEN + 2)))
  1378. return -EINVAL;
  1379. if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN))
  1380. return -EINVAL;
  1383. privptr->conn->max_buffsize = bs1;
  1384. if (!(dev->flags & IFF_RUNNING))
  1385. dev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
  1386. privptr->conn->flags |= CONN_FLAGS_BUFSIZE_CHANGED;
  1388. return count;
  1389. }
  1391. static ssize_t
  1392. netiucv_buffer_read(struct file *file, char *buf, size_t count, loff_t *off)
  1393. {
  1394. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1395. char *sbuf = (char *)file->private_data;
  1396. net_device *dev;
  1397. netiucv_priv *privptr;
  1398. ssize_t ret = 0;
  1399. char *p = sbuf;
  1400. int l;
  1402. if (!(dev = find_netdev_by_ino(ino)))
  1403. return -ENODEV;
  1404. if (off != &file->f_pos)
  1405. return -ESPIPE;
  1407. privptr = (netiucv_priv *)dev->priv;
  1409. if (file->f_pos == 0)
  1410. sprintf(sbuf, "%dn", privptr->conn->max_buffsize);
  1412. l = strlen(sbuf);
  1413. p = sbuf;
  1414. if (file->f_pos < l) {
  1415. p += file->f_pos;
  1416. l = strlen(p);
  1417. ret = (count > l) ? l : count;
  1418. if (copy_to_user(buf, p, ret))
  1419. return -EFAULT;
  1420. }
  1421. file->f_pos += ret;
  1422. return ret;
  1423. }
  1425. static int
  1426. netiucv_user_open(struct inode *inode, struct file *file)
  1427. {
  1428. file->private_data = kmalloc(CTRL_BUFSIZE, GFP_KERNEL);
  1429. if (file->private_data == NULL)
  1430. return -ENOMEM;
  1431. MOD_INC_USE_COUNT;
  1432. return 0;
  1433. }
  1435. static int
  1436. netiucv_user_close(struct inode *inode, struct file *file)
  1437. {
  1438. kfree(file->private_data);
  1439. MOD_DEC_USE_COUNT;
  1440. return 0;
  1441. }
  1443. static ssize_t
  1444. netiucv_user_write(struct file *file, const char *buf, size_t count,
  1445.    loff_t *off)
  1446. {
  1447. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1448. net_device   *dev;
  1449. netiucv_priv *privptr;
  1450. int          i;
  1451. char         *p;
  1452. char         tmp[CTRL_BUFSIZE];
  1453. char         user[9];
  1455. if (!(dev = find_netdev_by_ino(ino)))
  1456. return -ENODEV;
  1457. if (off != &file->f_pos)
  1458. return -ESPIPE;
  1460. privptr = (netiucv_priv *)dev->priv;
  1462. if (count >= CTRL_BUFSIZE-1)
  1463. return -EINVAL;
  1465. if (copy_from_user(tmp, buf, count))
  1466. return -EFAULT;
  1467. tmp[count+1] = '';
  1469. memset(user, ' ', sizeof(user));
  1470. user[8] = '';
  1471. for (p = tmp, i = 0; *p && (!isspace(*p)); p++) {
  1472. if (i > 7)
  1473. return -EINVAL;
  1474. user[i++] = *p;
  1475. }
  1477. if (memcmp(user, privptr->conn->userid, 8) != 0) {
  1478. /* username changed */
  1479. if (dev->flags & IFF_RUNNING)
  1480. return -EBUSY;
  1481. }
  1482. memcpy(privptr->conn->userid, user, 9);
  1483. return count;
  1484. }
  1486. static ssize_t
  1487. netiucv_user_read(struct file *file, char *buf, size_t count, loff_t *off)
  1488. {
  1489. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1490. char *sbuf = (char *)file->private_data;
  1491. net_device *dev;
  1492. netiucv_priv *privptr;
  1493. ssize_t ret = 0;
  1494. char *p = sbuf;
  1495. int l;
  1497. if (!(dev = find_netdev_by_ino(ino)))
  1498. return -ENODEV;
  1499. if (off != &file->f_pos)
  1500. return -ESPIPE;
  1502. privptr = (netiucv_priv *)dev->priv;
  1505. if (file->f_pos == 0)
  1506. sprintf(sbuf, "%sn",
  1507. netiucv_printname(privptr->conn->userid));
  1509. l = strlen(sbuf);
  1510. p = sbuf;
  1511. if (file->f_pos < l) {
  1512. p += file->f_pos;
  1513. l = strlen(p);
  1514. ret = (count > l) ? l : count;
  1515. if (copy_to_user(buf, p, ret))
  1516. return -EFAULT;
  1517. }
  1518. file->f_pos += ret;
  1519. return ret;
  1520. }
  1522. #define STATS_BUFSIZE 2048
  1524. static int
  1525. netiucv_stat_open(struct inode *inode, struct file *file)
  1526. {
  1527. file->private_data = kmalloc(STATS_BUFSIZE, GFP_KERNEL);
  1528. if (file->private_data == NULL)
  1529. return -ENOMEM;
  1530. MOD_INC_USE_COUNT;
  1531. return 0;
  1532. }
  1534. static int
  1535. netiucv_stat_close(struct inode *inode, struct file *file)
  1536. {
  1537. kfree(file->private_data);
  1538. MOD_DEC_USE_COUNT;
  1539. return 0;
  1540. }
  1542. static ssize_t
  1543. netiucv_stat_write(struct file *file, const char *buf, size_t count, loff_t *off)
  1544. {
  1545. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1546. net_device *dev;
  1547. netiucv_priv *privptr;
  1549. if (!(dev = find_netdev_by_ino(ino)))
  1550. return -ENODEV;
  1551. privptr = (netiucv_priv *)dev->priv;
  1552. privptr->conn->prof.maxmulti = 0;
  1553. privptr->conn->prof.maxcqueue = 0;
  1554. privptr->conn->prof.doios_single = 0;
  1555. privptr->conn->prof.doios_multi = 0;
  1556. privptr->conn->prof.txlen = 0;
  1557. privptr->conn->prof.tx_time = 0;
  1558. return count;
  1559. }
  1561. static ssize_t
  1562. netiucv_stat_read(struct file *file, char *buf, size_t count, loff_t *off)
  1563. {
  1564. unsigned int ino = ((struct inode *)file->f_dentry->d_inode)->i_ino;
  1565. char *sbuf = (char *)file->private_data;
  1566. net_device *dev;
  1567. netiucv_priv *privptr;
  1568. ssize_t ret = 0;
  1569. char *p = sbuf;
  1570. int l;
  1572. if (!(dev = find_netdev_by_ino(ino)))
  1573. return -ENODEV;
  1574. if (off != &file->f_pos)
  1575. return -ESPIPE;
  1577. privptr = (netiucv_priv *)dev->priv;
  1579. if (file->f_pos == 0) {
  1580. p += sprintf(p, "Device FSM state: %sn",
  1581.      fsm_getstate_str(privptr->fsm));
  1582. p += sprintf(p, "Connection FSM state: %sn",
  1583.      fsm_getstate_str(privptr->conn->fsm));
  1584. p += sprintf(p, "Max. TX buffer used: %ldn",
  1585.      privptr->conn->prof.maxmulti);
  1586. p += sprintf(p, "Max. chained SKBs: %ldn",
  1587.      privptr->conn->prof.maxcqueue);
  1588. p += sprintf(p, "TX single write ops: %ldn",
  1589.      privptr->conn->prof.doios_single);
  1590. p += sprintf(p, "TX multi write ops: %ldn",
  1591.      privptr->conn->prof.doios_multi);
  1592. p += sprintf(p, "Netto bytes written: %ldn",
  1593.      privptr->conn->prof.txlen);
  1594. p += sprintf(p, "Max. TX IO-time: %ldn",
  1595.      privptr->conn->prof.tx_time);
  1596. }
  1597. l = strlen(sbuf);
  1598. p = sbuf;
  1599. if (file->f_pos < l) {
  1600. p += file->f_pos;
  1601. l = strlen(p);
  1602. ret = (count > l) ? l : count;
  1603. if (copy_to_user(buf, p, ret))
  1604. return -EFAULT;
  1605. }
  1606. file->f_pos += ret;
  1607. return ret;
  1608. }
  1610. static struct file_operations netiucv_stat_fops = {
  1611. read:    netiucv_stat_read,
  1612. write:   netiucv_stat_write,
  1613. open:    netiucv_stat_open,
  1614. release: netiucv_stat_close,
  1615. };
  1617. static struct file_operations netiucv_buffer_fops = {
  1618. read:    netiucv_buffer_read,
  1619. write:   netiucv_buffer_write,
  1620. open:    netiucv_buffer_open,
  1621. release: netiucv_buffer_close,
  1622. };
  1624. static struct file_operations netiucv_user_fops = {
  1625. read:    netiucv_user_read,
  1626. write:   netiucv_user_write,
  1627. open:    netiucv_user_open,
  1628. release: netiucv_user_close,
  1629. };
  1631. static struct inode_operations netiucv_stat_iops = {
  1632. #if LINUX_VERSION_CODE < 0x020363
  1633. default_file_ops: &netiucv_stat_fops
  1634. #endif
  1635. };
  1636. static struct inode_operations netiucv_buffer_iops = {
  1637. #if LINUX_VERSION_CODE < 0x020363
  1638. default_file_ops: &netiucv_buffer_fops
  1639. #endif
  1640. };
  1642. static struct inode_operations netiucv_user_iops = {
  1643. #if LINUX_VERSION_CODE < 0x020363
  1644. default_file_ops: &netiucv_user_fops
  1645. #endif
  1646. };
  1648. static struct proc_dir_entry stat_entry = {
  1649. 0,                           /* low_ino */
  1650. 10,                          /* namelen */
  1651. "statistics",                /* name    */
  1652. S_IFREG | S_IRUGO | S_IWUSR, /* mode    */
  1653. 1,                           /* nlink   */
  1654. 0,                           /* uid     */
  1655. 0,                           /* gid     */
  1656. 0,                           /* size    */
  1657. &netiucv_stat_iops           /* ops     */
  1658. };
  1660. static struct proc_dir_entry buffer_entry = {
  1661. 0,                           /* low_ino */
  1662. 10,                          /* namelen */
  1663. "buffersize",                /* name    */
  1664. S_IFREG | S_IRUSR | S_IWUSR, /* mode    */
  1665. 1,                           /* nlink   */
  1666. 0,                           /* uid     */
  1667. 0,                           /* gid     */
  1668. 0,                           /* size    */
  1669. &netiucv_buffer_iops         /* ops     */
  1670. };
  1672. static struct proc_dir_entry user_entry = {
  1673. 0,                           /* low_ino */
  1674. 8,                           /* namelen */
  1675. "username",                  /* name    */
  1676. S_IFREG | S_IRUSR | S_IWUSR, /* mode    */
  1677. 1,                           /* nlink   */
  1678. 0,                           /* uid     */
  1679. 0,                           /* gid     */
  1680. 0,                           /* size    */
  1681. &netiucv_user_iops           /* ops     */
  1682. };
  1684. #if LINUX_VERSION_CODE < 0x020363
  1685. static struct proc_dir_entry netiucv_dir = {
  1686. 0,                           /* low_ino  */
  1687. 4,                           /* namelen  */
  1688. "iucv",                      /* name     */
  1689. S_IFDIR | S_IRUGO | S_IXUGO, /* mode     */
  1690. 2,                           /* nlink    */
  1691. 0,                           /* uid      */
  1692. 0,                           /* gid      */
  1693. 0,                           /* size     */
  1694. 0,                           /* ops      */
  1695. 0,                           /* get_info */
  1696. netiucv_fill_inode           /* fill_ino (for locking) */
  1697. };
  1699. static struct proc_dir_entry netiucv_template =
  1700. {
  1701. 0,                           /* low_ino  */
  1702. 0,                           /* namelen  */
  1703. "",                          /* name     */
  1704. S_IFDIR | S_IRUGO | S_IXUGO, /* mode     */
  1705. 2,                           /* nlink    */
  1706. 0,                           /* uid      */
  1707. 0,                           /* gid      */
  1708. 0,                           /* size     */
  1709. 0,                           /* ops      */
  1710. 0,                           /* get_info */
  1711. netiucv_fill_inode           /* fill_ino (for locking) */
  1712. };
  1713. #else
  1714. static struct proc_dir_entry *netiucv_dir = NULL;
  1715. static struct proc_dir_entry *netiucv_template = NULL;
  1716. #endif
  1718. /**
  1719.  * Create the driver's main directory /proc/net/iucv
  1720.  */
  1721. static void
  1722. netiucv_proc_create_main(void)
  1723. {
  1724. /**
  1725.  * If not registered, register main proc dir-entry now
  1726.  */
  1727. #if LINUX_VERSION_CODE > 0x020362
  1728. if (!netiucv_dir)
  1729. netiucv_dir = proc_mkdir("iucv", proc_net);
  1730. #else
  1731. if (netiucv_dir.low_ino == 0)
  1732. proc_net_register(&netiucv_dir);
  1733. #endif
  1734. }
  1736. #ifdef MODULE
  1737. /**
  1738.  * Destroy /proc/net/iucv
  1739.  */
  1740. static void
  1741. netiucv_proc_destroy_main(void)
  1742. {
  1743. #if LINUX_VERSION_CODE > 0x020362
  1744. remove_proc_entry("iucv", proc_net);
  1745. #else
  1746. proc_net_unregister(netiucv_dir.low_ino);
  1747. #endif
  1748. }
  1749. #endif MODULE
  1751. /**
  1752.  * Create a device specific subdirectory in /proc/net/iucv/ with the
  1753.  * same name like the device. In that directory, create 3 entries
  1754.  * "statistics", "buffersize" and "username".
  1755.  *
  1756.  * @param dev The device for which the subdirectory should be created.
  1757.  *
  1758.  */
  1759. static void
  1760. netiucv_proc_create_sub(net_device *dev) {
  1761. netiucv_priv *privptr = dev->priv;
  1763. #if LINUX_VERSION_CODE > 0x020362
  1764. privptr->proc_dentry = proc_mkdir(dev->name, netiucv_dir);
  1765. privptr->proc_stat_entry =
  1766. create_proc_entry("statistics",
  1767.   S_IFREG | S_IRUSR | S_IWUSR,
  1768.   privptr->proc_dentry);
  1769. privptr->proc_stat_entry->proc_fops = &netiucv_stat_fops;
  1770. privptr->proc_stat_entry->proc_iops = &netiucv_stat_iops;
  1771. privptr->proc_buffer_entry =
  1772. create_proc_entry("buffersize",
  1773.   S_IFREG | S_IRUSR | S_IWUSR,
  1774.   privptr->proc_dentry);
  1775. privptr->proc_buffer_entry->proc_fops = &netiucv_buffer_fops;
  1776. privptr->proc_buffer_entry->proc_iops = &netiucv_buffer_iops;
  1777. privptr->proc_user_entry =
  1778. create_proc_entry("username",
  1779.   S_IFREG | S_IRUSR | S_IWUSR,
  1780.   privptr->proc_dentry);
  1781. privptr->proc_user_entry->proc_fops = &netiucv_user_fops;
  1782. privptr->proc_user_entry->proc_iops = &netiucv_user_iops;
  1783. #else
  1784. privptr->proc_dentry->name = dev->name;
  1785. privptr->proc_dentry->namelen = strlen(dev->name);
  1786. proc_register(&netiucv_dir, privptr->proc_dentry);
  1787. proc_register(privptr->proc_dentry, privptr->proc_stat_entry);
  1788. proc_register(privptr->proc_dentry, privptr->proc_buffer_entry);
  1789. proc_register(privptr->proc_dentry, privptr->proc_user_entry);
  1790. #endif
  1791. privptr->proc_registered = 1;
  1792. }
  1795. /**
  1796.  * Destroy a device specific subdirectory.
  1797.  *
  1798.  * @param privptr Pointer to device private data.
  1799.  */
  1800. static void
  1801. netiucv_proc_destroy_sub(netiucv_priv *privptr) {
  1802. if (!privptr->proc_registered)
  1803. return;
  1804. #if LINUX_VERSION_CODE > 0x020362
  1805. remove_proc_entry("statistics", privptr->proc_dentry);
  1806. remove_proc_entry("buffersize", privptr->proc_dentry);
  1807. remove_proc_entry("username", privptr->proc_dentry);
  1808. remove_proc_entry(privptr->proc_dentry->name, netiucv_dir);
  1809. #else
  1810. proc_unregister(privptr->proc_dentry,
  1811. privptr->proc_stat_entry->low_ino);
  1812. proc_unregister(privptr->proc_dentry,
  1813. privptr->proc_buffer_entry->low_ino);
  1814. proc_unregister(privptr->proc_dentry,
  1815. privptr->proc_user_entry->low_ino);
  1816. proc_unregister(&netiucv_dir,
  1817. privptr->proc_dentry->low_ino);
  1818. #endif
  1819. privptr->proc_registered = 0;
  1820. }
  1823. /**
  1824.  * Allocate and initialize a new connection structure.
  1825.  * Add it to the list of connections;
  1826.  */
  1827. static iucv_connection *
  1828. netiucv_new_connection(net_device *dev, char *username)
  1829. {
  1830. iucv_connection **clist = &connections;
  1831. iucv_connection *conn =
  1832. (iucv_connection *)kmalloc(sizeof(iucv_connection), GFP_KERNEL);
  1833. if (conn) {
  1834. memset(conn, 0, sizeof(iucv_connection));
  1835. skb_queue_head_init(&conn->collect_queue);
  1836. conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
  1837. conn->netdev = dev;
  1839. conn->rx_buff = alloc_skb(NETIUCV_BUFSIZE_DEFAULT, GFP_DMA);
  1840. if (!conn->rx_buff) {
  1841. kfree(conn);
  1842. return NULL;
  1843. }
  1844. conn->tx_buff = alloc_skb(NETIUCV_BUFSIZE_DEFAULT, GFP_DMA);
  1845. if (!conn->tx_buff) {
  1846. kfree_skb(conn->rx_buff);
  1847. kfree(conn);
  1848. return NULL;
  1849. }
  1850. conn->fsm = init_fsm("netiucvconn", conn_state_names,
  1851.      conn_event_names, NR_CONN_STATES,
  1852.      NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
  1853.      GFP_KERNEL);
  1854. if (!conn->fsm) {
  1855. kfree_skb(conn->tx_buff);
  1856. kfree_skb(conn->rx_buff);
  1857. kfree(conn);
  1858. return NULL;
  1859. }
  1860. fsm_settimer(conn->fsm, &conn->timer);
  1861. fsm_newstate(conn->fsm, CONN_STATE_INVALID);
  1863. if (username) {
  1864. memcpy(conn->userid, username, 9);
  1865. fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
  1866. }
  1868. conn->next = *clist;
  1869. *clist = conn;
  1870. }
  1871. return conn;
  1872. }
  1874. /**
  1875.  * Release a connection structure and remove it from the
  1876.  * list of connections.
  1877.  */
  1878. static void
  1879. netiucv_remove_connection(iucv_connection *conn)
  1880. {
  1881. iucv_connection **clist = &connections;
  1883. if (conn == NULL)
  1884. return;
  1885. while (*clist) {
  1886. if (*clist == conn) {
  1887. *clist = conn->next;
  1888. if (conn->handle != 0) {
  1889. iucv_unregister_program(conn->handle);
  1890. conn->handle = 0;
  1891. }
  1892. fsm_deltimer(&conn->timer);
  1893. kfree_fsm(conn->fsm);
  1894. kfree_skb(conn->rx_buff);
  1895. kfree_skb(conn->tx_buff);
  1896. return;
  1897. }
  1898. clist = &((*clist)->next);
  1899. }
  1900. }
  1902. /**
  1903.  * Allocate and initialize everything of a net device.
  1904.  */
  1905. static net_device *
  1906. netiucv_init_netdevice(int ifno, char *username)
  1907. {
  1908. netiucv_priv *privptr;
  1909. int          priv_size;
  1911. net_device *dev = kmalloc(sizeof(net_device)
  1912. #if LINUX_VERSION_CODE < 0x020300
  1913.       + 11 /* name + zero */
  1914. #endif
  1915.       , GFP_KERNEL);
  1916. if (!dev)
  1917. return NULL;
  1918. memset(dev, 0, sizeof(net_device));
  1919. #if LINUX_VERSION_CODE < 0x020300
  1920. dev->name = (char *)dev + sizeof(net_device);
  1921. #endif
  1922. sprintf(dev->name, "iucv%d", ifno);
  1924. priv_size = sizeof(netiucv_priv) + sizeof(netiucv_template) +
  1925. sizeof(stat_entry) + sizeof(buffer_entry) + sizeof(user_entry);
  1926. dev->priv = kmalloc(priv_size, GFP_KERNEL);
  1927. if (dev->priv == NULL) {
  1928. kfree(dev);
  1929. return NULL;
  1930. }
  1931.         memset(dev->priv, 0, priv_size);
  1932.         privptr = (netiucv_priv *)dev->priv;
  1933.         privptr->proc_dentry = (struct proc_dir_entry *)
  1934. (((char *)privptr) + sizeof(netiucv_priv));
  1935.         privptr->proc_stat_entry = (struct proc_dir_entry *)
  1936. (((char *)privptr) + sizeof(netiucv_priv) +
  1937.  sizeof(netiucv_template));
  1938.         privptr->proc_buffer_entry = (struct proc_dir_entry *)
  1939. (((char *)privptr) + sizeof(netiucv_priv) +
  1940.  sizeof(netiucv_template) + sizeof(stat_entry));
  1941.         privptr->proc_user_entry = (struct proc_dir_entry *)
  1942. (((char *)privptr) + sizeof(netiucv_priv) +
  1943.  sizeof(netiucv_template) + sizeof(stat_entry) +
  1944.  sizeof(buffer_entry));
  1945. memcpy(privptr->proc_dentry, &netiucv_template,
  1946.        sizeof(netiucv_template));
  1947. memcpy(privptr->proc_stat_entry, &stat_entry, sizeof(stat_entry));
  1948. memcpy(privptr->proc_buffer_entry, &buffer_entry, sizeof(buffer_entry));
  1949. memcpy(privptr->proc_user_entry, &user_entry, sizeof(user_entry));
  1950. privptr->fsm = init_fsm("netiucvdev", dev_state_names,
  1951. dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
  1952. dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
  1953. if (privptr->fsm == NULL) {
  1954. kfree(privptr);
  1955. kfree(dev);
  1956. return NULL;
  1957. }
  1958. privptr->conn = netiucv_new_connection(dev, username);
  1959. if (!privptr->conn) {
  1960. kfree_fsm(privptr->fsm);
  1961. kfree(privptr);
  1962. kfree(dev);
  1963. return NULL;
  1964. }
  1966. fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
  1967. dev->mtu          = NETIUCV_MTU_DEFAULT;
  1968. dev->hard_start_xmit     = netiucv_tx;
  1969. dev->open          = netiucv_open;
  1970. dev->stop          = netiucv_close;
  1971. dev->get_stats          = netiucv_stats;
  1972. dev->change_mtu          = netiucv_change_mtu;
  1973. dev->hard_header_len     = NETIUCV_HDRLEN;
  1974. dev->addr_len            = 0;
  1975. dev->type                = ARPHRD_SLIP;
  1976. dev->tx_queue_len        = NETIUCV_QUEUELEN_DEFAULT;
  1977. dev_init_buffers(dev);
  1978. dev->flags          = IFF_POINTOPOINT | IFF_NOARP;
  1979. return dev;
  1980. }
  1982. /**
  1983.  * Allocate and initialize everything of a net device.
  1984.  */
  1985. static void
  1986. netiucv_free_netdevice(net_device *dev)
  1987. {
  1988. netiucv_priv *privptr;
  1990. if (!dev)
  1991. return;
  1993. privptr = (netiucv_priv *)dev->priv;
  1994. if (privptr) {
  1995. if (privptr->conn)
  1996. netiucv_remove_connection(privptr->conn);
  1997. if (privptr->fsm)
  1998. kfree_fsm(privptr->fsm);
  1999. netiucv_proc_destroy_sub(privptr);
  2000. kfree(privptr);
  2001. }
  2002. kfree(dev);
  2003. }
  2005. static void
  2006. netiucv_banner(void)
  2007. {
  2008. char vbuf[] = "$Revision: 1.17 $";
  2009. char *version = vbuf;
  2011. if ((version = strchr(version, ':'))) {
  2012. char *p = strchr(version + 1, '$');
  2013. if (p)
  2014. *p = '';
  2015. } else
  2016. version = " ??? ";
  2017. printk(KERN_INFO "NETIUCV driver Version%s initializedn", version);
  2018. }
  2020. #ifndef MODULE
  2021. # if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0))
  2022. #  define init_return(a) return a
  2023. static int __init
  2024. iucv_setup(char *param)
  2025. # else
  2026. #  define init_return(a) return
  2027. __initfunc (void iucv_setup(char *param, int *ints))
  2028. # endif
  2029. {
  2030. /**
  2031. * We do not parse parameters here because at the time of
  2032. * calling iucv_setup(), the kernel does not yet have
  2033. * memory management running. We delay this until probing
  2034. * is called.
  2035. */
  2036. iucv = param;
  2037. init_return(1);
  2038. }
  2040. # if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0))
  2041. __setup ("iucv=", iucv_setup);
  2042. # endif
  2043. #else
  2044. static void
  2045. netiucv_exit(void)
  2046. {
  2047. while (connections) {
  2048. net_device *dev = connections->netdev;
  2049. unregister_netdev(dev);
  2050. netiucv_free_netdevice(dev);
  2051. }
  2052. netiucv_proc_destroy_main();
  2054. printk(KERN_INFO "NETIUCV driver unloadedn");
  2055. return;
  2056. }
  2057. #endif
  2059. static int
  2060. netiucv_init(void)
  2061. {
  2062. char *p = iucv;
  2063. int ifno = 0;
  2064. int i = 0;
  2065. char username[10];
  2067. netiucv_proc_create_main();
  2068. while (p) {
  2069. if (isalnum(*p)) {
  2070. username[i++] = *p++;
  2071. username[i] = '';
  2072. if (i > 8) {
  2073. printk(KERN_WARNING
  2074.        "netiucv: Invalid user name '%s'n",
  2075.        username);
  2076. while (*p && (*p != ':') && (*p != ','))
  2077. p++;
  2078. }
  2079. } else {
  2080. if (*p && (*p != ':') && (*p != ',')) {
  2081. printk(KERN_WARNING
  2082.        "netiucv: Invalid delimiter '%c'n",
  2083.        *p);
  2084. while (*p && (*p != ':') && (*p != ','))
  2085. p++;
  2086. } else {
  2087. if (i) {
  2088. net_device *dev;
  2090. while (i < 9)
  2091. username[i++] = ' ';
  2092. username[9] = '';
  2093. dev = netiucv_init_netdevice(ifno,
  2094.      username);
  2095. if (!dev)
  2096. printk(KERN_WARNING
  2097.        "netiucv: Could not allocate network device structure for user '%s'n", netiucv_printname(username));
  2098. else {
  2099. if (register_netdev(dev)) {
  2100. printk(KERN_WARNING
  2101.        "netiucv: Could not register '%s'n", dev->name);
  2102. netiucv_free_netdevice(dev);
  2103. } else {
  2104. printk(KERN_INFO "%s: '%s'n", dev->name, netiucv_printname(username));
  2105. netiucv_proc_create_sub(dev);
  2106. ifno++;
  2107. }
  2108. }
  2109. }
  2110. if (!(*p))
  2111. break;
  2112. i = 0;
  2113. p++;
  2114. }
  2115. }
  2116. }
  2117. netiucv_banner();
  2118. return 0;
  2119. }
  2121. #ifdef MODULE
  2122. module_init(netiucv_init);
  2123. module_exit(netiucv_exit);
  2124. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,12))
  2125. MODULE_LICENSE("GPL");
  2126. #endif
  2127. #endif