Use Bucket Size for Filesystem Stats

cmd/mount.go

@@ -264,8 +264,8 @@ func parseConfig() error {
 // Look at https://cobra.dev/ for more information
 var mountCmd = &cobra.Command{
 	Use:               "mount <mount path>",
-	Short:             "Mounts the container as a filesystem",
-	Long:              "Mounts the container as a filesystem",
+	Short:             "Mount the container as a filesystem",
+	Long:              "Mount the container as a filesystem",
 	SuggestFor:        []string{"mnt", "mout"},
 	Args:              cobra.ExactArgs(1),
 	FlagErrorHandling: cobra.ExitOnError,

cmd/root.go

@@ -56,8 +56,8 @@ var disableVersionCheck bool
 
 var rootCmd = &cobra.Command{
 	Use:               "cloudfuse",
-	Short:             "Cloudfuse is an open source project developed to provide a virtual filesystem backed by the Azure Storage.",
-	Long:              "Cloudfuse is an open source project developed to provide a virtual filesystem backed by the Azure Storage. It uses the fuse protocol to communicate with the Linux FUSE kernel module, and implements the filesystem operations using the Azure Storage REST APIs.",
+	Short:             "Cloudfuse is an open source project developed to provide a virtual filesystem backed by cloud storage.",
+	Long:              "Cloudfuse is an open source project developed to provide a virtual filesystem backed by cloud storage. It uses the FUSE protocol to communicate with the operating system, and implements filesystem operations using Azure or S3 cloud storage REST APIs.",
 	Version:           common.CloudfuseVersion,
 	FlagErrorHandling: cobra.ExitOnError,
 	SilenceUsage:      true,

cmd/version.go

@@ -37,7 +37,7 @@ var check bool
 
 var versionCmd = &cobra.Command{
 	Use:               "version",
-	Short:             "Command to print the current version along with optional check for latest version",
+	Short:             "Print the current version and optionally check for latest version",
 	FlagErrorHandling: cobra.ExitOnError,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		fmt.Println("cloudfuse version:", common.CloudfuseVersion)

component/file_cache/file_cache.go

@@ -376,6 +376,51 @@ func (c *FileCache) GetPolicyConfig(conf FileCacheOptions) cachePolicyConfig {
 	return cacheConfig
 }
 
+func (fc *FileCache) StatFs() (*common.Statfs_t, bool, error) {
+
+	statfs, populated, err := fc.NextComponent().StatFs()
+	if populated {
+		return statfs, populated, err
+	}
+
+	log.Trace("FileCache::StatFs")
+
+	// cache_size = f_blocks * f_frsize/1024
+	// cache_size - used = f_frsize * f_bavail/1024
+	// cache_size - used = vfs.f_bfree * vfs.f_frsize / 1024
+	// if cache size is set to 0 then we have the root mount usage
+	maxCacheSize := fc.maxCacheSize * MB
+	if maxCacheSize == 0 {
+		log.Err("FileCache::StatFs : Not responding to StatFs because max cache size is zero")
+		return nil, false, nil
+	}
+	usage, _ := common.GetUsage(fc.tmpPath)
+	available := maxCacheSize - usage*MB
+
+	// how much space is available on the underlying file system?
+	availableOnCacheFS, err := fc.getAvailableSize()
+	if err != nil {
+		log.Err("FileCache::StatFs : Not responding to StatFs because getAvailableSize failed. Here's why: %v", err)
+		return nil, false, err
+	}
+
+	const blockSize = 4096
+
+	stat := common.Statfs_t{
+		Blocks:  uint64(maxCacheSize) / uint64(blockSize),
+		Bavail:  uint64(max(0, available)) / uint64(blockSize),
+		Bfree:   availableOnCacheFS / uint64(blockSize),
+		Bsize:   blockSize,
+		Ffree:   1e9,
+		Files:   1e9,
+		Frsize:  blockSize,
+		Namemax: 255,
+	}
+
+	log.Debug("FileCache::StatFs : responding with free=%d avail=%d blocks=%d (bsize=%d)", stat.Bfree, stat.Bavail, stat.Blocks, stat.Bsize)
+	return &stat, true, nil
+}
+
 // isLocalDirEmpty: Whether or not the local directory is empty.
 func isLocalDirEmpty(path string) bool {
 	f, _ := common.Open(path)

component/file_cache/file_cache_linux.go

@@ -29,16 +29,14 @@ package file_cache
 
 import (
 	"io/fs"
-	"math"
 	"os"
 	"syscall"
 	"time"
 
-	"golang.org/x/sys/unix"
-
 	"github.com/Seagate/cloudfuse/common"
 	"github.com/Seagate/cloudfuse/common/log"
 	"github.com/Seagate/cloudfuse/internal"
+	"golang.org/x/sys/unix"
 )
 
 // Creates a new object attribute
@@ -144,40 +142,6 @@ func (fc *FileCache) isDownloadRequired(localPath string, blobPath string, flock
 	return downloadRequired, fileExists, attr, err
 }
 
-func (c *FileCache) StatFs() (*common.Statfs_t, bool, error) {
-	// cache_size = f_blocks * f_frsize/1024
-	// cache_size - used = f_frsize * f_bavail/1024
-	// cache_size - used = vfs.f_bfree * vfs.f_frsize / 1024
-	// if cache size is set to 0 then we have the root mount usage
-	maxCacheSize := c.maxCacheSize * MB
-	if maxCacheSize == 0 {
-		return nil, false, nil
-	}
-	usage, _ := common.GetUsage(c.tmpPath)
-	usage *= MB
-
-	available := maxCacheSize - usage
-	statfs := &unix.Statfs_t{}
-	err := unix.Statfs("/", statfs)
-	if err != nil {
-		log.Debug("FileCache::StatFs : statfs err [%s].", err.Error())
-		return nil, false, err
-	}
-
-	stat := common.Statfs_t{
-		Blocks:  uint64(maxCacheSize) / uint64(statfs.Frsize),
-		Bavail:  uint64(math.Max(0, available)) / uint64(statfs.Frsize),
-		Bfree:   statfs.Bavail,
-		Bsize:   statfs.Bsize,
-		Ffree:   statfs.Ffree,
-		Files:   statfs.Files,
-		Frsize:  statfs.Frsize,
-		Namemax: 255,
-	}
-
-	return &stat, true, nil
-}
-
 func (fc *FileCache) getAvailableSize() (uint64, error) {
 	statfs := &unix.Statfs_t{}
 	err := unix.Statfs(fc.tmpPath, statfs)

component/file_cache/file_cache_windows.go

@@ -29,7 +29,6 @@ package file_cache
 
 import (
 	"io/fs"
-	"math"
 	"os"
 	"syscall"
 	"time"
@@ -144,47 +143,6 @@ func (fc *FileCache) isDownloadRequired(localPath string, blobPath string, flock
 	return downloadRequired, fileExists, attr, err
 }
 
-func (fc *FileCache) StatFs() (*common.Statfs_t, bool, error) {
-	// cache_size = f_blocks * f_frsize/1024
-	// cache_size - used = f_frsize * f_bavail/1024
-	// cache_size - used = vfs.f_bfree * vfs.f_frsize / 1024
-	// if cache size is set to 0 then we have the root mount usage
-	maxCacheSize := fc.maxCacheSize * MB
-	if maxCacheSize == 0 {
-		return nil, false, nil
-	}
-	usage, _ := common.GetUsage(fc.tmpPath)
-	available := maxCacheSize - usage
-
-	var free, total, avail uint64
-
-	// Get path to the cache
-	pathPtr, err := windows.UTF16PtrFromString(fc.tmpPath)
-	if err != nil {
-		return nil, false, err
-	}
-	err = windows.GetDiskFreeSpaceEx(pathPtr, &free, &total, &avail)
-	if err != nil {
-		log.Debug("FileCache::StatFs : statfs err [%s].", err.Error())
-		return nil, false, err
-	}
-
-	const blockSize = 4096
-
-	stat := common.Statfs_t{
-		Blocks:  uint64(maxCacheSize) / uint64(blockSize),
-		Bavail:  uint64(math.Max(0, available)) / uint64(blockSize),
-		Bfree:   free / uint64(blockSize),
-		Bsize:   blockSize,
-		Ffree:   1e9,
-		Files:   1e9,
-		Frsize:  blockSize,
-		Namemax: 255,
-	}
-
-	return &stat, true, nil
-}
-
 func (fc *FileCache) getAvailableSize() (uint64, error) {
 	var free, total, avail uint64
 

component/libfuse/libfuse2_handler.go

@@ -333,24 +333,32 @@ func (cf *CgofuseFS) Statfs(path string, stat *fuse.Statfs_t) int {
 	if populated {
 		stat.Bsize = uint64(attr.Bsize)
 		stat.Frsize = uint64(attr.Frsize)
-		stat.Blocks = attr.Blocks
-		stat.Bavail = attr.Bavail
-		stat.Bfree = attr.Bfree
+		// cloud storage always sets free and avail to zero
+		statsFromCloudStorage := attr.Bfree == 0 && attr.Bavail == 0
+		// calculate blocks used from attr
+		blocksUnavailable := attr.Blocks - attr.Bavail
+		blocksUsed := attr.Blocks - attr.Bfree
+		// we only use displayCapacity to complement used size from cloud storage
+		if statsFromCloudStorage {
+			displayCapacityBlocks := fuseFS.displayCapacityMb * common.MbToBytes / uint64(attr.Bsize)
+			// if used > displayCapacity, then report used and show that we are out of space
+			stat.Blocks = max(displayCapacityBlocks, blocksUnavailable)
+		} else {
+			stat.Blocks = attr.Blocks
+		}
+		// adjust avail and free to make sure we display used space correctly
+		stat.Bavail = stat.Blocks - blocksUnavailable
+		stat.Bfree = stat.Blocks - blocksUsed
 		stat.Files = attr.Files
 		stat.Ffree = attr.Ffree
 		stat.Namemax = attr.Namemax
 	} else {
-		var free, total, avail uint64
-		// TODO: if display capacity is specified, should it overwrite populated Bavail?
-		total = fuseFS.displayCapacityMb * common.MbToBytes
-		avail = total
-		free = total
-
 		stat.Bsize = blockSize
 		stat.Frsize = blockSize
-		stat.Blocks = total / blockSize
-		stat.Bavail = avail / blockSize
-		stat.Bfree = free / blockSize
+		displayCapacityBlocks := fuseFS.displayCapacityMb * common.MbToBytes / blockSize
+		stat.Blocks = displayCapacityBlocks
+		stat.Bavail = displayCapacityBlocks
+		stat.Bfree = displayCapacityBlocks
 		stat.Files = 1e9
 		stat.Ffree = 1e9
 		stat.Namemax = maxNameSize

component/s3storage/client.go

@@ -36,6 +36,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"strconv"
 	"strings"
 	"syscall"
 	"time"
@@ -47,12 +48,14 @@ import (
 	"github.com/Seagate/cloudfuse/internal/stats_manager"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/middleware"
 	awsHttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
 	"github.com/aws/aws-sdk-go-v2/config"
 	"github.com/aws/aws-sdk-go-v2/credentials"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
 	"github.com/aws/aws-sdk-go-v2/service/s3/types"
 	"github.com/aws/smithy-go"
+	smithyHttp "github.com/aws/smithy-go/transport/http"
 )
 
 const (
@@ -203,7 +206,7 @@ func (cl *Client) Configure(cfg Config) error {
 	}
 
 	// Check that the provided bucket exists and that user has access to bucket
-	exists, err := cl.headBucket()
+	exists, err := cl.bucketExists()
 	if err != nil || !exists {
 		// From the aws-sdk-go-v2 documentation
 		// If the bucket does not exist or you do not have permission to access it,
@@ -277,6 +280,11 @@ func (cl *Client) SetPrefixPath(path string) error {
 	return nil
 }
 
+func (cl *Client) bucketExists() (bool, error) {
+	_, err := cl.headBucket()
+	return err != syscall.ENOENT, err
+}
+
 // CreateFile : Create a new file in the bucket/virtual directory
 func (cl *Client) CreateFile(name string, mode os.FileMode) error {
 	log.Trace("Client::CreateFile : name %s", name)
@@ -1122,3 +1130,30 @@ func (cl *Client) combineSmallBlocks(name string, blockList []*common.Block) ([]
 	}
 	return newBlockList, nil
 }
+
+func (cl *Client) GetUsedSize() (uint64, error) {
+	headBucketOutput, err := cl.headBucket()
+	if err != nil {
+		return 0, err
+	}
+
+	response, ok := middleware.GetRawResponse(headBucketOutput.ResultMetadata).(*smithyHttp.Response)
+	if !ok || response == nil {
+		return 0, fmt.Errorf("Failed GetRawResponse from HeadBucketOutput")
+	}
+
+	headerValue, ok := response.Header["X-Rstor-Size"]
+	if !ok {
+		headerValue, ok = response.Header["X-Lyve-Size"]
+	}
+	if !ok || len(headerValue) == 0 {
+		return 0, fmt.Errorf("HeadBucket response has no size header (is the endpoint not Lyve Cloud?)")
+	}
+
+	bucketSizeBytes, err := strconv.ParseUint(headerValue[0], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return bucketSizeBytes, nil
+}

component/s3storage/client_test.go

@@ -88,6 +88,7 @@ func newTestClient(configuration string) (*Client, error) {
 		partSize:                  conf.PartSizeMb * common.MbToBytes,
 		uploadCutoff:              conf.UploadCutoffMb * common.MbToBytes,
 		usePathStyle:              conf.UsePathStyle,
+		disableUsage:              conf.DisableUsage,
 	}
 	// create a Client
 	client, err := NewConnection(configForS3Client)

component/s3storage/config.go

@@ -54,6 +54,7 @@ type Options struct {
 	EnableChecksum            bool                    `config:"enable-checksum" yaml:"enable-checksum,omitempty"`
 	ChecksumAlgorithm         types.ChecksumAlgorithm `config:"checksum-algorithm" yaml:"checksum-algorithm,omitempty"`
 	UsePathStyle              bool                    `config:"use-path-style" yaml:"use-path-style,omitempty"`
+	DisableUsage              bool                    `config:"disable-usage" yaml:"disable-usage,omitempty"`
 }
 
 // ParseAndValidateConfig : Parse and validate config
@@ -77,6 +78,7 @@ func ParseAndValidateConfig(s3 *S3Storage, opt Options) error {
 	s3.stConfig.restrictedCharsWin = opt.RestrictedCharsWin
 	s3.stConfig.disableConcurrentDownload = opt.DisableConcurrentDownload
 	s3.stConfig.usePathStyle = opt.UsePathStyle
+	s3.stConfig.disableUsage = opt.DisableUsage
 
 	// Part size must be at least 5 MB and smaller than 5GB. Otherwise, set to default.
 	if opt.PartSizeMb < 5 || opt.PartSizeMb > MaxPartSizeMb {

component/s3storage/connection.go

@@ -52,6 +52,7 @@ type Config struct {
 	checksumAlgorithm         types.ChecksumAlgorithm
 	usePathStyle              bool
 	disableSymlink            bool
+	disableUsage              bool
 }
 
 // TODO: move s3AuthConfig to s3auth.go
@@ -112,4 +113,5 @@ type S3Connection interface {
 	StageAndCommit(name string, bol *common.BlockOffsetList) error
 
 	NewCredentialKey(_, _ string) error
+	GetUsedSize() (uint64, error)
 }

component/s3storage/s3storage.go

@@ -476,6 +476,43 @@ func (s3 *S3Storage) FlushFile(options internal.FlushFileOptions) error {
 	return s3.storage.StageAndCommit(options.Handle.Path, options.Handle.CacheObj.BlockOffsetList)
 }
 
+const blockSize = 4096
+
+func (s3 *S3Storage) StatFs() (*common.Statfs_t, bool, error) {
+	if s3.stConfig.disableUsage {
+		return nil, false, nil
+	}
+
+	log.Trace("S3Storage::StatFs")
+	// cache_size = f_blocks * f_frsize/1024
+	// cache_size - used = f_frsize * f_bavail/1024
+	// cache_size - used = vfs.f_bfree * vfs.f_frsize / 1024
+	// if cache size is set to 0 then we have the root mount usage
+	sizeUsed, err := s3.storage.GetUsedSize()
+	if err != nil {
+		// TODO: will returning EIO break any applications that depend on StatFs?
+		return nil, true, err
+	}
+
+	stat := common.Statfs_t{
+		Blocks: sizeUsed / blockSize,
+		// there is no set capacity limit in cloud storage
+		// so we use zero for free and avail
+		// this zero value is used in the libfuse component to recognize that cloud storage responded
+		Bavail:  0,
+		Bfree:   0,
+		Bsize:   blockSize,
+		Ffree:   1e9,
+		Files:   1e9,
+		Frsize:  blockSize,
+		Namemax: 255,
+	}
+
+	log.Debug("S3Storage::StatFs : responding with free=%d avail=%d blocks=%d (bsize=%d)", stat.Bfree, stat.Bavail, stat.Blocks, stat.Bsize)
+
+	return &stat, true, nil
+}
+
 // TODO: decide if the TODO below is relevant and delete if not
 // TODO : Below methods are pending to be implemented
 // FlushFile(*handlemap.Handle) error