func (fs *memFS) CreateSymlink( op *fuseops.CreateSymlinkOp) (err error) { fs.mu.Lock() defer fs.mu.Unlock() // Grab the parent, which we will update shortly. parent := fs.getInodeOrDie(op.Parent) // Ensure that the name doesn't already exist, so we don't wind up with a // duplicate. _, _, exists := parent.LookUpChild(op.Name) if exists { err = fuse.EEXIST return } // Set up attributes from the child, using the credentials of the calling // process as owner (matching inode_init_owner, cf. http://goo.gl/5qavg8). now := fs.clock.Now() childAttrs := fuseops.InodeAttributes{ Nlink: 1, Mode: 0444 | os.ModeSymlink, Atime: now, Mtime: now, Ctime: now, Crtime: now, Uid: op.Header().Uid, Gid: op.Header().Gid, } // Allocate a child. childID, child := fs.allocateInode(childAttrs) // Set up its target. child.target = op.Target // Add an entry in the parent. parent.AddChild(childID, op.Name, fuseutil.DT_Link) // Fill in the response entry. op.Entry.Child = childID op.Entry.Attributes = child.attrs // We don't spontaneously mutate, so the kernel can cache as long as it wants // (since it also handles invalidation). op.Entry.AttributesExpiration = fs.clock.Now().Add(365 * 24 * time.Hour) op.Entry.EntryExpiration = op.Entry.EntryExpiration return }
// LOCKS_EXCLUDED(fs.mu) func (fs *fileSystem) CreateSymlink( op *fuseops.CreateSymlinkOp) (err error) { // Find the parent. fs.mu.Lock() parent := fs.inodes[op.Parent].(inode.DirInode) fs.mu.Unlock() // Create the object in GCS, failing if it already exists. parent.Lock() o, err := parent.CreateChildSymlink(op.Context(), op.Name, op.Target) parent.Unlock() // Special case: *gcs.PreconditionError means the name already exists. if _, ok := err.(*gcs.PreconditionError); ok { err = fuse.EEXIST return } // Propagate other errors. if err != nil { err = fmt.Errorf("CreateChildSymlink: %v", err) return } // Attempt to create a child inode using the object we created. If we fail to // do so, it means someone beat us to the punch with a newer generation // (unlikely, so we're probably okay with failing here). fs.mu.Lock() child := fs.lookUpOrCreateInodeIfNotStale(o.Name, o) if child == nil { err = fmt.Errorf("Newly-created record is already stale") return } defer fs.unlockAndMaybeDisposeOfInode(child, &err) // Fill out the response. op.Entry.Child = child.ID() op.Entry.Attributes, err = child.Attributes(op.Context()) if err != nil { err = fmt.Errorf("Attributes: %v", err) return } return }