IsMounted checks if the given source path is mounted in the given
destination path. It does so by reading the /proc/mounts file.
mounted, err := fs.IsMounted("tmpfs", "/tmp")
if err != nil {
fmt.Printf("Error checking if /tmp is mounted: %v", err)
return
}
fmt.Printf("/tmp is mounted: %v", mounted)
{
mounts, err := os.Open("/proc/mounts")
if err != nil {
return false, fmt.Errorf("error opening /proc/mounts: %w", err)
}
defer mounts.Close()
scanner := bufio.NewScanner(mounts)
for scanner.Scan() {
line := scanner.Text()
if strings.Contains(line, source) && strings.Contains(line, destination) {
return true, nil
}
}
return false, nil
}Mount mounts the given source path in the given destination path. It also
creates the destination path if it does not exist. An error is returned if
the source path does not exist.
Notes (for developers):
Avoid mapping the fsType into a custom type, as it would require further
maintenance once a new filesystem type is added to Vanilla OS.
err := fs.Mount("/dev/sda1", "/mnt", "ext4", "", syscall.MS_RDONLY)
if err != nil {
fmt.Printf("Error mounting /dev/sda1: %v", err)
return
}
{
info, err := os.Stat(source)
if err != nil {
return err
}
if info.IsDir() {
_ = os.MkdirAll(destination, 0o755)
} else {
file, _ := os.Create(destination)
defer func() { _ = file.Close() }()
}
return syscall.Mount(source, destination, fsType, mode, data)
}MountBind mounts bind the given source path in the given destination path.
err := fs.MountBind("/bruce", "/batman")
if err != nil {
fmt.Printf("Error bind mounting /batman: %v", err)
return
}
This is just a wrapper of the Mount function, for convenience.
{
return Mount(
src,
dest,
"bind",
"",
syscall.MS_BIND|
syscall.MS_REC|
syscall.MS_RDONLY|
syscall.MS_NOSUID|
syscall.MS_NOEXEC|
syscall.MS_NODEV|
syscall.MS_PRIVATE,
)
}MountOverlay mounts the given lower, upper and work directories in the
given destination path as an overlay filesystem.
err := fs.MountOverlay("/batman/lower", "/batman/upper", "/batman/work")
if err != nil {
fmt.Printf("Error overlay mounting /batman: %v", err)
return
}
This is just a wrapper of the Mount function, for convenience.
{
return Mount(
"overlay",
lowerDir,
"overlay",
fmt.Sprintf(
"lowerdir=%s,upperdir=%s,workdir=%s,userxattr",
lowerDir, upperDir, workDir,
),
0,
)
}MountFuseOverlay mounts the given lower, upper and work directories in the
given destination path as an overlay filesystem using fuse-overlayfs.
err := fs.MountFuseOverlay("/batman", "/batman/lower", "/batman/upper", "/batman/work")
if err != nil {
fmt.Printf("Error fuse-overlayfs mounting /batman: %v", err)
return
}
This implementation uses the fuse-overlayfs command-line tool, if that
is not available in the system, this function will return an error.
{
// TODO: Replace the command-line tool with a Go library, if available.
c := exec.Command(
"fuse-overlayfs",
targetDir,
"-o",
fmt.Sprintf(
"lowerdir=%s,upperdir=%s,workdir=%s",
lowerDir, upperDir, workDir,
),
)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
return c.Run()
}Unmount unmounts the given path. An error is returned if the path is not
mounted.
err := fs.Unmount("/mnt")
if err != nil {
fmt.Printf("Error unmounting /mnt: %v", err)
return
}
{
return syscall.Unmount(target, 0)
}UnmountFuseOverlay unmounts the given path using the fuse-overlayfs command-
line tool. An error is returned if the path is not mounted.
err := fs.UnmountFuseOverlay("/batman")
if err != nil {
fmt.Printf("Error fuse-overlayfs unmounting /batman: %v", err)
return
}
This implementation uses the fuse-overlayfs command-line tool, if that
is not available in the system, this function will return an error.
{
// TODO: Replace the command-line tool with a Go library, if available.
c := exec.Command("fusermount", "-u", targetDir)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
return c.Run()
}AtomicSwap atomically swaps two files or directories
err := fs.AtomicSwap("/tmp/file1", "/tmp/file2")
if err != nil {
fmt.Printf("Error swapping files: %v", err)
return
}
{
orig, err := os.Open(sourcePath)
if err != nil {
return err
}
newfile, err := os.Open(destinationPath)
if err != nil {
return err
}
err = unix.Renameat2(int(orig.Fd()), sourcePath, int(newfile.Fd()), destinationPath, unix.RENAME_EXCHANGE)
if err != nil {
return err
}
return nil
}GetFileDiff compares the content of two files and returns the changes
diff, err := fs.GetFileDiff("/tmp/batman", "/tmp/robin")
if err != nil {
fmt.Printf("Error getting file diff: %v", err)
return
}
fmt.Printf("Added lines: %v\n", diff.AddedLines)
fmt.Printf("Removed lines: %v\n", diff.RemovedLines)
{
firstContent, err := os.ReadFile(firstFile)
if err != nil {
return types.FileDiffInfo{}, err
}
secondContent, err := os.ReadFile(secondFile)
if err != nil {
return types.FileDiffInfo{}, err
}
diff := types.FileDiffInfo{}
dmp := diffmatchpatch.New()
diffs := dmp.DiffMain(string(firstContent), string(secondContent), false)
for _, d := range diffs {
switch d.Type {
case diffmatchpatch.DiffInsert:
diff.AddedLines = append(diff.AddedLines, d.Text)
case diffmatchpatch.DiffDelete:
diff.RemovedLines = append(diff.RemovedLines, d.Text)
}
}
return diff, nil
}GetDiskList returns a list of disks on the system
disks, err := fs.GetDiskList()
if err != nil {
fmt.Printf("Error getting disk list: %v", err)
return
}
for _, disk := range disks {
fmt.Printf("Disk: %s\n", disk.Path)
fmt.Printf("Size: %d\n", disk.Size)
fmt.Printf("HumanSize: %s\n", disk.HumanSize)
for _, partition := range disk.Partitions {
fmt.Printf("Partition: %s\n", partition.Path)
fmt.Printf("Size: %d\n", partition.Size)
fmt.Printf("HumanSize: %s\n", partition.HumanSize)
fmt.Printf("Filesystem: %s\n", partition.Filesystem)
fmt.Printf("Mountpoint: %s\n", partition.Mountpoint)
fmt.Printf("Label: %s\n", partition.Label)
fmt.Printf("UUID: %s\n", partition.UUID)
fmt.Printf("PARTUUID: %s\n", partition.PARTUUID)
fmt.Printf("Flags: %v\n", partition.Flags)
}
}
{
var disks []types.DiskInfo
files, err := os.ReadDir("/sys/class/block")
if err != nil {
return nil, err
}
diskMap := make(map[string]types.DiskInfo)
for _, file := range files {
name := file.Name()
if isPartition(name) {
continue
}
// Skip non-disk entries
if strings.HasPrefix(name, "loop") ||
strings.HasPrefix(name, "ram") ||
strings.HasPrefix(name, "zram") {
continue
}
diskPath := filepath.Join("/dev", name)
info, err := GetDiskInfo(diskPath)
if err != nil {
return nil, err
}
partitions, err := GetPartitionList(diskPath)
if err != nil {
return nil, err
}
diskInfo := types.DiskInfo{
BaseInfo: info,
Partitions: partitions,
}
diskMap[diskPath] = diskInfo
}
for _, disk := range diskMap {
disks = append(disks, disk)
}
return disks, nil
}GetPartitionList returns a list of disk partitions on the specified disk
partitions, err := fs.GetPartitionList("/dev/sda")
if err != nil {
fmt.Printf("Error getting partition list: %v", err)
return
}
for _, partition := range partitions {
fmt.Printf("Partition: %s\n", partition.Path)
fmt.Printf("Size: %d\n", partition.Size)
fmt.Printf("HumanSize: %s\n", partition.HumanSize)
}
{
var partitions []types.PartitionInfo
files, err := os.ReadDir(filepath.Join("/sys/class/block", filepath.Base(diskPath)))
if err != nil {
return nil, err
}
for _, file := range files {
name := file.Name()
// Skip non-partition entries
if !strings.HasPrefix(name, filepath.Base(diskPath)) {
continue
}
partitionPath := filepath.Join("/dev", name)
info, err := GetDiskInfo(partitionPath)
if err != nil {
return nil, err
}
partitionInfo := types.PartitionInfo{
BaseInfo: info,
}
partitions = append(partitions, partitionInfo)
}
return partitions, nil
}GetDiskInfo returns information about a specific disk partition
info, err := fs.GetDiskInfo("/dev/sda1")
if err != nil {
fmt.Printf("Error getting partition info: %v", err)
return
}
fmt.Printf("Path: %s\n", info.Path)
fmt.Printf("Size: %d\n", info.Size)
fmt.Printf("HumanSize: %s\n", info.HumanSize)
{
info := types.BaseInfo{
Path: partitionPath,
}
sizePath := filepath.Join("/sys/class/block", filepath.Base(partitionPath), "size")
size, err := os.ReadFile(sizePath)
if err != nil {
return info, err
}
sectorSize := 512
info.Size = int64(sectorSize) * int64(parseUint64(strings.TrimSpace(string(size))))
info.HumanSize = GetHumanSize(info.Size)
fsInfo := GetFilesystemInfo(partitionPath)
info.Filesystem = fsInfo["TYPE"]
info.Label = fsInfo["LABEL"]
info.UUID = fsInfo["UUID"]
info.PARTUUID = fsInfo["PARTUUID"]
return info, nil
}GetFilesystemInfo returns information about the filesystem of a file or
partition by reading from /etc/mtab.
{
info := make(map[string]string)
// FS information
u := udev.Udev{}
d := u.NewDeviceFromSyspath(filepath.Join("/sys/class/block", filepath.Base(path)))
info["LABEL"] = d.PropertyValue("ID_FS_LABEL")
info["TYPE"] = d.PropertyValue("ID_FS_TYPE")
info["UUID"] = d.PropertyValue("ID_FS_UUID")
info["PARTUUID"] = d.PropertyValue("ID_PART_ENTRY_UUID")
return info
}parseUint64 parses a string into a uint64 or returns 0 if parsing fails
{
value, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return 0
}
return value
}GetHumanSize converts the size from bytes to a human-readable format.
For example, 1024 bytes would be converted to "1 kB".
fmt.Println(GetHumanSize(1024)) // 1 kB
{
const (
kB = 1024.0
mB = kB * 1024.0
gB = mB * 1024.0
tB = gB * 1024.0
)
sizeFloat := float64(size)
switch {
case size < int64(kB):
return fmt.Sprintf("%d B", size)
case size < int64(mB):
return fmt.Sprintf("%.2f kB", sizeFloat/kB)
case size < int64(gB):
return fmt.Sprintf("%.2f MB", sizeFloat/mB)
case size < int64(tB):
return fmt.Sprintf("%.2f GB", sizeFloat/gB)
default:
return fmt.Sprintf("%.2f TB", sizeFloat/tB)
}
}isPartition returns true if the specified block device is a partition
{
path := filepath.Join("/sys/class/block", deviceName, "partition")
info, err := os.Stat(path)
if err == nil && !info.IsDir() {
return true
}
return false
}GetFileList returns a list of files in the specified directory.
If recursive is true, the function will recursively search for files, if
fullPaths is true, the full path of the file will be returned instead of
the relative path.
fileList, err := fs.GetFileList("/batmans/cave", true, false)
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
for _, file := range fileList {
fmt.Printf("Path: %s\n", file.Path)
fmt.Printf("Size: %d\n", file.Size)
fmt.Printf("Permissions: %s\n", file.Permissions.String())
fmt.Printf("Extension: %s\n", file.Extension)
}
{
var fileList []types.FileInfo
walkFunc := func(path string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
if !recursive && path != directory {
return fs.SkipDir
}
if d.IsDir() {
return nil
}
info, err := d.Info()
if err != nil {
return err
}
filePath := path
if !fullPaths {
filePath, _ = filepath.Rel(directory, path)
}
permissions := convertPermissions(info.Mode())
fileList = append(fileList, types.FileInfo{
Path: filePath,
ParentPath: filepath.Dir(filePath),
IsDirectory: false,
Size: info.Size(),
Permissions: permissions,
Extension: GetFileExtension(path),
})
return nil
}
if err := filepath.WalkDir(directory, walkFunc); err != nil {
return nil, err
}
return fileList, nil
}convertPermissions converts file mode to Permission type
{
return types.Permission{
OwnerRead: mode&0400 != 0,
OwnerWrite: mode&0200 != 0,
OwnerExecute: mode&0100 != 0,
GroupRead: mode&0040 != 0,
GroupWrite: mode&0020 != 0,
GroupExecute: mode&0010 != 0,
OthersRead: mode&0004 != 0,
OthersWrite: mode&0002 != 0,
OthersExecute: mode&0001 != 0,
}
}GetFile returns the file info of the specified file.
If fullPath is true, the full path of the file will be returned instead of
the relative path.
file, err := fs.GetFile("/batmans/cave/batmobile.txt", false)
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
fmt.Printf("Path: %s\n", file.Path)
fmt.Printf("Size: %d\n", file.Size)
fmt.Printf("Permissions: %s\n", file.Permissions.String())
{
info, err := os.Stat(filePath)
if err != nil {
return types.FileInfo{}, err
}
permissions := convertPermissions(info.Mode())
file := types.FileInfo{
Path: filePath,
ParentPath: filepath.Dir(filePath),
IsDirectory: info.IsDir(),
Size: info.Size(),
Permissions: permissions,
Extension: GetFileExtension(filePath),
}
if !fullPath {
file.Path, _ = filepath.Rel(".", filePath)
}
return file, nil
}GetFileExtension returns the extension of the given file
extension := fs.GetFileExtension("/batmans/cave/batmobile.txt")
fmt.Printf("Extension: %s\n", extension)
{
ext := filepath.Ext(filePath)
if ext != "" {
return strings.TrimPrefix(ext, ".")
}
return ""
}IsFile checks whether the given path is a regular file
if fs.IsFile("/batmans/cave/batmobile.txt") {
fmt.Println("It's a file!")
}
{
info, err := os.Stat(filePath)
if err != nil {
return false
}
return info.Mode().IsRegular()
}IsDirectory checks whether the given path is a directory
if fs.IsDirectory("/batmans/cave") {
fmt.Println("It's a directory!")
}
{
info, err := os.Stat(dirPath)
if err != nil {
return false
}
return info.Mode().IsDir()
}GetFileSize returns the size of the specified file in bytes
size := fs.GetFileSize("/batmans/cave/batmobile.txt")
fmt.Printf("Size: %d\n", size)
{
info, err := os.Stat(filePath)
if err != nil {
return 0
}
return info.Size()
}WriteFileContent writes content to the specified file
err := fs.WriteFileContent("/tmp/batman", "I'm Batman!")
if err != nil {
fmt.Printf("Error writing file content: %v", err)
return
}
{
err := os.WriteFile(filePath, []byte(content), 0644)
if err != nil {
return err
}
return nil
}FileExists checks if a file exists
if fs.FileExists("/tmp/batman") {
fmt.Println("The file exists!")
}
{
_, err := os.Stat(filePath)
return err == nil
}DirectoryExists checks if a directory exists
if fs.DirectoryExists("/tmp/batman") {
fmt.Println("The directory exists!")
}
{
fileInfo, err := os.Stat(directoryPath)
return err == nil && fileInfo.IsDir()
}ListDirectories returns a list of directories in the specified directory
directories, err := fs.ListDirectories("/tmp")
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
for _, directory := range directories {
fmt.Printf("Directory: %s\n", directory)
}
{
var directories []string
files, err := os.ReadDir(directoryPath)
if err != nil {
return nil, err
}
for _, file := range files {
if file.IsDir() {
directories = append(directories, file.Name())
}
}
return directories, nil
}CopyFile copies the contents of one file to another
err := fs.CopyFile("/tmp/batman", "/tmp/robin")
if err != nil {
fmt.Printf("Error copying file: %v", err)
return
}
{
source, err := os.ReadFile(sourcePath)
if err != nil {
return err
}
err = os.WriteFile(destinationPath, source, 0644)
if err != nil {
return err
}
return nil
}MoveFile moves a file from one location to another
err := fs.MoveFile("/tmp/batman", "/tmp/robin")
if err != nil {
fmt.Printf("Error moving file: %v", err)
return
}
{
err := os.Rename(sourcePath, destinationPath)
if err != nil {
return err
}
return nil
}DeleteFile deletes a file
err := fs.DeleteFile("/tmp/batman")
if err != nil {
fmt.Printf("Error deleting file: %v", err)
return
}
{
err := os.Remove(filePath)
if err != nil {
return err
}
return nil
}CreateDirectory creates a new directory
err := fs.CreateDirectory("/tmp/batman")
if err != nil {
fmt.Printf("Error creating directory: %v", err)
return
}
{
err := os.Mkdir(directoryPath, 0755)
if err != nil {
return err
}
return nil
}DeleteDirectory deletes a directory and its contents
err := fs.DeleteDirectory("/tmp/batman")
if err != nil {
fmt.Printf("Error deleting directory: %v", err)
return
}
{
err := os.RemoveAll(directoryPath)
if err != nil {
return err
}
return nil
}import "bufio"import "fmt"import "os"import "os/exec"import "strings"import "syscall"import "os"import "golang.org/x/sys/unix"import "os"import "github.com/sergi/go-diff/diffmatchpatch"import "github.com/vanilla-os/sdk/pkg/v1/fs/types"import "fmt"import "os"import "path/filepath"import "strconv"import "strings"import "github.com/jochenvg/go-udev"import "github.com/vanilla-os/sdk/pkg/v1/fs/types"import "io/fs"import "os"import "path/filepath"import "strings"import "github.com/vanilla-os/sdk/pkg/v1/fs/types"import "os"