/*
|
* Copyright (c) International Business Machines Corp., 2001-2004
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
* the GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
*/
|
#include <stdio.h>
|
#include <string.h>
|
#include <assert.h>
|
#include <inttypes.h>
|
#include <ctype.h>
|
|
#include "ffsb.h"
|
#include "parser.h"
|
#include "ffsb_tg.h"
|
#include "ffsb_stats.h"
|
#include "util.h"
|
#include "list.h"
|
|
#define BUFSIZE 1024
|
|
config_options_t global_options[] = GLOBAL_OPTIONS;
|
config_options_t tg_options[] = THREADGROUP_OPTIONS;
|
config_options_t fs_options[] = FILESYSTEM_OPTIONS;
|
config_options_t stats_options[] = STATS_OPTIONS;
|
container_desc_t container_desc[] = CONTAINER_DESC;
|
|
/* strips out whitespace and comments, returns NULL on eof */
|
void parseerror(char *msg)
|
{
|
fprintf(stderr, "Error parsing %s\n", msg);
|
exit(1);
|
}
|
|
static char *get_next_line(FILE * f)
|
{
|
static char buf[BUFSIZE];
|
char *ret, *tmp;
|
int flag = 1;
|
while (flag) {
|
ret = fgets(buf, BUFSIZE, f);
|
if (ret == NULL)
|
return NULL;
|
ret = buf;
|
while (isspace(*ret))
|
ret++;
|
|
if ((*ret == COMMENT_CHAR) || (*ret == '\0'))
|
continue;
|
|
tmp = ret;
|
while (*tmp != '\0') {
|
if (*tmp == COMMENT_CHAR) {
|
*tmp = '\0';
|
break;
|
}
|
tmp++;
|
}
|
flag = 0;
|
}
|
return ret;
|
}
|
|
static char *strip_space(char *buf)
|
{
|
int len;
|
char *tmp, *tmp2;
|
int flag = 1;
|
|
len = strnlen(buf, BUFSIZE);
|
tmp = malloc(sizeof(char) * len);
|
memset(tmp, 0, sizeof(char) * len);
|
tmp2 = tmp;
|
while (flag) {
|
if (!isspace(*buf)) {
|
*tmp = *buf;
|
tmp++;
|
}
|
buf++;
|
if (*buf != '\0')
|
continue;
|
flag = 0;
|
}
|
return tmp2;
|
}
|
|
static uint64_t size64_convert(char *buf)
|
{
|
size_t buf_size = strlen(buf);
|
char unit[3] = { 0 };
|
char search_str[256];
|
uint64_t size;
|
uint64_t multiplier = 1;
|
int i;
|
|
if (buf_size == 1)
|
goto out;
|
|
strcpy(unit, buf + (buf_size - 2));
|
for (i = 0; i < 2; i++) {
|
if (isdigit(unit[i]))
|
goto try_single;
|
unit[i] = toupper(unit[i]);
|
}
|
goto do_multiplier;
|
|
try_single:
|
memset(unit, 0, sizeof(unit));
|
strcpy(unit, buf + (buf_size - 1));
|
if (isdigit(unit[0])) {
|
unit[0] = 0;
|
goto out;
|
}
|
unit[0] = toupper(unit[0]);
|
|
do_multiplier:
|
if (!strcmp("KB", unit) || !strcmp("K", unit))
|
multiplier = 1024;
|
if (!strcmp("MB", unit) || !strcmp("M", unit))
|
multiplier = 1048576;
|
if (!strcmp("GB", unit) || !strcmp("G", unit))
|
multiplier = 1073741824;
|
if (multiplier == 1) {
|
unit[0] = 0;
|
multiplier = 0;
|
}
|
out:
|
sprintf(search_str, "%%llu%s", unit);
|
if (1 == sscanf(buf, search_str, &size))
|
return size * multiplier;
|
return 0;
|
}
|
|
static uint64_t *get_opt64(char *buf, char string[])
|
{
|
char search_str[256];
|
char *line = strip_space(buf);
|
uint64_t temp;
|
uint64_t *ret;
|
|
sprintf(search_str, "%s=%%llu\\n", string);
|
if (1 == sscanf(line, search_str, &temp)) {
|
ret = malloc(sizeof(uint64_t));
|
*ret = temp;
|
return ret;
|
}
|
free(line);
|
return NULL;
|
}
|
|
static uint32_t *get_opt32(char *buf, char string[])
|
{
|
uint32_t *ret;
|
uint64_t *res;
|
res = get_opt64(buf, string);
|
if (res) {
|
ret = malloc(sizeof(uint32_t));
|
*ret = *res;
|
free(res);
|
return ret;
|
}
|
return NULL;
|
}
|
|
static uint8_t *get_optbool(char *buf, char string[])
|
{
|
uint8_t *ret;
|
uint64_t *res;
|
res = get_opt64(buf, string);
|
if (res) {
|
if ((int)*res < 0 || (int)*res > 1) {
|
printf("Error in: %s", buf);
|
printf("%llu not boolean\n", (long long unsigned)*res);
|
exit(1);
|
}
|
ret = malloc(sizeof(uint8_t));
|
*ret = *res;
|
free(res);
|
return ret;
|
}
|
return NULL;
|
}
|
|
static char *get_optstr(char *buf, char string[])
|
{
|
char search_str[256];
|
char *line = strip_space(buf);
|
char *ret_buf;
|
char temp[BUFSIZE];
|
int len;
|
|
len = strnlen(string, BUFSIZE);
|
sprintf(search_str, "%s=%%%ds\\n", string, BUFSIZE - len - 1);
|
if (1 == sscanf(line, search_str, &temp)) {
|
len = strnlen(temp, 4096);
|
ret_buf = malloc(len);
|
strncpy(ret_buf, temp, len);
|
return ret_buf;
|
}
|
free(line);
|
return NULL;
|
}
|
|
static double *get_optdouble(char *buf, char string[])
|
{
|
char search_str[256];
|
char *line = strip_space(buf);
|
double temp;
|
double *ret;
|
|
sprintf(search_str, "%s=%%lf\\n", string);
|
if (1 == sscanf(line, search_str, &temp)) {
|
ret = malloc(sizeof(double));
|
*ret = temp;
|
return ret;
|
}
|
free(line);
|
return NULL;
|
}
|
|
static range_t *get_optrange(char *buf, char string[])
|
{
|
char search_str[256];
|
double a, b;
|
range_t *ret;
|
|
sprintf(search_str, "%s %%lf %%lf\\n", string);
|
if (2 == sscanf(buf, search_str, &a, &b)) {
|
ret = malloc(sizeof(struct range));
|
ret->a = a;
|
ret->b = b;
|
return ret;
|
}
|
return NULL;
|
}
|
|
static size_weight_t *get_optsizeweight(char *buf, char string[])
|
{
|
char search_str[256];
|
char size[256];
|
int weight;
|
size_weight_t *ret;
|
|
sprintf(search_str, "%s %%s %%d\\n", string);
|
if (2 == sscanf(buf, search_str, &size, &weight)) {
|
ret = malloc(sizeof(struct size_weight));
|
ret->size = size64_convert(size);
|
ret->weight = weight;
|
return ret;
|
}
|
return NULL;
|
}
|
|
static uint64_t *get_optsize64(char *buf, char string[])
|
{
|
char search_str[256];
|
char *line = strip_space(buf);
|
char temp[256];
|
uint64_t size;
|
uint64_t *ret = NULL;
|
|
sprintf(search_str, "%s=%%s\\n", string);
|
if (1 == sscanf(line, search_str, &temp)) {
|
ret = malloc(sizeof(uint64_t));
|
*ret = size64_convert(temp);
|
}
|
free(line);
|
return ret;
|
}
|
|
static uint32_t *get_optsize32(char *buf, char string[])
|
{
|
uint32_t *ret;
|
uint64_t *res;
|
res = get_optsize64(buf, string);
|
if (res) {
|
ret = malloc(sizeof(uint32_t));
|
*ret = *res;
|
free(res);
|
return ret;
|
}
|
return NULL;
|
}
|
|
static uint64_t *get_deprecated(char *buf, char string[])
|
{
|
char search_str[256];
|
char temp[BUFSIZE];
|
int len;
|
|
len = strnlen(string, BUFSIZE);
|
sprintf(search_str, "%s%%%ds\\n", string, BUFSIZE - len - 1);
|
if (1 == sscanf(buf, search_str, &temp))
|
printf("WARNING: The \"%s\" option is deprecated!!!\n", string);
|
|
return NULL;
|
}
|
|
static container_t *init_container(void)
|
{
|
container_t *container;
|
container = malloc(sizeof(container_t));
|
container->config = NULL;
|
container->type = 0;
|
container->next = NULL;
|
return container;
|
}
|
|
static int set_option(char *buf, config_options_t * options)
|
{
|
void *value;
|
|
while (options->name) {
|
switch (options->type) {
|
case TYPE_WEIGHT:
|
case TYPE_U32:
|
value = get_opt32(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_U64:
|
value = get_opt64(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_STRING:
|
value = get_optstr(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_BOOLEAN:
|
value = get_optbool(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_DOUBLE:
|
value = get_optdouble(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_RANGE:
|
value = get_optrange(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_SIZEWEIGHT:
|
value = get_optsizeweight(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_DEPRECATED:
|
value = get_deprecated(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_SIZE32:
|
value = get_optsize32(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
case TYPE_SIZE64:
|
value = get_optsize64(buf, options->name);
|
if (value)
|
goto out;
|
break;
|
default:
|
printf("Unknown type\n");
|
break;
|
}
|
options++;
|
}
|
return 0;
|
|
out:
|
if (options->storage_type == STORE_SINGLE)
|
options->value = value;
|
if (options->storage_type == STORE_LIST) {
|
if (!options->value) {
|
value_list_t *lhead;
|
lhead = malloc(sizeof(struct value_list));
|
INIT_LIST_HEAD(&lhead->list);
|
options->value = lhead;
|
}
|
value_list_t *tmp_list, *tmp_list2;
|
tmp_list = malloc(sizeof(struct value_list));
|
INIT_LIST_HEAD(&tmp_list->list);
|
tmp_list->value = value;
|
tmp_list2 = (struct value_list *)options->value;
|
list_add(&(tmp_list->list), &(tmp_list2->list));
|
}
|
|
return 1;
|
}
|
|
void insert_container(container_t * container, container_t * new_container)
|
{
|
while (container->next)
|
container = container->next;
|
container->next = new_container;
|
}
|
|
container_t *search_group(char *, FILE *);
|
|
container_t *handle_container(char *buf, FILE * f, uint32_t type,
|
config_options_t * options)
|
{
|
container_desc_t *desc = container_desc;
|
container_t *ret_container;
|
container_t *tmp_container, *tmp2_container;
|
container_t *child = NULL;
|
int is_option;
|
|
while (desc->name)
|
if (desc->type == type)
|
break;
|
else
|
desc++;
|
|
if (!desc->name)
|
return NULL;
|
|
buf = get_next_line(f);
|
while (buf) {
|
is_option = set_option(buf, options);
|
tmp_container = search_group(buf, f);
|
if (tmp_container) {
|
if (tmp_container->type == END) {
|
free(tmp_container);
|
break;
|
} else {
|
if (child == NULL)
|
child = tmp_container;
|
else {
|
tmp2_container = child;
|
while (tmp2_container->next)
|
tmp2_container =
|
tmp2_container->next;
|
tmp2_container->next = tmp_container;
|
}
|
|
}
|
}
|
if (!is_option && !tmp_container) {
|
printf("ERROR!!! Unknow option: %s", buf);
|
exit(1);
|
}
|
buf = get_next_line(f);
|
}
|
ret_container = init_container();
|
ret_container->config = options;
|
ret_container->type = type;
|
if (child)
|
ret_container->child = child;
|
|
return ret_container;
|
}
|
|
container_t *search_group(char *buf, FILE * f)
|
{
|
char temp[BUFSIZE];
|
char *ptr;
|
config_options_t *options;
|
container_desc_t *desc = container_desc;
|
container_t *ret_container;
|
|
if (1 == sscanf(buf, "[%s]\n", (char *)&temp))
|
while (desc->name) {
|
ptr = strstr(buf, desc->name);
|
if (ptr)
|
switch (desc->type) {
|
case FILESYSTEM:
|
options = malloc(sizeof(fs_options));
|
memcpy(options, fs_options,
|
sizeof(fs_options));
|
return handle_container(buf, f,
|
desc->type,
|
options);
|
break;
|
case THREAD_GROUP:
|
options = malloc(sizeof(tg_options));
|
memcpy(options, tg_options,
|
sizeof(tg_options));
|
return handle_container(buf, f,
|
desc->type,
|
options);
|
break;
|
case STATS:
|
options = malloc(sizeof(stats_options));
|
memcpy(options, stats_options,
|
sizeof(stats_options));
|
return handle_container(buf, f,
|
desc->type,
|
options);
|
break;
|
case END:
|
ret_container = init_container();
|
ret_container->type = END;
|
return ret_container;
|
break;
|
}
|
desc++;
|
}
|
return NULL;
|
}
|
|
void *get_value(config_options_t * config, char *name)
|
{
|
while (config->name) {
|
if (!strcmp(config->name, name)) {
|
if (config->value)
|
return config->value;
|
else
|
return NULL;
|
}
|
config++;
|
}
|
return 0;
|
}
|
|
char *get_config_str(config_options_t * config, char *name)
|
{
|
return get_value(config, name);
|
}
|
|
uint32_t get_config_u32(config_options_t * config, char *name)
|
{
|
void *value = get_value(config, name);
|
if (value)
|
return *(uint32_t *) value;
|
return 0;
|
}
|
|
uint8_t get_config_bool(config_options_t * config, char *name)
|
{
|
void *value = get_value(config, name);
|
if (value)
|
return *(uint8_t *) value;
|
return 0;
|
}
|
|
uint64_t get_config_u64(config_options_t * config, char *name)
|
{
|
void *value = get_value(config, name);
|
if (value)
|
return *(uint64_t *) value;
|
return 0;
|
}
|
|
double get_config_double(config_options_t * config, char *name)
|
{
|
void *value = get_value(config, name);
|
if (value)
|
return *(double *)value;
|
return 0;
|
}
|
|
static profile_config_t *parse(FILE * f)
|
{
|
char *buf;
|
profile_config_t *profile_conf;
|
container_t *tmp_container;
|
|
profile_conf = malloc(sizeof(profile_config_t));
|
profile_conf->global = malloc(sizeof(global_options));
|
memcpy(profile_conf->global, global_options, sizeof(global_options));
|
profile_conf->fs_container = NULL;
|
profile_conf->tg_container = NULL;
|
int is_option;
|
buf = get_next_line(f);
|
|
while (buf) {
|
is_option = set_option(buf, profile_conf->global);
|
tmp_container = search_group(buf, f);
|
if (tmp_container)
|
switch (tmp_container->type) {
|
case FILESYSTEM:
|
if (profile_conf->fs_container == NULL)
|
profile_conf->fs_container =
|
tmp_container;
|
else
|
insert_container(profile_conf->
|
fs_container,
|
tmp_container);
|
break;
|
case THREAD_GROUP:
|
if (profile_conf->tg_container == NULL)
|
profile_conf->tg_container =
|
tmp_container;
|
else
|
insert_container(profile_conf->
|
tg_container,
|
tmp_container);
|
break;
|
default:
|
break;
|
}
|
if (!is_option && !tmp_container) {
|
printf("ERROR!!! Unknow option: %s", buf);
|
exit(1);
|
}
|
buf = get_next_line(f);
|
}
|
return profile_conf;
|
}
|
|
void set_weight(ffsb_tg_t * tg, config_options_t * config)
|
{
|
char *op;
|
int len;
|
config_options_t *tmp_config = config;
|
|
while (tmp_config->name) {
|
if (tmp_config->type == TYPE_WEIGHT) {
|
len = strlen(tmp_config->name);
|
op = malloc(sizeof(char) * len - 6);
|
memset(op, 0, sizeof(char) * len - 6);
|
strncpy(op, tmp_config->name, len - 7);
|
tg_set_op_weight(tg, op,
|
get_config_u32(config,
|
tmp_config->name));
|
free(op);
|
}
|
tmp_config++;
|
}
|
}
|
|
int get_weight_total(ffsb_tg_t * tg)
|
{
|
char *op;
|
int len;
|
int total = 0;
|
config_options_t *tmp_config = tg_options;
|
|
while (tmp_config->name) {
|
if (tmp_config->type == TYPE_WEIGHT) {
|
len = strlen(tmp_config->name);
|
op = malloc(sizeof(char) * len - 6);
|
memset(op, 0, sizeof(char) * len - 6);
|
strncpy(op, tmp_config->name, len - 7);
|
total += tg_get_op_weight(tg, op);
|
free(op);
|
}
|
tmp_config++;
|
}
|
return total;
|
}
|
|
/* !!! hackish verification function, we should somehow roll this into the */
|
/* op descriptions/struct themselves at some point with a callback verify */
|
/* op requirements: */
|
/* require tg->read_blocksize: read, readall */
|
/* require tg->write_blocksize: write, create, append, rewritefsync */
|
/* */
|
|
static int verify_tg(ffsb_tg_t * tg)
|
{
|
uint32_t read_weight = tg_get_op_weight(tg, "read");
|
uint32_t readall_weight = tg_get_op_weight(tg, "readall");
|
uint32_t write_weight = tg_get_op_weight(tg, "write");
|
uint32_t create_weight = tg_get_op_weight(tg, "create");
|
uint32_t append_weight = tg_get_op_weight(tg, "append");
|
uint32_t createdir_weight = tg_get_op_weight(tg, "createdir");
|
uint32_t delete_weight = tg_get_op_weight(tg, "delete");
|
uint32_t writeall_weight = tg_get_op_weight(tg, "writeall");
|
uint32_t writeall_fsync_weight = tg_get_op_weight(tg, "writeall_fsync");
|
|
uint32_t sum_weight = get_weight_total(tg);
|
|
uint32_t read_blocksize = tg_get_read_blocksize(tg);
|
uint32_t write_blocksize = tg_get_write_blocksize(tg);
|
|
int read_random = tg_get_read_random(tg);
|
int read_skip = tg_get_read_skip(tg);
|
uint32_t read_skipsize = tg_get_read_skipsize(tg);
|
|
if (sum_weight == 0) {
|
printf("Error: A threadgroup must have at least one weighted "
|
"operation\n");
|
return 1;
|
}
|
|
if ((read_weight || readall_weight) && !(read_blocksize)) {
|
printf("Error: read and readall operations require a "
|
"read_blocksize\n");
|
return 1;
|
}
|
|
if ((write_weight || create_weight || append_weight || writeall_weight
|
|| writeall_fsync_weight) && !(write_blocksize)) {
|
printf("Error: write, writeall, create, append"
|
"operations require a write_blocksize\n");
|
return 1;
|
}
|
|
if (read_random && read_skip) {
|
printf("Error: read_random and read_skip are mutually "
|
"exclusive\n");
|
return 1;
|
}
|
|
if (read_skip && !(read_skipsize)) {
|
printf("Error: read_skip specified but read_skipsize is "
|
"zero\n");
|
return 1;
|
}
|
|
return 0;
|
}
|
|
static unsigned get_num_containers(container_t * container)
|
{
|
int numtg = 0;
|
while (container) {
|
numtg++;
|
container = container->next;
|
}
|
return numtg;
|
}
|
|
static unsigned get_num_threadgroups(profile_config_t * profile_conf)
|
{
|
return get_num_containers(profile_conf->tg_container);
|
}
|
|
static unsigned get_num_filesystems(profile_config_t * profile_conf)
|
{
|
return get_num_containers(profile_conf->fs_container);
|
}
|
|
static int get_num_totalthreads(profile_config_t * profile_conf)
|
{
|
int num_threads = 0;
|
container_t *tg = profile_conf->tg_container;
|
config_options_t *tg_config;
|
|
while (tg) {
|
tg_config = tg->config;
|
while (tg_config->name) {
|
if (!strcmp(tg_config->name, "num_threads"))
|
num_threads += *(uint32_t *) tg_config->value;
|
tg_config++;
|
}
|
if (tg->next)
|
tg = tg->next;
|
else
|
break;
|
}
|
|
return num_threads;
|
}
|
|
container_t *get_container(container_t * head_cont, int pos)
|
{
|
int count = 0;
|
while (head_cont) {
|
if (count == pos)
|
return head_cont;
|
head_cont = head_cont->next;
|
count++;
|
}
|
return NULL;
|
}
|
|
config_options_t *get_fs_config(ffsb_config_t * fc, int pos)
|
{
|
container_t *tmp_cont;
|
|
assert(pos < fc->num_filesys);
|
tmp_cont = get_container(fc->profile_conf->fs_container, pos);
|
if (tmp_cont)
|
return tmp_cont->config;
|
return NULL;
|
}
|
|
container_t *get_fs_container(ffsb_config_t * fc, int pos)
|
{
|
assert(pos < fc->num_filesys);
|
return get_container(fc->profile_conf->fs_container, pos);
|
}
|
|
config_options_t *get_tg_config(ffsb_config_t * fc, int pos)
|
{
|
container_t *tmp_cont;
|
|
assert(pos < fc->num_threadgroups);
|
tmp_cont = get_container(fc->profile_conf->tg_container, pos);
|
if (tmp_cont)
|
return tmp_cont->config;
|
return NULL;
|
}
|
|
container_t *get_tg_container(ffsb_config_t * fc, int pos)
|
{
|
assert(pos < fc->num_threadgroups);
|
return get_container(fc->profile_conf->tg_container, pos);
|
}
|
|
static void init_threadgroup(ffsb_config_t * fc, config_options_t * config,
|
ffsb_tg_t * tg, int tg_num)
|
{
|
int num_threads;
|
memset(tg, 0, sizeof(ffsb_tg_t));
|
|
num_threads = get_config_u32(config, "num_threads");
|
|
init_ffsb_tg(tg, num_threads, tg_num);
|
|
if (get_config_str(config, "bindfs")) {
|
int i;
|
config_options_t *tmp_config;
|
for (i = 0; i < fc->num_filesys; i++) {
|
tmp_config = get_fs_config(fc, i);
|
if (!strcmp(get_config_str(config, "bindfs"),
|
get_config_str(tmp_config, "location")))
|
break;
|
}
|
if (strcmp(get_config_str(config, "bindfs"),
|
get_config_str(tmp_config, "location"))) {
|
printf("Bind fs failed: Base fs \"%s\" not found\n",
|
get_config_str(config, "bindfs"));
|
exit(1);
|
}
|
printf("%d\n", i);
|
tg->bindfs = i;
|
}
|
|
tg->read_random = get_config_bool(config, "read_random");
|
tg->read_size = get_config_u64(config, "read_size");
|
tg->read_skip = get_config_bool(config, "read_skip");
|
tg->read_skipsize = get_config_u32(config, "read_skipsize");
|
|
tg->write_random = get_config_bool(config, "write_random");
|
tg->write_size = get_config_u64(config, "write_size");
|
tg->fsync_file = get_config_bool(config, "fsync_file");
|
|
tg->wait_time = get_config_u32(config, "op_delay");
|
|
tg_set_read_blocksize(tg, get_config_u32(config, "read_blocksize"));
|
tg_set_write_blocksize(tg, get_config_u32(config, "write_blocksize"));
|
|
set_weight(tg, config);
|
|
if (verify_tg(tg)) {
|
printf("threadgroup %d verification failed\n", tg_num);
|
exit(1);
|
}
|
}
|
|
static void init_filesys(ffsb_config_t * fc, int num)
|
{
|
config_options_t *config = get_fs_config(fc, num);
|
profile_config_t *profile_conf = fc->profile_conf;
|
ffsb_fs_t *fs = &fc->filesystems[num];
|
value_list_t *tmp_list, *list_head;
|
|
memset(fs, 0, sizeof(ffsb_fs_t));
|
|
fs->basedir = get_config_str(config, "location");
|
|
if (get_config_str(config, "clone")) {
|
int i;
|
config_options_t *tmp_config;
|
for (i = 0; i < fc->num_filesys; i++) {
|
tmp_config = get_fs_config(fc, i);
|
if (!strcmp(get_config_str(config, "clone"),
|
get_config_str(tmp_config, "location")))
|
break;
|
}
|
if (strcmp(get_config_str(config, "clone"),
|
get_config_str(tmp_config, "location"))) {
|
printf("Clone fs failed: Base fs \"%s\" not found\n",
|
get_config_str(config, "clone"));
|
exit(1);
|
}
|
config = tmp_config;
|
}
|
|
fs->num_dirs = get_config_u32(config, "num_dirs");
|
fs->num_start_files = get_config_u32(config, "num_files");
|
fs->minfilesize = get_config_u64(config, "min_filesize");
|
fs->maxfilesize = get_config_u64(config, "max_filesize");
|
fs->desired_fsutil = get_config_double(config, "desired_util");
|
fs->init_fsutil = get_config_double(config, "init_util");
|
fs->init_size = get_config_u64(config, "init_size");
|
|
fs->flags = 0;
|
if (get_config_bool(config, "reuse"))
|
fs->flags |= FFSB_FS_REUSE_FS;
|
|
if (get_config_bool(profile_conf->global, "directio"))
|
fs->flags |= FFSB_FS_DIRECTIO | FFSB_FS_ALIGNIO4K;
|
|
if (get_config_bool(profile_conf->global, "bufferio"))
|
fs->flags |= FFSB_FS_LIBCIO;
|
|
if (get_config_bool(profile_conf->global, "alignio"))
|
fs->flags |= FFSB_FS_ALIGNIO4K;
|
|
if (get_config_bool(config, "agefs")) {
|
container_t *age_cont = get_fs_container(fc, num);
|
if (!age_cont->child) {
|
printf("No age threaggroup in profile");
|
exit(1);
|
}
|
|
age_cont = age_cont->child;
|
ffsb_tg_t *age_tg = ffsb_malloc(sizeof(ffsb_tg_t));
|
init_threadgroup(fc, age_cont->config, age_tg, 0);
|
fs->aging_tg = age_tg;
|
fs->age_fs = 1;
|
}
|
|
if (get_config_u32(config, "create_blocksize"))
|
fs->create_blocksize = get_config_u32(config,
|
"create_blocksize");
|
else
|
fs->create_blocksize = FFSB_FS_DEFAULT_CREATE_BLOCKSIZE;
|
|
if (get_config_u32(config, "age_blocksize"))
|
fs->age_blocksize = get_config_u32(config, "age_blocksize");
|
else
|
fs->age_blocksize = FFSB_FS_DEFAULT_AGE_BLOCKSIZE;
|
|
list_head = (value_list_t *) get_value(config, "size_weight");
|
if (list_head) {
|
int count = 0;
|
size_weight_t *sizew;
|
list_for_each_entry(tmp_list, &list_head->list, list)
|
count++;
|
|
fs->num_weights = count;
|
fs->size_weights =
|
malloc(sizeof(size_weight_t) * fs->num_weights);
|
|
count = 0;
|
list_for_each_entry(tmp_list, &list_head->list, list) {
|
sizew = (size_weight_t *) tmp_list->value;
|
fs->size_weights[count].size = sizew->size;
|
fs->size_weights[count].weight = sizew->weight;
|
fs->sum_weights += sizew->weight;
|
count++;
|
}
|
}
|
}
|
|
static void init_tg_stats(ffsb_config_t * fc, int num)
|
{
|
config_options_t *config;
|
container_t *tmp_cont;
|
value_list_t *tmp_list, *list_head;
|
syscall_t sys;
|
ffsb_statsc_t fsc = { 0, };
|
char *sys_name;
|
range_t *bucket_range;
|
uint32_t min, max;
|
|
tmp_cont = get_tg_container(fc, num);
|
if (tmp_cont->child) {
|
if (tmp_cont->type == STATS) {
|
config = tmp_cont->config;
|
if (get_config_bool(config, "enable_stats")) {
|
|
list_head =
|
(value_list_t *) get_value(config,
|
"ignore");
|
if (list_head)
|
list_for_each_entry(tmp_list,
|
&list_head->list,
|
list) {
|
sys_name = (char *)tmp_list->value;
|
ffsb_stats_str2syscall(sys_name, &sys);
|
ffsb_statsc_ignore_sys(&fsc, sys);
|
}
|
|
list_head =
|
(value_list_t *) get_value(config,
|
"msec_range");
|
if (list_head
|
&& get_config_bool(config, "enable_range"))
|
list_for_each_entry(tmp_list,
|
&list_head->list,
|
list) {
|
bucket_range =
|
(range_t *) tmp_list->value;
|
min =
|
(uint32_t) (bucket_range->a *
|
1000.0f);
|
max =
|
(uint32_t) (bucket_range->b *
|
1000.0f);
|
ffsb_statsc_addbucket(&fsc, min, max);
|
}
|
|
tg_set_statsc(&fc->groups[num], &fsc);
|
}
|
}
|
}
|
}
|
|
static void init_config(ffsb_config_t * fc, profile_config_t * profile_conf)
|
{
|
config_options_t *config;
|
container_t *tmp_cont;
|
int i;
|
|
fc->time = get_config_u32(profile_conf->global, "time");
|
fc->num_filesys = get_num_filesystems(profile_conf);
|
fc->num_threadgroups = get_num_threadgroups(profile_conf);
|
fc->num_totalthreads = get_num_totalthreads(profile_conf);
|
fc->profile_conf = profile_conf;
|
fc->callout = get_config_str(profile_conf->global, "callout");
|
|
fc->filesystems = ffsb_malloc(sizeof(ffsb_fs_t) * fc->num_filesys);
|
for (i = 0; i < fc->num_filesys; i++)
|
init_filesys(fc, i);
|
|
fc->groups = ffsb_malloc(sizeof(ffsb_tg_t) * fc->num_threadgroups);
|
for (i = 0; i < fc->num_threadgroups; i++) {
|
config = get_tg_config(fc, i);
|
init_threadgroup(fc, config, &fc->groups[i], i);
|
init_tg_stats(fc, i);
|
}
|
}
|
|
void ffsb_parse_newconfig(ffsb_config_t * fc, char *filename)
|
{
|
FILE *f;
|
|
profile_config_t *profile_conf;
|
|
f = fopen(filename, "r");
|
if (f == NULL) {
|
perror(filename);
|
exit(1);
|
}
|
profile_conf = parse(f);
|
fclose(f);
|
|
init_config(fc, profile_conf);
|
}
|
