misc.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */

#pragma once

#ifndef __MOTR_LIB_MISC_H__
#define __MOTR_LIB_MISC_H__

#ifdef __KERNEL__
#  include <linux/string.h>       /* memset, strstr */
#  include <linux/bitops.h>       /* ffs */
#  include "lib/linux_kernel/misc.h"
#else
#  include <string.h>             /* memset, ffs, strstr */
#  include <limits.h>             /* CHAR_BIT */
#  include "lib/user_space/misc.h"
#endif
#include "lib/types.h"
#include "lib/assert.h"           /* M0_CASSERT */
#include "lib/buf.h"              /* m0_buf */

#define _QUOTE(s) #s
#define M0_QUOTE(s) _QUOTE(s)

#define M0_SRC_PATH(name) M0_QUOTE(M0_SRC_DIR) "/" name

M0_INTERNAL uint64_t m0_round_up(uint64_t val, uint64_t size);

M0_INTERNAL uint64_t m0_round_down(uint64_t val, uint64_t size);

#define M0_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)

#define M0_SET0(obj)                     \
({                                       \
        M0_CASSERT(!m0_is_array(obj));   \
        memset((obj), 0, sizeof *(obj)); \
})

#define M0_IS0(obj) m0_forall(i, sizeof *(obj), ((char *)obj)[i] == 0)

#define M0_SET_ARR0(arr)                \
({                                      \
        M0_CASSERT(m0_is_array(arr));   \
        memset((arr), 0, sizeof (arr)); \
})

#define m0_count(var, nr, ...)                     \
({                                                 \
        unsigned __nr = (nr);                      \
        unsigned var;                              \
        unsigned count;                            \
                                                   \
        for (count = var = 0; var < __nr; ++var) { \
                if (__VA_ARGS__)                   \
                        ++count;                   \
        }                                          \
        count;                                     \
})

#define m0_forall(var, nr, ...)                                 \
({                                                              \
        unsigned __nr = (nr);                                   \
        unsigned var;                                           \
                                                                \
        for (var = 0; var < __nr && ({ __VA_ARGS__ ; }); ++var) \
                ;                                               \
        var == __nr;                                            \
})

#define m0_exists(var, nr, ...) !m0_forall(var, (nr), !(__VA_ARGS__))

#define m0_reduce(var, nr, init, exp)           \
({                                              \
        unsigned __nr = (nr);                   \
        unsigned var;                           \
        typeof(init) __accum = (init);          \
                                                \
        for (var = 0; var < __nr; ++var) {      \
                __accum = __accum exp;          \
        }                                       \
        __accum;                                \
})

#define m0_fold(var, accum, nr, init, exp)      \
({                                              \
        unsigned __nr = (nr);                   \
        unsigned var;                           \
        typeof(init) accum = (init);            \
                                                \
        for (var = 0; var < __nr; ++var) {      \
                accum = exp;                    \
        }                                       \
        accum;                                  \
})

#define M0_IN(x, set)                                           \
        ({ typeof (x) __x = (x);                                \
                M0_IN0(__x, M0_UNPACK set); })

#define M0_UNPACK(...) __VA_ARGS__

#define M0_IN0(...) \
        M0_CAT(M0_IN_, M0_COUNT_PARAMS(__VA_ARGS__))(__VA_ARGS__)

#define M0_IN_1(x, v) ((x) == (v))
#define M0_IN_2(x, v, ...) ((x) == (v) || M0_IN_1(x, __VA_ARGS__))
#define M0_IN_3(x, v, ...) ((x) == (v) || M0_IN_2(x, __VA_ARGS__))
#define M0_IN_4(x, v, ...) ((x) == (v) || M0_IN_3(x, __VA_ARGS__))
#define M0_IN_5(x, v, ...) ((x) == (v) || M0_IN_4(x, __VA_ARGS__))
#define M0_IN_6(x, v, ...) ((x) == (v) || M0_IN_5(x, __VA_ARGS__))
#define M0_IN_7(x, v, ...) ((x) == (v) || M0_IN_6(x, __VA_ARGS__))
#define M0_IN_8(x, v, ...) ((x) == (v) || M0_IN_7(x, __VA_ARGS__))
#define M0_IN_9(x, v, ...) ((x) == (v) || M0_IN_8(x, __VA_ARGS__))

#define M0_BITS(...) \
        M0_CAT(__M0_BITS_, M0_COUNT_PARAMS(__VA_ARGS__))(__VA_ARGS__)

#define __M0_BITS_0(i)        (1ULL << (i))
#define __M0_BITS_1(i, ...)  ((1ULL << (i)) | __M0_BITS_0(__VA_ARGS__))
#define __M0_BITS_2(i, ...)  ((1ULL << (i)) | __M0_BITS_1(__VA_ARGS__))
#define __M0_BITS_3(i, ...)  ((1ULL << (i)) | __M0_BITS_2(__VA_ARGS__))
#define __M0_BITS_4(i, ...)  ((1ULL << (i)) | __M0_BITS_3(__VA_ARGS__))
#define __M0_BITS_5(i, ...)  ((1ULL << (i)) | __M0_BITS_4(__VA_ARGS__))
#define __M0_BITS_6(i, ...)  ((1ULL << (i)) | __M0_BITS_5(__VA_ARGS__))
#define __M0_BITS_7(i, ...)  ((1ULL << (i)) | __M0_BITS_6(__VA_ARGS__))
#define __M0_BITS_8(i, ...)  ((1ULL << (i)) | __M0_BITS_7(__VA_ARGS__))

