storage/mmap.go

   1 //go:build !wasm
   2 // +build !wasm
   3
   4 package storage
   5
   6 import (
   7         "errors"
   8         "fmt"
   9         "io"
  10         "os"
  11         "path/filepath"
  12
  13         "github.com/anacrolix/missinggo/v2"
  14         "github.com/edsrzf/mmap-go"
  15
  16         "github.com/anacrolix/torrent/metainfo"
  17         "github.com/anacrolix/torrent/mmap_span"
  18 )
  19
  20 type mmapClientImpl struct {
  21         baseDir string
  22         pc      PieceCompletion
  23 }
  24
  25 // TODO: Support all the same native filepath configuration that NewFileOpts provides.
  26 func NewMMap(baseDir string) ClientImplCloser {
  27         return NewMMapWithCompletion(baseDir, pieceCompletionForDir(baseDir))
  28 }
  29
  30 func NewMMapWithCompletion(baseDir string, completion PieceCompletion) *mmapClientImpl {
  31         return &mmapClientImpl{
  32                 baseDir: baseDir,
  33                 pc:      completion,
  34         }
  35 }
  36
  37 func (s *mmapClientImpl) OpenTorrent(info *metainfo.Info, infoHash metainfo.Hash) (_ TorrentImpl, err error) {
  38         span, err := mMapTorrent(info, s.baseDir)
  39         t := &mmapTorrentStorage{
  40                 infoHash: infoHash,
  41                 span:     span,
  42                 pc:       s.pc,
  43         }
  44         return TorrentImpl{Piece: t.Piece, Close: t.Close, Flush: t.Flush}, err
  45 }
  46
  47 func (s *mmapClientImpl) Close() error {
  48         return s.pc.Close()
  49 }
  50
  51 type mmapTorrentStorage struct {
  52         infoHash metainfo.Hash
  53         span     *mmap_span.MMapSpan
  54         pc       PieceCompletionGetSetter
  55 }
  56
  57 func (ts *mmapTorrentStorage) Piece(p metainfo.Piece) PieceImpl {
  58         return mmapStoragePiece{
  59                 pc:       ts.pc,
  60                 p:        p,
  61                 ih:       ts.infoHash,
  62                 ReaderAt: io.NewSectionReader(ts.span, p.Offset(), p.Length()),
  63                 WriterAt: missinggo.NewSectionWriter(ts.span, p.Offset(), p.Length()),
  64         }
  65 }
  66
  67 func (ts *mmapTorrentStorage) Close() error {
  68         errs := ts.span.Close()
  69         if len(errs) > 0 {
  70                 return errs[0]
  71         }
  72         return nil
  73 }
  74
  75 func (ts *mmapTorrentStorage) Flush() error {
  76         errs := ts.span.Flush()
  77         if len(errs) > 0 {
  78                 return errs[0]
  79         }
  80         return nil
  81 }
  82
  83 type mmapStoragePiece struct {
  84         pc PieceCompletionGetSetter
  85         p  metainfo.Piece
  86         ih metainfo.Hash
  87         io.ReaderAt
  88         io.WriterAt
  89 }
  90
  91 func (me mmapStoragePiece) pieceKey() metainfo.PieceKey {
  92         return metainfo.PieceKey{me.ih, me.p.Index()}
  93 }
  94
  95 func (sp mmapStoragePiece) Completion() Completion {
  96         c, err := sp.pc.Get(sp.pieceKey())
  97         if err != nil {
  98                 panic(err)
  99         }
 100         return c
 101 }
 102
 103 func (sp mmapStoragePiece) MarkComplete() error {
 104         sp.pc.Set(sp.pieceKey(), true)
 105         return nil
 106 }
 107
 108 func (sp mmapStoragePiece) MarkNotComplete() error {
 109         sp.pc.Set(sp.pieceKey(), false)
 110         return nil
 111 }
 112
 113 func mMapTorrent(md *metainfo.Info, location string) (mms *mmap_span.MMapSpan, err error) {
 114         mms = &mmap_span.MMapSpan{}
 115         defer func() {
 116                 if err != nil {
 117                         mms.Close()
 118                 }
 119         }()
 120         for _, miFile := range md.UpvertedFiles() {
 121                 var safeName string
 122                 safeName, err = ToSafeFilePath(append([]string{md.Name}, miFile.Path...)...)
 123                 if err != nil {
 124                         return
 125                 }
 126                 fileName := filepath.Join(location, safeName)
 127                 var mm mmap.MMap
 128                 mm, err = mmapFile(fileName, miFile.Length)
 129                 if err != nil {
 130                         err = fmt.Errorf("file %q: %s", miFile.DisplayPath(md), err)
 131                         return
 132                 }
 133                 if mm != nil {
 134                         mms.Append(mm)
 135                 }
 136         }
 137         mms.InitIndex()
 138         return
 139 }
 140
 141 func mmapFile(name string, size int64) (ret mmap.MMap, err error) {
 142         dir := filepath.Dir(name)
 143         err = os.MkdirAll(dir, 0o750)
 144         if err != nil {
 145                 err = fmt.Errorf("making directory %q: %s", dir, err)
 146                 return
 147         }
 148         var file *os.File
 149         file, err = os.OpenFile(name, os.O_CREATE|os.O_RDWR, 0o666)
 150         if err != nil {
 151                 return
 152         }
 153         defer file.Close()
 154         var fi os.FileInfo
 155         fi, err = file.Stat()
 156         if err != nil {
 157                 return
 158         }
 159         if fi.Size() < size {
 160                 // I think this is necessary on HFS+. Maybe Linux will SIGBUS too if
 161                 // you overmap a file but I'm not sure.
 162                 err = file.Truncate(size)
 163                 if err != nil {
 164                         return
 165                 }
 166         }
 167         if size == 0 {
 168                 // Can't mmap() regions with length 0.
 169                 return
 170         }
 171         intLen := int(size)
 172         if int64(intLen) != size {
 173                 err = errors.New("size too large for system")
 174                 return
 175         }
 176         ret, err = mmap.MapRegion(file, intLen, mmap.RDWR, 0, 0)
 177         if err != nil {
 178                 err = fmt.Errorf("error mapping region: %s", err)
 179                 return
 180         }
 181         if int64(len(ret)) != size {
 182                 panic(len(ret))
 183         }
 184         return
 185 }