trace.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-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_TRACE_H__
#define __MOTR_LIB_TRACE_H__

#include <stdarg.h>

#include "lib/types.h"
#include "lib/arith.h"
#include "lib/atomic.h"
#include "lib/time.h"    /* m0_time_t, printf_check */
#include "lib/misc.h"    /* M0_CAT */
#include "motr/magic.h"  /* M0_TRACE_DESCR_MAGIC */

#ifndef __KERNEL__
#include "lib/user_space/trace.h"
#endif

#define M0_LOG(level, ...) \
        M0_CAT(M0_LOG, M0_COUNT_PARAMS(__VA_ARGS__))(level, __VA_ARGS__)

#define M0_ENTRY(...) M0_LOG(M0_CALL, "> " __VA_ARGS__)
#define M0_LEAVE(...) M0_LOG(M0_CALL, "< " __VA_ARGS__)

#define M0_RC_HOOK (0)

#if M0_RC_HOOK
M0_INTERNAL void m0_rc_hook(int rc);
M0_INTERNAL void m0_err_hook(int rc);
#else
static inline void m0_rc_hook(int rc)
{;}
static inline void m0_err_hook(int rc)
{;}
#endif

#define M0_RC(rc) ({                        \
        typeof(rc) __rc = (rc);             \
        M0_LOG(M0_CALL, "< rc=%d", __rc);   \
        m0_rc_hook(__rc);                   \
        __rc;                               \
})

#define M0_ERR(rc) ({                        \
        typeof(rc) __rc = (rc);              \
        M0_ASSERT(__rc != 0);                \
        M0_LOG(M0_ERROR, "<! rc=%d", __rc);  \
        m0_err_hook(__rc);                   \
        __rc;                                \
})

#define M0_RC_INFO(rc, fmt, ...) ({                                \
        typeof(rc) __rc = (rc);                                    \
        M0_LOG(M0_CALL, "< rc=%d " fmt, __rc, ## __VA_ARGS__ );    \
        __rc;                                                      \
})

#define M0_ERR_INFO(rc, fmt, ...) ({                               \
        typeof(rc) __rc = (rc);                                    \
        M0_ASSERT(__rc != 0);                                      \
        M0_LOG(M0_ERROR, "<! rc=%d " fmt, __rc, ## __VA_ARGS__ );  \
        __rc;                                                      \
})

M0_INTERNAL int m0_trace_init(void);
M0_INTERNAL void m0_trace_fini(void);
M0_INTERNAL int m0_trace_set_immediate_mask(const char *mask);
M0_INTERNAL int m0_trace_set_print_context(const char *ctx_name);
M0_INTERNAL int m0_trace_set_level(const char *level);

#define M0_TRACE_SUBSYSTEMS      \
  M0_TRACE_SUBSYS(OTHER,      0) \
  M0_TRACE_SUBSYS(LIB,        1) \
  M0_TRACE_SUBSYS(UT,         2) \
                                 \
  M0_TRACE_SUBSYS(ADDB,       3) \
  M0_TRACE_SUBSYS(ADSTOB,     4) \
  M0_TRACE_SUBSYS(BALLOC,     5) \
  M0_TRACE_SUBSYS(BE,         6) \
  M0_TRACE_SUBSYS(BTREE,      7) \
  M0_TRACE_SUBSYS(CAS,        8) \
  M0_TRACE_SUBSYS(CLIENT,     9) \
  M0_TRACE_SUBSYS(CM,        10) \
  M0_TRACE_SUBSYS(COB,       11) \
  M0_TRACE_SUBSYS(CONF,      12) \
  M0_TRACE_SUBSYS(CONSOLE,   13) \
  M0_TRACE_SUBSYS(DIX,       14) \
  M0_TRACE_SUBSYS(DIXCM,     15) \
  M0_TRACE_SUBSYS(DTM,       16) \
  M0_TRACE_SUBSYS(EXTMAP,    17) \
  M0_TRACE_SUBSYS(FD,        18) \
  M0_TRACE_SUBSYS(FILE,      19) \
  M0_TRACE_SUBSYS(FOL,       20) \
  M0_TRACE_SUBSYS(FOP,       21) \
  M0_TRACE_SUBSYS(FORMATION, 22) \
  M0_TRACE_SUBSYS(HA,        23) \
  M0_TRACE_SUBSYS(IOSERVICE, 24) \
  M0_TRACE_SUBSYS(LAYOUT,    25) \
  M0_TRACE_SUBSYS(LNET,      26) \
  M0_TRACE_SUBSYS(M0D,       27) \
  M0_TRACE_SUBSYS(M0T1FS,    28) \
  M0_TRACE_SUBSYS(MDS,       29) \
  M0_TRACE_SUBSYS(MEMORY,    30) \
  M0_TRACE_SUBSYS(MGMT,      31) \
  M0_TRACE_SUBSYS(NET,       32) \
  M0_TRACE_SUBSYS(POOL,      33) \
  M0_TRACE_SUBSYS(RM,        34) \
  M0_TRACE_SUBSYS(RPC,       35) \
  M0_TRACE_SUBSYS(SM,        36) \
  M0_TRACE_SUBSYS(SNS,       37) \
  M0_TRACE_SUBSYS(SNSCM,     38) \
  M0_TRACE_SUBSYS(SPIEL,     39) \
  M0_TRACE_SUBSYS(SSS,       40) \
  M0_TRACE_SUBSYS(STATS,     41) \
  M0_TRACE_SUBSYS(STOB,      42) \
  M0_TRACE_SUBSYS(XCODE,     43) \
  M0_TRACE_SUBSYS(FDMI,      44) \
  M0_TRACE_SUBSYS(ISCS,      45) \
  M0_TRACE_SUBSYS(DTM0,      46)

