Skip navigation.
Home

Command line & Configuration File Options

[root@localhost ~]# /sbin/persistentfs --help

usage: persistentfs mountpoint [options]

Command options:
  --config=arg (=/etc/persistentfs.conf) Path to configuration file; all other
                                         parameters and options may be given on
                                         the command line or in the
                                         configuration file.
  --CreateNewFileSystem [=arg(=1)]       Create a new filesystem, overwriting
                                         any existing data stored at the same
                                         location; requests confirmation.
  --ForceCreateNewFileSystem [=arg(=1)]  Create a new filesystem, overwriting
                                         any existing data stored at the same
                                         location, without asking for
                                         confirmation.
  --RepairDismount [=arg(=1)]            Repair unclean dismount in order to
                                         mount the file system for reading and
                                         writing; requests confirmation.
  --ForceRepairDismount [=arg(=1)]       Repair unclean dismount in order to
                                         mount the file system for reading and
                                         writing, without asking for
                                         confirmation.

Required parameters:
  --S3Bucket=arg              Bucket in S3 where file system data is stored.
  --S3KeyPrefix=arg           Prefix for S3 key names where file system data is
                              stored.  Example: "pfs-"
  --AWS_ACCESS_KEY_ID=arg     AWS Access Key ID for reading and writing to S3
                              bucket.
  --AWS_SECRET_ACCESS_KEY=arg AWS Secret Access Key for reading and writing to
                              S3 bucket.

Optional parameters:
  --LogFilename=arg (=/var/log/persistentfs.log)       Path to log file.  If
                                                       you mount more than one
                                                       file system, they should
                                                       use different log files.
                                                       The log file is ignored
                                                       when the FUSE -f option
                                                       is used.
  --PidFilename=arg (=/var/run/persistentfs.pid)       Path to file where
                                                       PersistentFS records its
                                                       process id.  If you
                                                       mount more than one file
                                                       system, they should use
                                                       different pid files.
  --CacheFilename=arg (=/var/cache/persistentfs.cache) Path to cache file.  If
                                                       you mount more than one
                                                       file system, they must
                                                       use different cache
                                                       files.
  --CacheMegabytes=arg (=512)                          Size (MB) of cache file.
  --ReadOnly [=arg(=1)]                                Mount filesystem
                                                       Read-Only (boolean).
  --UseHttps [=arg(=1)]                                Use HTTPS for requests
                                                       to S3 (boolean).
  --UseS3VHostUrl [=arg(=1)]                           Use
                                                       bucket.s3.amazonaws.com
                                                       for requests to S3
                                                       (boolean); required if
                                                       bucket is in Amazon's EU
                                                       datacenter; cannot be
                                                       used if bucket name is
                                                       not a valid hostname.

Options for controlling data integrity vs. speed:
  --IndexDefaultMinFlushDelay=arg (=2000) Minimum time (ms) modified index
                                          pages are held waiting to see if they
                                          are modified again before being saved
                                          to S3.
  --IndexDefaultMaxFlushDelay=arg (=4000) Maximum time (ms) modified index
                                          pages are held before being saved to
                                          S3.
  --MaxIndexFlushBacklog=arg (=20)        Maximum backlog of modified index
                                          pages that have passed their save
                                          time limit; all file system writes
                                          will block when this backlog value is
                                          exceeded.
  --FileDefaultMinFlushDelay=arg (=5000)  Minimum time (ms) modified file
                                          blocks are held waiting to see if
                                          they are modified again before being
                                          saved to S3.
  --FileDefaultMaxFlushDelay=arg (=10000) Maximum time (ms) modified file
                                          blocks are held before being saved to
                                          S3.
  --MaxFileFlushBacklog=arg (=100)        Maximum backlog of modified file
                                          pages that have passed their save
                                          time limit; all file system writes
                                          will block when this backlog value is
                                          exceeded.

