net_core.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_NET_CORE_H_
#define ZEPHYR_INCLUDE_NET_NET_CORE_H_
 
#include <stdbool.h>
#include <string.h>
 
#include <zephyr/logging/log.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/kernel.h>
 
#include <zephyr/net/net_timeout.h>
#include <zephyr/net/net_linkaddr.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Network subsystem logging helpers */
#ifdef CONFIG_THREAD_NAME
#define NET_DBG(fmt, ...) LOG_DBG("(%s): " fmt,                         \
                        k_thread_name_get(k_current_get()), \
                        ##__VA_ARGS__)
#else
#define NET_DBG(fmt, ...) LOG_DBG("(%p): " fmt, k_current_get(),        \
                                  ##__VA_ARGS__)
#endif /* CONFIG_THREAD_NAME */
#define NET_ERR(fmt, ...) LOG_ERR(fmt, ##__VA_ARGS__)
#define NET_WARN(fmt, ...) LOG_WRN(fmt, ##__VA_ARGS__)
#define NET_INFO(fmt, ...) LOG_INF(fmt,  ##__VA_ARGS__)
 
/* Rate-limited network logging macros */
#define NET_ERR_RATELIMIT(fmt, ...)  LOG_ERR_RATELIMIT(fmt, ##__VA_ARGS__)
#define NET_WARN_RATELIMIT(fmt, ...) LOG_WRN_RATELIMIT(fmt, ##__VA_ARGS__)
#define NET_INFO_RATELIMIT(fmt, ...) LOG_INF_RATELIMIT(fmt, ##__VA_ARGS__)
#define NET_DBG_RATELIMIT(fmt, ...)  LOG_DBG_RATELIMIT(fmt, ##__VA_ARGS__)
 
#define NET_HEXDUMP_DBG(_data, _length, _str)  LOG_HEXDUMP_DBG(_data, _length, _str)
#define NET_HEXDUMP_ERR(_data, _length, _str)  LOG_HEXDUMP_ERR(_data, _length, _str)
#define NET_HEXDUMP_WARN(_data, _length, _str) LOG_HEXDUMP_WRN(_data, _length, _str)
#define NET_HEXDUMP_INFO(_data, _length, _str) LOG_HEXDUMP_INF(_data, _length, _str)
 
#define NET_ASSERT(cond, ...) __ASSERT(cond, "" __VA_ARGS__)
 
/* This needs to be here in order to avoid circular include dependency between
 * net_pkt.h and net_if.h
 */
#if defined(CONFIG_NET_PKT_TXTIME_STATS_DETAIL) || \
        defined(CONFIG_NET_PKT_RXTIME_STATS_DETAIL)
#if !defined(NET_PKT_DETAIL_STATS_COUNT)
#if defined(CONFIG_NET_PKT_TXTIME_STATS_DETAIL)
 
#if defined(CONFIG_NET_PKT_RXTIME_STATS_DETAIL)
#define NET_PKT_DETAIL_STATS_COUNT 4
#else
#define NET_PKT_DETAIL_STATS_COUNT 3
#endif /* CONFIG_NET_PKT_RXTIME_STATS_DETAIL */
 
#else
#define NET_PKT_DETAIL_STATS_COUNT 4
#endif /* CONFIG_NET_PKT_TXTIME_STATS_DETAIL */
 
#endif /* !NET_PKT_DETAIL_STATS_COUNT */
#endif /* CONFIG_NET_PKT_TXTIME_STATS_DETAIL ||
          CONFIG_NET_PKT_RXTIME_STATS_DETAIL */
 
struct net_buf;
struct net_pkt;
struct net_context;
struct net_if;
 
enum net_verdict {
        NET_OK,
        NET_CONTINUE,
        NET_DROP,
};
 
int net_recv_data(struct net_if *iface, struct net_pkt *pkt);
 
int net_try_send_data(struct net_pkt *pkt, k_timeout_t timeout);
 
static inline int net_send_data(struct net_pkt *pkt)
{
        k_timeout_t timeout = k_is_in_isr() ? K_NO_WAIT : K_FOREVER;
 
        return net_try_send_data(pkt, timeout);
}
 
/* Some helper defines for traffic class support */
#if defined(CONFIG_NET_TC_TX_COUNT) && defined(CONFIG_NET_TC_RX_COUNT)
#define NET_TC_TX_COUNT CONFIG_NET_TC_TX_COUNT
#define NET_TC_RX_COUNT CONFIG_NET_TC_RX_COUNT
 
#if NET_TC_TX_COUNT > NET_TC_RX_COUNT
#define NET_TC_COUNT NET_TC_TX_COUNT
#else
#define NET_TC_COUNT NET_TC_RX_COUNT
#endif
#else /* CONFIG_NET_TC_TX_COUNT && CONFIG_NET_TC_RX_COUNT */
#define NET_TC_TX_COUNT 0
#define NET_TC_RX_COUNT 0
#define NET_TC_COUNT 0
#endif /* CONFIG_NET_TC_TX_COUNT && CONFIG_NET_TC_RX_COUNT */
 
#if CONFIG_NET_TC_TX_SKIP_FOR_HIGH_PRIO
#define NET_TC_TX_EFFECTIVE_COUNT (NET_TC_TX_COUNT + 1)
#else
#define NET_TC_TX_EFFECTIVE_COUNT NET_TC_TX_COUNT
#endif
 
#if CONFIG_NET_TC_RX_SKIP_FOR_HIGH_PRIO
#define NET_TC_RX_EFFECTIVE_COUNT (NET_TC_RX_COUNT + 1)
#else
#define NET_TC_RX_EFFECTIVE_COUNT NET_TC_RX_COUNT
#endif
 
struct net_l3_register {
        const char * const name;
        const struct net_l2 * const l2;
        enum net_verdict (*handler)(struct net_if *iface,
                                    uint16_t ptype,
                                    struct net_pkt *pkt);
        uint16_t ptype;
};
 
#define NET_L3_GET_NAME(l3_name, ptype) __net_l3_register_##l3_name##_##ptype
 
#define NET_L3_REGISTER(_l2_type, _name, _ptype, _handler)              \
        static const STRUCT_SECTION_ITERABLE(net_l3_register,           \
                                    NET_L3_GET_NAME(_name, _ptype)) = { \
                .ptype = _ptype,                                        \
                .handler = _handler,                                    \
                .name = STRINGIFY(_name),                               \
                .l2 = _l2_type,                                         \
        };
 
/* @endcond */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_NET_CORE_H_ */