seaweedfs/weed/mount/inode_to_path.go

280 lines
6.1 KiB
Go
Raw Normal View History

2022-02-12 09:54:16 +00:00
package mount
import (
"github.com/hanwen/go-fuse/v2/fuse"
"github.com/seaweedfs/seaweedfs/weed/glog"
"github.com/seaweedfs/seaweedfs/weed/util"
2022-02-12 09:54:16 +00:00
"sync"
"time"
2022-02-12 09:54:16 +00:00
)
type InodeToPath struct {
sync.RWMutex
nextInodeId uint64
2022-02-13 13:49:29 +00:00
inode2path map[uint64]*InodeEntry
2022-02-12 09:54:16 +00:00
path2inode map[util.FullPath]uint64
}
2022-02-13 13:49:29 +00:00
type InodeEntry struct {
2022-07-23 19:57:00 +00:00
paths []util.FullPath
2022-02-14 09:09:31 +00:00
nlookup uint64
isDirectory bool
isChildrenCached bool
2022-02-13 13:49:29 +00:00
}
2022-02-12 09:54:16 +00:00
2022-07-23 19:57:00 +00:00
func (ie *InodeEntry) removeOnePath(p util.FullPath) bool {
if len(ie.paths) == 0 {
return false
}
idx := -1
for i, x := range ie.paths {
if x == p {
idx = i
break
}
}
if idx < 0 {
return false
}
2022-07-24 01:20:29 +00:00
for x := idx; x < len(ie.paths)-1; x++ {
ie.paths[x] = ie.paths[x+1]
2022-07-23 19:57:00 +00:00
}
ie.paths = ie.paths[0 : len(ie.paths)-1]
2022-07-24 20:43:11 +00:00
ie.nlookup--
2022-07-23 19:57:00 +00:00
return true
}
2022-02-28 20:16:53 +00:00
func NewInodeToPath(root util.FullPath) *InodeToPath {
2022-02-14 09:09:31 +00:00
t := &InodeToPath{
2022-02-25 08:53:27 +00:00
inode2path: make(map[uint64]*InodeEntry),
path2inode: make(map[util.FullPath]uint64),
2022-02-12 09:54:16 +00:00
}
2022-07-23 19:57:00 +00:00
t.inode2path[1] = &InodeEntry{[]util.FullPath{root}, 1, true, false}
2022-02-28 20:16:53 +00:00
t.path2inode[root] = 1
2022-02-14 09:09:31 +00:00
return t
2022-02-12 09:54:16 +00:00
}
// EnsurePath make sure the full path is tracked, used by symlink.
func (i *InodeToPath) EnsurePath(path util.FullPath, isDirectory bool) bool {
for {
dir, _ := path.DirAndName()
if dir == "/" {
return true
}
if i.EnsurePath(util.FullPath(dir), true) {
i.Lookup(path, time.Now().Unix(), isDirectory, false, 0, false)
2022-07-29 01:06:49 +00:00
return true
}
}
return false
}
2022-03-14 07:03:29 +00:00
func (i *InodeToPath) Lookup(path util.FullPath, unixTime int64, isDirectory bool, isHardlink bool, possibleInode uint64, isLookup bool) uint64 {
2022-02-12 09:54:16 +00:00
i.Lock()
defer i.Unlock()
inode, found := i.path2inode[path]
if !found {
2022-02-25 08:53:27 +00:00
if possibleInode == 0 {
2022-03-14 07:03:29 +00:00
inode = path.AsInode(unixTime)
} else {
inode = possibleInode
}
if !isHardlink {
2022-02-25 08:53:27 +00:00
for _, found := i.inode2path[inode]; found; inode++ {
_, found = i.inode2path[inode+1]
2022-02-25 08:53:27 +00:00
}
2022-02-17 00:49:03 +00:00
}
2022-02-25 08:53:27 +00:00
}
i.path2inode[path] = inode
if _, found := i.inode2path[inode]; found {
2022-02-17 00:49:03 +00:00
if isLookup {
i.inode2path[inode].nlookup++
}
2022-02-25 08:53:27 +00:00
} else {
if !isLookup {
2022-07-23 19:57:00 +00:00
i.inode2path[inode] = &InodeEntry{[]util.FullPath{path}, 0, isDirectory, false}
2022-02-25 08:53:27 +00:00
} else {
2022-07-23 19:57:00 +00:00
i.inode2path[inode] = &InodeEntry{[]util.FullPath{path}, 1, isDirectory, false}
2022-02-25 08:53:27 +00:00
}
2022-02-13 13:49:29 +00:00
}
2022-02-25 08:53:27 +00:00
2022-02-13 13:49:29 +00:00
return inode
}
2022-03-14 07:03:29 +00:00
func (i *InodeToPath) AllocateInode(path util.FullPath, unixTime int64) uint64 {
if path == "/" {
return 1
}
i.Lock()
defer i.Unlock()
2022-03-14 07:03:29 +00:00
inode := path.AsInode(unixTime)
for _, found := i.inode2path[inode]; found; inode++ {
_, found = i.inode2path[inode]
}
return inode
}
2022-02-13 13:49:29 +00:00
func (i *InodeToPath) GetInode(path util.FullPath) uint64 {
if path == "/" {
return 1
}
i.Lock()
defer i.Unlock()
inode, found := i.path2inode[path]
if !found {
2022-02-13 13:59:10 +00:00
// glog.Fatalf("GetInode unknown inode for %s", path)
// this could be the parent for mount point
2022-02-12 09:54:16 +00:00
}
return inode
}
func (i *InodeToPath) GetPath(inode uint64) (util.FullPath, fuse.Status) {
2022-02-12 09:54:16 +00:00
i.RLock()
defer i.RUnlock()
path, found := i.inode2path[inode]
2022-07-23 19:57:00 +00:00
if !found || len(path.paths) == 0 {
return "", fuse.ENOENT
2022-02-12 09:54:16 +00:00
}
2022-07-23 19:57:00 +00:00
return path.paths[0], fuse.OK
2022-02-12 09:54:16 +00:00
}
func (i *InodeToPath) HasPath(path util.FullPath) bool {
i.RLock()
defer i.RUnlock()
_, found := i.path2inode[path]
return found
}
2022-02-13 06:21:30 +00:00
2022-02-14 09:09:31 +00:00
func (i *InodeToPath) MarkChildrenCached(fullpath util.FullPath) {
i.RLock()
defer i.RUnlock()
inode, found := i.path2inode[fullpath]
if !found {
glog.Fatalf("MarkChildrenCached not found inode %v", fullpath)
}
path, found := i.inode2path[inode]
path.isChildrenCached = true
}
func (i *InodeToPath) IsChildrenCached(fullpath util.FullPath) bool {
i.RLock()
defer i.RUnlock()
inode, found := i.path2inode[fullpath]
if !found {
return false
}
path, found := i.inode2path[inode]
if found {
return path.isChildrenCached
}
return false
}
2022-02-13 06:21:30 +00:00
func (i *InodeToPath) HasInode(inode uint64) bool {
if inode == 1 {
return true
}
i.RLock()
defer i.RUnlock()
_, found := i.inode2path[inode]
return found
}
2022-02-13 11:09:24 +00:00
2022-07-23 20:37:07 +00:00
func (i *InodeToPath) AddPath(inode uint64, path util.FullPath) {
i.Lock()
defer i.Unlock()
i.path2inode[path] = inode
ie, found := i.inode2path[inode]
if found {
ie.paths = append(ie.paths, path)
2022-07-24 20:43:11 +00:00
ie.nlookup++
2022-07-23 20:37:07 +00:00
} else {
i.inode2path[inode] = &InodeEntry{
paths: []util.FullPath{path},
nlookup: 1,
isDirectory: false,
isChildrenCached: false,
}
}
}
2022-02-13 11:09:24 +00:00
func (i *InodeToPath) RemovePath(path util.FullPath) {
i.Lock()
defer i.Unlock()
inode, found := i.path2inode[path]
if found {
delete(i.path2inode, path)
2022-07-23 19:57:00 +00:00
i.removePathFromInode2Path(inode, path)
}
}
func (i *InodeToPath) removePathFromInode2Path(inode uint64, path util.FullPath) {
2022-07-23 20:21:42 +00:00
ie, found := i.inode2path[inode]
if !found {
return
}
if !ie.removeOnePath(path) {
return
}
if len(ie.paths) == 0 {
delete(i.inode2path, inode)
2022-02-13 11:09:24 +00:00
}
}
2022-02-13 13:49:29 +00:00
func (i *InodeToPath) MovePath(sourcePath, targetPath util.FullPath) (sourceInode, targetInode uint64) {
2022-02-14 00:34:57 +00:00
i.Lock()
defer i.Unlock()
sourceInode, sourceFound := i.path2inode[sourcePath]
targetInode, targetFound := i.path2inode[targetPath]
if targetFound {
2022-07-23 19:57:00 +00:00
i.removePathFromInode2Path(targetInode, targetPath)
delete(i.path2inode, targetPath)
}
2022-02-14 00:34:57 +00:00
if sourceFound {
delete(i.path2inode, sourcePath)
i.path2inode[targetPath] = sourceInode
} else {
// it is possible some source folder items has not been visited before
// so no need to worry about their source inodes
return
}
if entry, entryFound := i.inode2path[sourceInode]; entryFound {
2022-07-23 19:57:00 +00:00
for i, p := range entry.paths {
if p == sourcePath {
entry.paths[i] = targetPath
}
}
entry.isChildrenCached = false
if !targetFound {
entry.nlookup++
}
2022-02-14 00:34:57 +00:00
} else {
2022-06-21 19:21:02 +00:00
glog.Errorf("MovePath %s to %s: sourceInode %d not found", sourcePath, targetPath, sourceInode)
2022-02-14 00:34:57 +00:00
}
return
2022-02-14 00:34:57 +00:00
}
2022-02-14 09:09:31 +00:00
func (i *InodeToPath) Forget(inode, nlookup uint64, onForgetDir func(dir util.FullPath)) {
2022-02-13 13:49:29 +00:00
i.Lock()
2022-02-13 11:31:47 +00:00
path, found := i.inode2path[inode]
if found {
2022-02-13 13:49:29 +00:00
path.nlookup -= nlookup
if path.nlookup <= 0 {
2022-07-23 19:57:00 +00:00
for _, p := range path.paths {
delete(i.path2inode, p)
}
2022-02-13 13:49:29 +00:00
delete(i.inode2path, inode)
}
2022-02-13 11:31:47 +00:00
}
2022-02-14 09:09:31 +00:00
i.Unlock()
if found {
if path.isDirectory && path.nlookup <= 0 && onForgetDir != nil {
path.isChildrenCached = false
2022-07-23 19:57:00 +00:00
for _, p := range path.paths {
onForgetDir(p)
}
2022-02-14 09:09:31 +00:00
}
}
2022-02-13 11:31:47 +00:00
}