lib/hash/rte_hash.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2015 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_HASH_H_
   6 #define _RTE_HASH_H_
   7
   8 /**
   9  * @file
  10  *
  11  * RTE Hash Table
  12  */
  13
  14 #include <stdint.h>
  15 #include <stddef.h>
  16
  17 #include <rte_compat.h>
  18 #include <rte_rcu_qsbr.h>
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24 /** Maximum size of hash table that can be created. */
  25 #define RTE_HASH_ENTRIES_MAX                    (1 << 30)
  26
  27 /** Maximum number of characters in hash name.*/
  28 #define RTE_HASH_NAMESIZE                       32
  29
  30 /** Maximum number of keys that can be searched for using rte_hash_lookup_bulk. */
  31 #define RTE_HASH_LOOKUP_BULK_MAX                64
  32 #define RTE_HASH_LOOKUP_MULTI_MAX               RTE_HASH_LOOKUP_BULK_MAX
  33
  34 /** Enable Hardware transactional memory support. */
  35 #define RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT  0x01
  36
  37 /** Default behavior of insertion, single writer/multi writer */
  38 #define RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD 0x02
  39
  40 /** Flag to support reader writer concurrency */
  41 #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY 0x04
  42
  43 /** Flag to indicate the extendable bucket table feature should be used */
  44 #define RTE_HASH_EXTRA_FLAGS_EXT_TABLE 0x08
  45
  46 /** Flag to disable freeing of key index on hash delete.
  47  * Refer to rte_hash_del_xxx APIs for more details.
  48  * This is enabled by default when RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF
  49  * is enabled. However, if internal RCU is enabled, freeing of internal
  50  * memory/index is done on delete
  51  */
  52 #define RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL 0x10
  53
  54 /** Flag to support lock free reader writer concurrency. Both single writer
  55  * and multi writer use cases are supported.
  56  */
  57 #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF 0x20
  58
  59 /**
  60  * The type of hash value of a key.
  61  * It should be a value of at least 32bit with fully random pattern.
  62  */
  63 typedef uint32_t hash_sig_t;
  64
  65 /** Type of function that can be used for calculating the hash value. */
  66 typedef uint32_t (*rte_hash_function)(const void *key, uint32_t key_len,
  67                                       uint32_t init_val);
  68
  69 /** Type of function used to compare the hash key. */
  70 typedef int (*rte_hash_cmp_eq_t)(const void *key1, const void *key2, size_t key_len);
  71
  72 /**
  73  * Type of function used to free data stored in the key.
  74  * Required when using internal RCU to allow application to free key-data once
  75  * the key is returned to the ring of free key-slots.
  76  */
  77 typedef void (*rte_hash_free_key_data)(void *p, void *key_data);
  78
  79 /**
  80  * Parameters used when creating the hash table.
  81  */
  82 struct rte_hash_parameters {
  83         const char *name;               /**< Name of the hash. */
  84         uint32_t entries;               /**< Total hash table entries. */
  85         uint32_t reserved;              /**< Unused field. Should be set to 0 */
  86         uint32_t key_len;               /**< Length of hash key. */
  87         rte_hash_function hash_func;    /**< Primary Hash function used to calculate hash. */
  88         uint32_t hash_func_init_val;    /**< Init value used by hash_func. */
  89         int socket_id;                  /**< NUMA Socket ID for memory. */
  90         uint8_t extra_flag;             /**< Indicate if additional parameters are present. */
  91 };
  92
  93 /** RCU reclamation modes */
  94 enum rte_hash_qsbr_mode {
  95         /** Create defer queue for reclaim. */
  96         RTE_HASH_QSBR_MODE_DQ = 0,
  97         /** Use blocking mode reclaim. No defer queue created. */
  98         RTE_HASH_QSBR_MODE_SYNC
  99 };
 100
 101 /** HASH RCU QSBR configuration structure. */
 102 struct rte_hash_rcu_config {
 103         struct rte_rcu_qsbr *v;         /**< RCU QSBR variable. */
 104         enum rte_hash_qsbr_mode mode;
 105         /**< Mode of RCU QSBR. RTE_HASH_QSBR_MODE_xxx
 106          * '0' for default: create defer queue for reclaim.
 107          */
 108         uint32_t dq_size;
 109         /**< RCU defer queue size.
 110          * default: total hash table entries.
 111          */
 112         uint32_t trigger_reclaim_limit; /**< Threshold to trigger auto reclaim. */
 113         uint32_t max_reclaim_size;
 114         /**< Max entries to reclaim in one go.
 115          * default: RTE_HASH_RCU_DQ_RECLAIM_MAX.
 116          */
 117         void *key_data_ptr;
 118         /**< Pointer passed to the free function. Typically, this is the
 119          * pointer to the data structure to which the resource to free
 120          * (key-data) belongs. This can be NULL.
 121          */
 122         rte_hash_free_key_data free_key_data_func;
 123         /**< Function to call to free the resource (key-data). */
 124 };
 125
 126 /** @internal A hash table structure. */
 127 struct rte_hash;
 128
 129 /**
 130  * Create a new hash table.
 131  *
 132  * @param params
 133  *   Parameters used to create and initialise the hash table.
 134  * @return
 135  *   Pointer to hash table structure that is used in future hash table
 136  *   operations, or NULL on error, with error code set in rte_errno.
 137  *   Possible rte_errno errors include:
 138  *    - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
 139  *    - E_RTE_SECONDARY - function was called from a secondary process instance
 140  *    - ENOENT - missing entry
 141  *    - EINVAL - invalid parameter passed to function
 142  *    - ENOSPC - the maximum number of memzones has already been allocated
 143  *    - EEXIST - a memzone with the same name already exists
 144  *    - ENOMEM - no appropriate memory area found in which to create memzone
 145  */
 146 struct rte_hash *
 147 rte_hash_create(const struct rte_hash_parameters *params);
 148
 149 /**
 150  * Set a new hash compare function other than the default one.
 151  *
 152  * @note Function pointer does not work with multi-process, so do not use it
 153  * in multi-process mode.
 154  *
 155  * @param h
 156  *   Hash table for which the function is to be changed
 157  * @param func
 158  *   New compare function
 159  */
 160 void rte_hash_set_cmp_func(struct rte_hash *h, rte_hash_cmp_eq_t func);
 161
 162 /**
 163  * Find an existing hash table object and return a pointer to it.
 164  *
 165  * @param name
 166  *   Name of the hash table as passed to rte_hash_create()
 167  * @return
 168  *   Pointer to hash table or NULL if object not found
 169  *   with rte_errno set appropriately. Possible rte_errno values include:
 170  *    - ENOENT - value not available for return
 171  */
 172 struct rte_hash *
 173 rte_hash_find_existing(const char *name);
 174
 175 /**
 176  * De-allocate all memory used by hash table.
 177  * @param h
 178  *   Hash table to free
 179  */
 180 void
 181 rte_hash_free(struct rte_hash *h);
 182
 183 /**
 184  * Reset all hash structure, by zeroing all entries.
 185  * When RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled,
 186  * it is application's responsibility to make sure that
 187  * none of the readers are referencing the hash table
 188  * while calling this API.
 189  *
 190  * @param h
 191  *   Hash table to reset
 192  */
 193 void
 194 rte_hash_reset(struct rte_hash *h);
 195
 196 /**
 197  * Return the number of keys in the hash table
 198  * @param h
 199  *  Hash table to query from
 200  * @return
 201  *   - -EINVAL if parameters are invalid
 202  *   - A value indicating how many keys were inserted in the table.
 203  */
 204 int32_t
 205 rte_hash_count(const struct rte_hash *h);
 206
 207 /**
 208  * Return the maximum key value ID that could possibly be returned by
 209  * rte_hash_add_key function.
 210  *
 211  * @param h
 212  *  Hash table to query from
 213  * @return
 214  *   - -EINVAL if parameters are invalid
 215  *   - A value indicating the max key ID of key slots present in the table.
 216  */
 217 int32_t
 218 rte_hash_max_key_id(const struct rte_hash *h);
 219
 220 /**
 221  * Add a key-value pair to an existing hash table.
 222  * This operation is not multi-thread safe
 223  * and should only be called from one thread by default.
 224  * Thread safety can be enabled by setting flag during
 225  * table creation.
 226  * If the key exists already in the table, this API updates its value
 227  * with 'data' passed in this API. It is the responsibility of
 228  * the application to manage any memory associated with the old value.
 229  * The readers might still be using the old value even after this API
 230  * has returned.
 231  *
 232  * @param h
 233  *   Hash table to add the key to.
 234  * @param key
 235  *   Key to add to the hash table.
 236  * @param data
 237  *   Data to add to the hash table.
 238  * @return
 239  *   - 0 if added successfully
 240  *   - -EINVAL if the parameters are invalid.
 241  *   - -ENOSPC if there is no space in the hash for this key.
 242  */
 243 int
 244 rte_hash_add_key_data(const struct rte_hash *h, const void *key, void *data);
 245
 246 /**
 247  * Add a key-value pair with a pre-computed hash value
 248  * to an existing hash table.
 249  * This operation is not multi-thread safe
 250  * and should only be called from one thread by default.
 251  * Thread safety can be enabled by setting flag during
 252  * table creation.
 253  * If the key exists already in the table, this API updates its value
 254  * with 'data' passed in this API. It is the responsibility of
 255  * the application to manage any memory associated with the old value.
 256  * The readers might still be using the old value even after this API
 257  * has returned.
 258  *
 259  * @param h
 260  *   Hash table to add the key to.
 261  * @param key
 262  *   Key to add to the hash table.
 263  * @param sig
 264  *   Precomputed hash value for 'key'
 265  * @param data
 266  *   Data to add to the hash table.
 267  * @return
 268  *   - 0 if added successfully
 269  *   - -EINVAL if the parameters are invalid.
 270  *   - -ENOSPC if there is no space in the hash for this key.
 271  */
 272 int32_t
 273 rte_hash_add_key_with_hash_data(const struct rte_hash *h, const void *key,
 274                                                 hash_sig_t sig, void *data);
 275
 276 /**
 277  * Add a key to an existing hash table. This operation is not multi-thread safe
 278  * and should only be called from one thread by default.
 279  * Thread safety can be enabled by setting flag during
 280  * table creation.
 281  *
 282  * @param h
 283  *   Hash table to add the key to.
 284  * @param key
 285  *   Key to add to the hash table.
 286  * @return
 287  *   - -EINVAL if the parameters are invalid.
 288  *   - -ENOSPC if there is no space in the hash for this key.
 289  *   - A positive value that can be used by the caller as an offset into an
 290  *     array of user data. This value is unique for this key. This
 291  *     unique key id may be larger than the user specified entry count
 292  *     when RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD flag is set.
 293  */
 294 int32_t
 295 rte_hash_add_key(const struct rte_hash *h, const void *key);
 296
 297 /**
 298  * Add a key to an existing hash table.
 299  * This operation is not multi-thread safe
 300  * and should only be called from one thread by default.
 301  * Thread safety can be enabled by setting flag during
 302  * table creation.
 303  *
 304  * @param h
 305  *   Hash table to add the key to.
 306  * @param key
 307  *   Key to add to the hash table.
 308  * @param sig
 309  *   Precomputed hash value for 'key'.
 310  * @return
 311  *   - -EINVAL if the parameters are invalid.
 312  *   - -ENOSPC if there is no space in the hash for this key.
 313  *   - A positive value that can be used by the caller as an offset into an
 314  *     array of user data. This value is unique for this key. This
 315  *     unique key ID may be larger than the user specified entry count
 316  *     when RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD flag is set.
 317  */
 318 int32_t
 319 rte_hash_add_key_with_hash(const struct rte_hash *h, const void *key, hash_sig_t sig);
 320
 321 /**
 322  * Remove a key from an existing hash table.
 323  * This operation is not multi-thread safe
 324  * and should only be called from one thread by default.
 325  * Thread safety can be enabled by setting flag during
 326  * table creation.
 327  * If RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or
 328  * RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and
 329  * internal RCU is NOT enabled,
 330  * the key index returned by rte_hash_add_key_xxx APIs will not be
 331  * freed by this API. rte_hash_free_key_with_position API must be called
 332  * additionally to free the index associated with the key.
 333  * rte_hash_free_key_with_position API should be called after all
 334  * the readers have stopped referencing the entry corresponding to
 335  * this key. RCU mechanisms could be used to determine such a state.
 336  *
 337  * @param h
 338  *   Hash table to remove the key from.
 339  * @param key
 340  *   Key to remove from the hash table.
 341  * @return
 342  *   - -EINVAL if the parameters are invalid.
 343  *   - -ENOENT if the key is not found.
 344  *   - A positive value that can be used by the caller as an offset into an
 345  *     array of user data. This value is unique for this key, and is the same
 346  *     value that was returned when the key was added.
 347  */
 348 int32_t
 349 rte_hash_del_key(const struct rte_hash *h, const void *key);
 350
 351 /**
 352  * Remove a key from an existing hash table.
 353  * This operation is not multi-thread safe
 354  * and should only be called from one thread by default.
 355  * Thread safety can be enabled by setting flag during
 356  * table creation.
 357  * If RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or
 358  * RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and
 359  * internal RCU is NOT enabled,
 360  * the key index returned by rte_hash_add_key_xxx APIs will not be
 361  * freed by this API. rte_hash_free_key_with_position API must be called
 362  * additionally to free the index associated with the key.
 363  * rte_hash_free_key_with_position API should be called after all
 364  * the readers have stopped referencing the entry corresponding to
 365  * this key. RCU mechanisms could be used to determine such a state.
 366  *
 367  * @param h
 368  *   Hash table to remove the key from.
 369  * @param key
 370  *   Key to remove from the hash table.
 371  * @param sig
 372  *   Precomputed hash value for 'key'.
 373  * @return
 374  *   - -EINVAL if the parameters are invalid.
 375  *   - -ENOENT if the key is not found.
 376  *   - A positive value that can be used by the caller as an offset into an
 377  *     array of user data. This value is unique for this key, and is the same
 378  *     value that was returned when the key was added.
 379  */
 380 int32_t
 381 rte_hash_del_key_with_hash(const struct rte_hash *h, const void *key, hash_sig_t sig);
 382
 383 /**
 384  * Find a key in the hash table given the position.
 385  * This operation is multi-thread safe with regarding to other lookup threads.
 386  * Read-write concurrency can be enabled by setting flag during
 387  * table creation.
 388  *
 389  * @param h
 390  *   Hash table to get the key from.
 391  * @param position
 392  *   Position returned when the key was inserted.
 393  * @param key
 394  *   Output containing a pointer to the key
 395  * @return
 396  *   - 0 if retrieved successfully
 397  *   - -EINVAL if the parameters are invalid.
 398  *   - -ENOENT if no valid key is found in the given position.
 399  */
 400 int
 401 rte_hash_get_key_with_position(const struct rte_hash *h, const int32_t position,
 402                                void **key);
 403
 404 /**
 405  * Free a hash key in the hash table given the position
 406  * of the key. This operation is not multi-thread safe and should
 407  * only be called from one thread by default. Thread safety
 408  * can be enabled by setting flag during table creation.
 409  * If RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or
 410  * RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and
 411  * internal RCU is NOT enabled,
 412  * the key index returned by rte_hash_del_key_xxx APIs must be freed
 413  * using this API. This API should be called after all the readers
 414  * have stopped referencing the entry corresponding to this key.
 415  * RCU mechanisms could be used to determine such a state.
 416  * This API does not validate if the key is already freed.
 417  *
 418  * @param h
 419  *   Hash table to free the key from.
 420  * @param position
 421  *   Position returned when the key was deleted.
 422  * @return
 423  *   - 0 if freed successfully
 424  *   - -EINVAL if the parameters are invalid.
 425  */
 426 int
 427 rte_hash_free_key_with_position(const struct rte_hash *h,
 428                                 const int32_t position);
 429
 430 /**
 431  * Find a key-value pair in the hash table.
 432  * This operation is multi-thread safe with regarding to other lookup threads.
 433  * Read-write concurrency can be enabled by setting flag during
 434  * table creation.
 435  *
 436  * @param h
 437  *   Hash table to look in.
 438  * @param key
 439  *   Key to find.
 440  * @param data
 441  *   Output with pointer to data returned from the hash table.
 442  * @return
 443  *   - A positive value that can be used by the caller as an offset into an
 444  *     array of user data. This value is unique for this key, and is the same
 445  *     value that was returned when the key was added.
 446  *   - -EINVAL if the parameters are invalid.
 447  *   - -ENOENT if the key is not found.
 448  */
 449 int
 450 rte_hash_lookup_data(const struct rte_hash *h, const void *key, void **data);
 451
 452 /**
 453  * Find a key-value pair with a pre-computed hash value
 454  * to an existing hash table.
 455  * This operation is multi-thread safe with regarding to other lookup threads.
 456  * Read-write concurrency can be enabled by setting flag during
 457  * table creation.
 458  *
 459  * @param h
 460  *   Hash table to look in.
 461  * @param key
 462  *   Key to find.
 463  * @param sig
 464  *   Precomputed hash value for 'key'
 465  * @param data
 466  *   Output with pointer to data returned from the hash table.
 467  * @return
 468  *   - A positive value that can be used by the caller as an offset into an
 469  *     array of user data. This value is unique for this key, and is the same
 470  *     value that was returned when the key was added.
 471  *   - -EINVAL if the parameters are invalid.
 472  *   - -ENOENT if the key is not found.
 473  */
 474 int
 475 rte_hash_lookup_with_hash_data(const struct rte_hash *h, const void *key,
 476                                         hash_sig_t sig, void **data);
 477
 478 /**
 479  * Find a key in the hash table.
 480  * This operation is multi-thread safe with regarding to other lookup threads.
 481  * Read-write concurrency can be enabled by setting flag during
 482  * table creation.
 483  *
 484  * @param h
 485  *   Hash table to look in.
 486  * @param key
 487  *   Key to find.
 488  * @return
 489  *   - -EINVAL if the parameters are invalid.
 490  *   - -ENOENT if the key is not found.
 491  *   - A positive value that can be used by the caller as an offset into an
 492  *     array of user data. This value is unique for this key, and is the same
 493  *     value that was returned when the key was added.
 494  */
 495 int32_t
 496 rte_hash_lookup(const struct rte_hash *h, const void *key);
 497
 498 /**
 499  * Find a key in the hash table.
 500  * This operation is multi-thread safe with regarding to other lookup threads.
 501  * Read-write concurrency can be enabled by setting flag during
 502  * table creation.
 503  *
 504  * @param h
 505  *   Hash table to look in.
 506  * @param key
 507  *   Key to find.
 508  * @param sig
 509  *   Precomputed hash value for 'key'.
 510  * @return
 511  *   - -EINVAL if the parameters are invalid.
 512  *   - -ENOENT if the key is not found.
 513  *   - A positive value that can be used by the caller as an offset into an
 514  *     array of user data. This value is unique for this key, and is the same
 515  *     value that was returned when the key was added.
 516  */
 517 int32_t
 518 rte_hash_lookup_with_hash(const struct rte_hash *h,
 519                                 const void *key, hash_sig_t sig);
 520
 521 /**
 522  * Calc a hash value by key.
 523  * This operation is not multi-process safe.
 524  *
 525  * @param h
 526  *   Hash table to look in.
 527  * @param key
 528  *   Key to find.
 529  * @return
 530  *   - hash value
 531  */
 532 hash_sig_t
 533 rte_hash_hash(const struct rte_hash *h, const void *key);
 534
 535 /**
 536  * Find multiple keys in the hash table.
 537  * This operation is multi-thread safe with regarding to other lookup threads.
 538  * Read-write concurrency can be enabled by setting flag during
 539  * table creation.
 540  *
 541  * @param h
 542  *   Hash table to look in.
 543  * @param keys
 544  *   A pointer to a list of keys to look for.
 545  * @param num_keys
 546  *   How many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
 547  * @param hit_mask
 548  *   Output containing a bitmask with all successful lookups.
 549  * @param data
 550  *   Output containing array of data returned from all the successful lookups.
 551  * @return
 552  *   -EINVAL if there's an error, otherwise number of successful lookups.
 553  */
 554 int
 555 rte_hash_lookup_bulk_data(const struct rte_hash *h, const void **keys,
 556                       uint32_t num_keys, uint64_t *hit_mask, void *data[]);
 557
 558 /**
 559  * Find multiple keys in the hash table with precomputed hash value array.
 560  * This operation is multi-thread safe with regarding to other lookup threads.
 561  * Read-write concurrency can be enabled by setting flag during
 562  * table creation.
 563  *
 564  * @param h
 565  *   Hash table to look in.
 566  * @param keys
 567  *   A pointer to a list of keys to look for.
 568  * @param sig
 569  *   A pointer to a list of precomputed hash values for keys.
 570  * @param num_keys
 571  *   How many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
 572  * @param positions
 573  *   Output containing a list of values, corresponding to the list of keys that
 574  *   can be used by the caller as an offset into an array of user data. These
 575  *   values are unique for each key, and are the same values that were returned
 576  *   when each key was added. If a key in the list was not found, then -ENOENT
 577  *   will be the value.
 578  * @return
 579  *   -EINVAL if there's an error, otherwise 0.
 580  */
 581 int
 582 rte_hash_lookup_with_hash_bulk(const struct rte_hash *h, const void **keys,
 583                 hash_sig_t *sig, uint32_t num_keys, int32_t *positions);
 584
 585 /**
 586  * Find multiple keys in the hash table with precomputed hash value array.
 587  * This operation is multi-thread safe with regarding to other lookup threads.
 588  * Read-write concurrency can be enabled by setting flag during
 589  * table creation.
 590  *
 591  * @param h
 592  *   Hash table to look in.
 593  * @param keys
 594  *   A pointer to a list of keys to look for.
 595  * @param sig
 596  *   A pointer to a list of precomputed hash values for keys.
 597  * @param num_keys
 598  *   How many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
 599  * @param hit_mask
 600  *   Output containing a bitmask with all successful lookups.
 601  * @param data
 602  *   Output containing array of data returned from all the successful lookups.
 603  * @return
 604  *   -EINVAL if there's an error, otherwise number of successful lookups.
 605  */
 606 int
 607 rte_hash_lookup_with_hash_bulk_data(const struct rte_hash *h,
 608                 const void **keys, hash_sig_t *sig,
 609                 uint32_t num_keys, uint64_t *hit_mask, void *data[]);
 610
 611 /**
 612  * Find multiple keys in the hash table.
 613  * This operation is multi-thread safe with regarding to other lookup threads.
 614  * Read-write concurrency can be enabled by setting flag during
 615  * table creation.
 616  *
 617  * @param h
 618  *   Hash table to look in.
 619  * @param keys
 620  *   A pointer to a list of keys to look for.
 621  * @param num_keys
 622  *   How many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
 623  * @param positions
 624  *   Output containing a list of values, corresponding to the list of keys that
 625  *   can be used by the caller as an offset into an array of user data. These
 626  *   values are unique for each key, and are the same values that were returned
 627  *   when each key was added. If a key in the list was not found, then -ENOENT
 628  *   will be the value.
 629  * @return
 630  *   -EINVAL if there's an error, otherwise 0.
 631  */
 632 int
 633 rte_hash_lookup_bulk(const struct rte_hash *h, const void **keys,
 634                       uint32_t num_keys, int32_t *positions);
 635
 636 /**
 637  * Iterate through the hash table, returning key-value pairs.
 638  *
 639  * @param h
 640  *   Hash table to iterate
 641  * @param key
 642  *   Output containing the key where current iterator
 643  *   was pointing at
 644  * @param data
 645  *   Output containing the data associated with key.
 646  *   Returns NULL if data was not stored.
 647  * @param next
 648  *   Pointer to iterator. Should be 0 to start iterating the hash table.
 649  *   Iterator is incremented after each call of this function.
 650  * @return
 651  *   Position where key was stored, if successful.
 652  *   - -EINVAL if the parameters are invalid.
 653  *   - -ENOENT if end of the hash table.
 654  */
 655 int32_t
 656 rte_hash_iterate(const struct rte_hash *h, const void **key, void **data, uint32_t *next);
 657
 658 /**
 659  * Associate RCU QSBR variable with a Hash object.
 660  * This API should be called to enable the integrated RCU QSBR support and
 661  * should be called immediately after creating the Hash object.
 662  *
 663  * @param h
 664  *   the hash object to add RCU QSBR
 665  * @param cfg
 666  *   RCU QSBR configuration
 667  * @return
 668  *   On success - 0
 669  *   On error - 1 with error code set in rte_errno.
 670  *   Possible rte_errno codes are:
 671  *   - EINVAL - invalid pointer
 672  *   - EEXIST - already added QSBR
 673  *   - ENOMEM - memory allocation failure
 674  */
 675 int rte_hash_rcu_qsbr_add(struct rte_hash *h, struct rte_hash_rcu_config *cfg);
 676
 677 #ifdef __cplusplus
 678 }
 679 #endif
 680
 681 #endif /* _RTE_HASH_H_ */