juicefs debug echo看源码

断点

 

挂载后，在桶的根目录执行命令行 echo "11111" > /mnt/s3/333.txt

go-fuse库(server.go)::readRequest->handleRequest(这个时候handler是CREATE)->

go-fuse库(opcode.go)::doCreate

juicefs代码(pkg/fuse.go)::Create

juicefs代码(pkg/vfs/vfs.go)::Create

juicefs代码(pkg/meta/base.go)::Create

juicefs代码(pkg/meta/base.go)::Mknod

juicefs代码(pkg/meta/redis.go)::doMknod

创建完元数据后继续执行juicefs代码(base.go)::Create->m.of.Open(*inode, attr)

创建完inode继续执行juicefs代码(base.go)::Create->fh = v.newFileHandle(inode, attr.Length, flags)

juicefs代码(pkg/vfs/handle.go)::newFileHandle

写完文件，是写到cache层，还没持久化，所以要进行下一个动作flush，这里就是存到s3对象存储

go-fuse库(server.go)::readRequest->handleRequestt(这个时候handler是FLUSH)->

go-fuse库(opcode.go)::doFlush

juicefs代码(pkg/fuse.go)::Flush

juicefs代码(pkg/vfs/vfs.go)::Flush

go-fuse库(server.go)::readRequest->handleRequestt(这个时候handler是RELEASE)->

go-fuse库(opcode.go)::doRelease

juicefs代码(pkg/fuse.go)::Release

juicefs代码(pkg/vfs/vfs.go)::Release

可以看出元数据保存和数据保存是分开的，所以元数据保存成功到数据未成功保存到S3期间，断电，会导致元数据显示数据存在（ls可以看到），但是真实的文件不存在

这个大部分时候是CREATE+FLUSH+WRITE+FLUSH+RELEASE 第二FLUSH不会把内容保存到S3

文件存在的时候FLUSH+WRITE+FLUSH+RELEASE 第二FLUSH不会把内容保存到S3

---

go-fuse库(opcode.go)::doCreate

func doCreate(server *Server, req *request) {
   out := (*CreateOut)(req.outData())
   status := server.fileSystem.Create(req.cancel, (*CreateIn)(req.inData), req.filenames[0], out)
   req.status = status
}

juicefs代码(fuse.go)::Create

func (fs *fileSystem) Create(cancel <-chan struct{}, in *fuse.CreateIn, name string, out *fuse.CreateOut) (code fuse.Status) {
   ctx := newContext(cancel, &in.InHeader)
   defer releaseContext(ctx)
   entry, fh, err := fs.v.Create(ctx, Ino(in.NodeId), name, uint16(in.Mode), 0, in.Flags)
   if err != 0 {
      return fuse.Status(err)
   }
   out.Fh = fh
   return fs.replyEntry(ctx, &out.EntryOut, entry)
}

juicefs代码(vfs.go)::Create

func (v *VFS) Create(ctx Context, parent Ino, name string, mode uint16, cumask uint16, flags uint32) (entry *meta.Entry, fh uint64, err syscall.Errno) {
   defer func() {
      logit(ctx, "create (%d,%s,%s:0%04o): %s%s [fh:%d]", parent, name, smode(mode), mode, strerr(err), (*Entry)(entry), fh)
   }()
   if parent == rootID && IsSpecialName(name) {
      err = syscall.EEXIST
      return
   }
   if len(name) > maxName {
      err = syscall.ENAMETOOLONG
      return
   }

   var inode Ino
   var attr = &Attr{}
   err = v.Meta.Create(ctx, parent, name, mode&07777, cumask, flags, &inode, attr)
   if runtime.GOOS == "darwin" && err == syscall.ENOENT {
      err = syscall.EACCES
   }
   if err == 0 {
      v.UpdateLength(inode, attr)
      fh = v.newFileHandle(inode, attr.Length, flags)
      entry = &meta.Entry{Inode: inode, Attr: attr}
   }
   return
}

juicefs代码(base.go)::Create
 

func (m *baseMeta) Create(ctx Context, parent Ino, name string, mode uint16, cumask uint16, flags uint32, inode *Ino, attr *Attr) syscall.Errno {
   if attr == nil {
      attr = &Attr{}
   }
   eno := m.Mknod(ctx, parent, name, TypeFile, mode, cumask, 0, "", inode, attr)
   if eno == syscall.EEXIST && (flags&syscall.O_EXCL) == 0 && attr.Typ == TypeFile {
      eno = 0
   }
   if eno == 0 && inode != nil {
      m.of.Open(*inode, attr)
   }
   return eno
}

