drivers/net/mlx4/mlx4_utils.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2017 6WIND S.A.
   3  * Copyright 2017 Mellanox Technologies, Ltd
   4  */
   5
   6 /**
   7  * @file
   8  * Utility functions used by the mlx4 driver.
   9  */
  10
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <stddef.h>
  14 #include <stdint.h>
  15
  16 #include <rte_errno.h>
  17 #include <rte_malloc.h>
  18 #include <rte_memory.h>
  19
  20 #include "mlx4_utils.h"
  21
  22 /**
  23  * Make a file descriptor non-blocking.
  24  *
  25  * @param fd
  26  *   File descriptor to alter.
  27  *
  28  * @return
  29  *   0 on success, negative errno value otherwise and rte_errno is set.
  30  */
  31 int
  32 mlx4_fd_set_non_blocking(int fd)
  33 {
  34         int ret = fcntl(fd, F_GETFL);
  35
  36         if (ret != -1 && !fcntl(fd, F_SETFL, ret | O_NONBLOCK))
  37                 return 0;
  38         MLX4_ASSERT(errno);
  39         rte_errno = errno;
  40         return -rte_errno;
  41 }
  42
  43 /**
  44  * Internal helper to allocate memory once for several disparate objects.
  45  *
  46  * The most restrictive alignment constraint for standard objects is assumed
  47  * to be sizeof(double) and is used as a default value.
  48  *
  49  * C11 code would include stdalign.h and use alignof(max_align_t) however
  50  * we'll stick with C99 for the time being.
  51  */
  52 static inline size_t
  53 mlx4_mallocv_inline(const char *type, const struct mlx4_malloc_vec *vec,
  54                     unsigned int cnt, int zero, int socket)
  55 {
  56         unsigned int i;
  57         size_t size;
  58         size_t least;
  59         uint8_t *data = NULL;
  60         int fill = !vec[0].addr;
  61
  62 fill:
  63         size = 0;
  64         least = 0;
  65         for (i = 0; i < cnt; ++i) {
  66                 size_t align = (uintptr_t)vec[i].align;
  67
  68                 if (!align) {
  69                         align = sizeof(double);
  70                 } else if (!rte_is_power_of_2(align)) {
  71                         rte_errno = EINVAL;
  72                         goto error;
  73                 }
  74                 if (least < align)
  75                         least = align;
  76                 align = RTE_ALIGN_CEIL(size, align);
  77                 size = align + vec[i].size;
  78                 if (fill && vec[i].addr)
  79                         *vec[i].addr = data + align;
  80         }
  81         if (fill)
  82                 return size;
  83         if (!zero)
  84                 data = rte_malloc_socket(type, size, least, socket);
  85         else
  86                 data = rte_zmalloc_socket(type, size, least, socket);
  87         if (data) {
  88                 fill = 1;
  89                 goto fill;
  90         }
  91         rte_errno = ENOMEM;
  92 error:
  93         for (i = 0; i != cnt; ++i)
  94                 if (vec[i].addr)
  95                         *vec[i].addr = NULL;
  96         return 0;
  97 }
  98
  99 /**
 100  * Allocate memory once for several disparate objects.
 101  *
 102  * This function adds iovec-like semantics (e.g. readv()) to rte_malloc().
 103  * Memory is allocated once for several contiguous objects of nonuniform
 104  * sizes and alignment constraints.
 105  *
 106  * Each entry of @p vec describes the size, alignment constraint and
 107  * provides a buffer address where the resulting object pointer must be
 108  * stored.
 109  *
 110  * The buffer of the first entry is guaranteed to point to the beginning of
 111  * the allocated region and is safe to use with rte_free().
 112  *
 113  * NULL buffers are silently ignored.
 114  *
 115  * Providing a NULL buffer in the first entry prevents this function from
 116  * allocating any memory but has otherwise no effect on its behavior. In
 117  * this case, the contents of remaining non-NULL buffers are updated with
 118  * addresses relative to zero (i.e. offsets that would have been used during
 119  * the allocation).
 120  *
 121  * @param[in] type
 122  *   A string identifying the type of allocated objects (useful for debug
 123  *   purposes, such as identifying the cause of a memory leak). Can be NULL.
 124  * @param[in, out] vec
 125  *   Description of objects to allocate memory for.
 126  * @param cnt
 127  *   Number of entries in @p vec.
 128  *
 129  * @return
 130  *   Size in bytes of the allocated region including any padding. In case of
 131  *   error, rte_errno is set, 0 is returned and NULL is stored in the
 132  *   non-NULL buffers pointed by @p vec.
 133  *
 134  * @see struct mlx4_malloc_vec
 135  * @see rte_malloc()
 136  */
 137 size_t
 138 mlx4_mallocv(const char *type, const struct mlx4_malloc_vec *vec,
 139              unsigned int cnt)
 140 {
 141         return mlx4_mallocv_inline(type, vec, cnt, 0, SOCKET_ID_ANY);
 142 }
 143
 144 /**
 145  * Combines the semantics of mlx4_mallocv() with those of rte_zmalloc().
 146  *
 147  * @see mlx4_mallocv()
 148  * @see rte_zmalloc()
 149  */
 150 size_t
 151 mlx4_zmallocv(const char *type, const struct mlx4_malloc_vec *vec,
 152               unsigned int cnt)
 153 {
 154         return mlx4_mallocv_inline(type, vec, cnt, 1, SOCKET_ID_ANY);
 155 }
 156
 157 /**
 158  * Socket-aware version of mlx4_mallocv().
 159  *
 160  * This function takes one additional parameter.
 161  *
 162  * @param socket
 163  *   NUMA socket to allocate memory on. If SOCKET_ID_ANY is used, this
 164  *   function will behave the same as mlx4_mallocv().
 165  *
 166  * @see mlx4_mallocv()
 167  * @see rte_malloc_socket()
 168  */
 169 size_t
 170 mlx4_mallocv_socket(const char *type, const struct mlx4_malloc_vec *vec,
 171                     unsigned int cnt, int socket)
 172 {
 173         return mlx4_mallocv_inline(type, vec, cnt, 0, socket);
 174 }
 175
 176 /**
 177  * Combines the semantics of mlx4_mallocv_socket() with those of
 178  * mlx4_zmalloc_socket().
 179  *
 180  * @see mlx4_mallocv_socket()
 181  * @see rte_zmalloc_socket()
 182  */
 183 size_t
 184 mlx4_zmallocv_socket(const char *type, const struct mlx4_malloc_vec *vec,
 185                      unsigned int cnt, int socket)
 186 {
 187         return mlx4_mallocv_inline(type, vec, cnt, 1, socket);
 188 }