Basic tuning parameters:
  --DefaultFileBlockSize=arg (=262144) Default block size (bytes) for file data.
  --CachePageSize=arg (=262144)        Size (bytes) of a cache page; must be
                                       same size or larger than the largest file
                                       data block.
  --MaxBytesPerPage=arg (=262144)      Maximum bytes per file system index page.
  --MaxFetchBytes=arg (=12000000)      Limits number of bytes that will be down
                                       loaded in one request; this value has no
                                       effect on performance, but must be safely
                                       larger than the largest index page and
                                       largest file data block.

Advanced operation and tuning parameters:
  --S3Timeout=arg (=10)                   Timeout (sec) for requests to S3.
  --S3FastRetries=arg (=3)                Number of fast (no pause) retries
                                          after failed request to S3.
  --S3RetryBackoff=arg (=200)             Increasing pause (ms) to add after
                                          each failed request to S3.
  --MaxS3RetrySleep=arg (=2000)           Maximum pause (ms) after failed
                                          request to S3.
  --S3RetrySecondsToPauseFS=arg (=20)     Time (sec) after which repeated S3
                                          errors will cause file system writes
                                          to block until a retry succeeds 
                                          (0 = never).
  --S3RetriesToPanicFS=arg (=20000)       Number of consecutive request
                                          failures that will cause file system
                                          to panic, discarding all changes not
                                          saved to S3 and operating read-only
                                          until remounted (0 = never).
  --MaxS3ErrorsOnMount=arg (=5)           Maximum number of S3 errors that will
                                          be retried when attempting to mount
                                          file system (0 = infinite).
  --DnsCacheExpiration=arg (=120)         Expiration time (sec) for cached DNS
                                          lookups.
  --MaxFetchConnections=arg (=6)          Maximum concurrent connections
                                          downloading data from S3.
  --FileFlushThreads=arg (=8)             Number of worker threads uploading
                                          modified file data to S3.
  --MaxCacheFiles=arg (=0)                Maximum number of files that can have
                                          some or all of their data blocks in
                                          cache (0 = the maximum, 65534); uses
                                          28 bytes of virtual memory each.
  --CachePagesToFreeWhenFull=arg (=10)    Number of pages to free each time
                                          cache becomes full.
  --MinPageDataAllocSize=arg (=0)         Minimum bytes to allocate for an
                                          index page structure.
  --PageAllocIncrement=arg (=64)          Size increment when reallocating
                                          index page structure.
  --MinSegmentDataAllocSize=arg (=0)      Minimum bytes to allocate for an
                                          index page segment structure.
  --SegmentAllocIncrement=arg (=256)      Size increment when reallocating
                                          index page segment structure.
  --MaxSegmentsPerPage=arg (=1000)        Maximum segments per in-memory index
                                          page.
  --MaxBytesPerSegment=arg (=2048)        Maximum bytes per in-memory index
                                          page segment.
  --MaxKeysPerSegment=arg (=1000)         Maximum keys per in-memory index page
                                          segment.
  --PageFetchSegmentFillPercent=arg (=75) Percent of space to use in each
                                          segment when downloading an index
                                          page from S3.

