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 FileMapping
 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                 mms.Append(mm)
 134         }
 135         mms.InitIndex()
 136         return
 137 }
 138
 139 func mmapFile(name string, size int64) (_ FileMapping, err error) {
 140         dir := filepath.Dir(name)
 141         err = os.MkdirAll(dir, 0o750)
 142         if err != nil {
 143                 err = fmt.Errorf("making directory %q: %s", dir, err)
 144                 return
 145         }
 146         var file *os.File
 147         file, err = os.OpenFile(name, os.O_CREATE|os.O_RDWR, 0o666)
 148         if err != nil {
 149                 return
 150         }
 151         defer func() {
 152                 if err != nil {
 153                         file.Close()
 154                 }
 155         }()
 156         var fi os.FileInfo
 157         fi, err = file.Stat()
 158         if err != nil {
 159                 return
 160         }
 161         if fi.Size() < size {
 162                 // I think this is necessary on HFS+. Maybe Linux will SIGBUS too if
 163                 // you overmap a file but I'm not sure.
 164                 err = file.Truncate(size)
 165                 if err != nil {
 166                         return
 167                 }
 168         }
 169         return func() (ret mmapWithFile, err error) {
 170                 ret.f = file
 171                 if size == 0 {
 172                         // Can't mmap() regions with length 0.
 173                         return
 174                 }
 175                 intLen := int(size)
 176                 if int64(intLen) != size {
 177                         err = errors.New("size too large for system")
 178                         return
 179                 }
 180                 ret.mmap, err = mmap.MapRegion(file, intLen, mmap.RDWR, 0, 0)
 181                 if err != nil {
 182                         err = fmt.Errorf("error mapping region: %s", err)
 183                         return
 184                 }
 185                 if int64(len(ret.mmap)) != size {
 186                         panic(len(ret.mmap))
 187                 }
 188                 return
 189         }()
 190 }
 191
 192 // Combines a mmapped region and file into a storage Mmap abstraction, which handles closing the
 193 // mmap file handle.
 194 func WrapFileMapping(region mmap.MMap, file *os.File) FileMapping {
 195         return mmapWithFile{
 196                 f:    file,
 197                 mmap: region,
 198         }
 199 }
 200
 201 type FileMapping = mmap_span.Mmap
 202
 203 // Handles closing the mmap's file handle (needed for Windows). Could be implemented differently by
 204 // OS.
 205 type mmapWithFile struct {
 206         f    *os.File
 207         mmap mmap.MMap
 208 }
 209
 210 func (m mmapWithFile) Flush() error {
 211         return m.mmap.Flush()
 212 }
 213
 214 func (m mmapWithFile) Unmap() (err error) {
 215         if m.mmap != nil {
 216                 err = m.mmap.Unmap()
 217         }
 218         fileErr := m.f.Close()
 219         if err == nil {
 220                 err = fileErr
 221         }
 222         return
 223 }
 224
 225 func (m mmapWithFile) Bytes() []byte {
 226         if m.mmap == nil {
 227                 return nil
 228         }
 229         return m.mmap
 230 }