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