ofproto/ofproto-dpif-rid.h

   1 /*
   2  * Copyright (c) 2014, 2015 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef OFPROTO_DPIF_RID_H
  18 #define OFPROTO_DPIF_RID_H
  19
  20 #include <stddef.h>
  21 #include <stdint.h>
  22
  23 #include "cmap.h"
  24 #include "list.h"
  25 #include "ofp-actions.h"
  26 #include "ofproto-dpif-mirror.h"
  27 #include "ovs-thread.h"
  28
  29 struct ofproto_dpif;
  30 struct rule;
  31
  32 /*
  33  * Recirculation
  34  * =============
  35  *
  36  * Recirculation is a technique to allow a frame to re-enter the datapath
  37  * packet processing path to achieve more flexible packet processing, such as
  38  * modifying header fields after MPLS POP action and selecting a slave port for
  39  * bond ports.
  40  *
  41  * Data path and user space interface
  42  * -----------------------------------
  43  *
  44  * Recirculation uses two uint32_t fields, recirc_id and dp_hash, and a RECIRC
  45  * action.  recirc_id is used to select the next packet processing steps among
  46  * multiple instances of recirculation.  When a packet initially enters the
  47  * datapath it is assigned with recirc_id 0, which indicates no recirculation.
  48  * Recirc_ids are managed by the user space, opaque to the datapath.
  49  *
  50  * On the other hand, dp_hash can only be computed by the datapath, opaque to
  51  * the user space, as the datapath is free to choose the hashing algorithm
  52  * without informing user space about it.  The dp_hash value should be
  53  * wildcarded for newly received packets.  HASH action specifies whether the
  54  * hash is computed, and if computed, how many fields are to be included in the
  55  * hash computation.  The computed hash value is stored into the dp_hash field
  56  * prior to recirculation.
  57  *
  58  * The RECIRC action sets the recirc_id field and then reprocesses the packet
  59  * as if it was received again on the same input port.  RECIRC action works
  60  * like a function call; actions listed after the RECIRC action will be
  61  * executed after recirculation.  RECIRC action can be nested, but datapath
  62  * implementation limits the number of nested recirculations to prevent
  63  * unreasonable nesting depth or infinite loop.
  64  *
  65  * User space recirculation context
  66  * ---------------------------------
  67  *
  68  * Recirculation is usually hidden from the OpenFlow controllers.  Action
  69  * translation code deduces when recirculation is necessary and issues a
  70  * datapath recirculation action.  All OpenFlow actions to be performed after
  71  * recirculation are derived from the OpenFlow pipeline and are stored with the
  72  * recirculation ID.  When the OpenFlow tables are changed in a way affecting
  73  * the recirculation flows, new recirculation ID with new metadata and actions
  74  * is allocated and the old one is timed out.
  75  *
  76  * Recirculation ID pool
  77  * ----------------------
  78  *
  79  * Recirculation ID needs to be unique for all datapaths.  Recirculation ID
  80  * pool keeps track of recirculation ids and stores OpenFlow pipeline
  81  * translation context so that flow processing may continue after
  82  * recirculation.
  83  *
  84  * A Recirculation ID can be any uint32_t value, except for that the value 0 is
  85  * reserved for 'no recirculation' case.
  86  *
  87  * Thread-safety
  88  * --------------
  89  *
  90  * All APIs are thread safe.
  91  */
  92
  93 /* Metadata for restoring pipeline context after recirculation.  Helpers
  94  * are inlined below to keep them together with the definition for easier
  95  * updates. */
  96 BUILD_ASSERT_DECL(FLOW_WC_SEQ == 34);
  97
  98 struct recirc_metadata {
  99     /* Metadata in struct flow. */
 100     const struct flow_tnl *tunnel; /* Encapsulating tunnel parameters. */
 101     ovs_be64 metadata;            /* OpenFlow Metadata. */
 102     uint64_t regs[FLOW_N_XREGS];  /* Registers. */
 103     ofp_port_t in_port;           /* Incoming port. */
 104     ofp_port_t actset_output;     /* Output port in action set. */
 105 };
 106
 107 static inline void
 108 recirc_metadata_from_flow(struct recirc_metadata *md,
 109                           const struct flow *flow)
 110 {
 111     memset(md, 0, sizeof *md);
 112     md->tunnel = &flow->tunnel;
 113     md->metadata = flow->metadata;
 114     memcpy(md->regs, flow->regs, sizeof md->regs);
 115     md->in_port = flow->in_port.ofp_port;
 116     md->actset_output = flow->actset_output;
 117 }
 118
 119 static inline void
 120 recirc_metadata_to_flow(const struct recirc_metadata *md,
 121                         struct flow *flow)
 122 {
 123     if (md->tunnel && md->tunnel->ip_dst) {
 124         flow->tunnel = *md->tunnel;
 125     } else {
 126         memset(&flow->tunnel, 0, sizeof flow->tunnel);
 127     }
 128     flow->metadata = md->metadata;
 129     memcpy(flow->regs, md->regs, sizeof flow->regs);
 130     flow->in_port.ofp_port = md->in_port;
 131     flow->actset_output = md->actset_output;
 132 }
 133
 134 /* State that flow translation can save, to restore when recirculation
 135  * occurs.  */
 136 struct recirc_state {
 137     /* Initial table for post-recirculation processing. */
 138     uint8_t table_id;
 139
 140     /* Pipeline context for post-recirculation processing. */
 141     struct ofproto_dpif *ofproto; /* Post-recirculation bridge. */
 142     struct recirc_metadata metadata; /* Flow metadata. */
 143     struct ofpbuf *stack;         /* Stack if any. */
 144     mirror_mask_t mirrors;        /* Mirrors already output. */
 145     bool conntracked;             /* Conntrack occurred prior to recirc. */
 146
 147     /* Actions to be translated on recirculation. */
 148     uint32_t action_set_len;      /* How much of 'ofpacts' consists of an
 149                                    * action set? */
 150     uint32_t ofpacts_len;         /* Size of 'ofpacts', in bytes. */
 151     struct ofpact *ofpacts;       /* Sequence of "struct ofpacts". */
 152 };
 153
 154 /* This maps a recirculation ID to saved state that flow translation can
 155  * restore when recirculation occurs. */
 156 struct recirc_id_node {
 157     /* Index data. */
 158     struct ovs_list exp_node OVS_GUARDED;
 159     struct cmap_node id_node;
 160     struct cmap_node metadata_node;
 161     uint32_t id;
 162     uint32_t hash;
 163     struct ovs_refcount refcount;
 164
 165     /* Saved state.
 166      *
 167      * This state should not be modified after inserting a node in the pool,
 168      * hence the 'const' to emphasize that. */
 169     const struct recirc_state state;
 170
 171     /* Storage for tunnel metadata. */
 172     struct flow_tnl state_metadata_tunnel;
 173 };
 174
 175 void recirc_init(void);
 176
 177 /* This is only used for bonds and will go away when bonds implementation is
 178  * updated to use this mechanism instead of internal rules. */
 179 uint32_t recirc_alloc_id(struct ofproto_dpif *);
 180
 181 uint32_t recirc_alloc_id_ctx(const struct recirc_state *);
 182 uint32_t recirc_find_id(const struct recirc_state *);
 183 void recirc_free_id(uint32_t recirc_id);
 184 void recirc_free_ofproto(struct ofproto_dpif *, const char *ofproto_name);
 185
 186 const struct recirc_id_node *recirc_id_node_find(uint32_t recirc_id);
 187
 188 static inline bool recirc_id_node_try_ref_rcu(const struct recirc_id_node *n_)
 189 {
 190     struct recirc_id_node *node = CONST_CAST(struct recirc_id_node *, n_);
 191
 192     return node ? ovs_refcount_try_ref_rcu(&node->refcount) : false;
 193 }
 194
 195 void recirc_id_node_unref(const struct recirc_id_node *);
 196
 197 void recirc_run(void);
 198
 199 #endif