func mountServer(token, mountpoint string) (*fuse.Server, error) { if err := os.MkdirAll(filepath.Dir(mountpoint), 0755); err != nil { return nil, err } client, err := vault.Client(token) if err != nil { return nil, err } kwfs, root := fs.NewFs(client) mountOptions := &fuse.MountOptions{ AllowOther: true, Name: kwfs.String(), Options: []string{"default_permissions"}, } // Empty Options struct avoids setting a global uid/gid override. conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{}) server, err := fuse.NewServer(conn.RawFS(), mountpoint, mountOptions) if err != nil { log.Printf("Mount fail: %v\n", err) return nil, err } go server.Serve() return server, nil }
func newFuseFS(tmpDir string, rpcFS *RpcFs, writableRoot string) (*fuseFS, error) { tmpDir, err := ioutil.TempDir(tmpDir, "termite-task") if err != nil { return nil, err } fs := &fuseFS{ writableRoot: strings.TrimLeft(writableRoot, "/"), workers: map[string]*workerFS{}, rpcFS: rpcFS, rpcNodeFS: pathfs.NewPathNodeFs(&multiRPCFS{rpcFS}, &pathfs.PathNodeFsOptions{ClientInodes: true}), tmpDir: tmpDir, mount: filepath.Join(tmpDir, "mnt"), } if err := os.Mkdir(fs.mount, 0755); err != nil { return nil, err } fs.fsConnector = nodefs.NewFileSystemConnector(fs.rpcNodeFS.Root(), nodeFSOptions()) fuseOpts := fuse.MountOptions{} if os.Geteuid() == 0 { fuseOpts.AllowOther = true } fs.server, err = fuse.NewServer(fs.fsConnector.RawFS(), fs.mount, &fuseOpts) if err != nil { return nil, err } go fs.server.Serve() return fs, nil }
// this function was borrowed from https://raw.githubusercontent.com/hanwen/go-fuse/master/example/memfs/main.go func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") flag.Parse() if flag.NArg() < 3 { fmt.Println("usage: appendfs <mountpoint> <datafile> <metadatafile>") os.Exit(2) } mountPoint := flag.Arg(0) fs, err := appendfs.NewAppendFS(flag.Arg(1), flag.Arg(2)) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } options := nodefs.NewOptions() options.Owner = nil conn := nodefs.NewFileSystemConnector(fs.Root(), options) server, err := fuse.NewServer(conn.RawFS(), mountPoint, nil) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } server.SetDebug(*debug) fmt.Println("Mounted!") server.Serve() fmt.Println("Closing filesystem") err = fs.Close() if err != nil { fmt.Printf("Unmount fail: %v\n", err) os.Exit(1) } }
func setupMemNodeTest(t *testing.T) (wd string, root Node, clean func()) { tmp, err := ioutil.TempDir("", "go-fuse-memnode_test") if err != nil { t.Fatalf("TempDir failed: %v", err) } back := tmp + "/backing" os.Mkdir(back, 0700) root = NewMemNodeFSRoot(back) mnt := tmp + "/mnt" os.Mkdir(mnt, 0700) connector := NewFileSystemConnector(root, &Options{ EntryTimeout: testTtl, AttrTimeout: testTtl, NegativeTimeout: 0.0, }) connector.SetDebug(VerboseTest()) state, err := fuse.NewServer(connector.RawFS(), mnt, nil) if err != nil { t.Fatal("NewServer", err) } //me.state.SetDebug(false) state.SetDebug(VerboseTest()) // Unthreaded, but in background. go state.Serve() return mnt, root, func() { state.Unmount() os.RemoveAll(tmp) } }
func main() { if len(os.Args) < 2 { fmt.Fprintf(os.Stderr, "Usage: %s <mountpoint>\n", os.Args[0]) os.Exit(1) } mountOptions := &fuse.MountOptions{ AllowOther: true, Name: "boardfs", Options: []string{"default_permissions"}, } mountpoint := os.Args[1] root := boardfs.NewRootNode() conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{}) server, err := fuse.NewServer(conn.RawFS(), mountpoint, mountOptions) if err != nil { log.Fatalf("Mount fail: %v\n", err) } // shutdown fuseserver on SIGINT sigchan := make(chan os.Signal, 1) signal.Notify(sigchan, os.Interrupt, os.Kill) go func() { sig := <-sigchan fmt.Print("\nExiting on ", sig, "\n") server.Unmount() }() server.Serve() signal.Stop(sigchan) }
// Start takes a path to the directory where the goinfo file system // should be mounted. If the directory does not exist, it will be // created. Start will return an error if the directory cannot be // created or if the file system cannot be mounted at this location // for any reason. func Start(mountpoint string) error { //already mounted there if _, found := servers[mountpoint]; found { return nil } if _, err := os.Stat(mountpoint); os.IsNotExist(err) { if err = os.Mkdir(mountpoint, 0755); err != nil { return err } } nfs := pathfs.NewPathNodeFs(gfs, nil) conn := nodefs.NewFileSystemConnector(nfs.Root(), nil) server, err := fuse.NewServer(conn.RawFS(), mountpoint, &fuse.MountOptions{AllowOther: true}) if err != nil { return errors.New("Failed to mount monitoring fs at " + mountpoint + ": " + err.Error()) } servers[mountpoint] = server //start handling the fs calls go server.Serve() return nil }
func (d *driver) mountServer(mountpoint string) (*fuse.Server, error) { if err := os.MkdirAll(filepath.Dir(mountpoint), 0755); err != nil { return nil, err } conf := api.DefaultConfig() client, err := api.NewClient(conf) if err != nil { return nil, err } ownership := keywhizfs.NewOwnership("root", "root") kwfs, root := NewFs(client, ownership) mountOptions := &fuse.MountOptions{ AllowOther: true, Name: kwfs.String(), Options: []string{"default_permissions"}, } // Empty Options struct avoids setting a global uid/gid override. conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{}) server, err := fuse.NewServer(conn.RawFS(), mountpoint, mountOptions) if err != nil { log.Printf("Mount fail: %v\n", err) return nil, err } go server.Serve() return server, nil }
func main() { debug := flag.Bool("debug", false, "print debugging messages.") flag.Parse() if flag.NArg() < 2 { _, program_name := path.Split(os.Args[0]) fmt.Fprintf(os.Stderr, "usage: %s DEVICE MOUNTPOINT\n", program_name) os.Exit(2) } device := flag.Arg(0) mountpoint := flag.Arg(1) //fd, err := os.Open(device) //if err != nil { // fmt.Printf("unable to open %v: %v\n", device, err) // os.Exit(sys.EINVAL) //} //hfs.Fd = fd fs := NewHammerFileSystem(device) server, err := fuse.NewServer(fuse.RawFileSystem(fs), mountpoint, nil) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } server.SetDebug(*debug) fmt.Println("Mounted!") server.Serve() }
func pathfsFrontend(key []byte, cipherdir string, mountpoint string, debug bool, openssl bool) *fuse.Server { finalFs := pathfs_frontend.NewFS(key, cipherdir, openssl) pathFsOpts := &pathfs.PathNodeFsOptions{ClientInodes: true} pathFs := pathfs.NewPathNodeFs(finalFs, pathFsOpts) fuseOpts := &nodefs.Options{ // These options are to be compatible with libfuse defaults, // making benchmarking easier. NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } conn := nodefs.NewFileSystemConnector(pathFs.Root(), fuseOpts) var mOpts fuse.MountOptions mOpts.AllowOther = false // Set values shown in "df -T" and friends // First column, "Filesystem" mOpts.Options = append(mOpts.Options, "fsname="+cipherdir) // Second column, "Type", will be shown as "fuse." + Name mOpts.Name = "gocryptfs" srv, err := fuse.NewServer(conn.RawFS(), mountpoint, &mOpts) if err != nil { fmt.Printf("Mount failed: %v", err) os.Exit(ERREXIT_MOUNT) } srv.SetDebug(debug) return srv }
func MountFileSystem(mountpoint string, nodeFs FileSystem, opts *Options) (*fuse.Server, *FileSystemConnector, error) { conn := NewFileSystemConnector(nodeFs, opts) s, err := fuse.NewServer(conn.RawFS(), mountpoint, nil) if err != nil { return nil, nil, err } return s, conn, nil }
func mount() error { var err error if fs != nil || server != nil { // already mounting return nil } // create mountpoint os.Mkdir(TEST_MOUNTPOINT, 0777) // config config := &config.Config{ MountPoint: TEST_MOUNTPOINT, ContainerName: TEST_CONTAINER_NAME, CreateContainer: true, Debug: true, NoDaemon: true, } // swift swift := openstack.NewSwift(config) if err = swift.Auth(); err != nil { return err } swift.DeleteContainer() // mapper mapper, err := mapper.NewObjectMapper(config) if err != nil { return err } // initialize filesystem fs = NewObjectFileSystem(config, mapper) path := pathfs.NewPathNodeFs(fs, nil) con := nodefs.NewFileSystemConnector(path.Root(), &nodefs.Options{}) opts := &fuse.MountOptions{ Name: "test-filesystem", FsName: "test-filesystem", } // create server and do mount with dedicated goroutine server, err = fuse.NewServer(con.RawFS(), TEST_MOUNTPOINT, opts) if err != nil { return err } go func() { server.Serve() }() server.WaitMount() return nil }
// Create and mount filesystem. func NewTestCase(t *testing.T) *testCase { tc := &testCase{} tc.tester = t // Make sure system setting does not affect test. syscall.Umask(0) const name string = "hello.txt" const subdir string = "subdir" var err error tc.tmpDir, err = ioutil.TempDir("", "go-fuse") if err != nil { t.Fatalf("TempDir failed: %v", err) } tc.orig = tc.tmpDir + "/orig" tc.mnt = tc.tmpDir + "/mnt" tc.Mkdir(tc.orig, 0700) tc.Mkdir(tc.mnt, 0700) tc.mountFile = filepath.Join(tc.mnt, name) tc.mountSubdir = filepath.Join(tc.mnt, subdir) tc.origFile = filepath.Join(tc.orig, name) tc.origSubdir = filepath.Join(tc.orig, subdir) var pfs pathfs.FileSystem pfs = pathfs.NewLoopbackFileSystem(tc.orig) pfs = pathfs.NewLockingFileSystem(pfs) tc.pathFs = pathfs.NewPathNodeFs(pfs, &pathfs.PathNodeFsOptions{ ClientInodes: true}) tc.connector = nodefs.NewFileSystemConnector(tc.pathFs.Root(), &nodefs.Options{ EntryTimeout: testTtl, AttrTimeout: testTtl, NegativeTimeout: 0.0, Debug: VerboseTest(), }) tc.state, err = fuse.NewServer( fuse.NewRawFileSystem(tc.connector.RawFS()), tc.mnt, &fuse.MountOptions{ SingleThreaded: true, Debug: VerboseTest(), }) if err != nil { t.Fatal("NewServer:", err) } go tc.state.Serve() if err := tc.state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } return tc }
func main() { var Usage = func() { fmt.Fprintf(os.Stderr, "Usage: %s [options] url mountpoint\n", os.Args[0]) flag.PrintDefaults() } flag.Parse() if flag.NArg() != 2 { Usage() os.Exit(1) } serverURL, mountpoint := flag.Args()[0], flag.Args()[1] logConfig := klog.Config{*debug, mountpoint} logger = klog.New("kwfs_main", logConfig) defer logger.Close() if *certFile == "" { logger.Debugf("Certificate file not specified, assuming certificate also in %s", *keyFile) certFile = keyFile } lockMemory() clientTimeout := time.Duration(*timeoutSeconds) * time.Second freshThreshold := 200 * time.Millisecond backendDeadline := 500 * time.Millisecond maxWait := clientTimeout + backendDeadline timeouts := keywhizfs.Timeouts{freshThreshold, backendDeadline, maxWait} client := keywhizfs.NewClient(*certFile, *keyFile, *caFile, serverURL, clientTimeout, logConfig, *ping) ownership := keywhizfs.NewOwnership(*user, *group) kwfs, root, err := keywhizfs.NewKeywhizFs(&client, ownership, timeouts, logConfig) if err != nil { log.Fatalf("KeywhizFs init fail: %v\n", err) } mountOptions := &fuse.MountOptions{ AllowOther: true, Name: kwfs.String(), Options: []string{"default_permissions"}, } // Empty Options struct avoids setting a global uid/gid override. conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{}) server, err := fuse.NewServer(conn.RawFS(), mountpoint, mountOptions) if err != nil { log.Fatalf("Mount fail: %v\n", err) } server.Serve() }
// Create and mount filesystem. func NewTestCase(t *testing.T) *testCase { me := &testCase{} me.tester = t // Make sure system setting does not affect test. syscall.Umask(0) const name string = "hello.txt" const subdir string = "subdir" var err error me.tmpDir, err = ioutil.TempDir("", "go-fuse") if err != nil { t.Fatalf("TempDir failed: %v", err) } me.orig = me.tmpDir + "/orig" me.mnt = me.tmpDir + "/mnt" os.Mkdir(me.orig, 0700) os.Mkdir(me.mnt, 0700) me.mountFile = filepath.Join(me.mnt, name) me.mountSubdir = filepath.Join(me.mnt, subdir) me.origFile = filepath.Join(me.orig, name) me.origSubdir = filepath.Join(me.orig, subdir) var pfs pathfs.FileSystem pfs = pathfs.NewLoopbackFileSystem(me.orig) pfs = pathfs.NewLockingFileSystem(pfs) me.pathFs = pathfs.NewPathNodeFs(pfs, &pathfs.PathNodeFsOptions{ ClientInodes: true}) me.connector = nodefs.NewFileSystemConnector(me.pathFs.Root(), &nodefs.Options{ EntryTimeout: testTtl, AttrTimeout: testTtl, NegativeTimeout: 0.0, }) me.connector.SetDebug(VerboseTest()) me.state, err = fuse.NewServer( fuse.NewRawFileSystem(me.connector.RawFS()), me.mnt, &fuse.MountOptions{SingleThreaded: true}) if err != nil { t.Fatal("NewServer:", err) } me.state.SetDebug(VerboseTest()) // Unthreaded, but in background. go me.state.Serve() me.state.WaitMount() return me }
// Mounts a filesystem with the given root node on the given directory func MountRoot(mountpoint string, root Node, opts *Options) (*fuse.Server, *FileSystemConnector, error) { conn := NewFileSystemConnector(root, opts) mountOpts := fuse.MountOptions{} if opts != nil && opts.Debug { mountOpts.Debug = opts.Debug } s, err := fuse.NewServer(conn.RawFS(), mountpoint, &mountOpts) if err != nil { return nil, nil, err } return s, conn, nil }
func main() { fsdebug := flag.Bool("fs-debug", false, "switch on FS debugging") p4port := flag.String("p4-server", "", "address for P4 server") p4binary := flag.String("p4-binary", "p4", "binary for P4 commandline client") backingDir := flag.String("backing", "", "directory to store file contents.") profile := flag.String("profile", "", "record cpu profile.") flag.Parse() if len(flag.Args()) != 1 { log.Fatal("Usage: p4fs MOUNT-POINT") } mountpoint := flag.Arg(0) opts := p4.ConnOptions{ Binary: *p4binary, Address: *p4port, } p4conn := p4.NewConn(opts) if *backingDir == "" { d, err := ioutil.TempDir("", "p4fs") if err != nil { log.Fatalf("TempDir failed: %v", err) } *backingDir = d defer os.RemoveAll(d) } root := NewP4FSRoot(p4conn, *backingDir) conn := nodefs.NewFileSystemConnector(root, nodefs.NewOptions()) mount, err := fuse.NewServer(conn.RawFS(), mountpoint, nil) if err != nil { log.Fatalf("mount failed: %v", err) } conn.SetDebug(*fsdebug) mount.SetDebug(*fsdebug) log.Println("starting FUSE.") if *profile != "" { profFile, err := os.Create(*profile) if err != nil { log.Fatalf("os.Create: %v", err) } pprof.StartCPUProfile(profFile) defer pprof.StopCPUProfile() } mount.Serve() }
func main() { // godaemon.MakeDaemon(&godaemon.DaemonAttr{}) // log.SetFlags(log.Lshortfile) layers := os.Args[1] mountPoint := os.Args[2] // F, err := os.OpenFile("/tmp/constor", os.O_APPEND|os.O_WRONLY, 0) // F.Write([]byte("START\n")) // F.Write([]byte(layers)) // F.Write([]byte(" ")) // F.Write([]byte(mountPoint)) // F.Write([]byte("\n")) if len(os.Args) != 3 { fmt.Println("Usage: constor /layer0:/layer1:....:/layerN /mnt/point") os.Exit(1) } pid := os.Getpid() pidstr := strconv.Itoa(pid) logf, err := os.Create("/tmp/constor.log." + pidstr) logfd := logf.Fd() syscall.Dup2(int(logfd), 1) syscall.Dup2(int(logfd), 2) constor := new(Constor) constor.inodemap = NewInodemap(constor) constor.dentrymap = NewDentrymap(constor) constor.fdmap = make(map[uintptr]*FD) constor.logf = logf constor.layers = strings.Split(layers, ":") constor.rootfs = constor.layers[0] constor.log("%s %s", layers, mountPoint) mOpts := &fuse.MountOptions{ Name: "constor", // SingleThreaded: true, Options: []string{"nonempty", "allow_other", "default_permissions", "user_id=0", "group_id=0", "fsname=" + constor.layers[0]}, } _ = syscall.Umask(000) state, err := fuse.NewServer(constor, mountPoint, mOpts) if err != nil { // fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } // fmt.Println("Mounted!") state.Serve() }
func (d *keywhizDriver) mountServer(mountpoint string) (*fuse.Server, error) { logConfig := klog.Config{ Debug: d.config.Debug, Mountpoint: mountpoint, } if err := os.MkdirAll(filepath.Dir(mountpoint), 0755); err != nil { return nil, err } freshThreshold := 200 * time.Millisecond backendDeadline := 500 * time.Millisecond maxWait := d.config.TimeoutSeconds + backendDeadline timeouts := keywhizfs.Timeouts{ Fresh: freshThreshold, BackendDeadline: backendDeadline, MaxWait: maxWait, } client := keywhizfs.NewClient(d.config.CertFile, d.config.KeyFile, d.config.CaFile, d.config.ServerURL, d.config.TimeoutSeconds, logConfig, d.config.Ping) ownership := keywhizfs.NewOwnership(d.config.User, d.config.Group) kwfs, root, err := keywhizfs.NewKeywhizFs(&client, ownership, timeouts, logConfig) if err != nil { client.Errorf("Mount fail: %v\n", err) return nil, err } mountOptions := &fuse.MountOptions{ AllowOther: true, Name: kwfs.String(), Options: []string{"default_permissions"}, } // Empty Options struct avoids setting a global uid/gid override. conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{}) server, err := fuse.NewServer(conn.RawFS(), mountpoint, mountOptions) if err != nil { client.Errorf("Mount fail: %v\n", err) return nil, err } go server.Serve() return server, nil }
func MountVfs(store *storage.Storage, mountPath string, options []string) (*FuseVfs, error) { fuseVfs := FuseVfs{nil, "", nil} pathFs := pathfs.NewPathNodeFs(&fuseVfs, nil) conn := nodefs.NewFileSystemConnector(pathFs.Root(), nil) mountOptions := &fuse.MountOptions{Options: options} server, err := fuse.NewServer(conn.RawFS(), mountPath, mountOptions) if err != nil { return nil, fmt.Errorf("could not mount virtual filesystem at '%v': %v", mountPath, err) } fuseVfs.store = store fuseVfs.mountPath = mountPath fuseVfs.server = server return &fuseVfs, nil }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") other := flag.Bool("allow-other", false, "mount with -o allowother.") flag.Parse() if flag.NArg() < 2 { // TODO - where to get program name? fmt.Println("usage: main MOUNTPOINT ORIGINAL") os.Exit(2) } var finalFs pathfs.FileSystem orig := flag.Arg(1) loopbackfs := pathfs.NewLoopbackFileSystem(orig) finalFs = loopbackfs opts := &nodefs.Options{ // These options are to be compatible with libfuse defaults, // making benchmarking easier. NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } pathFs := pathfs.NewPathNodeFs(finalFs, nil) conn := nodefs.NewFileSystemConnector(pathFs.Root(), opts) mountPoint := flag.Arg(0) origAbs, _ := filepath.Abs(orig) mOpts := &fuse.MountOptions{ AllowOther: *other, Name: "loopbackfs", FsName: origAbs, } state, err := fuse.NewServer(conn.RawFS(), mountPoint, mOpts) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } state.SetDebug(*debug) fmt.Println("Mounted!") state.Serve() }
func mount(fs pathfs.FileSystem, mountpoint string) (server *fuse.Server, err error) { path := pathfs.NewPathNodeFs(fs, nil) con := nodefs.NewFileSystemConnector(path.Root(), &nodefs.Options{ EntryTimeout: time.Second, AttrTimeout: time.Second, NegativeTimeout: time.Second, }) opts := &fuse.MountOptions{ Name: config.APP_NAME, FsName: config.APP_NAME, } server, err = fuse.NewServer(con.RawFS(), mountpoint, opts) if err != nil { return nil, err } return server, nil }
// this function was borrowed from https://raw.githubusercontent.com/hanwen/go-fuse/master/example/memfs/main.go func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") flag.Parse() if flag.NArg() < 1 { fmt.Println("usage: inmemfs MOUNTPOINT") os.Exit(2) } mountPoint := flag.Arg(0) root := newInMemFS().root conn := nodefs.NewFileSystemConnector(root, nil) server, err := fuse.NewServer(conn.RawFS(), mountPoint, nil) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } server.SetDebug(*debug) fmt.Println("Mounted!") server.Serve() }
func main() { var finalFs pathfs.FileSystem config, err := parseConfig("config.json") if err != nil { log.Fatal(err) } event.StartListening() kakigoorifs := fs.NewKakigooriFileSystem(config.Root) finalFs = kakigoorifs opts := &nodefs.Options{ NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } pathFs := pathfs.NewPathNodeFs(finalFs, nil) conn := nodefs.NewFileSystemConnector(pathFs, opts) mOpts := &fuse.MountOptions{ AllowOther: false, } state, err := fuse.NewServer(conn.RawFS(), config.MountPoint, mOpts) if err != nil { log.Printf("Mount fail: %v\n", err) os.Exit(1) } state.SetDebug(false) log.Println("Mounted!") state.Serve() }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") flag.Parse() if flag.NArg() < 2 { // TODO - where to get program name? fmt.Println("usage: main MOUNTPOINT BACKING-PREFIX") os.Exit(2) } mountPoint := flag.Arg(0) prefix := flag.Arg(1) fs := nodefs.NewMemNodeFs(prefix) conn := nodefs.NewFileSystemConnector(fs, nil) server, err := fuse.NewServer(conn.RawFS(), mountPoint, nil) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } server.SetDebug(*debug) fmt.Println("Mounted!") server.Serve() }
func mountAndServe(options *Options) { log.Printf("[DEBUG] mounting at %s directed at %s with options: %+v", options.Args.Mountpoint, options.Endpoint, options.MountOptions.opts) nfs := pathfs.NewPathNodeFs(metadatafs.New(options.Endpoint), nil) server, err := fuse.NewServer( nodefs.NewFileSystemConnector(nfs.Root(), nil).RawFS(), options.Args.Mountpoint, &fuse.MountOptions{Options: options.MountOptions.opts}) if err != nil { log.Fatalf("mount fail: %v\n", err) } server.SetDebug(len(options.Verbose) >= moreVerbose) if options.Tags { go func() { server.WaitMount() log.Printf("[DEBUG] mounting tags") mountTags(nfs, options) log.Printf("[DEBUG] tags mounted") }() } log.Printf("[DEBUG] mounting") server.Serve() }
// pathfsFrontend - initialize gocryptfs/pathfs_frontend // Calls os.Exit on errors func pathfsFrontend(key []byte, args argContainer, confFile *cryptfs.ConfFile) *fuse.Server { // Reconciliate CLI and config file arguments into a Args struct that is passed to the // filesystem implementation frontendArgs := pathfs_frontend.Args{ Cipherdir: args.cipherdir, Masterkey: key, OpenSSL: args.openssl, PlaintextNames: args.plaintextnames, DirIV: args.diriv, EMENames: args.emenames, GCMIV128: args.gcmiv128, } // confFile is nil when "-zerokey" or "-masterkey" was used if confFile != nil { // Settings from the config file override command line args frontendArgs.PlaintextNames = confFile.IsFeatureFlagSet(cryptfs.FlagPlaintextNames) frontendArgs.DirIV = confFile.IsFeatureFlagSet(cryptfs.FlagDirIV) frontendArgs.EMENames = confFile.IsFeatureFlagSet(cryptfs.FlagEMENames) frontendArgs.GCMIV128 = confFile.IsFeatureFlagSet(cryptfs.FlagGCMIV128) } // EMENames implies DirIV, both on the command line and in the config file. if frontendArgs.EMENames { frontendArgs.DirIV = true } // PlainTexnames disables both EMENames and DirIV if frontendArgs.PlaintextNames { frontendArgs.DirIV = false frontendArgs.EMENames = false } cryptfs.Debug.Printf("frontendArgs: ") cryptfs.Debug.JSONDump(frontendArgs) finalFs := pathfs_frontend.NewFS(frontendArgs) pathFsOpts := &pathfs.PathNodeFsOptions{ClientInodes: true} pathFs := pathfs.NewPathNodeFs(finalFs, pathFsOpts) fuseOpts := &nodefs.Options{ // These options are to be compatible with libfuse defaults, // making benchmarking easier. NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } conn := nodefs.NewFileSystemConnector(pathFs.Root(), fuseOpts) var mOpts fuse.MountOptions mOpts.AllowOther = false // Set values shown in "df -T" and friends // First column, "Filesystem" mOpts.Options = append(mOpts.Options, "fsname="+args.cipherdir) // Second column, "Type", will be shown as "fuse." + Name mOpts.Name = "gocryptfs" srv, err := fuse.NewServer(conn.RawFS(), args.mountpoint, &mOpts) if err != nil { fmt.Printf("Mount failed: %v", err) os.Exit(ERREXIT_MOUNT) } srv.SetDebug(args.fusedebug) // All FUSE file and directory create calls carry explicit permission // information. We need an unrestricted umask to create the files and // directories with the requested permissions. syscall.Umask(0000) return srv }
func main() { debug := flag.String("debug", "", "comma-separated list of debugging options: usb, data, mtp, fuse") usbTimeout := flag.Int("usb-timeout", 5000, "timeout in milliseconds") vfat := flag.Bool("vfat", true, "assume removable RAM media uses VFAT, and rewrite names.") other := flag.Bool("allow-other", false, "allow other users to access mounted fuse. Default: false.") deviceFilter := flag.String("dev", "", "regular expression to filter device IDs, "+ "which are composed of manufacturer/product/serial.") storageFilter := flag.String("storage", "", "regular expression to filter storage areas.") android := flag.Bool("android", true, "use android extensions if available") flag.Parse() if len(flag.Args()) != 1 { log.Fatalf("Usage: %s [options] MOUNT-POINT\n", os.Args[0]) } mountpoint := flag.Arg(0) dev, err := mtp.SelectDevice(*deviceFilter) if err != nil { log.Fatalf("detect failed: %v", err) } defer dev.Close() debugs := map[string]bool{} for _, s := range strings.Split(*debug, ",") { debugs[s] = true } dev.MTPDebug = debugs["mtp"] dev.DataDebug = debugs["data"] dev.USBDebug = debugs["usb"] dev.Timeout = *usbTimeout if err = dev.Configure(); err != nil { log.Fatalf("Configure failed: %v", err) } sids, err := fs.SelectStorages(dev, *storageFilter) if err != nil { log.Fatalf("selectStorages failed: %v", err) } opts := fs.DeviceFsOptions{ RemovableVFat: *vfat, Android: *android, } fs, err := fs.NewDeviceFs(dev, sids, opts) if err != nil { log.Fatalf("NewDeviceFs failed: %v", err) } conn := nodefs.NewFileSystemConnector(fs, nodefs.NewOptions()) rawFs := fuse.NewLockingRawFileSystem(conn.RawFS()) mOpts := &fuse.MountOptions{ AllowOther: *other, } mount, err := fuse.NewServer(rawFs, mountpoint, mOpts) if err != nil { log.Fatalf("mount failed: %v", err) } conn.SetDebug(debugs["fuse"] || debugs["fs"]) mount.SetDebug(debugs["fuse"] || debugs["fs"]) log.Printf("starting FUSE.") mount.Serve() fs.OnUnmount() }
func TestDeleteNotify(t *testing.T) { dir := testutil.TempDir() defer os.RemoveAll(dir) root := nodefs.NewMemNodeFSRoot(dir + "/backing") conn := nodefs.NewFileSystemConnector(root, &nodefs.Options{PortableInodes: true}) mnt := dir + "/mnt" err := os.Mkdir(mnt, 0755) if err != nil { t.Fatal(err) } state, err := fuse.NewServer(conn.RawFS(), mnt, &fuse.MountOptions{ Debug: testutil.VerboseTest(), }) if err != nil { t.Fatal(err) } go state.Serve() defer state.Unmount() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } _, code := root.Mkdir("testdir", 0755, nil) if !code.Ok() { t.Fatal(code) } ch := root.Inode().RmChild("testdir") ch.Node().SetInode(nil) flip := flipNode{ Node: ch.Node(), ok: make(chan int), } root.Inode().NewChild("testdir", true, &flip) err = ioutil.WriteFile(mnt+"/testdir/testfile", []byte{42}, 0644) if err != nil { t.Fatal(err) } // Do the test here, so we surely have state.KernelSettings() if state.KernelSettings().Minor < 18 { t.Log("Kernel does not support deletion notify; aborting test.") return } buf := bytes.Buffer{} cmd := exec.Command("/usr/bin/tail", "-f", "testfile") cmd.Dir = mnt + "/testdir" cmd.Stdin = &buf cmd.Stdout = &bytes.Buffer{} cmd.Stderr = os.Stderr err = cmd.Start() if err != nil { t.Fatal(err) } defer func() { cmd.Process.Kill() time.Sleep(100 * time.Millisecond) }() // Wait until tail opened the file. time.Sleep(100 * time.Millisecond) err = os.Remove(mnt + "/testdir/testfile") if err != nil { t.Fatal(err) } // Simulate deletion+mkdir coming from the network close(flip.ok) oldCh := root.Inode().RmChild("testdir") _, code = root.Inode().Node().Mkdir("testdir", 0755, nil) if !code.Ok() { t.Fatal("mkdir status", code) } conn.DeleteNotify(root.Inode(), oldCh, "testdir") _, err = os.Lstat(mnt + "/testdir") if err != nil { t.Fatalf("lstat after del + mkdir failed: %v", err) } }
func main() { log.SetFlags(log.Lmicroseconds) // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") other := flag.Bool("allow-other", false, "mount with -o allowother.") enableLinks := flag.Bool("l", false, "Enable hard link support") cpuprofile := flag.String("cpuprofile", "", "write cpu profile to this file") memprofile := flag.String("memprofile", "", "write memory profile to this file") flag.Parse() if flag.NArg() < 2 { fmt.Printf("usage: %s MOUNTPOINT ORIGINAL\n", path.Base(os.Args[0])) fmt.Printf("\noptions:\n") flag.PrintDefaults() os.Exit(2) } if *cpuprofile != "" { fmt.Printf("Writing cpu profile to %s\n", *cpuprofile) f, err := os.Create(*cpuprofile) if err != nil { fmt.Println(err) os.Exit(3) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } if *memprofile != "" { log.Printf("send SIGUSR1 to %d to dump memory profile", os.Getpid()) profSig := make(chan os.Signal, 1) signal.Notify(profSig, syscall.SIGUSR1) go writeMemProfile(*memprofile, profSig) } if *cpuprofile != "" || *memprofile != "" { fmt.Printf("Note: You must unmount gracefully, otherwise the profile file(s) will stay empty!\n") } var finalFs pathfs.FileSystem orig := flag.Arg(1) loopbackfs := pathfs.NewLoopbackFileSystem(orig) finalFs = loopbackfs opts := &nodefs.Options{ // These options are to be compatible with libfuse defaults, // making benchmarking easier. NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } // Enable ClientInodes so hard links work pathFsOpts := &pathfs.PathNodeFsOptions{ClientInodes: *enableLinks} pathFs := pathfs.NewPathNodeFs(finalFs, pathFsOpts) conn := nodefs.NewFileSystemConnector(pathFs.Root(), opts) mountPoint := flag.Arg(0) origAbs, _ := filepath.Abs(orig) mOpts := &fuse.MountOptions{ AllowOther: *other, Name: "loopbackfs", FsName: origAbs, Debug: *debug, } state, err := fuse.NewServer(conn.RawFS(), mountPoint, mOpts) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } fmt.Println("Mounted!") state.Serve() }
func startFs(t *testing.T, useAndroid bool) (root string, cleanup func()) { dev, err := mtp.SelectDevice("") if err != nil { t.Fatalf("SelectDevice failed: %v", err) } defer func() { if dev != nil { dev.Close() } }() if err = dev.Configure(); err != nil { t.Fatalf("Configure failed: %v", err) } sids, err := SelectStorages(dev, "") if err != nil { t.Fatalf("selectStorages failed: %v", err) } if len(sids) == 0 { t.Fatal("no storages found. Unlock device?") } tempdir, err := ioutil.TempDir("", "mtpfs") if err != nil { t.Fatal(err) } opts := DeviceFsOptions{ Android: useAndroid, } fs, err := NewDeviceFs(dev, sids, opts) if err != nil { t.Fatal("NewDeviceFs failed:", err) } conn := nodefs.NewFileSystemConnector(fs, nodefs.NewOptions()) rawFs := fuse.NewLockingRawFileSystem(conn.RawFS()) mount, err := fuse.NewServer(rawFs, tempdir, nil) if err != nil { t.Fatalf("mount failed: %v", err) } mount.SetDebug(fuse.VerboseTest()) dev.MTPDebug = fuse.VerboseTest() dev.USBDebug = fuse.VerboseTest() dev.DataDebug = fuse.VerboseTest() go mount.Serve() for i := 0; i < 10; i++ { fis, err := ioutil.ReadDir(tempdir) if err == nil && len(fis) > 0 { root = filepath.Join(tempdir, fis[0].Name()) break } time.Sleep(1) } if root == "" { mount.Unmount() t.Fatal("could not find entries in mount point.") } d := dev dev = nil return root, func() { mount.Unmount() d.Close() } }