#define M0_TRACE_SUBSYS(name, value) M0_TRACE_SUBSYS_ ## name = (1UL << value),

enum m0_trace_subsystem {
        M0_TRACE_SUBSYSTEMS
};

extern unsigned long m0_trace_immediate_mask;

extern unsigned int m0_trace_print_context;

extern unsigned int m0_trace_level;

/*
 * Below is the internal implementation stuff.
 */

enum {
        M0_TRACE_BUF_HEADER_SIZE = (1 << 16), /* 64KB */
        M0_TRACE_REC_ALIGN = 8, /* word size on x86_64 */
};

extern struct m0_trace_buf_header *m0_logbuf_header; 
extern void      *m0_logbuf;        
enum m0_trace_buf_type {
        M0_TRACE_BUF_KERNEL = 1,
        M0_TRACE_BUF_USER   = 2,
};

enum m0_trace_buf_flags {
        M0_TRACE_BUF_MKFS  = 1 << 0,
        M0_TRACE_BUF_DIRTY = 1 << 1,

        M0_TRACE_BUF_FLAGS_MAX
};
M0_BASSERT(M0_TRACE_BUF_FLAGS_MAX < UINT16_MAX);

struct m0_trace_buf_header {
        union {
                struct {
                        /* XXX: don't change fields order */
                        /* XXX: new fields should be added at the end */

                        uint64_t                tbh_magic;
                        const void             *tbh_header_addr;
                        uint32_t                tbh_header_size;
                        const void             *tbh_buf_addr;
                        uint64_t                tbh_buf_size;
                        uint16_t                tbh_buf_type;
                        uint16_t                tbh_buf_flags;
                        struct m0_atomic64      tbh_cur_pos;
                        struct m0_atomic64      tbh_rec_cnt;
                        const void             *tbh_magic_sym_addr;
                        char                    tbh_motr_version[16];
                        char                    tbh_motr_git_describe[64];
                        char                    tbh_motr_kernel_ver[128];
                        m0_time_t               tbh_log_time;
                        const void             *tbh_module_struct;
                        const void             *tbh_module_core_addr;
                        unsigned int            tbh_module_core_size;
                        char                    tbh_cli_args[1024];
                        uint16_t                tbh_magic_sym_addresses_nr;
                        const void             *tbh_magic_sym_addresses[128];

                        /* XXX: add new field right above this line */
                };
                char    tbh_header_area[M0_TRACE_BUF_HEADER_SIZE];
        };
};
M0_BASSERT(sizeof (struct m0_trace_buf_header) == M0_TRACE_BUF_HEADER_SIZE);

