sflist.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SYS_SFLIST_H_
#define ZEPHYR_INCLUDE_SYS_SFLIST_H_
 
#include <stdint.h>
#include <stdbool.h>
#include <zephyr/sys/__assert.h>
#include "list_gen.h"
 
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Flag bits are stored in the low bits of the node address, so a node must be
 * aligned to at least 4 bytes. Not every ABI gives uintptr_t that alignment
 * naturally, so require it explicitly. See SYS_SFLIST_FLAGS_MASK below.
 */
struct _sfnode {
        uintptr_t next_and_flags;
} __aligned(sizeof(void *));

typedef struct _sfnode sys_sfnode_t;

struct _sflist {
        sys_sfnode_t *head;
        sys_sfnode_t *tail;
};

typedef struct _sflist sys_sflist_t;

#define SYS_SFLIST_FOR_EACH_NODE(__sl, __sn)                            \
        Z_GENLIST_FOR_EACH_NODE(sflist, __sl, __sn)

#define SYS_SFLIST_ITERATE_FROM_NODE(__sl, __sn)                                \
        Z_GENLIST_ITERATE_FROM_NODE(sflist, __sl, __sn)

#define SYS_SFLIST_FOR_EACH_NODE_SAFE(__sl, __sn, __sns)                        \
        Z_GENLIST_FOR_EACH_NODE_SAFE(sflist, __sl, __sn, __sns)

#define SYS_SFLIST_CONTAINER(__ln, __cn, __n) \
        Z_GENLIST_CONTAINER(__ln, __cn, __n)

#define SYS_SFLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n) \
        Z_GENLIST_PEEK_HEAD_CONTAINER(sflist, __sl, __cn, __n)

#define SYS_SFLIST_PEEK_TAIL_CONTAINER(__sl, __cn, __n) \
        Z_GENLIST_PEEK_TAIL_CONTAINER(sflist, __sl, __cn, __n)

#define SYS_SFLIST_PEEK_NEXT_CONTAINER(__cn, __n) \
        Z_GENLIST_PEEK_NEXT_CONTAINER(sflist, __cn, __n)

#define SYS_SFLIST_FOR_EACH_CONTAINER(__sl, __cn, __n)                  \
        Z_GENLIST_FOR_EACH_CONTAINER(sflist, __sl, __cn, __n)

#define SYS_SFLIST_FOR_EACH_CONTAINER_SAFE(__sl, __cn, __cns, __n)      \
        Z_GENLIST_FOR_EACH_CONTAINER_SAFE(sflist, __sl, __cn, __cns, __n)
 
 
/*
 * Required function definitions for the list_gen.h interface
 *
 * These are the only functions that do not treat the list/node pointers
 * as completely opaque types.
 */

static inline void sys_sflist_init(sys_sflist_t *list)
{
        list->head = NULL;
        list->tail = NULL;
}

#define SYS_SFLIST_STATIC_INIT(ptr_to_list) {NULL, NULL}
 
/* Flag bits are stored in unused LSB of the sys_sfnode_t pointer */
#define SYS_SFLIST_FLAGS_MASK   ((uintptr_t)(__alignof__(sys_sfnode_t) - 1))
/* At least 2 available flag bits are expected */
BUILD_ASSERT(SYS_SFLIST_FLAGS_MASK >= 0x3);
 
static inline sys_sfnode_t *z_sfnode_next_peek(const sys_sfnode_t *node)
{
        return (sys_sfnode_t *)(node->next_and_flags & ~SYS_SFLIST_FLAGS_MASK);
}
 
static inline uint8_t sys_sfnode_flags_get(const sys_sfnode_t *node);
 
static inline void z_sfnode_next_set(sys_sfnode_t *parent,
                                       sys_sfnode_t *child)
{
        uint8_t cur_flags = sys_sfnode_flags_get(parent);
 
        parent->next_and_flags = cur_flags | (uintptr_t)child;
}
 
static inline void z_sflist_head_set(sys_sflist_t *list, sys_sfnode_t *node)
{
        list->head = node;
}
 
static inline void z_sflist_tail_set(sys_sflist_t *list, sys_sfnode_t *node)
{
        list->tail = node;
}

static inline sys_sfnode_t *sys_sflist_peek_head(const sys_sflist_t *list)
{
        return list->head;
}

static inline sys_sfnode_t *sys_sflist_peek_tail(const sys_sflist_t *list)
{
        return list->tail;
}
 
/*
 * APIs specific to sflist type
 */

static inline uint8_t sys_sfnode_flags_get(const sys_sfnode_t *node)
{
        return node->next_and_flags & SYS_SFLIST_FLAGS_MASK;
}

static inline void sys_sfnode_init(sys_sfnode_t *node, uint8_t flags)
{
        __ASSERT((flags & ~SYS_SFLIST_FLAGS_MASK) == 0UL, "flags too large");
        node->next_and_flags = flags;
}

static inline void sys_sfnode_flags_set(sys_sfnode_t *node, uint8_t flags)
{
        __ASSERT((flags & ~SYS_SFLIST_FLAGS_MASK) == 0UL, "flags too large");
        node->next_and_flags = (uintptr_t)(z_sfnode_next_peek(node)) | flags;
}
 
/*
 * Derived, generated APIs
 */

static inline bool sys_sflist_is_empty(const sys_sflist_t *list);
 
Z_GENLIST_IS_EMPTY(sflist)
 

static inline sys_sfnode_t *sys_sflist_peek_next_no_check(const sys_sfnode_t *node);
 
Z_GENLIST_PEEK_NEXT_NO_CHECK(sflist, sfnode)
 

static inline sys_sfnode_t *sys_sflist_peek_next(const sys_sfnode_t *node);
 
Z_GENLIST_PEEK_NEXT(sflist, sfnode)
 

static inline void sys_sflist_prepend(sys_sflist_t *list,
                                      sys_sfnode_t *node);
 
Z_GENLIST_PREPEND(sflist, sfnode)
 

static inline void sys_sflist_append(sys_sflist_t *list,
                                     sys_sfnode_t *node);
 
Z_GENLIST_APPEND(sflist, sfnode)
 

static inline void sys_sflist_append_list(sys_sflist_t *list,
                                          void *head, void *tail);
 
Z_GENLIST_APPEND_LIST(sflist, sfnode)
 

static inline void sys_sflist_merge_sflist(sys_sflist_t *list,
                                           sys_sflist_t *list_to_append);
 
Z_GENLIST_MERGE_LIST(sflist, sfnode)
 

static inline void sys_sflist_insert(sys_sflist_t *list,
                                     sys_sfnode_t *prev,
                                     sys_sfnode_t *node);
 
Z_GENLIST_INSERT(sflist, sfnode)
 

static inline sys_sfnode_t *sys_sflist_get_not_empty(sys_sflist_t *list);
 
Z_GENLIST_GET_NOT_EMPTY(sflist, sfnode)
 

static inline sys_sfnode_t *sys_sflist_get(sys_sflist_t *list);
 
Z_GENLIST_GET(sflist, sfnode)
 

static inline void sys_sflist_remove(sys_sflist_t *list,
                                     sys_sfnode_t *prev_node,
                                     sys_sfnode_t *node);
 
Z_GENLIST_REMOVE(sflist, sfnode)
 

static inline bool sys_sflist_find_and_remove(sys_sflist_t *list,
                                              sys_sfnode_t *node);
 
Z_GENLIST_FIND_AND_REMOVE(sflist, sfnode)
 

static inline size_t sys_sflist_len(const sys_sflist_t *list);
 
Z_GENLIST_LEN(sflist, sfnode)
 

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_SFLIST_H_ */