Using pfil hooks to implement an io-net filter

We recommend that you use pfil hooks to rewrite your io-net filter to work in io-pkt . Here are the basic steps:

• Change your entry point function to remove the second argument (dispatch_t) and change the third option to be struct _iopkt_self.
• Remove the io_net_dll_entry_t and replace it with the appropriate version of:

  struct _iopkt_lsm_entry IOPKT_LSM_ENTRY_SYM(mod) =
  IOPKT_LSM_ENTRY_SYM_INIT(mod_entry);
    
  

• The rx_up and rx_down functions are essentially pfil_hook entries with a flag of PFIL_IN and PFIL_OUT, respectively.

  Information about the interface that the packet was received on is contained in the ifp pointer (defined in usr/include/net/if.h). For example, the external interface name is in ifp->if_xname; you can use this to determine where the packet came from.

  The cell, endpoint, and iface parameters are essentially wrapped up in the ifp pointer.

• There are no advertisement packets used within io-pkt. For information about interfaces being added, removed, or reconfigured, you can add an interface hook as shown in the sample code in " Packet Filters " in the Packet Filtering chapter in this guide.
• Buffering in io-pkt is handled using a different structure than in io-net. The io-net stack uses npkt_t buffers, whereas io-pkt uses the standard mbuf buffers. You have to modify your io-net code to deal with the different buffer format.

  You can find information about using mbuf buffers in many places on the web. The header file that covers the io-pkt mbuf support is in $QNX_TARGET/usr/include/sys/mbuf.h.

• The shutdown1 and shutdown2 routines are somewhat similar to the "remove_hook" options, in which the filtering functions are removed from the processing stream. Typically, a filter requiring interaction with the user (e.g. read, write, umount) would export a resource manager interface to provide a mechanism for indicating that the filter has to be removed. You can then use pfil_remove_hook() calls after cleaning up to remove the functions from the data path.
• There isn't an equivalent of tx_done for pfil. In io-net, buffers are allocated by endpoints (e.g. a driver or a protocol) and therefore an endpoint-specific function for freeing buffers needs to be called to release the buffer back to the endpoint's buffer pool.

  In io-pkt, all buffer allocation is handled explicitly by the stack middleware. This means that any element requiring a buffer goes directly to the middleware to get it, and anything freeing a buffer (e.g. the driver) puts it directly back into the middleware buffer pools. This makes things easier to deal with, because you now no longer have to track and manage your own buffer pools as an endpoint. As soon as the code is finished with the buffer, it simply performs an m_freem() of the buffer which places it back in the general pool.

  There is one downside to the global buffer implementation. You can't create a thread using pthread_create() that allocates or frees a buffer from the stack, because the thread has to modify internal stack structures. The locking implemented within io-pkt is optimized to reduce thread context-switch times, and this means that non-stack threads can't lock-protect these structures. Instead, the stack provides its own thread-creation function (defined in trunk/sys/nw_thread.h):

  int nw_pthread_create(pthread_t *tidp,
                        pthread_attr_t *attrp,
                        void *(*funcp)(void *),
                        void *arg,
                        int flags,
                        int (*init_func)(void *),
                        void *init_arg);
    
  

  The first four arguments are the standard arguments to pthread_create(); the last three are specific to io-pkt. You can find a fairly simplistic example of how to use this function in net/ppp_tty.c.

• In terms of transmitting packets, the ifp interface structure contains the if_output function that you can use to transmit a user-built Ethernet packet. The if_output maps to ether_output for an Ethernet interface. This function queues the mbuf to the driver queue for sending, and subsequently calls if_start to transmit the packet on the queue. The preliminary queuing is implemented to allow traffic shaping to take place on the interface.