storage/mmap.go

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