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