struct m0_trace_rec_header {
        /* XXX: don't change fields order */
        /* XXX: new fields should be added to the end */
        uint64_t                     trh_magic;
        uint64_t                     trh_sp; 
        uint64_t                     trh_no; 
        uint64_t                     trh_pos; 
        uint64_t                     trh_timestamp;
        const struct m0_trace_descr *trh_descr;
        uint32_t                     trh_string_data_size;
        uint32_t                     trh_record_size; 
        pid_t                        trh_pid; 
};

enum m0_trace_level {
        M0_NONE   = 0,

        M0_ALWAYS = 1 << 0,

        M0_FATAL  = 1 << 1,
        M0_ERROR  = 1 << 2,
        M0_WARN   = 1 << 3,
        M0_NOTICE = 1 << 4,
        M0_INFO   = 1 << 5,
        M0_DEBUG  = 1 << 6,

        M0_CALL   = 1 << 7,
};

enum m0_trace_print_context {
        M0_TRACE_PCTX_NONE  = 0,
        M0_TRACE_PCTX_FUNC  = 1,
        M0_TRACE_PCTX_SHORT = 2,
        M0_TRACE_PCTX_FULL  = 3,

        M0_TRACE_PCTX_INVALID
};

struct m0_trace_descr {
        uint64_t             td_magic;
        const char          *td_fmt;
        const char          *td_func;
        const char          *td_file;
        uint64_t             td_subsys;
        int                  td_line;
        int                  td_size;
        int                  td_nr;
        const int           *td_offset;
        const int           *td_sizeof;
        const bool          *td_isstr;
        enum m0_trace_level  td_level;
        bool                 td_hasstr;
};

M0_INTERNAL void m0_trace_level_allow(unsigned level);

M0_INTERNAL void m0_trace_allot(const struct m0_trace_descr *td,
                                const void *data);
M0_INTERNAL void m0_trace_record_print(const struct m0_trace_rec_header *trh,
                                       const void *buf);

M0_INTERNAL void m0_trace_print_subsystems(void);

__attribute__ ((format (printf, 1, 2)))
void m0_console_printf(const char *fmt, ...);

void m0_console_flush(void);

__attribute__ ((format (printf, 1, 2)))
void m0_error_printf(const char *fmt, ...);

M0_INTERNAL
int  m0_trace_record_print_yaml(char *outbuf, size_t outbuf_size,
                                const struct m0_trace_rec_header *trh,
                                const void *tr_body, bool yaml_stream_mode);

/*
 * The code below abuses C preprocessor badly. Looking at it might be damaging
 * to your eyes and sanity.
 */

#define M0_TRACE_POINT(LEVEL, NR, DECL, OFFSET, SIZEOF, ISSTR, HASSTR, FMT, ...)\
({                                                                      \
        struct t_body DECL;                                             \
        static const int  _offset[NR] = OFFSET;                         \
        static const int  _sizeof[NR] = SIZEOF;                         \
        static const bool _isstr[NR]  = ISSTR;                          \
        static const struct m0_trace_descr __trace_descr = {            \
                .td_magic  = M0_TRACE_DESCR_MAGIC,                      \
                .td_level  = (LEVEL),                                   \
                .td_fmt    = (FMT),                                     \
                .td_func   = __func__,                                  \
                .td_file   = __FILE__,                                  \
                .td_line   = __LINE__,                                  \
                .td_subsys = M0_TRACE_SUBSYSTEM,                        \
                .td_size   = sizeof(struct t_body),                     \
                .td_nr     = (NR),                                      \
                .td_offset = _offset,                                   \
                .td_sizeof = _sizeof,                                   \
                .td_isstr  = _isstr,                                    \
                .td_hasstr = (HASSTR),                                  \
        };                                                              \
        printf_check(FMT , ## __VA_ARGS__);                             \
        m0_trace_allot(&__trace_descr, &(const struct t_body){ __VA_ARGS__ });\
})

#ifndef M0_TRACE_SUBSYSTEM
#  define M0_TRACE_SUBSYSTEM M0_TRACE_SUBSYS_OTHER
#endif

enum {
        M0_TRACE_ARGC_MAX = 9
};

/*
 *  Helpers for M0_LOG{n}().
 */
#define LOG_TYPEOF(a, v) typeof(a) v
#define LOG_OFFSETOF(v) offsetof(struct t_body, v)
#define LOG_SIZEOF(a) sizeof(a)
#define LOG_IS_STR_ARG(a)                           \
                M0_HAS_TYPE((a), char*)        ?:   \
                M0_HAS_TYPE((a), const char*)  ?:   \
                M0_HAS_TYPE((a), char[])       ?:   \
                M0_HAS_TYPE((a), const char[]) ?: false


#define LOG_CHECK(a)                                                    \
M0_CASSERT(!M0_HAS_TYPE(a, const char []) &&                            \
           (sizeof(a) == 1 || sizeof(a) == 2 || sizeof(a) == 4 ||       \
            sizeof(a) == 8))

#define LOG_GROUP(...) __VA_ARGS__

#define M0_LOG0(level, fmt) \
        M0_TRACE_POINT(level, 0, { ; }, {}, {}, {}, false, fmt)

#define M0_LOG1(level, fmt, a0)                                         \
({ M0_TRACE_POINT(level, 1,                                             \
   { LOG_TYPEOF(a0, v0); },                                             \
   { LOG_OFFSETOF(v0) },                                                \
   { LOG_SIZEOF(a0) },                                                  \
   { LOG_IS_STR_ARG(a0) },                                              \
   LOG_IS_STR_ARG(a0),                                                  \
   fmt, a0);                                                            \
   LOG_CHECK(a0); })

#define M0_LOG2(level, fmt, a0, a1)                                     \
({ M0_TRACE_POINT(level, 2,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); },                         \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1) }),                   \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1) }),                       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1) }),               \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1),                            \
   fmt, a0, a1);                                                        \
   LOG_CHECK(a0); LOG_CHECK(a1); })