M0_INTERNAL const char *m0_bool_to_str(bool b);

M0_INTERNAL const char *m0_short_file_name(const char *fname);

/* strtoull for user- and kernel-space */
uint64_t m0_strtou64(const char *str, char **endptr, int base);

/* strtoul for user- and kernel-space */
uint32_t m0_strtou32(const char *str, char **endptr, int base);

/*
 * Helper macros for implication and equivalence.
 *
 * Unfortunately, name clashes are possible and m0_ prefix is too awkward. See
 * M0_BASSERT() checks in lib/misc.c
 */
#ifndef ergo
#define ergo(a, b) (!(a) || (b))
#endif

#ifndef equi
#define equi(a, b) (!(a) == !(b))
#endif

void __dummy_function(void);

#define AND_NOTHING_ELSE else __dummy_function();

#define m0_is_array(x) \
        (!__builtin_types_compatible_p(typeof(&(x)[0]), typeof(x)))

#define IS_IN_ARRAY(idx, array)                     \
({                                                  \
        M0_CASSERT(m0_is_array(array));             \
        ((unsigned long)(idx)) < ARRAY_SIZE(array); \
})

M0_INTERNAL bool m0_elems_are_unique(const void *array, unsigned nr_elems,
                                     size_t elem_size);

#define M0_AMB(obj, ptr, field)                         \
        (container_of((ptr), typeof(*(obj)), field))

#define M0_MEMBER_PTR(ptr, member)              \
({                                              \
        typeof(ptr) __ptr = (ptr);              \
        __ptr == NULL ? NULL : &__ptr->member;  \
})

#define M0_MEMBER(ptr, member)                  \
({                                              \
        typeof(ptr) __ptr = (ptr);              \
        __ptr == NULL ? NULL : __ptr->member;   \
})

#define M0_FIELD_VALUE(type, field) (((type *)0)->field)

#define M0_HAS_TYPE(expr, type) __builtin_types_compatible_p(typeof(expr), type)

#define M0_FIELD_IS(type, field, ftype) \
        M0_HAS_TYPE(M0_FIELD_VALUE(type, field), ftype)

#define M0_MAGIX_OFFSET(type, field) \
M0_FIELD_IS(type, field, uint64_t) ? \
        offsetof(type, field) :      \
        sizeof(char [M0_FIELD_IS(type, field, uint64_t) - 1])

#define M0_COUNT_PARAMS(...) \
        M0_COUNT_PARAMS2(__VA_ARGS__, 9,8,7,6,5,4,3,2,1,0)
#define M0_COUNT_PARAMS2(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_, ...) _

#define M0_CAT(A, B) M0_CAT2(A, B)
#define M0_CAT2(A, B) A ## B

#define M0_UNUSED __attribute__((unused))

M0_INTERNAL uint32_t m0_no_of_bits_set(uint64_t val);

M0_INTERNAL unsigned int
m0_full_name_hash(const unsigned char *name, unsigned int len);

M0_INTERNAL uint64_t m0_ptr_wrap(const void *p);

M0_INTERNAL const void *m0_ptr_unwrap(uint64_t val);

#define M0_CIRCULAR_SHIFT_LEFT(val, bits)                       \
({                                                              \
        typeof(val) __v = (val);                                \
        typeof(bits) __b = (bits);                              \
                                                                \
        (__v << __b) | (__v >> (sizeof(__v) * CHAR_BIT - __b)); \
})

enum {
        UINT32_STR_LEN = 64
};


struct m0_key_val {
        struct m0_buf kv_key;
        struct m0_buf kv_val;
};

M0_INTERNAL void m0_permute(uint64_t n, uint64_t *k, uint64_t *s, uint64_t *r);

M0_INTERNAL void m0_array_sort(uint64_t *arr, uint64_t arr_len);

#define M0_BYTES(bits_nr) ((bits_nr + 7) / 8)

M0_INTERNAL bool m0_bit_get(void *buffer, m0_bcount_t i);

M0_INTERNAL void m0_bit_set(void *buffer, m0_bcount_t i, bool val);

M0_INTERNAL void m0_key_val_init(struct m0_key_val *kv, const struct m0_buf *key,
                                 const struct m0_buf *val);

M0_INTERNAL void *m0_vote_majority_get(struct m0_key_val *arr, uint32_t len,
                                       bool (*cmp)(const struct m0_buf *,
                                                   const struct m0_buf *),
                                       uint32_t *vote_nr);

M0_INTERNAL bool m0_key_val_is_null(struct m0_key_val *kv);

M0_INTERNAL void m0_key_val_null_set(struct m0_key_val *kv);

M0_EXTERN const struct m0_key_val M0_KEY_VAL_NULL;

M0_INTERNAL uint64_t m0_dummy_id_generate(void);

#endif /* __MOTR_LIB_MISC_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */