static int builtin_posix_module_dataset_unlink (struct hio_module_t *module, const char *name, int64_t set_id) {
struct stat statinfo;
char *path = NULL;
int rc;
if (module->context->c_rank) {
return HIO_ERR_NOT_AVAILABLE;
}
rc = builtin_posix_dataset_path (module, &path, name, set_id);
if (HIO_SUCCESS != rc) {
return rc;
}
if (stat (path, &statinfo)) {
free (path);
return hioi_err_errno (errno);
}
hioi_log (module->context, HIO_VERBOSE_DEBUG_LOW, "posix: unlinking existing dataset %s::%llu",
name, set_id);
/* use tree walk depth-first to remove all of the files for this dataset */
rc = nftw (path, builtin_posix_unlink_cb, 32, FTW_DEPTH | FTW_PHYS);
free (path);
if (0 > rc) {
hioi_err_push (hioi_err_errno (errno), &module->context->c_object, "posix: could not unlink dataset. errno: %d",
errno);
return hioi_err_errno (errno);
}
return HIO_SUCCESS;
}
static int builtin_posix_create_dataset_dirs (builtin_posix_module_t *posix_module, builtin_posix_module_dataset_t *posix_dataset) {
mode_t access_mode = posix_module->access_mode;
hio_context_t context = posix_module->base.context;
int rc;
if (context->c_rank > 0) {
return HIO_SUCCESS;
}
hioi_log (context, HIO_VERBOSE_DEBUG_MED, "posix: creating dataset directory @ %s", posix_dataset->base_path);
rc = hio_mkpath (context, posix_dataset->base_path, access_mode);
if (0 > rc || EEXIST == errno) {
if (EEXIST != errno) {
hioi_err_push (hioi_err_errno (errno), &context->c_object, "posix: error creating context directory: %s",
posix_dataset->base_path);
}
return hioi_err_errno (errno);
}
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix: successfully created dataset directories");
return HIO_SUCCESS;
}
static int builtin_posix_open_file (builtin_posix_module_t *posix_module, builtin_posix_module_dataset_t *posix_dataset,
char *path, hio_file_t *file) {
hio_object_t hio_object = &posix_dataset->base.ds_object;
int open_flags, fd;
#if BUILTIN_POSIX_USE_STDIO
char *file_mode;
#endif
/* determine the fopen file mode to use */
if (HIO_FLAG_WRITE & posix_dataset->base.ds_flags) {
open_flags = O_CREAT | O_WRONLY;
} else {
open_flags = O_RDONLY;
}
/* it is not possible to get open with create without truncation using fopen so use a
* combination of open and fdopen to get the desired effect */
//hioi_log (context, HIO_VERBOSE_DEBUG_HIGH, "posix: calling open; path: %s open_flags: %i", path, open_flags);
fd = open (path, open_flags, posix_module->access_mode);
if (fd < 0) {
hioi_err_push (fd, hio_object, "posix: error opening element path %s. "
"errno: %d", path, errno);
return fd;
}
#if BUILTIN_POSIX_USE_STDIO
if (HIO_FLAG_WRITE & posix_dataset->base.ds_flags) {
file_mode = "w";
} else {
file_mode = "r";
}
file->f_hndl = fdopen (fd, file_mode);
if (NULL == file->f_hndl) {
int hrc = hioi_err_errno (errno);
hioi_err_push (hrc, hio_object, "posix: error opening element file %s. "
"errno: %d", path, errno);
return hrc;
}
#else
file->f_fd = fd;
#endif
file->f_offset = 0;
return HIO_SUCCESS;
}
static int builtin_posix_component_query (hio_context_t context, const char *data_root,
const char *next_data_root, hio_module_t **module) {
builtin_posix_module_t *new_module;
if (0 == strncasecmp("datawarp", data_root, 8) || 0 == strncasecmp("dw", data_root, 2)) {
return HIO_ERR_NOT_AVAILABLE;
}
if (0 == strncasecmp("posix:", data_root, 6)) {
/* skip posix: */
data_root += 6;
}
if (access (data_root, F_OK)) {
hioi_err_push (hioi_err_errno (errno), &context->c_object, "posix: data root %s does not exist or can not be accessed",
data_root);
return hioi_err_errno (errno);
}
new_module = calloc (1, sizeof (builtin_posix_module_t));
if (NULL == new_module) {
return HIO_ERR_OUT_OF_RESOURCE;
}
memcpy (new_module, &builtin_posix_module_template, sizeof (builtin_posix_module_template));
new_module->base.data_root = strdup (data_root);
new_module->base.context = context;
/* get the current umask */
new_module->access_mode = umask (0);
umask (new_module->access_mode);
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix: created module for data root %s. using umask %o",
data_root, new_module->access_mode);
new_module->access_mode ^= 0777;
*module = &new_module->base;
return HIO_SUCCESS;
}
int hio_config_set_value (hio_object_t object, const char *variable, const char *value) {
int rc = HIO_SUCCESS;
hio_var_t *var;
int config_index;
if (NULL == object || NULL == variable || NULL == value) {
return HIO_ERR_BAD_PARAM;
}
hioi_object_lock (object);
do {
/* go ahead and push this value into the object's key-value store. if the
* configuration parameter has not yet been registered it will be read from
* this key-valye store after the file store is checked. */
hioi_config_list_kv_push (&object->config_set, hioi_object_identifier (object),
object->type, variable, value);
config_index = hioi_var_lookup (&object->configuration, variable);
if (0 > config_index) {
/* variable does not exist (yet). nothing more to do */
break;
}
var = object->configuration.vars + config_index;
if (HIO_VAR_FLAG_READONLY & var->var_flags) {
hioi_err_push (HIO_ERR_PERM, object, "could not set read-only parameter: %s", variable);
rc = HIO_ERR_PERM;
break;
}
rc = hioi_config_set_value_internal (hioi_object_context(object), var, value);
} while (0);
hioi_object_unlock (object);
return rc;
}
int hioi_config_parse (hio_context_t context, const char *config_file, const char *config_file_prefix) {
char *key, *value, *default_file = NULL, *buffer, *line, *lastl;
int data_size = 0, fd, rc = HIO_SUCCESS;
struct stat statinfo;
int ret;
if (NULL == config_file) {
/* nothing to do */
return HIO_SUCCESS;
}
if (!hioi_context_using_mpi (context) || 0 == context->c_rank) {
if (HIO_CONFIG_FILE_DEFAULT == config_file) {
ret = asprintf (&default_file, "%s.cfg", context->c_object.identifier);
if (0 > ret) {
return HIO_ERR_OUT_OF_RESOURCE;
}
config_file = default_file;
}
if (stat (config_file, &statinfo)) {
data_size = 0;
} else {
data_size = statinfo.st_size;
}
fd = open (config_file, O_RDONLY);
if (0 > fd) {
hioi_err_push (HIO_ERR_NOT_FOUND, &context->c_object, "Could not open configuration file %s for reading. "
"errno: %d", config_file, errno);
return HIO_ERR_NOT_FOUND;
}
if (default_file) {
free (default_file);
}
}
#if HIO_MPI_HAVE(1)
if (hioi_context_using_mpi (context)) {
MPI_Bcast (&data_size, 1, MPI_UNSIGNED, 0, context->c_comm);
}
#endif
if (0 == data_size) {
close (fd);
return HIO_ERR_NOT_FOUND;
}
buffer = calloc (data_size, 1);
if (NULL == buffer) {
close (fd);
return HIO_ERR_OUT_OF_RESOURCE;
}
if (!hioi_context_using_mpi (context) || 0 == context->c_rank) {
rc = read (fd, buffer, data_size);
if (data_size != rc) {
hioi_err_push (HIO_ERR_TRUNCATE, &context->c_object, "Read from configuration file %s trucated",
config_file);
}
close (fd);
}
#if HIO_MPI_HAVE(1)
if (hioi_context_using_mpi (context)) {
MPI_Bcast (buffer, data_size, MPI_BYTE, 0, context->c_comm);
}
#endif
if (config_file_prefix && 0 == strlen (config_file_prefix)) {
config_file_prefix = NULL;
}
line = strtok_r (buffer, "\n", &lastl);
hioi_config_parser_set_file_prefix (config_file_prefix);
do {
char *identifier;
hio_object_type_t type;
rc = hioi_config_parser_parse_line (line, &key, &value, &identifier, &type);
if (HIOI_CONFIG_PARSER_PARSE_ERROR == rc) {
hioi_err_push (HIO_ERROR, &context->c_object, "Error parsing input file");
rc = HIO_ERROR;
break;
}
if (HIOI_CONFIG_PARSER_PARSE_KV == rc) {
if (HIO_OBJECT_TYPE_CONTEXT == type && strcmp (identifier, context->c_object.identifier)) {
continue;
}
hioi_config_list_kv_push (&context->c_fconfig, identifier, type, key, value);
}
rc = HIO_SUCCESS;
} while (NULL != (line = strtok_r (NULL, "\n", &lastl)));
free (buffer);
return rc;
}
static int builtin_posix_module_dataset_close (hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
builtin_posix_module_t *posix_module = (builtin_posix_module_t *) dataset->ds_module;
hio_context_t context = hioi_object_context ((hio_object_t) dataset);
hio_module_t *module = dataset->ds_module;
unsigned char *manifest;
uint64_t start, stop;
int rc = HIO_SUCCESS;
size_t manifest_size;
start = hioi_gettime ();
for (int i = 0 ; i < HIO_POSIX_MAX_OPEN_FILES ; ++i) {
if (posix_dataset->files[i].f_file.f_hndl != NULL) {
fclose (posix_dataset->files[i].f_file.f_hndl);
posix_dataset->files[i].f_file.f_hndl = NULL;
}
}
if (dataset->ds_flags & HIO_FLAG_WRITE) {
rc = hioi_dataset_gather_manifest (dataset, &manifest, &manifest_size, dataset->ds_use_bzip);
if (HIO_SUCCESS != rc) {
dataset->ds_status = rc;
}
if (0 == context->c_rank) {
char *path;
rc = asprintf (&path, "%s/manifest.json%s", posix_dataset->base_path,
dataset->ds_use_bzip ? ".bz2" : "");
if (0 < rc) {
int fd;
errno = 0;
fd = open (path, O_CREAT | O_WRONLY, posix_module->access_mode);
if (0 <= fd) {
(void) write (fd, manifest, manifest_size);
close (fd);
}
free (manifest);
rc = hioi_err_errno (errno);
free (path);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &dataset->ds_object, "posix: error writing dataset manifest");
}
} else {
rc = HIO_ERR_OUT_OF_RESOURCE;
}
}
}
#if HIO_USE_MPI
/* ensure all ranks have closed the dataset before continuing */
if (hioi_context_using_mpi (context)) {
MPI_Allreduce (MPI_IN_PLACE, &rc, 1, MPI_INT, MPI_MIN, context->c_comm);
}
#endif
free (posix_dataset->base_path);
pthread_mutex_destroy (&posix_dataset->lock);
stop = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: successfully closed posix dataset %s:%llu on data root %s. "
"close time %lu usec", hioi_object_identifier(dataset), dataset->ds_id, module->data_root, stop - start);
return rc;
}
static int builtin_posix_module_dataset_open (struct hio_module_t *module, hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
builtin_posix_module_t *posix_module = (builtin_posix_module_t *) module;
hio_context_t context = hioi_object_context ((hio_object_t) dataset);
unsigned char *manifest = NULL;
size_t manifest_size = 0;
hio_fs_attr_t *fs_attr;
uint64_t start, stop;
int rc = HIO_SUCCESS;
char *path = NULL;
start = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_MED, "posix:dataset_open: opening dataset %s:%lu mpi: %d flags: 0x%x mode: 0x%x",
hioi_object_identifier (dataset), (unsigned long) dataset->ds_id, hioi_context_using_mpi (context),
dataset->ds_flags, dataset->ds_mode);
rc = builtin_posix_module_dataset_init (module, posix_dataset);
if (HIO_SUCCESS != rc) {
return rc;
}
fs_attr = &posix_dataset->base.ds_fsattr;
rc = hioi_fs_query (context, module->data_root, fs_attr);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &context->c_object, "posix: error querying the filesystem");
return rc;
}
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_STRIPING) {
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_scount,
"stripe_count", HIO_CONFIG_TYPE_UINT32, NULL, "Stripe count for all dataset "
"data files", 0);
if (fs_attr->fs_scount > fs_attr->fs_smax_count) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe count %u exceeds the available resources. "
"adjusting to maximum %u", fs_attr->fs_scount, fs_attr->fs_smax_count);
fs_attr->fs_scount = fs_attr->fs_smax_count;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_ssize,
"stripe_size", HIO_CONFIG_TYPE_UINT64, NULL, "Stripe size for all dataset "
"data files", 0);
/* ensure the stripe size is a multiple of the stripe unit */
fs_attr->fs_ssize = fs_attr->fs_sunit * ((fs_attr->fs_ssize + fs_attr->fs_sunit - 1) / fs_attr->fs_sunit);
if (fs_attr->fs_ssize > fs_attr->fs_smax_size) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe size %" PRIu64 " exceeds the maximum %"
PRIu64 ". ", fs_attr->fs_ssize, fs_attr->fs_smax_size);
fs_attr->fs_ssize = fs_attr->fs_smax_size;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_raid_level,
"raid_level", HIO_CONFIG_TYPE_UINT64, NULL, "RAID level for dataset "
"data files. Keep in mind that some filesystems only support 1/2 RAID "
"levels", 0);
if (HIO_FILE_MODE_OPTIMIZED == dataset->ds_fmode) {
fs_attr->fs_scount = 1;
fs_attr->fs_ssize = dataset->ds_bs;
fs_attr->fs_use_group_locking = true;
}
}
do {
if (0 != context->c_rank) {
break;
}
if (dataset->ds_flags & HIO_FLAG_TRUNC) {
/* blow away the existing dataset */
(void) builtin_posix_module_dataset_unlink (module, hioi_object_identifier(dataset),
dataset->ds_id);
/* ensure we take the create path later */
dataset->ds_flags |= HIO_FLAG_CREAT;
}
if (!(dataset->ds_flags & HIO_FLAG_CREAT)) {
/* load manifest. the manifest data will be shared with other processes in hioi_dataset_scatter */
rc = asprintf (&path, "%s/manifest.json.bz2", posix_dataset->base_path);
assert (0 < rc);
if (access (path, F_OK)) {
free (path);
rc = asprintf (&path, "%s/manifest.json", posix_dataset->base_path);
assert (0 < rc);
if (access (path, F_OK)) {
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: could not find top-level manifest");
rc = HIO_ERR_NOT_FOUND;
break;
}
}
rc = hioi_manifest_read (path, &manifest, &manifest_size);
free (path);
} else {
rc = builtin_posix_create_dataset_dirs (posix_module, posix_dataset);
if (HIO_SUCCESS != rc) {
break;
}
rc = hioi_manifest_serialize (dataset, &manifest, &manifest_size, true);
}
} while (0);
/* share dataset information will all processes in the communication domain */
rc = hioi_dataset_scatter (dataset, manifest, manifest_size, rc);
if (HIO_SUCCESS != rc) {
free (posix_dataset->base_path);
return rc;
}
free (manifest);
if (HIO_FILE_MODE_OPTIMIZED == dataset->ds_fmode) {
if (HIO_SET_ELEMENT_UNIQUE == dataset->ds_mode || 2 > context->c_size || NULL == dataset->ds_shared_control) {
posix_dataset->base.ds_fmode = HIO_FILE_MODE_BASIC;
/* NTH: no optimized mode for N->N yet */
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: optimized file mode requested but not supported in this "
"dataset mode. falling back to basic file mode");
}
}
dataset->ds_module = module;
dataset->ds_close = builtin_posix_module_dataset_close;
dataset->ds_element_open = builtin_posix_module_element_open;
dataset->ds_process_reqs = builtin_posix_module_process_reqs;
pthread_mutex_init (&posix_dataset->lock, NULL);
/* record the open time */
gettimeofday (&dataset->ds_otime, NULL);
stop = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: successfully %s posix dataset %s:%llu on data root %s. "
"open time %lu usec", (dataset->ds_flags & HIO_FLAG_CREAT) ? "created" : "opened", hioi_object_identifier(dataset),
dataset->ds_id, module->data_root, stop - start);
return HIO_SUCCESS;
}
static int builtin_posix_create_dataset_dirs (builtin_posix_module_t *posix_module, builtin_posix_module_dataset_t *posix_dataset) {
mode_t access_mode = posix_module->access_mode;
hio_context_t context = posix_module->base.context;
char *path;
int rc;
if (context->c_rank > 0) {
return HIO_SUCCESS;
}
/* create the data directory*/
hioi_log (context, HIO_VERBOSE_DEBUG_MED, "posix: creating dataset directory @ %s", posix_dataset->base_path);
rc = asprintf (&path, "%s/data", posix_dataset->base_path);
if (0 > rc) {
return hioi_err_errno (errno);
}
rc = hio_mkpath (context, path, access_mode);
if (0 > rc || EEXIST == errno) {
if (EEXIST != errno) {
hioi_err_push (hioi_err_errno (errno), &context->c_object, "posix: error creating context directory: %s",
path);
}
free (path);
return hioi_err_errno (errno);
}
/* set striping parameters on the directory */
if (posix_dataset->base.ds_fsattr.fs_flags & HIO_FS_SUPPORTS_STRIPING) {
rc = hioi_fs_set_stripe (path, &posix_dataset->base.ds_fsattr);
if (HIO_SUCCESS != rc) {
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix: could not set file system striping on %s", path);
}
}
free (path);
/* create trace directory if requested */
if (context->c_enable_tracing) {
rc = asprintf (&path, "%s/trace", posix_dataset->base_path);
if (0 > rc) {
return hioi_err_errno (errno);
}
rc = hio_mkpath (context, path, access_mode);
if (0 > rc || EEXIST == errno) {
if (EEXIST != errno) {
hioi_err_push (hioi_err_errno (errno), &context->c_object, "posix: error creating context directory: %s",
path);
}
free (path);
return hioi_err_errno (errno);
}
}
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix: successfully created dataset directories %s", posix_dataset->base_path);
return HIO_SUCCESS;
}
static int builtin_posix_module_dataset_close (hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
hio_context_t context = hioi_object_context ((hio_object_t) dataset);
hio_module_t *module = dataset->ds_module;
unsigned char *manifest = NULL;
uint64_t start, stop;
int rc = HIO_SUCCESS;
size_t manifest_size;
start = hioi_gettime ();
for (int i = 0 ; i < HIO_POSIX_MAX_OPEN_FILES ; ++i) {
if (posix_dataset->files[i].f_bid >= 0) {
POSIX_TRACE_CALL(posix_dataset, hioi_file_close (posix_dataset->files + i), "file_close",
posix_dataset->files[i].f_bid, 0);
}
}
#if HIO_MPI_HAVE(3)
/* release the shared state if it was allocated */
(void) hioi_dataset_shared_fini (dataset);
/* release the dataset map if one was allocated */
(void) hioi_dataset_map_release (dataset);
#endif
if (dataset->ds_flags & HIO_FLAG_WRITE) {
char *path;
/* write manifest header */
POSIX_TRACE_CALL(posix_dataset, rc = hioi_dataset_gather_manifest (dataset, &manifest, &manifest_size, false, true),
"gather_manifest", 0, 0);
if (HIO_SUCCESS != rc) {
dataset->ds_status = rc;
}
if (0 == context->c_rank) {
rc = asprintf (&path, "%s/manifest.json", posix_dataset->base_path);
if (0 > rc) {
/* out of memory. not much we can do now */
return hioi_err_errno (errno);
}
rc = hioi_manifest_save (dataset, manifest, manifest_size, path);
free (manifest);
free (path);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &dataset->ds_object, "posix: error writing dataset manifest");
}
}
#if HIO_MPI_HAVE(3)
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
/* optimized mode requires a data manifest to describe how the data landed on the filesystem */
POSIX_TRACE_CALL(posix_dataset, rc = hioi_dataset_gather_manifest_comm (dataset, context->c_shared_comm, &manifest, &manifest_size,
posix_dataset->ds_use_bzip, false),
"gather_manifest", 0, 0);
if (HIO_SUCCESS != rc) {
dataset->ds_status = rc;
}
if (NULL != manifest) {
rc = asprintf (&path, "%s/manifest.%x.json%s", posix_dataset->base_path, context->c_rank,
posix_dataset->ds_use_bzip ? ".bz2" : "");
if (0 > rc) {
return hioi_err_errno (errno);
}
rc = hioi_manifest_save (dataset, manifest, manifest_size, path);
free (manifest);
free (path);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &dataset->ds_object, "posix: error writing dataset manifest");
}
}
}
#endif
}
#if HIO_MPI_HAVE(1)
/* ensure all ranks have closed the dataset before continuing */
if (hioi_context_using_mpi (context)) {
MPI_Allreduce (MPI_IN_PLACE, &rc, 1, MPI_INT, MPI_MIN, context->c_comm);
}
#endif
free (posix_dataset->base_path);
stop = hioi_gettime ();
builtin_posix_trace (posix_dataset, "close", 0, 0, start, stop);
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: successfully closed posix dataset "
"%s:%" PRIu64 " on data root %s. close time %" PRIu64 " usec", hioi_object_identifier(dataset),
dataset->ds_id, module->data_root, stop - start);
builtin_posix_trace (posix_dataset, "trace_end", 0, 0, 0, 0);
if (posix_dataset->ds_trace_fh) {
fclose (posix_dataset->ds_trace_fh);
}
return rc;
}
static int builtin_posix_module_setup_striping (hio_context_t context, struct hio_module_t *module, hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
hio_fs_attr_t *fs_attr = &dataset->ds_fsattr;
int rc;
/* query the filesystem for current striping parameters */
rc = hioi_fs_query (context, module->data_root, fs_attr);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &context->c_object, "posix: error querying the filesystem");
return rc;
}
/* for now do not use stripe exclusivity in any path */
posix_dataset->my_stripe = 0;
/* set default stripe count */
fs_attr->fs_scount = 1;
posix_dataset->ds_fcount = 1;
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_STRIPING) {
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
/* pick a reasonable default stripe size */
fs_attr->fs_ssize = 1 << 24;
/* use group locking if available as we guarantee stripe exclusivity in optimized mode */
fs_attr->fs_use_group_locking = true;
#if HIO_MPI_HAVE(3)
/* if group locking is not available then each rank should attempt to write to
* a different stripe to maximize the available IO bandwidth */
fs_attr->fs_scount = min(context->c_shared_size, fs_attr->fs_smax_count);
#endif
} else if (HIO_FILE_MODE_STRIDED == posix_dataset->ds_fmode) {
/* pick a reasonable default stripe size */
fs_attr->fs_ssize = posix_dataset->ds_bs;
posix_dataset->ds_fcount = fs_attr->fs_smax_count * 32;
fs_attr->fs_scount = 16;
if (context->c_size < posix_dataset->ds_fcount) {
posix_dataset->ds_fcount = context->c_size;
}
} else if (HIO_SET_ELEMENT_UNIQUE != dataset->ds_mode) {
/* set defaults striping count */
fs_attr->fs_ssize = 1 << 20;
fs_attr->fs_scount = max (1, (unsigned) ((float) fs_attr->fs_smax_count * 0.9));
} else {
fs_attr->fs_ssize = 1 << 20;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_scount,
"stripe_count", HIO_CONFIG_TYPE_UINT32, NULL, "Stripe count for all dataset "
"data files", 0);
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_ssize,
"stripe_size", HIO_CONFIG_TYPE_UINT64, NULL, "Stripe size for all dataset "
"data files", 0);
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_RAID) {
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_raid_level,
"raid_level", HIO_CONFIG_TYPE_UINT64, NULL, "RAID level for dataset "
"data files. Keep in mind that some filesystems only support 1/2 RAID "
"levels", 0);
}
/* ensure stripe count is sane */
if (fs_attr->fs_scount > fs_attr->fs_smax_count) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe count %u exceeds the available resources. "
"adjusting to maximum %u", fs_attr->fs_scount, fs_attr->fs_smax_count);
fs_attr->fs_scount = fs_attr->fs_smax_count;
}
/* ensure the stripe size is a multiple of the stripe unit */
fs_attr->fs_ssize = fs_attr->fs_sunit * ((fs_attr->fs_ssize + fs_attr->fs_sunit - 1) / fs_attr->fs_sunit);
if (fs_attr->fs_ssize > fs_attr->fs_smax_size) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe size %" PRIu64 " exceeds the maximum %"
PRIu64 ". ", fs_attr->fs_ssize, fs_attr->fs_smax_size);
fs_attr->fs_ssize = fs_attr->fs_smax_size;
}
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode && posix_dataset->ds_bs < fs_attr->fs_ssize) {
posix_dataset->ds_bs = fs_attr->fs_ssize;
}
}
return HIO_SUCCESS;
}