#define M0_LOG3(level, fmt, a0, a1, a2)                                 \
({ M0_TRACE_POINT(level, 3,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2); },     \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2) }), \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2) }),       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2) }),                                   \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2),      \
   fmt, a0, a1, a2);                                                    \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); })

#define M0_LOG4(level, fmt, a0, a1, a2, a3)                             \
({ M0_TRACE_POINT(level, 4,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); },                                             \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3) }),                                     \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3) }),                                       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3)  }),              \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3),                                                     \
   fmt, a0, a1, a2, a3);                                                \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3); })

#define M0_LOG5(level, fmt, a0, a1, a2, a3, a4)                         \
({ M0_TRACE_POINT(level, 5,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); LOG_TYPEOF(a4, v4); },                         \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3), LOG_OFFSETOF(v4) }),                   \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3), LOG_SIZEOF(a4) }),                       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3),                  \
               LOG_IS_STR_ARG(a4) }),                                   \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3) || LOG_IS_STR_ARG(a4),                       \
   fmt, a0, a1, a2, a3, a4);                                            \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3);          \
   LOG_CHECK(a4); })

#define M0_LOG6(level, fmt, a0, a1, a2, a3, a4, a5)                     \
({ M0_TRACE_POINT(level, 6,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); LOG_TYPEOF(a4, v4); LOG_TYPEOF(a5, v5); },     \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3), LOG_OFFSETOF(v4), LOG_OFFSETOF(v5) }), \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3), LOG_SIZEOF(a4), LOG_SIZEOF(a5) }),       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3),                  \
               LOG_IS_STR_ARG(a4), LOG_IS_STR_ARG(a5) }),               \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3) || LOG_IS_STR_ARG(a4) || LOG_IS_STR_ARG(a5), \
   fmt, a0, a1, a2, a3, a4, a5);                                        \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3);          \
   LOG_CHECK(a4); LOG_CHECK(a5); })

#define M0_LOG7(level, fmt, a0, a1, a2, a3, a4, a5, a6)                 \
({ M0_TRACE_POINT(level, 7,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); LOG_TYPEOF(a4, v4); LOG_TYPEOF(a5, v5);        \
     LOG_TYPEOF(a6, v6); },                                             \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3), LOG_OFFSETOF(v4),                      \
               LOG_OFFSETOF(v5), LOG_OFFSETOF(v6) }),                   \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3), LOG_SIZEOF(a4),                          \
               LOG_SIZEOF(a5), LOG_SIZEOF(a6) }),                       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3),                  \
               LOG_IS_STR_ARG(a4), LOG_IS_STR_ARG(a5),                  \
               LOG_IS_STR_ARG(a6) }),                                   \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3) || LOG_IS_STR_ARG(a4) ||                     \
        LOG_IS_STR_ARG(a5) || LOG_IS_STR_ARG(a6),                       \
   fmt, a0, a1, a2, a3, a4, a5, a6);                                    \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3);          \
   LOG_CHECK(a4); LOG_CHECK(a5); LOG_CHECK(a6); })

