FreeRTOS-RISCV/FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/posix/fsstress.c

2051 lines
50 KiB
C

/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
*/
/** @file
@brief File system stress test.
This version of SGI fsstress has been modified to be single-threaded and to
work with the Reliance Edge POSIX-like API.
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include <redposix.h>
#include <redtests.h>
#if FSSTRESS_SUPPORTED
#include "redposixcompat.h"
#include <redosserv.h>
#include <redutils.h>
#include <redmacs.h>
#include <redvolume.h>
#include <redgetopt.h>
#include <redtoolcmn.h>
#if REDCONF_CHECKER == 1
#include <redcoreapi.h>
#endif
/* Create POSIX types. Use #define to avoid name conflicts in those
environments where the type names already exist.
*/
#define off_t int64_t
#define off64_t off_t
#define ino_t uint32_t
#define mode_t uint16_t
#define __int64_t int64_t
/** @brief Generate a random number.
@return A nonnegative random number.
*/
#define random() ((int)(RedRand32(NULL) & 0x7FFFFFFF))
/** @brief Seed the random number generator.
*/
#define srandom(seed) RedRandSeed(seed)
#define _exit(status) exit(status)
#define getpagesize() 4096U
#define getpid() 1
/** @brief Determine the maximum file size.
This is used for the MAXFSSIZE macro.
*/
static uint64_t MaxFileSize(void)
{
REDSTATFS info;
int32_t iStatus;
REDSTATUS errnoSave = errno;
uint64_t ullMaxFileSize;
iStatus = red_statvfs("", &info);
if(iStatus == 0)
{
ullMaxFileSize = info.f_maxfsize;
}
else
{
/* This function does not change errno.
*/
errno = errnoSave;
ullMaxFileSize = 0x7FFFFFFFU;
}
return ullMaxFileSize;
}
/*-------------------------------------------------------------------
Simulated current working directory support
-------------------------------------------------------------------*/
/* Forward declaration for red_chdir().
*/
static int red_stat(const char *pszPath, REDSTAT *pStat);
/* The simulated CWD functions.
*/
#undef chdir
#undef getcwd
#define chdir(path) red_chdir(path)
#define getcwd(buf, size) red_getcwd(buf, size)
/* Redefine the path-based APIs to call MakeFullPath() on their arguments
since there is no CWD support in the red_*() APIs.
*/
#undef open
#undef unlink
#undef mkdir
#undef rmdir
#undef rename
#undef link
#undef opendir
#define open(path, oflag) red_open(MakeFullPath(path), oflag)
#define unlink(path) red_unlink(MakeFullPath(path))
#define mkdir(path) red_mkdir(MakeFullPath(path))
#define rmdir(path) red_rmdir(MakeFullPath(path))
#define rename(old, new) red_rename(MakeFullPath(old), MakeFullPath(new))
#define link(path, hardlink) red_link(MakeFullPath(path), MakeFullPath(hardlink))
#define opendir(path) red_opendir(MakeFullPath(path))
#define FSSTRESS_BUF_SIZE 1024U
/* Stores the simulated current working directory.
*/
static char szLocalCwd[FSSTRESS_BUF_SIZE] = "/";
/** @brief Change the current working directory.
This function only supports a subset of what is possible with POSIX chdir().
@param pszPath The new current working directory.
@return Upon successful completion, 0 shall be returned. Otherwise, -1
shall be returned, and errno shall be set to indicate the error.
*/
static int red_chdir(
const char *pszPath)
{
uint32_t ulIdx;
int iErrno = 0;
if(strcmp(pszPath, "..") == 0)
{
uint32_t ulLastSlashIdx = 0U;
/* Chop off the last path separator and everything after it, so that
"/foo/bar/baz" becomes "/foo/bar", moving the CWD up one directory.
*/
for(ulIdx = 0U; szLocalCwd[ulIdx] != '\0'; ulIdx++)
{
if(szLocalCwd[ulIdx] == '/')
{
ulLastSlashIdx = ulIdx;
}
}
if(ulLastSlashIdx != 0U)
{
szLocalCwd[ulLastSlashIdx] = '\0';
}
}
else
{
char szOldCwd[FSSTRESS_BUF_SIZE];
/* chdir() must have no effect on the CWD if it fails, so save the CWD
so we can revert it if necessary.
*/
strcpy(szOldCwd, szLocalCwd);
if(pszPath[0U] == '/')
{
if(strlen(pszPath) >= sizeof(szLocalCwd))
{
iErrno = RED_ENAMETOOLONG;
}
else
{
strcpy(szLocalCwd, pszPath);
}
}
else
{
ulIdx = strlen(szLocalCwd);
if((ulIdx + 1U + strlen(pszPath)) >= sizeof(szLocalCwd))
{
iErrno = RED_ENAMETOOLONG;
}
else
{
if(szLocalCwd[1U] != '\0')
{
szLocalCwd[ulIdx] = '/';
ulIdx++;
}
strcpy(&szLocalCwd[ulIdx], pszPath);
}
}
if(iErrno == 0)
{
REDSTAT s;
int iStatus;
iStatus = red_stat(szLocalCwd, &s);
if(iStatus != 0)
{
iErrno = errno;
}
else if(!S_ISDIR(s.st_mode))
{
iErrno = RED_ENOTDIR;
}
else
{
/* No error, new CWD checks out.
*/
}
}
if(iErrno != 0)
{
strcpy(szLocalCwd, szOldCwd);
}
}
if(iErrno != 0)
{
errno = iErrno;
}
return iErrno == 0 ? 0 : -1;
}
/** @brief Retrieve the current working directory.
@param pszBuf On successful return, populated with the current working
directory. If NULL, memory will be allocated for the CWD
and returned by this function.
@param nSize The size of @p pszBuf.
@return On success, if @p pszBuf was non-NULL, returns @p pszBuf; if
@p pszBuf was NULL, returns an allocated buffer populated with the
CWD which must be freed by the caller. On failure, returns NULL
and errno will be set.
*/
static char *red_getcwd(
char *pszBuf,
size_t nSize)
{
char *pszRet;
if(pszBuf == NULL)
{
pszRet = malloc(strlen(szLocalCwd) + 1U);
if(pszRet == NULL)
{
errno = RED_ENOMEM;
}
else
{
strcpy(pszRet, szLocalCwd);
}
}
else if(nSize < strlen(szLocalCwd) + 1U)
{
errno = RED_ERANGE;
pszRet = NULL;
}
else
{
strcpy(pszBuf, szLocalCwd);
pszRet = pszBuf;
}
return pszRet;
}
/** @brief Make a relative path into a fully qualified path.
@param pszName The relative path.
@return On success, a pointer to a fully qualified path. On error, NULL.
*/
static const char *MakeFullPath(
const char *pszName)
{
#define MAXVOLNAME 64U /* Enough for most configs. */
static char aszFullPath[2U][MAXVOLNAME + 1U + FSSTRESS_BUF_SIZE];
static uint32_t ulWhich = 0U;
char *pszFullPath = aszFullPath[ulWhich];
const char *pszVolume = gpRedVolConf->pszPathPrefix;
int32_t iLen;
if(pszName[0U] == '/')
{
iLen = RedSNPrintf(pszFullPath, sizeof(aszFullPath[0U]), "%s%s", pszVolume, pszName);
}
else if(strcmp(pszName, ".") == 0U)
{
iLen = RedSNPrintf(pszFullPath, sizeof(aszFullPath[0U]), "%s%s", pszVolume, szLocalCwd);
}
else if((szLocalCwd[0U] == '/') && (szLocalCwd[1U] == '\0'))
{
iLen = RedSNPrintf(pszFullPath, sizeof(aszFullPath[0U]), "%s/%s", pszVolume, pszName);
}
else
{
iLen = RedSNPrintf(pszFullPath, sizeof(aszFullPath[0U]), "%s%s/%s", pszVolume, szLocalCwd, pszName);
}
if(iLen == -1)
{
/* Insufficient path buffer space.
*/
pszFullPath = NULL;
}
else
{
/* Toggle between two full path arrays; a kluge to make rename() and
link() work correctly.
*/
ulWhich ^= 1U;
}
return pszFullPath;
}
/*-------------------------------------------------------------------
POSIX functions not implemented by the RED POSIX-like API
-------------------------------------------------------------------*/
#define stat(p, s) red_stat(p, s)
#define stat64(p, s) stat(p, s)
#define lstat(p, s) stat(p, s)
#define lstat64(p, s) stat(p, s)
#define truncate(p, s) red_truncate(p, s)
#define truncate64(p, s) truncate(p, s)
/** @brief Get the status of a file or directory.
*/
static int red_stat(
const char *pszPath,
REDSTAT *pStat)
{
int iFd;
int iRet;
iFd = open(pszPath, O_RDONLY);
iRet = iFd;
if(iFd != -1)
{
iRet = fstat(iFd, pStat);
(void)close(iFd);
}
return iRet;
}
/** @brief Truncate a file to a specified length.
*/
static int red_truncate(
const char *pszPath,
off_t llSize)
{
int iFd;
int iRet;
iFd = open(pszPath, O_WRONLY);
iRet = iFd;
if(iFd != -1)
{
iRet = ftruncate(iFd, llSize);
(void)close(iFd);
}
return iRet;
}
/*-------------------------------------------------------------------
Begin ported fsstress code
-------------------------------------------------------------------*/
/* Stuff from xfscompat.h */
#define MAXNAMELEN (REDCONF_NAME_MAX+1U) /* Assumed to include NUL */
struct dioattr {
int d_miniosz, d_maxiosz, d_mem;
};
#define MIN(a,b) ((a)<(b) ? (a):(b))
#define MAX(a,b) ((a)>(b) ? (a):(b))
/* End xfscompat.h */
typedef enum {
OP_CREAT,
OP_FDATASYNC,
OP_FSYNC,
OP_GETDENTS,
OP_LINK,
OP_MKDIR,
OP_READ,
OP_RENAME,
OP_RMDIR,
OP_STAT,
OP_TRUNCATE,
OP_UNLINK,
OP_WRITE,
#if REDCONF_CHECKER == 1
OP_CHECK,
#endif
OP_LAST
} opty_t;
typedef void (*opfnc_t) (int, long);
typedef struct opdesc {
opty_t op;
const char *name;
opfnc_t func;
int freq;
int iswrite;
} opdesc_t;
typedef struct fent {
int id;
int parent;
} fent_t;
typedef struct flist {
int nfiles;
int nslots;
int tag;
fent_t *fents;
} flist_t;
typedef struct pathname {
int len;
char *path;
} pathname_t;
#define FT_DIR 0
#define FT_DIRm (1 << FT_DIR)
#define FT_REG 1
#define FT_REGm (1 << FT_REG)
#define FT_SYM 2
#define FT_SYMm (1 << FT_SYM)
#define FT_DEV 3
#define FT_DEVm (1 << FT_DEV)
#define FT_RTF 4
#define FT_RTFm (1 << FT_RTF)
#define FT_nft 5
#define FT_ANYm ((1 << FT_nft) - 1)
#define FT_REGFILE (FT_REGm | FT_RTFm)
#define FT_NOTDIR (FT_ANYm & ~FT_DIRm)
#define FLIST_SLOT_INCR 16
#define NDCACHE 64
#define MAXFSIZE MaxFileSize()
static void creat_f(int opno, long r);
static void fdatasync_f(int opno, long r);
static void fsync_f(int opno, long r);
static void getdents_f(int opno, long r);
static void link_f(int opno, long r);
static void mkdir_f(int opno, long r);
static void read_f(int opno, long r);
static void rename_f(int opno, long r);
static void rmdir_f(int opno, long r);
static void stat_f(int opno, long r);
static void truncate_f(int opno, long r);
static void unlink_f(int opno, long r);
static void write_f(int opno, long r);
#if REDCONF_CHECKER == 1
static void check_f(int opno, long r);
#endif
static opdesc_t ops[] = {
{OP_CREAT, "creat", creat_f, 4, 1},
{OP_FDATASYNC, "fdatasync", fdatasync_f, 1, 1},
{OP_FSYNC, "fsync", fsync_f, 1, 1},
{OP_GETDENTS, "getdents", getdents_f, 1, 0},
{OP_LINK, "link", link_f, 1, 1},
{OP_MKDIR, "mkdir", mkdir_f, 2, 1},
{OP_READ, "read", read_f, 1, 0},
{OP_RENAME, "rename", rename_f, 2, 1},
{OP_RMDIR, "rmdir", rmdir_f, 1, 1},
{OP_STAT, "stat", stat_f, 1, 0},
{OP_TRUNCATE, "truncate", truncate_f, 2, 1},
{OP_UNLINK, "unlink", unlink_f, 1, 1},
{OP_WRITE, "write", write_f, 4, 1},
#if REDCONF_CHECKER == 1
{OP_CHECK, "check", check_f, 1, 1},
#endif
}, *ops_end;
static flist_t flist[FT_nft] = {
{0, 0, 'd', NULL},
{0, 0, 'f', NULL},
{0, 0, 'l', NULL},
{0, 0, 'c', NULL},
{0, 0, 'r', NULL},
};
static int dcache[NDCACHE];
static opty_t *freq_table;
static int freq_table_size;
static char *homedir;
static int *ilist;
static int ilistlen;
static off64_t maxfsize;
static int namerand;
static int nameseq;
static int nops;
static int operations = 1;
static int procid;
static int rtpct;
static unsigned long seed = 0;
static ino_t top_ino;
static int verbose = 0;
static int delete_tree(const char *path);
static void add_to_flist(int fd, int it, int parent);
static void append_pathname(pathname_t *name, const char *str);
static void check_cwd(void);
static int creat_path(pathname_t *name, mode_t mode);
static void dcache_enter(int dirid, int slot);
static void dcache_init(void);
static fent_t *dcache_lookup(int dirid);
static void dcache_purge(int dirid);
static void del_from_flist(int ft, int slot);
static void doproc(void);
static void fent_to_name(pathname_t *name, flist_t *flp, fent_t *fep);
static void fix_parent(int oldid, int newid);
static void free_pathname(pathname_t *name);
static int generate_fname(fent_t *fep, int ft, pathname_t *name, int *idp, int *v);
static int get_fname(int which, long r, pathname_t *name, flist_t **flpp, fent_t **fepp, int *v);
static void init_pathname(pathname_t *name);
static int link_path(pathname_t *name1, pathname_t *name2);
static int lstat64_path(pathname_t *name, REDSTAT *sbuf);
static void make_freq_table(void);
static int mkdir_path(pathname_t *name, mode_t mode);
static void namerandpad(int id, char *buf, int len);
static int open_path(pathname_t *name, int oflag);
static DIR *opendir_path(pathname_t *name);
static int rename_path(pathname_t *name1, pathname_t *name2);
static int rmdir_path(pathname_t *name);
static void separate_pathname(pathname_t *name, char *buf, pathname_t *newname);
static int stat64_path(pathname_t *name, REDSTAT *sbuf);
static int truncate64_path(pathname_t *name, off64_t length);
static int unlink_path(pathname_t *name);
static void usage(const char *progname);
/** @brief Parse parameters for fsstress.
@param argc The number of arguments from main().
@param argv The vector of arguments from main().
@param pParam Populated with the fsstress parameters.
@param pbVolNum If non-NULL, populated with the volume number.
@param ppszDevice If non-NULL, populated with the device name argument or
NULL if no device argument is provided.
@return The result of parsing the parameters.
*/
PARAMSTATUS FsstressParseParams(
int argc,
char *argv[],
FSSTRESSPARAM *pParam,
uint8_t *pbVolNum,
const char **ppszDevice)
{
int c;
uint8_t bVolNum;
const REDOPTION aLongopts[] =
{
{ "no-cleanup", red_no_argument, NULL, 'c' },
{ "loops", red_required_argument, NULL, 'l' },
{ "nops", red_required_argument, NULL, 'n' },
{ "namepad", red_no_argument, NULL, 'r' },
{ "seed", red_required_argument, NULL, 's' },
{ "verbose", red_no_argument, NULL, 'v' },
{ "dev", red_required_argument, NULL, 'D' },
{ "help", red_no_argument, NULL, 'H' },
{ NULL }
};
/* If run without parameters, treat as a help request.
*/
if(argc <= 1)
{
goto Help;
}
/* Assume no device argument to start with.
*/
if(ppszDevice != NULL)
{
*ppszDevice = NULL;
}
/* Set default parameters.
*/
FsstressDefaultParams(pParam);
while((c = RedGetoptLong(argc, argv, "cl:n:rs:vD:H", aLongopts, NULL)) != -1)
{
switch(c)
{
case 'c': /* --no-cleanup */
pParam->fNoCleanup = true;
break;
case 'l': /* --loops */
pParam->ulLoops = RedAtoI(red_optarg);
break;
case 'n': /* --nops */
pParam->ulNops = RedAtoI(red_optarg);
break;
case 'r': /* --namepad */
pParam->fNamePad = true;
break;
case 's': /* --seed */
pParam->ulSeed = RedAtoI(red_optarg);
break;
case 'v': /* --verbose */
pParam->fVerbose = true;
break;
case 'D': /* --dev */
if(ppszDevice != NULL)
{
*ppszDevice = red_optarg;
}
break;
case 'H': /* --help */
goto Help;
case '?': /* Unknown or ambiguous option */
case ':': /* Option missing required argument */
default:
goto BadOpt;
}
}
/* RedGetoptLong() has permuted argv to move all non-option arguments to
the end. We expect to find a volume identifier.
*/
if(red_optind >= argc)
{
RedPrintf("Missing volume argument\n");
goto BadOpt;
}
bVolNum = RedFindVolumeNumber(argv[red_optind]);
if(bVolNum == REDCONF_VOLUME_COUNT)
{
RedPrintf("Error: \"%s\" is not a valid volume identifier.\n", argv[red_optind]);
goto BadOpt;
}
if(pbVolNum != NULL)
{
*pbVolNum = bVolNum;
}
red_optind++; /* Move past volume parameter. */
if(red_optind < argc)
{
int32_t ii;
for(ii = red_optind; ii < argc; ii++)
{
RedPrintf("Error: Unexpected command-line argument \"%s\".\n", argv[ii]);
}
goto BadOpt;
}
return PARAMSTATUS_OK;
BadOpt:
RedPrintf("%s - invalid parameters\n", argv[0U]);
usage(argv[0U]);
return PARAMSTATUS_BAD;
Help:
usage(argv[0U]);
return PARAMSTATUS_HELP;
}
/** @brief Set default fsstress parameters.
@param pParam Populated with the default fsstress parameters.
*/
void FsstressDefaultParams(
FSSTRESSPARAM *pParam)
{
RedMemSet(pParam, 0U, sizeof(*pParam));
pParam->ulLoops = 1U;
pParam->ulNops = 10000U;
}
/** @brief Start fsstress.
@param pParam fsstress parameters, either from FsstressParseParams() or
constructed programatically.
@return Zero on success, otherwise nonzero.
*/
int FsstressStart(
const FSSTRESSPARAM *pParam)
{
char buf[10];
int fd;
int i;
int cleanup;
int loops;
int loopcntr = 1;
nops = sizeof(ops) / sizeof(ops[0]);
ops_end = &ops[nops];
/* Copy the already-parsed parameters into the traditional variables.
*/
cleanup = pParam->fNoCleanup ? 1 : 0;
loops = pParam->ulLoops;
operations = pParam->ulNops;
namerand = pParam->fNamePad ? 1 : 0;
seed = pParam->ulSeed;
verbose = pParam->fVerbose ? 1 : 0;
make_freq_table();
while ((loopcntr <= loops) || (loops == 0)) {
RedSNPrintf(buf, sizeof(buf), "fss%x", getpid());
fd = creat(buf, 0666);
maxfsize = (off64_t) MAXFSIZE;
dcache_init();
if (!seed) {
seed = (unsigned long)RedOsClockGetTime();
RedPrintf("seed = %ld\n", seed);
}
close(fd);
unlink(buf);
procid = 0;
doproc();
if (cleanup == 0) {
delete_tree("/");
for (i = 0; i < FT_nft; i++) {
flist[i].nslots = 0;
flist[i].nfiles = 0;
free(flist[i].fents);
flist[i].fents = NULL;
}
}
loopcntr++;
}
return 0;
}
static int delete_tree(const char *path)
{
REDSTAT sb;
DIR *dp;
REDDIRENT *dep;
char *childpath;
size_t len;
int e;
e = stat(path, &sb);
if (e)
return errno;
if (!S_ISDIR(sb.st_mode))
return unlink(path) ? errno : 0;
dp = opendir(path);
if (dp == NULL)
return errno;
while((dep = readdir(dp)) != NULL) {
len = strlen(path) + 1 + strlen(dep->d_name) + 1;
childpath = malloc(len);
strcpy(childpath, path);
if (childpath[strlen(childpath) - 1] != '/')
strcat(childpath, "/");
strcat(childpath, dep->d_name);
e = delete_tree(childpath);
free(childpath);
if (e)
break;
}
if (e == 0 && strcmp(path, "/") != 0) {
e = rmdir(path) ? errno : 0;
}
closedir(dp);
return e;
}
static void add_to_flist(int ft, int id, int parent)
{
fent_t *fep;
flist_t *ftp;
ftp = &flist[ft];
if (ftp->nfiles == ftp->nslots) {
ftp->nslots += FLIST_SLOT_INCR;
ftp->fents = realloc(ftp->fents, ftp->nslots * sizeof(fent_t));
}
fep = &ftp->fents[ftp->nfiles++];
fep->id = id;
fep->parent = parent;
}
static void append_pathname(pathname_t *name, const char *str)
{
int len;
len = strlen(str);
#ifdef DEBUG
if (len && *str == '/' && name->len == 0) {
RedPrintf("fsstress: append_pathname failure\n");
chdir(homedir);
abort();
}
#endif
name->path = realloc(name->path, name->len + 1 + len);
strcpy(&name->path[name->len], str);
name->len += len;
}
static void check_cwd(void)
{
#ifdef DEBUG
REDSTAT statbuf;
if (stat64(".", &statbuf) == 0 && statbuf.st_ino == top_ino)
return;
chdir(homedir);
RedPrintf("fsstress: check_cwd failure\n");
abort();
#endif
}
static int creat_path(pathname_t *name, mode_t mode)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = creat(name->path, mode);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = creat_path(&newname, mode);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static void dcache_enter(int dirid, int slot)
{
dcache[dirid % NDCACHE] = slot;
}
static void dcache_init(void)
{
int i;
for (i = 0; i < NDCACHE; i++)
dcache[i] = -1;
}
static fent_t *dcache_lookup(int dirid)
{
fent_t *fep;
int i;
i = dcache[dirid % NDCACHE];
if (i >= 0 && (fep = &flist[FT_DIR].fents[i])->id == dirid)
return fep;
return NULL;
}
static void dcache_purge(int dirid)
{
int *dcp;
dcp = &dcache[dirid % NDCACHE];
if (*dcp >= 0 && flist[FT_DIR].fents[*dcp].id == dirid)
*dcp = -1;
}
static void del_from_flist(int ft, int slot)
{
flist_t *ftp;
ftp = &flist[ft];
if (ft == FT_DIR)
dcache_purge(ftp->fents[slot].id);
if (slot != ftp->nfiles - 1) {
if (ft == FT_DIR)
dcache_purge(ftp->fents[ftp->nfiles - 1].id);
ftp->fents[slot] = ftp->fents[--ftp->nfiles];
} else
ftp->nfiles--;
}
static fent_t *dirid_to_fent(int dirid)
{
fent_t *efep;
fent_t *fep;
flist_t *flp;
if ((fep = dcache_lookup(dirid)))
return fep;
flp = &flist[FT_DIR];
for (fep = flp->fents, efep = &fep[flp->nfiles]; fep < efep; fep++) {
if (fep->id == dirid) {
dcache_enter(dirid, (int)(fep - flp->fents));
return fep;
}
}
return NULL;
}
static void doproc(void)
{
REDSTAT statbuf;
char buf[10];
int opno;
opdesc_t *p;
RedSNPrintf(buf, sizeof(buf), "p%x", procid);
(void)mkdir(buf);
if (chdir(buf) < 0 || stat64(".", &statbuf) < 0) {
perror(buf);
_exit(1);
}
top_ino = statbuf.st_ino;
homedir = getcwd(NULL, 0);
seed += procid;
srandom(seed);
if (namerand)
namerand = random();
for (opno = 0; opno < operations; opno++) {
p = &ops[freq_table[random() % freq_table_size]];
if ((unsigned long)p->func < 4096)
abort();
p->func(opno, random());
}
free(homedir);
}
static void fent_to_name(pathname_t *name, flist_t *flp, fent_t *fep)
{
char buf[MAXNAMELEN];
int i;
fent_t *pfep;
if (fep == NULL)
return;
if (fep->parent != -1) {
pfep = dirid_to_fent(fep->parent);
fent_to_name(name, &flist[FT_DIR], pfep);
append_pathname(name, "/");
}
i = RedSNPrintf(buf, sizeof(buf), "%c%x", flp->tag, fep->id);
namerandpad(fep->id, buf, i);
append_pathname(name, buf);
}
static void fix_parent(int oldid, int newid)
{
fent_t *fep;
flist_t *flp;
int i;
int j;
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
for (j = 0, fep = flp->fents; j < flp->nfiles; j++, fep++) {
if (fep->parent == oldid)
fep->parent = newid;
}
}
}
static void free_pathname(pathname_t *name)
{
if (name->path) {
free(name->path);
name->path = NULL;
name->len = 0;
}
}
static int generate_fname(fent_t *fep, int ft, pathname_t *name, int *idp, int *v)
{
char buf[MAXNAMELEN];
flist_t *flp;
int id;
int j;
int len;
flp = &flist[ft];
len = RedSNPrintf(buf, sizeof(buf), "%c%x", flp->tag, id = nameseq++);
namerandpad(id, buf, len);
if (fep) {
fent_to_name(name, &flist[FT_DIR], fep);
append_pathname(name, "/");
}
append_pathname(name, buf);
*idp = id;
*v = verbose;
for (j = 0; !*v && j < ilistlen; j++) {
if (ilist[j] == id) {
*v = 1;
break;
}
}
return 1;
}
static int
get_fname(int which, long r, pathname_t *name, flist_t **flpp, fent_t **fepp, int *v)
{
int c;
fent_t *fep;
flist_t *flp;
int i;
int j;
int x;
for (i = 0, c = 0, flp = flist; i < FT_nft; i++, flp++) {
if (which & (1 << i))
c += flp->nfiles;
}
if (c == 0) {
if (flpp)
*flpp = NULL;
if (fepp)
*fepp = NULL;
*v = verbose;
return 0;
}
x = (int)(r % c);
for (i = 0, c = 0, flp = flist; i < FT_nft; i++, flp++) {
if (which & (1 << i)) {
if (x < c + flp->nfiles) {
fep = &flp->fents[x - c];
if (name)
fent_to_name(name, flp, fep);
if (flpp)
*flpp = flp;
if (fepp)
*fepp = fep;
*v = verbose;
for (j = 0; !*v && j < ilistlen; j++) {
if (ilist[j] == fep->id) {
*v = 1;
break;
}
}
return 1;
}
c += flp->nfiles;
}
}
#ifdef DEBUG
RedPrintf("fsstress: get_fname failure\n");
abort();
#endif
return -1;
}
static void init_pathname(pathname_t *name)
{
name->len = 0;
name->path = NULL;
}
static int link_path(pathname_t *name1, pathname_t *name2)
{
char buf1[MAXNAMELEN];
char buf2[MAXNAMELEN];
int down1;
pathname_t newname1;
pathname_t newname2;
int rval;
rval = link(name1->path, name2->path);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name1, buf1, &newname1);
separate_pathname(name2, buf2, &newname2);
if (strcmp(buf1, buf2) == 0) {
if (chdir(buf1) == 0) {
rval = link_path(&newname1, &newname2);
chdir("..");
}
} else {
if (strcmp(buf1, "..") == 0)
down1 = 0;
else if (strcmp(buf2, "..") == 0)
down1 = 1;
else if (strlen(buf1) == 0)
down1 = 0;
else if (strlen(buf2) == 0)
down1 = 1;
else
down1 = MAX(newname1.len, 3 + name2->len) <=
MAX(3 + name1->len, newname2.len);
if (down1) {
free_pathname(&newname2);
append_pathname(&newname2, "../");
append_pathname(&newname2, name2->path);
if (chdir(buf1) == 0) {
rval = link_path(&newname1, &newname2);
chdir("..");
}
} else {
free_pathname(&newname1);
append_pathname(&newname1, "../");
append_pathname(&newname1, name1->path);
if (chdir(buf2) == 0) {
rval = link_path(&newname1, &newname2);
chdir("..");
}
}
}
free_pathname(&newname1);
free_pathname(&newname2);
return rval;
}
static int lstat64_path(pathname_t *name, REDSTAT *sbuf)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = lstat64(name->path, sbuf);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = lstat64_path(&newname, sbuf);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static void make_freq_table(void)
{
int f;
int i;
opdesc_t *p;
for (p = ops, f = 0; p < ops_end; p++)
f += p->freq;
freq_table = malloc(f * sizeof(*freq_table));
freq_table_size = f;
for (p = ops, i = 0; p < ops_end; p++) {
for (f = 0; f < p->freq; f++, i++)
freq_table[i] = p->op;
}
}
static int mkdir_path(pathname_t *name, mode_t mode)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = mkdir(name->path);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = mkdir_path(&newname, mode);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static void namerandpad(int id, char *buf, int len)
{
int bucket;
static int buckets[8] = {0};
static int bucket_count = 0;
int bucket_value;
int i;
int padlen;
int padmod;
if (namerand == 0)
return;
/* buckets[] used to be a statically initialized array with the following
initializer: { 2, 4, 8, 16, 32, 64, 128, MAXNAMELEN - 1 }
The problem is that with Reliance Edge, the maximum name length might be
less than 128. So the below code populates buckets[] in a similar
fashion but avoids name lengths longer than the maximum. For example,
if the max name is 20, the resulting array is { 2, 4, 8, 16, 20 }.
*/
if (!bucket_count) {
bucket_count = sizeof(buckets) / sizeof(buckets[0]);
bucket_value = 2;
for (i = 0; i < bucket_count; i++) {
if (bucket_value > 128 || bucket_value >= (int)MAXNAMELEN - 1)
break;
buckets[i] = bucket_value;
bucket_value *= 2;
}
if (i < bucket_count) {
buckets[i] = MAXNAMELEN - 1;
i++;
}
bucket_count = i;
}
bucket = (id ^ namerand) % bucket_count;
padmod = buckets[bucket] + 1 - len;
if (padmod <= 0)
return;
padlen = (id ^ namerand) % padmod;
if (padlen) {
memset(&buf[len], 'X', padlen);
buf[len + padlen] = '\0';
}
}
static int open_path(pathname_t *name, int oflag)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = open(name->path, oflag);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = open_path(&newname, oflag);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static DIR *opendir_path(pathname_t *name)
{
char buf[MAXNAMELEN];
pathname_t newname;
DIR *rval;
rval = opendir(name->path);
if (rval || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = opendir_path(&newname);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static int rename_path(pathname_t *name1, pathname_t *name2)
{
char buf1[MAXNAMELEN];
char buf2[MAXNAMELEN];
int down1;
pathname_t newname1;
pathname_t newname2;
int rval;
rval = rename(name1->path, name2->path);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name1, buf1, &newname1);
separate_pathname(name2, buf2, &newname2);
if (strcmp(buf1, buf2) == 0) {
if (chdir(buf1) == 0) {
rval = rename_path(&newname1, &newname2);
chdir("..");
}
} else {
if (strcmp(buf1, "..") == 0)
down1 = 0;
else if (strcmp(buf2, "..") == 0)
down1 = 1;
else if (strlen(buf1) == 0)
down1 = 0;
else if (strlen(buf2) == 0)
down1 = 1;
else
down1 = MAX(newname1.len, 3 + name2->len) <=
MAX(3 + name1->len, newname2.len);
if (down1) {
free_pathname(&newname2);
append_pathname(&newname2, "../");
append_pathname(&newname2, name2->path);
if (chdir(buf1) == 0) {
rval = rename_path(&newname1, &newname2);
chdir("..");
}
} else {
free_pathname(&newname1);
append_pathname(&newname1, "../");
append_pathname(&newname1, name1->path);
if (chdir(buf2) == 0) {
rval = rename_path(&newname1, &newname2);
chdir("..");
}
}
}
free_pathname(&newname1);
free_pathname(&newname2);
return rval;
}
static int rmdir_path(pathname_t *name)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = rmdir(name->path);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = rmdir_path(&newname);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static void separate_pathname(pathname_t *name, char *buf, pathname_t *newname)
{
char *slash;
init_pathname(newname);
slash = strchr(name->path, '/');
if (slash == NULL) {
buf[0] = '\0';
return;
}
*slash = '\0';
strcpy(buf, name->path);
*slash = '/';
append_pathname(newname, slash + 1);
}
static int stat64_path(pathname_t *name, REDSTAT *sbuf)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = stat64(name->path, sbuf);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = stat64_path(&newname, sbuf);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static int truncate64_path(pathname_t *name, off64_t length)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = truncate64(name->path, length);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = truncate64_path(&newname, length);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static int unlink_path(pathname_t *name)
{
char buf[MAXNAMELEN];
pathname_t newname;
int rval;
rval = unlink(name->path);
if (rval >= 0 || errno != RED_ENAMETOOLONG)
return rval;
separate_pathname(name, buf, &newname);
if (chdir(buf) == 0) {
rval = unlink_path(&newname);
chdir("..");
}
free_pathname(&newname);
return rval;
}
static void usage(const char *progname)
{
RedPrintf("usage: %s VolumeID [Options]\n", progname);
RedPrintf("File system stress test.\n\n");
RedPrintf("Where:\n");
RedPrintf(" VolumeID\n");
RedPrintf(" A volume number (e.g., 2) or a volume path prefix (e.g., VOL1: or /data)\n");
RedPrintf(" of the volume to test.\n");
RedPrintf("And 'Options' are any of the following:\n");
RedPrintf(" --no-cleanup, -c\n");
RedPrintf(" Specifies not to remove files (cleanup) after execution\n");
RedPrintf(" --loops=count, -l count\n");
RedPrintf(" Specifies the number of times the entire test should loop. Use 0 for\n");
RedPrintf(" infinite. Default 1.\n");
RedPrintf(" --nops=count, -n count\n");
RedPrintf(" Specifies the number of operations to run (default 10000).\n");
RedPrintf(" --namepad, -r\n");
RedPrintf(" Specifies to use random name padding (resulting in longer names).\n");
RedPrintf(" --seed=value, -s value\n");
RedPrintf(" Specifies the seed for the random number generator (default timestamp).\n");
RedPrintf(" --verbose, -v\n");
RedPrintf(" Specifies verbose mode (without this, test is very quiet).\n");
RedPrintf(" --dev=devname, -D devname\n");
RedPrintf(" Specifies the device name. This is typically only meaningful when\n");
RedPrintf(" running the test on a host machine. This can be \"ram\" to test on a RAM\n");
RedPrintf(" disk, the path and name of a file disk (e.g., red.bin); or an OS-specific\n");
RedPrintf(" reference to a device (on Windows, a drive letter like G: or a device name\n");
RedPrintf(" like \\\\.\\PhysicalDrive7).\n");
RedPrintf(" --help, -H\n");
RedPrintf(" Prints this usage text and exits.\n\n");
RedPrintf("Warning: This test will format the volume -- destroying all existing data.\n\n");
}
static void creat_f(int opno, long r)
{
int e;
int e1;
pathname_t f;
int fd;
fent_t *fep;
int id;
int parid;
int type;
int v;
int v1;
int esz = 0;
if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v1))
parid = -1;
else
parid = fep->id;
init_pathname(&f);
type = rtpct ? ((int)(random() % 100) > rtpct ? FT_REG : FT_RTF) : FT_REG;
e = generate_fname(fep, type, &f, &id, &v);
v |= v1;
if (!e) {
if (v) {
fent_to_name(&f, &flist[FT_DIR], fep);
RedPrintf("%d/%d: creat - no filename from %s\n",
procid, opno, f.path);
}
free_pathname(&f);
return;
}
fd = creat_path(&f, 0666);
e = fd < 0 ? errno : 0;
e1 = 0;
check_cwd();
esz = 0;
if (fd >= 0) {
add_to_flist(type, id, parid);
close(fd);
}
if (v)
RedPrintf("%d/%d: creat %s x:%d %d %d\n", procid, opno, f.path,
esz, e, e1);
free_pathname(&f);
}
static void fdatasync_f(int opno, long r)
{
int e;
pathname_t f;
int fd;
int v;
init_pathname(&f);
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: fdatasync - no filename\n",
procid, opno);
free_pathname(&f);
return;
}
fd = open_path(&f, O_WRONLY);
e = fd < 0 ? errno : 0;
check_cwd();
if (fd < 0) {
if (v)
RedPrintf("%d/%d: fdatasync - open %s failed %d\n",
procid, opno, f.path, e);
free_pathname(&f);
return;
}
e = fdatasync(fd) < 0 ? errno : 0;
if (v)
RedPrintf("%d/%d: fdatasync %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
close(fd);
}
static void fsync_f(int opno, long r)
{
int e;
pathname_t f;
int fd;
int v;
init_pathname(&f);
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: fsync - no filename\n", procid, opno);
free_pathname(&f);
return;
}
fd = open_path(&f, O_WRONLY);
e = fd < 0 ? errno : 0;
check_cwd();
if (fd < 0) {
if (v)
RedPrintf("%d/%d: fsync - open %s failed %d\n",
procid, opno, f.path, e);
free_pathname(&f);
return;
}
e = fsync(fd) < 0 ? errno : 0;
if (v)
RedPrintf("%d/%d: fsync %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
close(fd);
}
static void getdents_f(int opno, long r)
{
DIR *dir;
pathname_t f;
int v;
init_pathname(&f);
if (!get_fname(FT_DIRm, r, &f, NULL, NULL, &v))
append_pathname(&f, ".");
dir = opendir_path(&f);
check_cwd();
if (dir == NULL) {
if (v)
RedPrintf("%d/%d: getdents - can't open %s\n",
procid, opno, f.path);
free_pathname(&f);
return;
}
while (readdir64(dir) != NULL)
continue;
if (v)
RedPrintf("%d/%d: getdents %s 0\n", procid, opno, f.path);
free_pathname(&f);
closedir(dir);
}
static void link_f(int opno, long r)
{
int e;
pathname_t f;
fent_t *fep;
flist_t *flp;
int id;
pathname_t l;
int parid;
int v;
int v1;
init_pathname(&f);
if (!get_fname(FT_NOTDIR, r, &f, &flp, NULL, &v1)) {
if (v1)
RedPrintf("%d/%d: link - no file\n", procid, opno);
free_pathname(&f);
return;
}
if (!get_fname(FT_DIRm, random(), NULL, NULL, &fep, &v))
parid = -1;
else
parid = fep->id;
v |= v1;
init_pathname(&l);
e = generate_fname(fep, (int)(flp - flist), &l, &id, &v1);
v |= v1;
if (!e) {
if (v) {
fent_to_name(&l, &flist[FT_DIR], fep);
RedPrintf("%d/%d: link - no filename from %s\n",
procid, opno, l.path);
}
free_pathname(&l);
free_pathname(&f);
return;
}
e = link_path(&f, &l) < 0 ? errno : 0;
check_cwd();
if (e == 0)
add_to_flist((int)(flp - flist), id, parid);
if (v)
RedPrintf("%d/%d: link %s %s %d\n", procid, opno, f.path, l.path,
e);
free_pathname(&l);
free_pathname(&f);
}
static void mkdir_f(int opno, long r)
{
int e;
pathname_t f;
fent_t *fep;
int id;
int parid;
int v;
int v1;
if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v))
parid = -1;
else
parid = fep->id;
init_pathname(&f);
e = generate_fname(fep, FT_DIR, &f, &id, &v1);
v |= v1;
if (!e) {
if (v) {
fent_to_name(&f, &flist[FT_DIR], fep);
RedPrintf("%d/%d: mkdir - no filename from %s\n",
procid, opno, f.path);
}
free_pathname(&f);
return;
}
e = mkdir_path(&f, 0777) < 0 ? errno : 0;
check_cwd();
if (e == 0)
add_to_flist(FT_DIR, id, parid);
if (v)
RedPrintf("%d/%d: mkdir %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
}
static void read_f(int opno, long r)
{
char *buf;
int e;
pathname_t f;
int fd;
uint32_t len;
__int64_t lr;
off64_t off;
REDSTAT stb;
int v;
init_pathname(&f);
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: read - no filename\n", procid, opno);
free_pathname(&f);
return;
}
fd = open_path(&f, O_RDONLY);
e = fd < 0 ? errno : 0;
check_cwd();
if (fd < 0) {
if (v)
RedPrintf("%d/%d: read - open %s failed %d\n",
procid, opno, f.path, e);
free_pathname(&f);
return;
}
if (fstat64(fd, &stb) < 0) {
if (v)
RedPrintf("%d/%d: read - fstat64 %s failed %d\n",
procid, opno, f.path, errno);
free_pathname(&f);
close(fd);
return;
}
if (stb.st_size == 0) {
if (v)
RedPrintf("%d/%d: read - %s zero size\n", procid, opno,
f.path);
free_pathname(&f);
close(fd);
return;
}
lr = ((__int64_t) random() << 32) + random();
off = (off64_t) (lr % stb.st_size);
lseek64(fd, off, SEEK_SET);
len = (random() % (getpagesize() * 4)) + 1;
buf = malloc(len);
e = read(fd, buf, len) < 0 ? errno : 0;
free(buf);
if (v)
RedPrintf("%d/%d: read %s [%lld,%ld] %d\n",
procid, opno, f.path, (long long)off, (long int)len, e);
free_pathname(&f);
close(fd);
}
static void rename_f(int opno, long r)
{
fent_t *dfep;
int e;
pathname_t f;
fent_t *fep;
flist_t *flp;
int id;
pathname_t newf;
int oldid;
int parid;
int v;
int v1;
init_pathname(&f);
if (!get_fname(FT_ANYm, r, &f, &flp, &fep, &v1)) {
if (v1)
RedPrintf("%d/%d: rename - no filename\n", procid, opno);
free_pathname(&f);
return;
}
if (!get_fname(FT_DIRm, random(), NULL, NULL, &dfep, &v))
parid = -1;
else
parid = dfep->id;
v |= v1;
init_pathname(&newf);
e = generate_fname(dfep, (int)(flp - flist), &newf, &id, &v1);
v |= v1;
if (!e) {
if (v) {
fent_to_name(&f, &flist[FT_DIR], dfep);
RedPrintf("%d/%d: rename - no filename from %s\n",
procid, opno, f.path);
}
free_pathname(&newf);
free_pathname(&f);
return;
}
e = rename_path(&f, &newf) < 0 ? errno : 0;
check_cwd();
if (e == 0) {
if (flp - flist == FT_DIR) {
oldid = fep->id;
fix_parent(oldid, id);
}
del_from_flist((int)(flp - flist), (int)(fep - flp->fents));
add_to_flist((int)(flp - flist), id, parid);
}
if (v)
RedPrintf("%d/%d: rename %s to %s %d\n", procid, opno, f.path,
newf.path, e);
free_pathname(&newf);
free_pathname(&f);
}
static void rmdir_f(int opno, long r)
{
int e;
pathname_t f;
fent_t *fep;
int v;
init_pathname(&f);
if (!get_fname(FT_DIRm, r, &f, NULL, &fep, &v)) {
if (v)
RedPrintf("%d/%d: rmdir - no directory\n", procid, opno);
free_pathname(&f);
return;
}
e = rmdir_path(&f) < 0 ? errno : 0;
check_cwd();
if (e == 0)
del_from_flist(FT_DIR, (int)(fep - flist[FT_DIR].fents));
if (v)
RedPrintf("%d/%d: rmdir %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
}
static void stat_f(int opno, long r)
{
int e;
pathname_t f;
REDSTAT stb;
int v;
init_pathname(&f);
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: stat - no entries\n", procid, opno);
free_pathname(&f);
return;
}
e = lstat64_path(&f, &stb) < 0 ? errno : 0;
check_cwd();
if (v)
RedPrintf("%d/%d: stat %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
}
static void truncate_f(int opno, long r)
{
int e;
pathname_t f;
__int64_t lr;
off64_t off;
REDSTAT stb;
int v;
init_pathname(&f);
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: truncate - no filename\n", procid, opno);
free_pathname(&f);
return;
}
e = stat64_path(&f, &stb) < 0 ? errno : 0;
check_cwd();
if (e > 0) {
if (v)
RedPrintf("%d/%d: truncate - stat64 %s failed %d\n",
procid, opno, f.path, e);
free_pathname(&f);
return;
}
lr = ((__int64_t) random() << 32) + random();
off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
off %= maxfsize;
e = truncate64_path(&f, off) < 0 ? errno : 0;
check_cwd();
if (v)
RedPrintf("%d/%d: truncate %s %lld %d\n", procid, opno, f.path,
(long long)off, e);
free_pathname(&f);
}
static void unlink_f(int opno, long r)
{
int e;
pathname_t f;
fent_t *fep;
flist_t *flp;
int v;
init_pathname(&f);
if (!get_fname(FT_NOTDIR, r, &f, &flp, &fep, &v)) {
if (v)
RedPrintf("%d/%d: unlink - no file\n", procid, opno);
free_pathname(&f);
return;
}
e = unlink_path(&f) < 0 ? errno : 0;
check_cwd();
if (e == 0)
del_from_flist((int)(flp - flist), (int)(fep - flp->fents));
if (v)
RedPrintf("%d/%d: unlink %s %d\n", procid, opno, f.path, e);
free_pathname(&f);
}
static void write_f(int opno, long r)
{
char *buf;
int e;
pathname_t f;
int fd;
uint32_t len;
__int64_t lr;
off64_t off;
REDSTAT stb;
int v;
init_pathname(&f);
if (!get_fname(FT_REGm, r, &f, NULL, NULL, &v)) {
if (v)
RedPrintf("%d/%d: write - no filename\n", procid, opno);
free_pathname(&f);
return;
}
fd = open_path(&f, O_WRONLY);
e = fd < 0 ? errno : 0;
check_cwd();
if (fd < 0) {
if (v)
RedPrintf("%d/%d: write - open %s failed %d\n",
procid, opno, f.path, e);
free_pathname(&f);
return;
}
if (fstat64(fd, &stb) < 0) {
if (v)
RedPrintf("%d/%d: write - fstat64 %s failed %d\n",
procid, opno, f.path, errno);
free_pathname(&f);
close(fd);
return;
}
lr = ((__int64_t) random() << 32) + random();
off = (off64_t) (lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
lseek64(fd, off, SEEK_SET);
len = (random() % (getpagesize() * 4)) + 1;
buf = malloc(len);
memset(buf, nameseq & 0xff, len);
e = write(fd, buf, len) < 0 ? errno : 0;
free(buf);
if (v)
RedPrintf("%d/%d: write %s [%lld,%ld] %d\n",
procid, opno, f.path, (long long)off, (long int)len, e);
free_pathname(&f);
close(fd);
}
#if REDCONF_CHECKER == 1
static void check_f(int opno, long r)
{
int32_t ret;
const char *pszVolume = gpRedVolConf->pszPathPrefix;
(void)r;
errno = 0;
ret = red_transact(pszVolume);
if(ret == 0)
{
ret = red_umount(pszVolume);
if(ret == 0)
{
int32_t ret2;
errno = -RedCoreVolCheck();
if(errno != 0)
{
ret = -1;
}
ret2 = red_mount(pszVolume);
if(ret == 0)
{
ret = ret2;
}
if(ret2 != 0)
{
exit(1);
}
}
}
if (verbose)
{
RedPrintf("%d/%d: check %s %d\n", procid, opno, pszVolume, errno);
}
}
#endif
#endif /* FSSTRESS_SUPPORTED */