tr-driver.h

Go to the documentation of this file.

#ifndef _TR_DRIVER_H
#define _TR_DRIVER_H

#include <linux/limits.h>
#include <unistd.h>
#include <sys/types.h>

#include <json.h>

#include <generic.h>
#include <trace_replay.h>

#define tr_info_list_traverse(ptr, head)                                       \
        for (ptr = head; ptr != NULL; ptr = ptr->next)

#define tr_json_field_traverse(ptr, begin, end)                                \
        for (ptr = begin; ptr != end; ptr++)

#ifdef REDHAT_LINUX
#pragma message "Compile redhat version"
#define TR_CGROUP_PREFIX "/sys/fs/cgroup/"
#define TR_CGROUP_WEIGHT_PREFIX "io"
#define TR_CGROUP_SET_PID "cgroup.procs"
#endif

#ifndef REDHAT_LINUX
#pragma message "Compile not redhat version"
#define TR_CGROUP_PREFIX "/sys/fs/cgroup/blkio/"
#define TR_CGROUP_WEIGHT_PREFIX "blkio"
#define TR_CGROUP_SET_PID "tasks"
#endif

#ifdef DEBUG
#define tr_print_info(info)                                                    \
        pr_info(INFO,                                                          \
                "\n"                                                           \
                "\t\t[[ current %p ]]\n"                                       \
                "\t\tpid: %d\n"                                                \
                "\t\ttime: %u\n"                                               \
                "\t\tq_depth: %u\n"                                            \
                "\t\tnr_thread: %u\n"                                          \
                "\t\tweight: %u\n"                                             \
                "\t\ttrace_repeat: %u\n"                                       \
                "\t\twss: %u\n"                                                \
                "\t\tutilization: %u\n"                                        \
                "\t\tiosize: %u\n"                                             \
                "\t\tmqid: %d\n"                                               \
                "\t\tshmid: %d\n"                                              \
                "\t\tsemid: %d\n"                                              \
                "\t\tprefix_cgroup_name: %s\n"                                 \
                "\t\tscheduler: %s\n"                                          \
                "\t\tname: %s\n"                                               \
                "\t\ttrace_replay_path: %s\n"                                  \
                "\t\ttrace_data_path: %s\n"                                    \
                "\t\tdevice: %s\n"                                             \
                "\t\tglobal_config: %p\n"                                      \
                "\t\tnext: %p\n",                                              \
                (info), (info)->pid, (info)->time, (info)->q_depth,            \
                (info)->nr_thread, (info)->weight, (info)->trace_repeat,       \
                (info)->wss, (info)->utilization, (info)->iosize,              \
                (info)->mqid, (info)->shmid, (info)->semid,                    \
                (info)->prefix_cgroup_name, (info)->scheduler,                 \
                (info)->cgroup_id, (info)->trace_replay_path,                  \
                (info)->trace_data_path, (info)->device,                       \
                (info)->global_config, (info)->next);
#endif

enum { TR_IPC_NOT_FREE = 0x0, 
       TR_IPC_FREE = 0x1, };

enum { TR_NOT_SYNTH = 0, 
       TR_SYNTH = 0x1, };

enum { TR_ERROR_PRINT, 
       TR_PRINT_NONE, };

struct tr_json_field {
        const char *name; 
        const void *member; 
};

struct tr_total_json_object {
        struct json_object
                *trace[MAX_THREADS]; 
        struct json_object *per_trace
                [MAX_THREADS]; 
        struct json_object *synthetic
                [MAX_THREADS]; 
        struct json_object
                *stats[MAX_THREADS]; 
};

struct tr_info {
        pid_t ppid; 
        pid_t pid; 
        unsigned int
                time; 
        unsigned int
                q_depth; 
        unsigned int nr_thread; 
        unsigned int weight; 
        int mqid; 
        int shmid; 
        int semid; 
        unsigned int trace_repeat; 
        unsigned int wss; 
        unsigned int utilization; 
        unsigned int iosize; 
        char prefix_cgroup_name
                [NAME_MAX]; 
        char device[NAME_MAX]; 
        char scheduler[NAME_MAX]; 
        char cgroup_id
                [NAME_MAX]; 
        char trace_replay_path[PATH_MAX]; 
        char trace_data_path[PATH_MAX]; 
        void *global_config; 
        struct tr_info *next; 
};

/* tr-driver.c */
int tr_init(void *object);
int tr_runner(void);
int tr_valid_scheduler_test(const char *scheduler);
int tr_has_weight_scheduler(const int scheduler_index);
int tr_get_interval(const char *key, char *buffer);
int tr_get_total(const char *key, char *buffer);
void tr_free(void);

/* tr-serializer.c */
void tr_total_serializer(const struct tr_info *info,
                         const struct total_results *total, char *buffer);
void tr_realtime_serializer(const struct tr_info *info,
                            const struct realtime_log *log, char *buffer);
/* tr-info.c */
struct tr_info *tr_info_init(struct json_object *setting, int index);

/* tr-shm.c */
int tr_shm_init(struct tr_info *info);
int tr_shm_get(const struct tr_info *info, void *buffer);
void tr_shm_free(struct tr_info *info, int flags);

/* tr-mq.c */
int tr_mq_init(struct tr_info *info);
int tr_mq_get(const struct tr_info *info, void *buffer);
void tr_mq_free(struct tr_info *info, int flags);

#endif