eno := m.Mknod(ctx, parent, name, TypeFile, mode, cumask, 0, "", inode, attr)

func (m *baseMeta) Mknod(ctx Context, parent Ino, name string, _type uint8, mode, cumask uint16, rdev uint32, path string, inode *Ino, attr *Attr) syscall.Errno {
   if isTrash(parent) {
      return syscall.EPERM
   }
   if parent == RootInode && name == TrashName {
      return syscall.EPERM
   }
   if m.conf.ReadOnly {
      return syscall.EROFS
   }
   if name == "" {
      return syscall.ENOENT
   }

   defer m.timeit(time.Now())
   if m.checkQuota(4<<10, 1) {
      return syscall.ENOSPC
   }
   return m.en.doMknod(ctx, m.checkRoot(parent), name, _type, mode, cumask, rdev, path, inode, attr)
}

return m.en.doMknod(ctx, m.checkRoot(parent), name, _type, mode, cumask, rdev, path, inode, attr)

func (m *redisMeta) doMknod(ctx Context, parent Ino, name string, _type uint8, mode, cumask uint16, rdev uint32, path string, inode *Ino, attr *Attr) syscall.Errno {
   var ino Ino
   var err error
   if parent == TrashInode {
      var next int64
      next, err = m.incrCounter("nextTrash", 1)
      ino = TrashInode + Ino(next)
   } else {
      ino, err = m.nextInode()
   }
   if err != nil {
      return errno(err)
   }
   if attr == nil {
      attr = &Attr{}
   }
   attr.Typ = _type
   attr.Mode = mode & ^cumask
   attr.Uid = ctx.Uid()
   attr.Gid = ctx.Gid()
   if _type == TypeDirectory {
      attr.Nlink = 2
      attr.Length = 4 << 10
   } else {
      attr.Nlink = 1
      if _type == TypeSymlink {
         attr.Length = uint64(len(path))
      } else {
         attr.Length = 0
         attr.Rdev = rdev
      }
   }
   attr.Parent = parent
   attr.Full = true
   if inode != nil {
      *inode = ino
   }

   err = m.txn(ctx, func(tx *redis.Tx) error {
      var pattr Attr
      a, err := tx.Get(ctx, m.inodeKey(parent)).Bytes()
      if err != nil {
         return err
      }
      m.parseAttr(a, &pattr)
      if pattr.Typ != TypeDirectory {
         return syscall.ENOTDIR
      }
      if (pattr.Flags & FlagImmutable) != 0 {
         return syscall.EPERM
      }

      buf, err := tx.HGet(ctx, m.entryKey(parent), name).Bytes()
      if err != nil && err != redis.Nil {
         return err
      }
      var foundIno Ino
      var foundType uint8
      if err == nil {
         foundType, foundIno = m.parseEntry(buf)
      } else if m.conf.CaseInsensi { // err == redis.Nil
         if entry := m.resolveCase(ctx, parent, name); entry != nil {
            foundType, foundIno = entry.Attr.Typ, entry.Inode
         }
      }
      if foundIno != 0 {
         if _type == TypeFile || _type == TypeDirectory { // file for create, directory for subTrash
            a, err = tx.Get(ctx, m.inodeKey(foundIno)).Bytes()
            if err == nil {
               m.parseAttr(a, attr)
            } else if err == redis.Nil {
               *attr = Attr{Typ: foundType, Parent: parent} // corrupt entry
            } else {
               return err
            }
            if inode != nil {
               *inode = foundIno
            }
         }
         return syscall.EEXIST
      }

      var updateParent bool
      now := time.Now()
      if parent != TrashInode {
         if _type == TypeDirectory {
            pattr.Nlink++
            updateParent = true
         }
         if updateParent || now.Sub(time.Unix(pattr.Mtime, int64(pattr.Mtimensec))) >= minUpdateTime {
            pattr.Mtime = now.Unix()
            pattr.Mtimensec = uint32(now.Nanosecond())
            pattr.Ctime = now.Unix()
            pattr.Ctimensec = uint32(now.Nanosecond())
            updateParent = true
         }
      }
      attr.Atime = now.Unix()
      attr.Atimensec = uint32(now.Nanosecond())
      attr.Mtime = now.Unix()
      attr.Mtimensec = uint32(now.Nanosecond())
      attr.Ctime = now.Unix()
      attr.Ctimensec = uint32(now.Nanosecond())
      if pattr.Mode&02000 != 0 || ctx.Value(CtxKey("behavior")) == "Hadoop" || runtime.GOOS == "darwin" {
         attr.Gid = pattr.Gid
         if _type == TypeDirectory && runtime.GOOS == "linux" {
            attr.Mode |= pattr.Mode & 02000
         }
      }

      _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
         pipe.HSet(ctx, m.entryKey(parent), name, m.packEntry(_type, ino))
         if updateParent {
            pipe.Set(ctx, m.inodeKey(parent), m.marshal(&pattr), 0)
         }
         pipe.Set(ctx, m.inodeKey(ino), m.marshal(attr), 0)
         if _type == TypeSymlink {
            pipe.Set(ctx, m.symKey(ino), path, 0)
         }
         pipe.IncrBy(ctx, m.usedSpaceKey(), align4K(0))
         pipe.Incr(ctx, m.totalInodesKey())
         return nil
      })
      return err
   }, m.inodeKey(parent), m.entryKey(parent))
   if err == nil {
      m.updateStats(align4K(0), 1)
   }
   return errno(err)
}

