NeXT/nbq.h

   1 /*
   2  * All very trivial - the simpler the better I say. We try and keep
   3  * quqes of netbufs by squirreling a pointer away below the data area.
   4  * This is done by the ppp_nb_alloc function. As long as everyone
   5  * uses the ppp shrink and grow functions we should be o.k. This code
   6  * has now been modified to keep the mark_t stuff nhere as well since
   7  * we probably shafted that good and proper in the last version. oops !
   8  * PCF
   9  */
  10
  11 #ifndef __NBQ_H__
  12 #define __NBQ_H__
  13
  14
  15 #define KERNEL 1
  16
  17 #include <sys/types.h>
  18 #include <kernserv/prototypes.h>
  19
  20 #include "netbuf.h"
  21 typedef u_int mark_t;
  22
  23 /*
  24  * Netbufs and Netbuf wrappers don't help us because we
  25  * have no way of keeping track of information on start
  26  * position once nb_grow* or nb_shrink* are called.
  27  */
  28
  29 #ifdef NETBUF_PROXY
  30
  31 #warning ...you are compiling with NETBUF_PROXY
  32
  33 typedef struct _bpf_encapsulater
  34 {
  35   /*
  36    * Depending on the direction of packet travel, these
  37    * values have different meanings.
  38    *
  39    * INCOMING:
  40    *    first  -- time first byte of packet received.
  41    *    second -- time last byte of packet received.
  42    *    third  -- Decompression start time
  43    *    fourth  -- Packet Handoff time
  44    *   (second-first) -- receive time
  45    *   (third-second) -- queue time waiting for decompression
  46    *   (fourth-third) -- decompression time
  47    *   (fourth - first) -- total receive time.
  48    *   (fourth - second) -- total system process time.
  49    *
  50    *   async_esc  -- The number of characters escaped in this packet.
  51    *   size1  --  The size of the inital packet before decompression.
  52    *              This value includes the expansion caused by AC and PC compression.
  53    *                If flags set:
  54    *                   AC implies packet got increased by 2 during receive.
  55    *                   PC implies packet got increased by 1 during receive.
  56    *              This + "async_esc" - (AC + PC expansion) describe actual bytes over link.
  57    *              Includes PPP header and trailer.
  58    *              Doesn't count framing PPP_FLAG character.
  59    *
  60    *   size2  --  The size after BSD decompression.  PPP trailer was removed
  61    *              so packet should be at least 2 shorter than original.
  62    *   size3  --  The size after VJ decompression.
  63    *
  64    *
  65    * OUTGOING:  (very similar to incoming)
  66    *   first  -- time packet arrived to pppwrite() or pppoutput()
  67    *   second -- time compression started
  68    *   third  -- time compression ended
  69    *   fourth -- time first byte sent to interface
  70    *   fifth --  time last byte sent to interface
  71    *
  72    *   (second - first) Time waiting in system before compression
  73    *   (third - second) Time for compression
  74    *   (fourth - third) Time waiting in system out queue waiting to be
  75    *                      selected for sending to interface
  76    *   (fourth - first) Total system processing time
  77    *   (fifth-fourth)   Total interface send time.
  78    *   (fifth-first)    Total send time.
  79    *
  80    *   size1 -- The size of the intial packet as receved from the stack
  81    *   size2 -- The size after VJ compression
  82    *   size3 -- The size after BSD compression
  83    *
  84    */
  85   struct timeval first, second, third, fourth, fifth;
  86   unsigned async_esc, size1, size2, size3;
  87
  88   int flags;                                 /* info about packet   */
  89 #define NBFLAG_INCOMING     0x01             /* else outgoing       */
  90 #define NBFLAG_AC           0x02             /* Address compressed  */
  91 #define NBFLAG_PC           0x04             /* Protocol Compressed */
  92 #define NBFLAG_VJC          0x08             /* VJ compressed       */
  93 #define NBFLAG_CCP          0x10             /* BSD compressed      */
  94 #define NBFLAG_CCPINC       0x20             /* BSD incompressible  */
  95 #define NBFLAG_VJCINC       0x40             /* VJ incompressible   */
  96
  97 } bpf_encapsulater;
  98
  99 typedef struct _ppp_netbuf_t
 100 {
 101   netbuf_t buffer;
 102   netbuf_t orig_buffer;                     /*
 103                                              * Original outgoing datagram
 104                                              * received.  We do compression and
 105                                              * statistics gathering on buffer,
 106                                              * we send buffer, but we return
 107                                              * orig_buffer to BPF so that it doesn't
 108                                              * have to understand all the compression.
 109                                              */
 110
 111
 112   struct _ppp_netbuf_t *next;               /* for linked list */
 113
 114   unsigned int size;                        /* original size requested for netbuf.
 115                                              * We leave it up to caller to
 116                                              * determine extra space they need.  We
 117                                              * may also include extra space we need
 118                                              * for bounds checking.
 119                                              */
 120
 121   unsigned char *wrapper,                   /* unaligned address returned for this containing
 122                                              * structure.  Used for freeing.
 123                                              */
 124
 125   *init_offset;                             /* Init_offset is nb_map  of the netbuf_t before
 126                                              * user can change it around.  Can check bounds
 127                                              * against this.
 128                                              */
 129   mark_t mark;
 130
 131   bpf_encapsulater pktinfo;                  /* The size and compression stats that
 132                                               * get passed to user level tcpdump
 133                                               */
 134
 135 } *ppp_netbuf_t;
 136
 137 /*
 138  * These prototypes are identical to the corrisponding functions
 139  * found in netbuf.h except they use the ppp_netbuf_t type.
 140  */
 141
 142 extern ppp_netbuf_t    cb_nb_alloc(unsigned size);
 143 extern void            cb_nb_free(ppp_netbuf_t nb);
 144 extern void            cb_nb_duplicate(ppp_netbuf_t from, ppp_netbuf_t to);
 145 extern char *          cb_nb_map(ppp_netbuf_t nb);
 146 extern char *          cb_nb_map_orig(ppp_netbuf_t nb);
 147 extern unsigned        cb_nb_size(ppp_netbuf_t nb);
 148 extern unsigned        cb_nb_size_orig(ppp_netbuf_t nb);
 149 extern int             cb_nb_shrink_top(ppp_netbuf_t nb, unsigned size);
 150 extern int             cb_nb_grow_top(ppp_netbuf_t nb, unsigned size);
 151 extern int             cb_nb_shrink_bot(ppp_netbuf_t nb, unsigned size);
 152 extern int             cb_nb_grow_bot(ppp_netbuf_t nb, unsigned size);
 153 extern int             cb_nb_read(ppp_netbuf_t nb, unsigned offset, unsigned size, void *target);
 154 extern int             cb_nb_write(ppp_netbuf_t nb, unsigned offset, unsigned size, void *source);
 155 extern void            cb_nb_get_mark(ppp_netbuf_t nb, mark_t *ptr);
 156 extern void            cb_nb_set_mark(ppp_netbuf_t nb, mark_t ptr);
 157 extern void            cb_nb_get_next(ppp_netbuf_t nb, ppp_netbuf_t *ptr);
 158 extern void            cb_nb_set_next(ppp_netbuf_t nb, ppp_netbuf_t ptr);
 159 extern ppp_netbuf_t    cb_nb_to_NB(netbuf_t);
 160 extern netbuf_t        cb_NB_to_nb(ppp_netbuf_t);
 161
 162 #define NETBUF_T ppp_netbuf_t
 163 #define NB_ALLOC cb_nb_alloc
 164 #define NB_FREE cb_nb_free
 165 #define NB_DUPLICATE cb_nb_duplicate
 166 #define NB_MAP cb_nb_map
 167 #define NB_MAP_ORIG cb_nb_map_orig
 168 #define NB_SIZE cb_nb_size
 169 #define NB_SIZE_ORIG cb_nb_size_orig
 170 #define NB_SHRINK_TOP cb_nb_shrink_top
 171 #define NB_GROW_TOP cb_nb_grow_top
 172 #define NB_SHRINK_BOT cb_nb_shrink_bot
 173 #define NB_GROW_BOT cb_nb_grow_bot
 174 #define NB_READ cb_nb_read
 175 #define NB_WRITE cb_nb_write
 176 #define NB_GET_MARK cb_nb_get_mark
 177 #define NB_SET_MARK cb_nb_set_mark
 178 #define NB_GET_NEXT cb_nb_get_next
 179 #define NB_SET_NEXT cb_nb_set_next
 180 #define nb_TO_NB cb_nb_to_NB
 181 #define NB_TO_nb cb_NB_to_nb
 182
 183 #else  /* NETBUF_PROXY */
 184
 185 #define NETBUF_T netbuf_t
 186 #define NB_ALLOC ppp_nb_alloc
 187 #define NB_FREE nb_free
 188 #define NB_MAP nb_map
 189 #define NB_SIZE nb_size
 190 #define NB_SHRINK_TOP ppp_nb_shrink_top
 191 #define NB_GROW_TOP ppp_nb_grow_top
 192 #define NB_SHRINK_BOT nb_shrink_bot
 193 #define NB_GROW_BOT nb_grow_bot
 194 #define NB_READ nb_read
 195 #define NB_WRITE nb_write
 196 #define NB_GET_MARK nb_get_mark
 197 #define NB_SET_MARK nb_set_mark
 198 #define NB_GET_NEXT nb_get_next
 199 #define NB_SET_NEXT nb_set_next
 200 #define nb_TO_NB(nb) (nb)
 201 #define NB_TO_nb(NB) (NB)
 202
 203 #endif /* NETBUF_PROXY  */
 204
 205
 206 struct qparms {
 207     u_char      q_low, q_high, q_max;
 208     char        *q_name;
 209 };
 210
 211 struct nb_queue {
 212     char        *name;
 213     int         low, high, max, len, dropped;
 214     NETBUF_T    head, tail;
 215 };
 216
 217 #ifndef NETBUF_PROXY
 218 #define NB_EXTRA (sizeof(mark_t)+sizeof(netbuf_t))
 219
 220 static inline void
 221 nb_set_next(netbuf_t nb, netbuf_t ptr)
 222 {
 223 if(nb) bcopy(&ptr,NB_MAP(nb)-sizeof(netbuf_t),sizeof(netbuf_t));
 224 }
 225
 226 static inline void
 227 nb_get_next(netbuf_t nb, netbuf_t *ptr)
 228 {
 229 if(nb && ptr) bcopy(NB_MAP(nb)-sizeof(netbuf_t),ptr,sizeof(netbuf_t));
 230 }
 231
 232 static inline void
 233 nb_set_mark(netbuf_t nb, mark_t ptr)
 234 {
 235 if(nb) bcopy(&ptr,NB_MAP(nb)-NB_EXTRA,sizeof(mark_t));
 236 }
 237
 238 static inline void
 239 nb_get_mark(netbuf_t nb, mark_t *ptr)
 240 {
 241 if(nb && ptr) bcopy(NB_MAP(nb)-NB_EXTRA,ptr,sizeof(mark_t));
 242 }
 243
 244 static inline void
 245 ppp_nb_shrink_top(netbuf_t nb, unsigned int size)
 246 {
 247     netbuf_t ptr;
 248     mark_t   mark;
 249     NB_GET_NEXT(nb,&ptr);
 250     NB_GET_MARK(nb,&mark);
 251     nb_shrink_top(nb,size);
 252     NB_SET_MARK(nb,mark);
 253     NB_SET_NEXT(nb,ptr);
 254 }
 255
 256 static inline void
 257 ppp_nb_grow_top(netbuf_t nb, unsigned int size)
 258 {
 259     netbuf_t ptr;
 260     mark_t   mark;
 261     NB_GET_NEXT(nb,&ptr);
 262     NB_GET_MARK(nb,&mark);
 263     nb_grow_top(nb,size);
 264     NB_SET_MARK(nb,mark);
 265     NB_SET_NEXT(nb,ptr);
 266 }
 267
 268
 269 static inline netbuf_t
 270 ppp_nb_alloc(unsigned int size)
 271 {
 272     netbuf_t nb;
 273
 274     size+=NB_EXTRA;
 275     nb=nb_alloc(size);
 276     if(nb) {
 277         NB_SHRINK_TOP(nb,NB_EXTRA);
 278         NB_SET_NEXT(nb,NULL);
 279         NB_SET_MARK(nb,0);
 280     }
 281     return nb;
 282 }
 283 #endif /* NETBUF_PROXY  */
 284 #endif /* __NBQ_H__ */
 285