/* | |
* 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)) | |
/* Stores the simulated current working directory. | |
*/ | |
static char szLocalCwd[1024U] = "/"; | |
/** @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[1024U]; | |
/* 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 + 1024U]; | |
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 */ | |