Print this page 
Factor out fixed/1-1 processing from vxlnat_vxlan_one(), paving way for
future processing types.
Initial definitions of NAT flows.
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/inet/vxlnat_impl.h
          +++ new/usr/src/uts/common/inet/vxlnat_impl.h
↓ open down ↓ 61 lines elided ↑ open up ↑ 
  62   62  }
  63   63  #define VXNR_REFRELE(vxnr) {                                    \
  64   64          ASSERT((vxnr)->vxnr_refcount > 0);                      \
  65   65          membar_exit();                                          \
  66   66          if (atomic_dec_32_nv(&(vxnr)->vxnr_refcount) == 0)      \
  67   67                  vxlnat_rule_free(vxnr);                         \
  68   68  }
  69   69  extern void vxlnat_rule_free(vxlnat_rule_t *);
  70   70  
  71   71  /*
       72 + * NAT FLOWS.  These are per-vnet, and keyed/searched by:
       73 + * <inner-IP-source,IP-dest,inner-source-port,dest-port,protocol>.
       74 + * They will be tied-to/part-of
       75 + */
       76 +typedef struct vxlnat_flow_s {
       77 +        avl_node_t vxnfl_treenode;
       78 +        /*
       79 +         * I'm guessing that dst varies more than src.  Also
       80 +         * the plan is for the comparitor function to bcmp() both
       81 +         * of these as one call for IPv6 (if we ever get to that..).
       82 +         */
       83 +        in6_addr_t vxnfl_dst;
       84 +        in6_addr_t vxnfl_src;   /* INNER source address. */
       85 +        uint32_t vxnfl_ports;
       86 +        uint8_t vxnfl_protocol;
       87 +        uint8_t vxnfl_isv4 : 1, /* Will save us 12 bytes of compares... */
       88 +                vxlfl_reserved1 : 7;
       89 +        conn_t *vxnfl_connp;    /* Question - embed instead? */
       90 +        vxlnat_rule_t *vxnfl_rule; /* Refhold to rule that generated me. */
       91 +} vxlnat_flow_t;
       92 +/* Exploit endianisms, maintain network order... */
       93 +#ifdef _BIG_ENDIAN
       94 +#define VXNFL_SPORT(ports) (uint16_t)((ports) >> 16) /* Unsigned all around. */
       95 +#define VXNFL_DPORT(ports) ((ports) & 0xFFFF)
       96 +#else
       97 +#define VXNFL_SPORT(ports) ((ports) & 0xFFFF)
       98 +#define VXNFL_DPORT(ports) (uint16_t)((ports) >> 16) /* Unsigned all around. */
       99 +#endif
      100 +
      101 +/*
  72  102   * 1-1 IP mapping.
  73  103   */
  74  104  typedef struct vxlnat_fixed_s {
  75  105          avl_node_t vxnf_treenode;
  76      -        in6_addr_t vxnf_addr;   /* XXX KEBE ASKS - must it match to a rule? */
      106 +        in6_addr_t vxnf_addr;   /* For now it needn't match to a rule. */
  77  107          in6_addr_t vxnf_pubaddr; /* External IP. */
  78  108          struct vxlnat_vnet_s *vxnf_vnet;
  79      -        ire_t *vxnf_ire;        /* Should be a local IRE from the ftable. */
      109 +        ire_t *vxnf_ire;        /* Should be an IRE_LOCAL from the ftable. */
  80  110          struct vxlnat_remote_s *vxnf_remote;
  81  111          uint8_t vxnf_myether[ETHERADDRL];
  82  112          uint16_t vxnf_vlanid;   /* Stored in network order for quick xmit. */
  83  113          uint32_t vxnf_refcount;
  84  114          boolean_t vxnf_clear_router;    /* XXX KEBE SAYS CHEESY HACK */
  85  115  } vxlnat_fixed_t;
  86  116  #define VXNF_REFHOLD(vxnf) {                    \
  87  117          atomic_inc_32(&(vxnf)->vxnf_refcount);  \
  88  118          ASSERT((vxnf)->vxnf_refcount > 0);      \
  89  119  }
