| /* | |
| * 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 */ | |