docker-driver.h

Go to the documentation of this file.

#ifndef _DOCKER_DRIVER_H
#define _DOCKER_DRIVER_H

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

#include <json.h>

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

#define DOCKER_ID_LEN 65

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

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

#ifdef DEBUG
#define docker_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 { DOCKER_IPC_NOT_FREE = 0x0, 
       DOCKER_IPC_FREE = 0x1, };

enum { DOCKER_NOT_SYNTH = 0, 
       DOCKER_SYNTH = 0x1, };

enum { DOCKER_ERROR_PRINT, 
       DOCKER_PRINT_NONE, };

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

struct docker_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 docker_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 docker_info *next; 
        char container_id[DOCKER_ID_LEN]; 
};

/* docker-driver.c */
int docker_init(void *object);
int docker_runner(void);
int docker_valid_scheduler_test(const char *scheduler);
int docker_has_weight_scheduler(const int scheduler_index);
int docker_get_interval(const char *key, char *buffer);
int docker_get_total(const char *key, char *buffer);
void docker_free(void);

/* docker-serializer.c */
void docker_total_serializer(const struct docker_info *info,
                             const struct total_results *total, char *buffer);
void docker_realtime_serializer(const struct docker_info *info,
                                const struct realtime_log *log, char *buffer);
/* docker-info.c */
struct docker_info *docker_info_init(struct json_object *setting, int index);
int docker_is_synth_type(const char *trace_data_path);

/* docker-shm.c */
int docker_shm_init(struct docker_info *info);
int docker_shm_get(const struct docker_info *info, void *buffer);
void docker_shm_free(struct docker_info *info, int flags);

/* docker-mq.c */
int docker_mq_init(struct docker_info *info);
int docker_mq_get(const struct docker_info *info, void *buffer);
void docker_mq_free(struct docker_info *info, int flags);

#endif