↓ open down ↓ 3 lines elided ↑ open up ↑ 
  93  123          if (atomic_dec_32_nv(&(vxnf)->vxnf_refcount) == 0)      \
  94  124                  vxlnat_fixed_free(vxnf);                        \
  95  125  }
  96  126  extern void vxlnat_fixed_free(vxlnat_fixed_t *);
  97  127  
  98  128  /*
  99  129   * REMOTE VXLAN destinations.
 100  130   */
 101  131  typedef struct vxlnat_remote_s {
 102  132          avl_node_t vxnrem_treenode;
 103      -        in6_addr_t vxnrem_addr; /* Same prefix as one in rule. */
      133 +        in6_addr_t vxnrem_addr; /* Same prefix as one in rule, or fixed addr. */
 104  134          in6_addr_t vxnrem_uaddr; /* Underlay VXLAN destination. */
 105  135          struct vxlnat_vnet_s *vxnrem_vnet;      /* Reference-held. */
 106  136          uint32_t vxnrem_refcount;
 107  137          uint8_t vxnrem_ether[ETHERADDRL];
 108  138          uint16_t vxnrem_vlan;
 109  139          /*
 110  140           * XXX KEBE SAYS put some lifetime/usetime/etc. here
 111  141           * so we don't keep too many of these.  Either that, or maybe
 112  142           * convert to a qqcache or (patents expiring) ARC.
 113  143           */
↓ open down ↓ 12 lines elided ↑ open up ↑ 
 126  156  
 127  157  /*
 128  158   * per-vnetid overarching structure.  AVL tree keyed by vnetid.
 129  159   * NOTE:  Could be split into vnetid-hashed buckets to split any
 130  160   * locks.
 131  161   */
 132  162  typedef struct vxlnat_vnet_s {
 133  163          avl_node_t vxnv_treenode;
 134  164          /*
 135  165           * 1-1 IP mappings. (1st lookup for an in-to-out packet.)
 136      -         * Will map to SOMETHING in IP.
 137      -         * XXX KEBE ASKS - conn_t or something else TBD?!
      166 +         * Will map to an IRE_LOCAL in IP.
 138  167           */
 139  168          krwlock_t vxnv_fixed_lock;
 140  169          avl_tree_t vxnv_fixed_ips;
      170 +
 141  171          /*
 142  172           * NAT flows. (2nd lookup for an in-to-out packet.)
 143  173           * These are also conn_ts with outer-packet fields for out-to-in
 144  174           * matches against a conn_t.
      175 +         *
      176 +         * NOTE: We're going to keep a separate tree for inner IPv6 NAT, if
      177 +         * we ever need it.
 145  178           */
 146      -        krwlock_t vxnv_flow_lock;
 147      -        avl_tree_t vxnv_flows;
      179 +        krwlock_t vxnv_flowv4_lock;
      180 +        avl_tree_t vxnv_flows_v4;
      181 +
 148  182          /* NAT rules. (3rd lookup for an in-to-out packet.) */
 149  183          kmutex_t vxnv_rule_lock;
 150  184          list_t vxnv_rules;
      185 +
 151  186          /*
 152  187           * Internal-network remote-nodes. (only lookup for out-to-in packet.)
 153  188           * Entries here are also refheld by 1-1s or NAT flows.
 154  189           */
 155  190          kmutex_t vxnv_remote_lock;
 156  191          avl_tree_t vxnv_remotes;
 157  192  
 158  193          uint32_t vxnv_refcount;
 159  194          uint32_t vxnv_vnetid;   /* Wire byteorder for less swapping on LE */
 160  195  } vxlnat_vnet_t;
↓ open down ↓ 78 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX