add seal and verify interface

seal/basicfs/fs.go

+package basicfs
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	
+	"fil_integrate/build/storage"
+	"fil_integrate/build/storiface"
+)
+
+type sectorFile struct {
+	abi.SectorID
+	storiface.SectorFileType
+}
+
+type Provider struct {
+	Root string
+
+	lk         sync.Mutex
+	waitSector map[sectorFile]chan struct{}
+}
+
+func (b *Provider) GetRoot() string {
+	return b.Root
+}
+
+func (b *Provider) AcquireSector(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType, numbers ...int32) (storiface.SectorPaths, func(), error) {
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTUnsealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTSealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTCache.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+
+	done := func() {}
+
+	out := storiface.SectorPaths{
+		ID: id.ID,
+	}
+
+	for _, fileType := range storiface.PathTypes {
+		if !existing.Has(fileType) && !allocate.Has(fileType) {
+			continue
+		}
+
+		b.lk.Lock()
+		if b.waitSector == nil {
+			b.waitSector = map[sectorFile]chan struct{}{}
+		}
+		ch, found := b.waitSector[sectorFile{id.ID, fileType}]
+		if !found {
+			ch = make(chan struct{}, 1)
+			b.waitSector[sectorFile{id.ID, fileType}] = ch
+		}
+		b.lk.Unlock()
+
+		select {
+		case ch <- struct{}{}:
+		case <-ctx.Done():
+			done()
+			return storiface.SectorPaths{}, nil, ctx.Err()
+		}
+
+		path := filepath.Join(b.Root, fileType.String(), storiface.SectorName(id.ID, numbers...))
+
+		prevDone := done
+		done = func() {
+			prevDone()
+			<-ch
+		}
+
+		if !allocate.Has(fileType) {
+			if _, err := os.Stat(path); os.IsNotExist(err) {
+				done()
+				return storiface.SectorPaths{}, nil, storiface.ErrSectorNotFound
+			}
+		}
+
+		storiface.SetPathByType(&out, fileType, path)
+	}
+
+	return out, done, nil
+}
+
+func (b *Provider) AcquireUnsealed(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) {
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTUnsealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTSealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, storiface.FTCache.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return storiface.SectorPaths{}, nil, err
+	}
+
+	done := func() {}
+
+	out := storiface.SectorPaths{
+		ID: id.ID,
+	}
+
+	for _, fileType := range storiface.PathTypes {
+		if !existing.Has(fileType) && !allocate.Has(fileType) {
+			continue
+		}
+
+		b.lk.Lock()
+		if b.waitSector == nil {
+			b.waitSector = map[sectorFile]chan struct{}{}
+		}
+		ch, found := b.waitSector[sectorFile{id.ID, fileType}]
+		if !found {
+			ch = make(chan struct{}, 1)
+			b.waitSector[sectorFile{id.ID, fileType}] = ch
+		}
+		b.lk.Unlock()
+
+		select {
+		case ch <- struct{}{}:
+		case <-ctx.Done():
+			done()
+			return storiface.SectorPaths{}, nil, ctx.Err()
+		}
+
+		path := filepath.Join(b.Root, fileType.String(), "unsealed.dat")
+
+		prevDone := done
+		done = func() {
+			prevDone()
+			<-ch
+		}
+
+		if !allocate.Has(fileType) {
+			if _, err := os.Stat(path); os.IsNotExist(err) {
+				done()
+				return storiface.SectorPaths{}, nil, storiface.ErrSectorNotFound
+			}
+		}
+
+		storiface.SetPathByType(&out, fileType, path)
+	}
+
+	return out, done, nil
+}

seal/partialfile.go

