ffiwrapper: Fix RegenerateSectorKey

storage/paths/fetch.go

@@ -91,7 +91,7 @@ func FetchWithTemp(ctx context.Context, urls []string, dest string, header http.
 			continue
 		}
 
-		if err := move(tempDest, dest); err != nil {
+		if err := Move(tempDest, dest); err != nil {
 			return "", xerrors.Errorf("fetch move error %s -> %s: %w", tempDest, dest, err)
 		}
 

storage/paths/local.go

@@ -720,7 +720,7 @@ func (st *Local) MoveStorage(ctx context.Context, s storiface.SectorRef, types s
 			return xerrors.Errorf("dropping source sector from index: %w", err)
 		}
 
-		if err := move(storiface.PathByType(src, fileType), storiface.PathByType(dest, fileType)); err != nil {
+		if err := Move(storiface.PathByType(src, fileType), storiface.PathByType(dest, fileType)); err != nil {
 			// TODO: attempt some recovery (check if src is still there, re-declare)
 			return xerrors.Errorf("moving sector %v(%d): %w", s, fileType, err)
 		}

storage/paths/remote.go

@@ -249,7 +249,7 @@ func (r *Remote) acquireFromRemote(ctx context.Context, s abi.SectorID, fileType
 				continue
 			}
 
-			if err := move(tempDest, dest); err != nil {
+			if err := Move(tempDest, dest); err != nil {
 				return "", xerrors.Errorf("fetch move error (storage %s) %s -> %s: %w", info.ID, tempDest, dest, err)
 			}
 

storage/paths/util_unix.go

@@ -12,7 +12,7 @@ import (
 	"golang.org/x/xerrors"
 )
 
-func move(from, to string) error {
+func Move(from, to string) error {
 	from, err := homedir.Expand(from)
 	if err != nil {
 		return xerrors.Errorf("move: expanding from: %w", err)

storage/sealer/ffiwrapper/sealer_cgo.go

@@ -10,6 +10,7 @@ import (
 	"crypto/rand"
 	"encoding/base64"
 	"encoding/json"
+	"github.com/filecoin-project/lotus/storage/sealer/proofpaths"
 	"io"
 	"math/bits"
 	"os"
@@ -31,7 +32,6 @@ import (
 
 	"github.com/filecoin-project/lotus/lib/nullreader"
 	spaths "github.com/filecoin-project/lotus/storage/paths"
-	nr "github.com/filecoin-project/lotus/storage/pipeline/lib/nullreader"
 	"github.com/filecoin-project/lotus/storage/sealer/fr32"
 	"github.com/filecoin-project/lotus/storage/sealer/partialfile"
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
@@ -434,21 +434,14 @@ func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector stori
 		return paths, done, xerrors.Errorf("reading sector key: %w", err)
 	}
 
-	// Sector key can't be found, so let's regenerate it
 	sectorSize, err := sector.ProofType.SectorSize()
 	if err != nil {
 		return paths, done, xerrors.Errorf("retrieving sector size: %w", err)
 	}
-	paddedSize := abi.PaddedPieceSize(sectorSize)
 
-	_, err = sb.AddPiece(ctx, sector, nil, paddedSize.Unpadded(), nr.NewNullReader(paddedSize.Unpadded()))
+	err = sb.RegenerateSectorKey(ctx, sector, randomness, zerocomm.ZeroPieceCommitment(abi.PaddedPieceSize(sectorSize).Unpadded()))
 	if err != nil {
-		return paths, done, xerrors.Errorf("recomputing empty data: %w", err)
-	}
-
-	err = sb.RegenerateSectorKey(ctx, sector, randomness, []abi.PieceInfo{{PieceCID: zerocomm.ZeroPieceCommitment(paddedSize.Unpadded()), Size: paddedSize}})
-	if err != nil {
-		return paths, done, xerrors.Errorf("during pc1: %w", err)
+		return paths, done, xerrors.Errorf("regenerating sector key: %w", err)
 	}
 
 	// Sector key should exist now, let's grab the paths
@@ -687,44 +680,62 @@ func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector storif
 	return true, nil
 }
 
-func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) error {
+func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, keyDataCid cid.Cid) error {
 	paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTCache, storiface.FTSealed, storiface.PathSealing)
 	if err != nil {
 		return xerrors.Errorf("acquiring sector paths: %w", err)
 	}
 	defer done()
 
-	e, err := os.OpenFile(paths.Sealed, os.O_RDWR|os.O_CREATE, 0644) // nolint:gosec
+	// stat paths.Sealed, make sure it doesn't exist
+	_, err = os.Stat(paths.Sealed)
+	if err == nil {
+		return xerrors.Errorf("sealed file exists before regenerating sector key")
+	}
+	if !os.IsNotExist(err) {
+		return xerrors.Errorf("stat sealed path: %w", err)
+	}
+
+	// prepare SDR params
+	commp, err := commcid.CIDToDataCommitmentV1(keyDataCid)
 	if err != nil {
-		return xerrors.Errorf("ensuring sealed file exists: %w", err)
-	}
-	if err := e.Close(); err != nil {
-		return err
+		return xerrors.Errorf("computing commP: %w", err)
 	}
 
-	var sum abi.UnpaddedPieceSize
-	for _, piece := range pieces {
-		sum += piece.Size.Unpadded()
-	}
-	ssize, err := sector.ProofType.SectorSize()
+	replicaID, err := sector.ProofType.ReplicaId(sector.ID.Miner, sector.ID.Number, ticket, commp)
 	if err != nil {
-		return err
-	}
-	ussize := abi.PaddedPieceSize(ssize).Unpadded()
-	if sum != ussize {
-		return xerrors.Errorf("aggregated piece sizes don't match sector size: %d != %d (%d)", sum, ussize, int64(ussize-sum))
+		return xerrors.Errorf("computing replica id: %w", err)
 	}
 
-	panic("todo")
-
+	// generate new sector key
 	err = ffi.GenerateSDR(
 		sector.ProofType,
 		paths.Cache,
-		[32]byte{},
+		replicaID,
 	)
 	if err != nil {
 		return xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err)
 	}
+
+	// move the last layer (sector key) to the sealed location
+	layerCount, err := proofpaths.SDRLayers(sector.ProofType)
+	if err != nil {
+		return xerrors.Errorf("getting SDR layer count: %w", err)
+	}
+
+	err = spaths.Move(proofpaths.LayerFileName(layerCount), paths.Sealed)
+	if err != nil {
+		return xerrors.Errorf("moving sector key: %w", err)
+	}
+
+	// remove other layer files
+	for i := 1; i < layerCount; i++ {
+		err = os.Remove(proofpaths.LayerFileName(i))
+		if err != nil {
+			return xerrors.Errorf("removing layer file %d: %w", i, err)
+		}
+	}
+
 	return nil
 }
 

storage/sealer/proofpaths/cachefiles.go

@@ -0,0 +1,30 @@
+package proofpaths
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+var dataFilePrefix = "sc-02-data-"
+
+func LayerFileName(layer int) string {
+	return fmt.Sprintf("%slayer-%d.dat", dataFilePrefix, layer)
+}
+
+func SDRLayers(spt abi.RegisteredSealProof) (int, error) {
+	switch spt {
+	case abi.RegisteredSealProof_StackedDrg2KiBV1, abi.RegisteredSealProof_StackedDrg2KiBV1_1:
+		return 2, nil
+	case abi.RegisteredSealProof_StackedDrg8MiBV1, abi.RegisteredSealProof_StackedDrg8MiBV1_1:
+		return 2, nil
+	case abi.RegisteredSealProof_StackedDrg512MiBV1, abi.RegisteredSealProof_StackedDrg512MiBV1_1:
+		return 2, nil
+	case abi.RegisteredSealProof_StackedDrg32GiBV1, abi.RegisteredSealProof_StackedDrg32GiBV1_1:
+		return 11, nil
+	case abi.RegisteredSealProof_StackedDrg64GiBV1, abi.RegisteredSealProof_StackedDrg64GiBV1_1:
+		return 11, nil
+	default:
+		return 0, fmt.Errorf("unsupported proof type: %v", spt)
+	}
+}

storage/sealer/proofpaths/cachefiles_test.go

@@ -0,0 +1,16 @@
+package proofpaths
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+func TestSDRLayersDefined(t *testing.T) {
+	for proof := range abi.SealProofInfos {
+		_, err := SDRLayers(proof)
+		require.NoError(t, err)
+	}
+}