#define M0_LOG8(level, fmt, a0, a1, a2, a3, a4, a5, a6, a7)             \
({ M0_TRACE_POINT(level, 8,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); LOG_TYPEOF(a4, v4); LOG_TYPEOF(a5, v5);        \
     LOG_TYPEOF(a6, v6); LOG_TYPEOF(a7, v7); },                         \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3), LOG_OFFSETOF(v4), LOG_OFFSETOF(v5),    \
               LOG_OFFSETOF(v6), LOG_OFFSETOF(v7) }),                   \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3), LOG_SIZEOF(a4), LOG_SIZEOF(a5),          \
               LOG_SIZEOF(a6), LOG_SIZEOF(a7) }),                       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3),                  \
               LOG_IS_STR_ARG(a4), LOG_IS_STR_ARG(a5),                  \
               LOG_IS_STR_ARG(a6), LOG_IS_STR_ARG(a7) }),               \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3) || LOG_IS_STR_ARG(a4) ||                     \
        LOG_IS_STR_ARG(a5) || LOG_IS_STR_ARG(a6) ||                     \
        LOG_IS_STR_ARG(a7),                                             \
   fmt, a0, a1, a2, a3, a4, a5, a6, a7);                                \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3);          \
   LOG_CHECK(a4); LOG_CHECK(a5); LOG_CHECK(a6); LOG_CHECK(a7); })

#define M0_LOG9(level, fmt, a0, a1, a2, a3, a4, a5, a6, a7, a8)         \
({ M0_TRACE_POINT(level, 9,                                             \
   { LOG_TYPEOF(a0, v0); LOG_TYPEOF(a1, v1); LOG_TYPEOF(a2, v2);        \
     LOG_TYPEOF(a3, v3); LOG_TYPEOF(a4, v4); LOG_TYPEOF(a5, v5);        \
     LOG_TYPEOF(a6, v6); LOG_TYPEOF(a7, v7); LOG_TYPEOF(a8, v8); },     \
   LOG_GROUP({ LOG_OFFSETOF(v0), LOG_OFFSETOF(v1), LOG_OFFSETOF(v2),    \
               LOG_OFFSETOF(v3), LOG_OFFSETOF(v4), LOG_OFFSETOF(v5),    \
               LOG_OFFSETOF(v6), LOG_OFFSETOF(v7), LOG_OFFSETOF(v8) }), \
   LOG_GROUP({ LOG_SIZEOF(a0), LOG_SIZEOF(a1), LOG_SIZEOF(a2),          \
               LOG_SIZEOF(a3), LOG_SIZEOF(a4), LOG_SIZEOF(a5),          \
               LOG_SIZEOF(a6), LOG_SIZEOF(a7), LOG_SIZEOF(a8) }),       \
   LOG_GROUP({ LOG_IS_STR_ARG(a0), LOG_IS_STR_ARG(a1),                  \
               LOG_IS_STR_ARG(a2), LOG_IS_STR_ARG(a3),                  \
               LOG_IS_STR_ARG(a4), LOG_IS_STR_ARG(a5),                  \
               LOG_IS_STR_ARG(a6), LOG_IS_STR_ARG(a7),                  \
               LOG_IS_STR_ARG(a8) }),                                   \
   LOG_IS_STR_ARG(a0) || LOG_IS_STR_ARG(a1) || LOG_IS_STR_ARG(a2) ||    \
        LOG_IS_STR_ARG(a3) || LOG_IS_STR_ARG(a4) ||                     \
        LOG_IS_STR_ARG(a5) || LOG_IS_STR_ARG(a6) ||                     \
        LOG_IS_STR_ARG(a7) || LOG_IS_STR_ARG(a8),                       \
   fmt, a0, a1, a2, a3, a4, a5, a6, a7, a8);                            \
   LOG_CHECK(a0); LOG_CHECK(a1); LOG_CHECK(a2); LOG_CHECK(a3);          \
   LOG_CHECK(a4); LOG_CHECK(a5); LOG_CHECK(a6); LOG_CHECK(a7); LOG_CHECK(a8); })

#endif /* __MOTR_LIB_TRACE_H__ */

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