xref: /external/ltp/utils/ffsb-6.0-rc2/ffsb_fs.h

/*
 *   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
 */
#ifndef _FFSB_FS_H_
#define _FFSB_FS_H_

#include "filelist.h"
#include "ffsb_op.h"
#include "ffsb_tg.h"
#include "ffsb_stats.h"

/* These are the base names for the different file types on a
 * filesystem.
*/
#define FILES_BASE "data"
#define META_BASE  "meta"
#define AGE_BASE   "fill"

struct ffsb_tg;

typedef struct size_weight {
	uint64_t size;
	int weight;
} size_weight_t;

/* A filesystem object
 * --
 * represents a filesystem on disk, and maintains access to the different
 * directories within it.  Currently there are two directories created in
 * each filesystem: data and meta
 * "data" contains the aging files and the working set files
 * "meta" only contains directories for use in the metadata operation
 *
 * Aging
 * This object contains methods for aging the filesystem if needed
 * a properly set up threadgroup is supplied by the parser which is run
 * until the filesystem reaches the desired utilization
 *
 * Operations
 * The semantics of a ffsb operation are always such that they occur on
 * a filesystem, so the filesystem also hold operation specific data as
 * an opaque type
 * One example of how this is useful is the aging process, where a different
 * set of files is operated upon than in the regular benchmark and the
 * op_data is pointing to the "fill" set rather than the "files" set
 */

typedef struct ffsb_fs {
	char *basedir;

	struct benchfiles files;
	struct benchfiles meta;
	struct benchfiles fill;

	int flags;
#define FFSB_FS_DIRECTIO   (1 << 0)
#define FFSB_FS_ALIGNIO4K  (1 << 1)
#define FFSB_FS_LIBCIO     (1 << 2)
#define FFSB_FS_REUSE_FS   (1 << 3)

	/* These pararmeters pertain to files in the files and fill
	 * dirs.  Meta dir only contains directories, starting with 0.
	 */
	uint32_t num_dirs;
	uint32_t num_start_files;
	uint64_t minfilesize, maxfilesize;
	double init_fsutil;
	uint64_t init_size;

	/* These two parameters specify the blocksize to use for
	 * writes when creating and aging the fs.
	 */
	uint32_t create_blocksize, age_blocksize;
#define FFSB_FS_DEFAULT_CREATE_BLOCKSIZE 4096
#define FFSB_FS_DEFAULT_AGE_BLOCKSIZE    4096

	double start_fsutil;

	/* Aging data/parameters */
	double desired_fsutil;
	int age_fs;
	uint32_t num_age_dirs;

	/* Use an ffsb thread group to do the aging work */
	struct ffsb_tg *aging_tg;

	/* If a particular operation wants to maintain fs-specific
	 * data, it should use this array.  Naturally, the ops must
	 * synchonize access to the data for now, they are all just
	 * putting pointers to a particular benchfiles struct here,
	 * which is already sync'ed
	 */
	void *op_data[FFSB_NUMOPS];

	/* per-fs stats */
	ffsb_statsc_t fsc;
	ffsb_statsd_t fsd;

	size_weight_t *size_weights;
	unsigned num_weights;
	unsigned sum_weights;

} ffsb_fs_t;

/* Set up the structure, zeros everything out and dups the basedir
 * string
 */
void init_ffsb_fs(ffsb_fs_t *fs, char *basedir, uint32_t num_data_dirs,
		  uint32_t num_start_files, unsigned flags);

/* Does not remove files/dirs on disk, only frees up data
 * structures
 */
void destroy_ffsb_fs(ffsb_fs_t *fs);

/* Set up the files and such on the disk including aging if requested.
 * Should call back into each op, which initialize its op_data[]
 * entry.  Aging is done by starting the aging_tg thread group, and
 * waiting until the desired utilization is achieved.  It can (and is)
 * be used with pthread_create().  Parameter should be a ffsb_fs_t * ,
 * and it will return the same type
 */
void *construct_ffsb_fs(void *ffsb_fs_ptr);

/* Shallow clone, original should simply be discarded (not destroyed).
 * Generally should only be used by parser to write into the config
 * object
 */
void clone_ffsb_fs(ffsb_fs_t *target, ffsb_fs_t *original);

void fs_print_config(ffsb_fs_t *fs);

char *fs_get_basedir(ffsb_fs_t *fs);
int fs_get_directio(ffsb_fs_t *fs);
void fs_set_directio(ffsb_fs_t *fs, int dio);
int fs_get_alignio(ffsb_fs_t *fs);
void fs_set_alignio(ffsb_fs_t *fs, int aio);
int fs_get_libcio(ffsb_fs_t *fs);
void fs_set_libcio(ffsb_fs_t *fs, int lio);
int fs_get_reuse_fs(ffsb_fs_t *fs);
void fs_set_reuse_fs(ffsb_fs_t *fs, int rfs);

struct benchfiles *fs_get_datafiles(ffsb_fs_t *fs);
struct benchfiles *fs_get_metafiles(ffsb_fs_t *fs);
struct benchfiles *fs_get_agefiles(ffsb_fs_t *fs);

void fs_set_aging_tg(ffsb_fs_t *fs, struct ffsb_tg *, double util);
struct ffsb_tg *fs_get_aging_tg(ffsb_fs_t *fs);
int fs_get_agefs(ffsb_fs_t *fs);

void fs_set_opdata(ffsb_fs_t *fs, void *data, unsigned opnum);
void *fs_get_opdata(ffsb_fs_t *fs, unsigned opnum);
void fs_set_min_filesize(ffsb_fs_t *fs, uint64_t size);
void fs_set_max_filesize(ffsb_fs_t *fs, uint64_t size);
void fs_set_create_blocksize(ffsb_fs_t *fs, uint32_t blocksize);
void fs_set_age_blocksize(ffsb_fs_t *fs, uint32_t blocksize);
uint32_t fs_get_create_blocksize(ffsb_fs_t *fs);
uint32_t fs_get_age_blocksize(ffsb_fs_t *fs);
uint64_t fs_get_min_filesize(ffsb_fs_t *fs);
uint64_t fs_get_max_filesize(ffsb_fs_t *fs);
uint32_t fs_get_numstartfiles(ffsb_fs_t *fs);
uint32_t fs_get_numdirs(ffsb_fs_t *fs);

double fs_get_desired_fsutil(ffsb_fs_t *fs);

/* For these two, fs == NULL is OK */
int fs_needs_stats(ffsb_fs_t *fs, syscall_t s);
void fs_add_stat(ffsb_fs_t *fs, syscall_t sys, uint32_t val);

#endif /* _FFSB_FS_H_ */