juicefs代码(base.go)::Create->m.of.Open(*inode, attr)

func (m *baseMeta) Create(ctx Context, parent Ino, name string, mode uint16, cumask uint16, flags uint32, inode *Ino, attr *Attr) syscall.Errno {
   if attr == nil {
      attr = &Attr{}
   }
   eno := m.Mknod(ctx, parent, name, TypeFile, mode, cumask, 0, "", inode, attr)
   if eno == syscall.EEXIST && (flags&syscall.O_EXCL) == 0 && attr.Typ == TypeFile {
      eno = 0
   }
   if eno == 0 && inode != nil {
      m.of.Open(*inode, attr)
   }
   return eno
}

type baseMeta struct {
   .....
   of           *openfiles
   ......
   en engine
}

type openfiles struct {
   sync.Mutex
   expire time.Duration
   files  map[Ino]*openFile
}

type openFile struct {
   sync.RWMutex
   attr      Attr
   refs      int
   lastCheck time.Time
   chunks    map[uint32][]Slice
}



func (o *openfiles) Open(ino Ino, attr *Attr) {
   o.Lock()
   defer o.Unlock()
   of, ok := o.files[ino]
   if !ok {
      of = &openFile{}
      of.chunks = make(map[uint32][]Slice)
      o.files[ino] = of
   } else if attr != nil && attr.Mtime == of.attr.Mtime && attr.Mtimensec == of.attr.Mtimensec {
      attr.KeepCache = of.attr.KeepCache
   } else {
      of.chunks = make(map[uint32][]Slice)
   }
   if attr != nil {
      of.attr = *attr
   }
   // next open can keep cache if not modified
   of.attr.KeepCache = true
   of.refs++
   of.lastCheck = time.Now()
}

juicefs代码(base.go)::Create->v.UpdateLength(inode, attr)

if err == 0 {
   v.UpdateLength(inode, attr)
   fh = v.newFileHandle(inode, attr.Length, flags)
   entry = &meta.Entry{Inode: inode, Attr: attr}
}

juicefs代码(pkg/vfs/handle.go)::newFileHandle

func (v *VFS) newFileHandle(inode Ino, length uint64, flags uint32) uint64 {
   h := v.newHandle(inode)
   h.Lock()
   defer h.Unlock()
   switch flags & O_ACCMODE {
   case syscall.O_RDONLY:
      h.reader = v.reader.Open(inode, length)
   case syscall.O_WRONLY: // FUSE writeback_cache mode need reader even for WRONLY
      fallthrough
   case syscall.O_RDWR:
      h.reader = v.reader.Open(inode, length)
      h.writer = v.writer.Open(inode, length)
   }
   return h.fh
}

GETATTR

LOOKUP

GETATTR

LOOKUP

CREATE

GETATTR

WRITE

FLUSH

GETATTR

LOOKUP

RELEASE