// LOCKS_EXCLUDED(fs.mu)
func (fs *fileSystem) MkDir(
op *fuseops.MkDirOp) (err error) {
// Find the parent.
fs.mu.Lock()
parent := fs.inodes[op.Parent].(inode.DirInode)
fs.mu.Unlock()
// Create an empty backing object for the child, failing if it already
// exists.
parent.Lock()
o, err := parent.CreateChildDir(op.Context(), op.Name)
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("CreateChildDir: %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
}
func (fs *fsImpl) MkDir(
ctx context.Context,
op *fuseops.MkDirOp) (err error) {
fs.mu.Lock()
defer fs.mu.Unlock()
// Make sure the parent exists and has not been forgotten.
_ = fs.findInodeByID(op.Parent)
// Mint a child inode.
childID := fs.nextInodeID
fs.nextInodeID++
child := &inode{
attributes: fuseops.InodeAttributes{
Nlink: 0,
Mode: 0777 | os.ModeDir,
},
}
fs.inodes[childID] = child
child.IncrementLookupCount()
// Return an appropriate entry.
op.Entry = fuseops.ChildInodeEntry{
Child: childID,
Attributes: child.attributes,
}
return
}
func (fs *memFS) MkDir(
op *fuseops.MkDirOp) (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).
childAttrs := fuseops.InodeAttributes{
Nlink: 1,
Mode: op.Mode,
Uid: op.Header().Uid,
Gid: op.Header().Gid,
}
// Allocate a child.
childID, child := fs.allocateInode(childAttrs)
// Add an entry in the parent.
parent.AddChild(childID, op.Name, fuseutil.DT_Directory)
// Fill in the response.
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
}