Log/Tracing Options:
  --TraceFuseIn [=arg(=1)]             Log file system calls (except read, write,
                                       readdir, getattr and fsync).
  --TraceFuseOut [=arg(=1)]            Log results of file system calls (except
                                       read, write, readdir, getattr and fsync).
  --TraceReadWriteIn [=arg(=1)]        Log file system calls to read, write,
                                       readdir and getattr.
  --TraceReadWriteOut [=arg(=1)]       Log results of file system calls to read,
                                       write, readdir and getattr.
  --TraceFsync [=arg(=1)]              Log file system fsync calls and results.
  --TraceFsyncVerbose [=arg(=1)]       Verbose trace of file system fsync calls
                                       and results.
  --TraceIndexLock [=arg(=1)]          Trace locking of file system index.
  --TraceFind [=arg(=1)]               Log file system index lookups.
  --TraceFindVerbose [=arg(=1)]        Verbose trace of file system index lookups.
  --TraceIndexInsDel [=arg(=1)]        Log file system index inserts and delete.
  --TraceIndexPageOps [=arg(=1)]       Log file system index page operations.
  --TraceIndexSegmentOps [=arg(=1)]    Log file system index page segment
                                       operations.
  --TraceFlushQueues [=arg(=1)]        Trace modified data flush queues.
  --TraceFlushQueuesVerbose [=arg(=1)] Verbose trace modified data flush queues.
  --TraceExcessFlushBacklog [=arg(=1)] Trace file system write blocking caused
                                       by excess flush queue backlog.
  --TraceS3Requests [=arg(=1)] (=1)    Log requests to S3.
  --AlwaysFlushLog [=arg(=1)] (=1)     Flush the log after every output; if not
                                       set, log is flushed only after an error
                                       message.  Allows monitoring the log in
                                       "real-time", at the cost of reduced speed.
  --LibCurlVerbose [=arg(=1)]          Enable libcurl verbose logging.

Diagnostic Options:
  --CheckFsAfterPreWrite [=arg(=1)]            Perform full index check before
                                               modifying index.
  --CheckFsDuringWrite [=arg(=1)]              Perform multiple full index
                                               checks during index
                                               modifications.
  --CheckFsAfterWriteUnlock [=arg(=1)]         Perform full index check
                                               immediately after every index
                                               modification.
  --CheckFsAfterWriteCleanup [=arg(=1)]        Perform full index check after
                                               cleaning up every index
                                               modification.
  --CheckFsAfterEveryCall [=arg(=1)]           Perform full index check after
                                               every file system call.
  --CheckFsBeforePageFlush [=arg(=1)]          Perform full index check before
                                               uploading an index page to S3.
  --CheckFlushQueuesAfterEnqueuing [=arg(=1)]  Check flush queues after an
                                               entry is queued.
  --CheckFlushQueuesBeforeDequeuing [=arg(=1)] Check flush queues before an
                                               entry is dequeued.
  --NetCheckIF arg (=eth0)                     PersistentFS waits until this
                                               interface has an IP address
                                               before starting up.  Used to
                                               ensure the network is up before
                                               attempting to access S3.


The following FUSE options may be used on the command line:

general options:
    -o opt,[opt...]         mount options
    -h    --help            print help
    -V    --version         print version

FUSE options:
    -d    -o debug          enable debug output (implies -f)
    -f                      foreground operation
    -s                      disable multi-threaded operation

    -o allow_other          allow access to other users
    -o allow_root           allow access to root
    -o nonempty             allow mounts over non-empty file/dir
    -o default_permissions  enable permission checking by kernel
    -o fsname=NAME          set filesystem name
    -o subtype=NAME         set filesystem type
    -o large_read           issue large read requests (2.4 only)
    -o max_read=N           set maximum size of read requests

    -o hard_remove          immediate removal (don't hide files)
    -o use_ino              let filesystem set inode numbers
    -o readdir_ino          try to fill in d_ino in readdir
    -o direct_io            use direct I/O
    -o kernel_cache         cache files in kernel
    -o [no]auto_cache       enable caching based on modification times
    -o umask=M              set file permissions (octal)
    -o uid=N                set file owner
    -o gid=N                set file group
    -o entry_timeout=T      cache timeout for names (1.0s)
    -o negative_timeout=T   cache timeout for deleted names (0.0s)
    -o attr_timeout=T       cache timeout for attributes (1.0s)
    -o ac_attr_timeout=T    auto cache timeout for attributes (attr_timeout)
    -o intr                 allow requests to be interrupted
    -o intr_signal=NUM      signal to send on interrupt (10)
    -o modules=M1[:M2...]   names of modules to push onto filesystem stack

    -o max_write=N          set maximum size of write requests
    -o max_readahead=N      set maximum readahead
    -o async_read           perform reads asynchronously (default)
    -o sync_read            perform reads synchronously