+package seal
+
+import (
+	"encoding/binary"
+	"io"
+	"os"
+	"syscall"
+
+	"github.com/detailyang/go-fallocate"
+	"golang.org/x/xerrors"
+
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"fil_integrate/build/storiface"
+)
+
+const veryLargeRle = 1 << 20
+
+const FallocFlPunchHole = 0x02 // linux/falloc.h
+
+// Sectors can be partially unsealed. We support this by appending a small
+// trailer to each unsealed sector file containing an RLE+ marking which bytes
+// in a sector are unsealed, and which are not (holes)
+
+// unsealed sector files internally have this structure
+// [unpadded (raw) data][rle+][4B LE length fo the rle+ field]
+
+type partialFile struct {
+	maxPiece abi.PaddedPieceSize
+
+	path      string
+	allocated rlepluslazy.RLE
+
+	file *os.File
+}
+
+func writeTrailer(maxPieceSize int64, w *os.File, r rlepluslazy.RunIterator) error {
+	trailer, err := rlepluslazy.EncodeRuns(r, nil)
+	if err != nil {
+		return xerrors.Errorf("encoding trailer: %w", err)
+	}
+
+	// maxPieceSize == unpadded(sectorSize) == trailer start
+	if _, err := w.Seek(maxPieceSize, io.SeekStart); err != nil {
+		return xerrors.Errorf("seek to trailer start: %w", err)
+	}
+
+	rb, err := w.Write(trailer)
+	if err != nil {
+		return xerrors.Errorf("writing trailer data: %w", err)
+	}
+
+	if err := binary.Write(w, binary.LittleEndian, uint32(len(trailer))); err != nil {
+		return xerrors.Errorf("writing trailer length: %w", err)
+	}
+
+	return w.Truncate(maxPieceSize + int64(rb) + 4)
+}
+
+func createPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialFile, error) {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644) // nolint
+	if err != nil {
+		return nil, xerrors.Errorf("openning partial file '%s': %w", path, err)
+	}
+
+	err = func() error {
+		err := fallocate.Fallocate(f, 0, int64(maxPieceSize))
+		if errno, ok := err.(syscall.Errno); ok {
+			if errno == syscall.EOPNOTSUPP || errno == syscall.ENOSYS {
+				log.Warnf("could not allocated space, ignoring: %v", errno)
+				err = nil // log and ignore
+			}
+		}
+		if err != nil {
+			return xerrors.Errorf("fallocate '%s': %w", path, err)
+		}
+
+		if err := writeTrailer(int64(maxPieceSize), f, &rlepluslazy.RunSliceIterator{}); err != nil {
+			return xerrors.Errorf("writing trailer: %w", err)
+		}
+
+		return nil
+	}()
+	if err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+	if err := f.Close(); err != nil {
+		return nil, xerrors.Errorf("close empty partial file: %w", err)
+	}
+
+	return openPartialFile(maxPieceSize, path)
+}
+
+func openPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialFile, error) {
+	f, err := os.OpenFile(path, os.O_RDWR, 0644) // nolint
+	if err != nil {
+		return nil, xerrors.Errorf("openning partial file '%s': %w", path, err)
+	}
+
+	var rle rlepluslazy.RLE
+	err = func() error {
+		st, err := f.Stat()
+		if err != nil {
+			return xerrors.Errorf("stat '%s': %w", path, err)
+		}
+		if st.Size() < int64(maxPieceSize) {
+			return xerrors.Errorf("sector file '%s' was smaller than the sector size %d < %d", path, st.Size(), maxPieceSize)
+		}
+		// read trailer
+		var tlen [4]byte
+		_, err = f.ReadAt(tlen[:], st.Size()-int64(len(tlen)))
+		if err != nil {
+			return xerrors.Errorf("reading trailer length: %w", err)
+		}
+
+		// sanity-check the length
+		trailerLen := binary.LittleEndian.Uint32(tlen[:])
+		expectLen := int64(trailerLen) + int64(len(tlen)) + int64(maxPieceSize)
+		if expectLen != st.Size() {
+			return xerrors.Errorf("file '%s' has inconsistent length; has %d bytes; expected %d (%d trailer, %d sector data)", path, st.Size(), expectLen, int64(trailerLen)+int64(len(tlen)), maxPieceSize)
+		}
+		if trailerLen > veryLargeRle {
+			log.Warnf("Partial file '%s' has a VERY large trailer with %d bytes", path, trailerLen)
+		}
+
+		trailerStart := st.Size() - int64(len(tlen)) - int64(trailerLen)
+		if trailerStart != int64(maxPieceSize) {
+			return xerrors.Errorf("expected sector size to equal trailer start index")
+		}
+
+		trailerBytes := make([]byte, trailerLen)
+		_, err = f.ReadAt(trailerBytes, trailerStart)
+		if err != nil {
+			return xerrors.Errorf("reading trailer: %w", err)
+		}
+
+		rle, err = rlepluslazy.FromBuf(trailerBytes)
+		if err != nil {
+			return xerrors.Errorf("decoding trailer: %w", err)
+		}
+
+		it, err := rle.RunIterator()
+		if err != nil {
+			return xerrors.Errorf("getting trailer run iterator: %w", err)
+		}
+
+		f, err := rlepluslazy.Fill(it)
+		if err != nil {
+			return xerrors.Errorf("filling bitfield: %w", err)
+		}
+		lastSet, err := rlepluslazy.Count(f)
+		if err != nil {
+			return xerrors.Errorf("finding last set byte index: %w", err)
+		}
+
+		if lastSet > uint64(maxPieceSize) {
+			return xerrors.Errorf("last set byte at index higher than sector size: %d > %d", lastSet, maxPieceSize)
+		}
+
+		return nil
+	}()
+	if err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+
+	return &partialFile{
+		maxPiece:  maxPieceSize,
+		path:      path,
+		allocated: rle,
+		file:      f,
+	}, nil
+}
+
+func (pf *partialFile) Close() error {
+	return pf.file.Close()
+}
+
+func (pf *partialFile) Writer(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) (io.Writer, error) {
+	if _, err := pf.file.Seek(int64(offset), io.SeekStart); err != nil {
+		return nil, xerrors.Errorf("seek piece start: %w", err)
+	}
+
+	{
+		have, err := pf.allocated.RunIterator()
+		if err != nil {
+			return nil, err
+		}
+
+		and, err := rlepluslazy.And(have, pieceRun(offset, size))
+		if err != nil {
+			return nil, err
+		}
+
+		c, err := rlepluslazy.Count(and)
+		if err != nil {
+			return nil, err
+		}
+
+		if c > 0 {
+			log.Warnf("getting partial file writer overwriting %d allocated bytes", c)
+		}
+	}
+
+	return pf.file, nil
+}
+
+func (pf *partialFile) MarkAllocated(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) error {
+	have, err := pf.allocated.RunIterator()
+	if err != nil {
+		return err
+	}
+
+	ored, err := rlepluslazy.Or(have, pieceRun(offset, size))
+	if err != nil {
+		return err
+	}
+
+	if err := writeTrailer(int64(pf.maxPiece), pf.file, ored); err != nil {
+		return xerrors.Errorf("writing trailer: %w", err)
+	}
+
+	return nil
+}
+
+func (pf *partialFile) Free(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) error {
+	have, err := pf.allocated.RunIterator()
+	if err != nil {
+		return err
+	}
+
+	if err := Deallocate(pf.file, int64(offset), int64(size)); err != nil {
+		return xerrors.Errorf("deallocating: %w", err)
+	}
+
+	s, err := rlepluslazy.Subtract(have, pieceRun(offset, size))
+	if err != nil {
+		return err
+	}
+
+	if err := writeTrailer(int64(pf.maxPiece), pf.file, s); err != nil {
+		return xerrors.Errorf("writing trailer: %w", err)
+	}
+
+	return nil
+}
+
+func (pf *partialFile) Reader(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) (*os.File, error) {
+	if _, err := pf.file.Seek(int64(offset), io.SeekStart); err != nil {
+		return nil, xerrors.Errorf("seek piece start: %w", err)
+	}
+
+	{
+		have, err := pf.allocated.RunIterator()
+		if err != nil {
+			return nil, err
+		}
+
+		and, err := rlepluslazy.And(have, pieceRun(offset, size))
+		if err != nil {
+			return nil, err
+		}
+
+		c, err := rlepluslazy.Count(and)
+		if err != nil {
+			return nil, err
+		}
+
+		if c != uint64(size) {
+			log.Warnf("getting partial file reader reading %d unallocated bytes", uint64(size)-c)
+		}
+	}
+
+	return pf.file, nil
+}
+
+func (pf *partialFile) Allocated() (rlepluslazy.RunIterator, error) {
+	return pf.allocated.RunIterator()
+}
+
+func (pf *partialFile) HasAllocated(offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	have, err := pf.Allocated()
+	if err != nil {
+		return false, err
+	}
+
+	u, err := rlepluslazy.And(have, pieceRun(offset.Padded(), size.Padded()))
+	if err != nil {
+		return false, err
+	}
+
+	uc, err := rlepluslazy.Count(u)
+	if err != nil {
+		return false, err
+	}
+
+	return abi.PaddedPieceSize(uc) == size.Padded(), nil
+}
+
+func pieceRun(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) rlepluslazy.RunIterator {
+	var runs []rlepluslazy.Run
+	if offset > 0 {
+		runs = append(runs, rlepluslazy.Run{
+			Val: false,
+			Len: uint64(offset),
+		})
+	}
+
+	runs = append(runs, rlepluslazy.Run{
+		Val: true,
+		Len: uint64(size),
+	})
+
+	return &rlepluslazy.RunSliceIterator{Runs: runs}
+}
+
+func Deallocate(file *os.File, offset int64, length int64) error {
+	if length == 0 {
+		return nil
+	}
+
+	err := syscall.Fallocate(int(file.Fd()), FallocFlPunchHole, offset, length)
+	if errno, ok := err.(syscall.Errno); ok {
+		if errno == syscall.EOPNOTSUPP || errno == syscall.ENOSYS {
+			log.Warnf("could not deallocate space, ignoring: %v", errno)
+			err = nil // log and ignore
+		}
+	}
+
+	return err
+}

seal/type.go

+package seal
+
+import(
+	"context"
+	"io"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
+	spproof "fil_integrate/build/proof"
+	"fil_integrate/build/storage"
+	"fil_integrate/build/storiface"
+	"fil_integrate/seal/basicfs"
+)
+
+//interface
+type SectorSealer interface{
+	AddPiece(ctx context.Context, sector storage.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storage.Data, numbers ...int32) (abi.PieceInfo, error)
+	CheckPieceAndDataRoot(sid storage.SectorRef, commd cid.Cid, pieces []abi.PieceInfo) (bool, error)
+	Sealed(ctx context.Context, sid storage.SectorRef, seed abi.InteractiveSealRandomness, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.SectorCids, storage.Proof, error) 
+	GenProofForC2( ctx context.Context, sid storage.SectorRef, seed abi.InteractiveSealRandomness, ticket abi.SealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Proof, error)
+	GenProofForWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []spproof.SectorInfo, randomness abi.PoStRandomness) ([]spproof.PoStProof, []abi.SectorID, error)
+	UnsealedRange(ctx context.Context, sid storage.SectorRef, sectorSize abi.SectorSize, ticket abi.SealRandomness, commd cid.Cid, out io.Writer, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) error
+	AggregateSealProofs(aggregateInfo spproof.AggregateSealVerifyProofAndInfos, proofs [][]byte) ([]byte, error)
+	AggregateWindowPoStProofs(aggregateInfo spproof.AggregateWindowPostInfos, proofs []spproof.PoStProof) ([]byte, error)
+}
+
+type SectorVerifier interface{
+	VerifySeal(info spproof.SealVerifyInfo) (bool, error)
+	VerifyAggregateSeals(aggregate spproof.AggregateSealVerifyProofAndInfos) (bool, error)
+	VerifyWindowPoSt(info spproof.WindowPoStVerifyInfo) (bool, error)
+	VerifyAggregateWindowPostProofs(aggregateInfo spproof.AggregateWindowPostInfos, sealedSectors [][]spproof.SectorInfo) (bool, error)
+}
+
+type SectorProvider interface {
+	// * returns storiface.ErrSectorNotFound if a requested existing sector doesn't exist
+	// * returns an error when allocate is set, and existing isn't, and the sector exists
+	GetRoot() (string)
+	AcquireUnsealed(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error)
+	AcquireSector(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType, numbers ...int32) (storiface.SectorPaths, func(), error)
+}
+
+var _ SectorProvider = &basicfs.Provider{}
\ No newline at end of file

seal/unseal_ranges.go

+package seal
+
+import (
+	"golang.org/x/xerrors"
+
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"fil_integrate/build/storiface"
+)
+
+// merge gaps between ranges which are close to each other
+//  TODO: more benchmarking to come up with more optimal number
+const mergeGaps = 32 << 20
+
+// TODO const expandRuns = 16 << 20 // unseal more than requested for future requests
+
+func computeUnsealRanges(unsealed rlepluslazy.RunIterator, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (rlepluslazy.RunIterator, error) {
+	todo := pieceRun(offset.Padded(), size.Padded())
+	todo, err := rlepluslazy.Subtract(todo, unsealed)
+	if err != nil {
+		return nil, xerrors.Errorf("compute todo-unsealed: %w", err)
+	}
+
+	return rlepluslazy.JoinClose(todo, mergeGaps)
+}