Revert changes to fullreader

fuse.go

@@ -11,10 +11,8 @@ import (
 	"github.com/CalebQ42/squashfs/internal/inode"
 )
 
-// Mounts the archive to the given mountpoint using fuse3.
+// Mounts the archive to the given mountpoint using fuse3. Non-blocking.
-// Blocks until the arhive is unmounted.
+// If Unmount does not get called, the mount point must be unmounted using umount before the directory can be used again.
-// Hightly suggested to run in a goroutine.
-// Will take a moment before MountWait and Unmount will work correctly.
 func (r *Reader) Mount(mountpoint string) (err error) {
 	if r.con != nil {
 		return errors.New("squashfs archive already mounted")
@@ -23,14 +21,19 @@ func (r *Reader) Mount(mountpoint string) (err error) {
 	if err != nil {
 		return
 	}
-	err = fs.Serve(r.con, &squashFuse{r: r})
+	<-r.con.Ready
+	r.mountDone = make(chan struct{})
+	go func() {
+		fs.Serve(r.con, &squashFuse{r: r})
+		close(r.mountDone)
+	}()
 	return
 }
 
 // Blocks until the mount ends.
 func (r *Reader) MountWait() {
-	if r.con != nil {
+	if r.mountDone != nil {
-		<-r.con.Ready
+		<-r.mountDone
 	}
 }
 

internal/data/fullreader.go

@@ -2,7 +2,6 @@ package data
 
 import (
 	"io"
-	"sync"
 
 	"github.com/CalebQ42/squashfs/internal/decompress"
 	"github.com/CalebQ42/squashfs/internal/toreader"
@@ -27,9 +26,9 @@ func NewFullReader(r io.ReaderAt, start uint64, d decompress.Decompressor, block
 	}
 }
 
-func (r *FullReader) AddFragment(rdr func() (io.Reader, error), size uint32) {
+func (r *FullReader) AddFragment(rdr func() (io.Reader, error)) {
 	r.fragRdr = rdr
-	r.sizes = append(r.sizes, size)
+	r.sizes = append(r.sizes, 0)
 }
 
 type outDat struct {
@@ -38,50 +37,49 @@ type outDat struct {
 	i    int
 }
 
-func (r FullReader) process(index int, offset int64, od *outDat, out chan *outDat) {
+func (r FullReader) process(index int, offset int64, out chan outDat) {
-	defer func() {
+	var err error
-		out <- od
+	var dat []byte
-	}()
+	var rdr io.ReadCloser
-	od.i = index
 	size := realSize(r.sizes[index])
 	if size == 0 {
-		od.err = nil
+		out <- outDat{
-		od.data = make([]byte, r.blockSize)
+			i:    index,
+			err:  nil,
+			data: make([]byte, r.blockSize),
+		}
 		return
 	}
+	// rdr := io.LimitReader(toreader.NewReader(r.r, offset), int64(size))
 	if size == r.sizes[index] {
 		if dec, ok := r.d.(decompress.Decoder); ok {
-			dat := make([]byte, size)
+			dat = make([]byte, size)
-			_, od.err = r.r.ReadAt(dat, offset)
+			_, err = r.r.ReadAt(dat, offset)
-			if od.err != nil {
+			if err == nil {
-				return
+				dat, err = dec.Decode(dat, int(r.blockSize))
 			}
-			od.data, od.err = dec.Decode(dat, int(r.blockSize))
-			return
-		}
-		var rdr io.ReadCloser
-		rdr, od.err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
-		if od.err != nil {
-			return
-		}
-		od.data = make([]byte, r.blockSize)
-		var read int
-		read, od.err = rdr.Read(od.data)
-		od.data = od.data[:read]
-		rdr.Close()
 		} else {
-		od.data = make([]byte, size)
+			rdr, err = r.d.Reader(io.LimitReader(toreader.NewReader(r.r, offset), int64(size)))
-		_, od.err = r.r.ReadAt(od.data, offset)
+			if err == nil {
+				dat, err = io.ReadAll(rdr)
+			}
+		}
+	} else {
+		dat = make([]byte, size)
+		_, err = r.r.ReadAt(dat, offset)
+	}
+	out <- outDat{
+		i:    index,
+		err:  err,
+		data: dat,
+	}
+	if clr, ok := rdr.(io.Closer); ok {
+		clr.Close()
 	}
 }
 
 func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
-	pol := &sync.Pool{
+	out := make(chan outDat, len(r.sizes))
-		New: func() any {
-			return new(outDat)
-		},
-	}
-	out := make(chan *outDat, len(r.sizes))
 	offset := r.start
 	num := len(r.sizes)
 	start := off / int64(r.blockSize)
@@ -101,42 +99,40 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 			offset += uint64(realSize(r.sizes[i]))
 			continue
 		}
-		od := pol.Get().(*outDat)
 		if i == num-1 && r.fragRdr != nil {
 			go func() {
-				defer func() {
-					out <- od
-				}()
 				rdr, e := r.fragRdr()
 				if err != nil {
-					od.i = num - 1
+					out <- outDat{
-					od.err = e
+						i:   num - 1,
+						err: e,
+					}
 					return
 				}
-				od.data = make([]byte, r.sizes[num-1])
+				dat, e := io.ReadAll(rdr)
-				_, e = rdr.Read(od.data)
+				out <- outDat{
-				od.i = num - 1
+					i:    num - 1,
-				od.err = e
+					err:  e,
+					data: dat,
+				}
 				if clr, ok := rdr.(io.Closer); ok {
 					clr.Close()
 				}
 			}()
 			continue
 		}
-		go r.process(i, int64(offset), od, out)
+		go r.process(i, int64(offset), out)
 		offset += uint64(realSize(r.sizes[i]))
 	}
-	cur := start
 	cache := make(map[int]outDat)
-	for dat := range out {
+	for cur := start; cur < int64(end); {
+		dat := <-out
 		if dat.err != nil {
 			err = dat.err
-			pol.Put(dat)
 			return
 		}
 		if dat.i != int(cur) {
-			cache[dat.i] = *dat
+			cache[dat.i] = dat
-			pol.Put(dat)
 			continue
 		}
 		if cur == start {
@@ -147,18 +143,16 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 		}
 		n += len(dat.data)
 		cur++
-		pol.Put(dat)
 		var ok bool
-		var curDat outDat
 		for {
-			curDat, ok = cache[int(cur)]
+			dat, ok = cache[int(cur)]
 			if !ok {
 				break
 			}
-			for i := range curDat.data {
+			for i := range dat.data {
-				p[n+i] = curDat.data[i]
+				p[n+i] = dat.data[i]
 			}
-			n += len(curDat.data)
+			n += len(dat.data)
 			cur++
 			delete(cache, int(cur))
 		}
@@ -170,56 +164,45 @@ func (r FullReader) ReadAt(p []byte, off int64) (n int, err error) {
 }
 
 func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
-	pol := &sync.Pool{
+	out := make(chan outDat, len(r.sizes))
-		New: func() any {
-			return new(outDat)
-		},
-	}
-	out := make(chan *outDat, len(r.sizes))
 	offset := r.start
 	num := len(r.sizes)
 	for i := 0; i < num; i++ {
-		od := pol.Get().(*outDat)
 		if i == num-1 && r.fragRdr != nil {
 			go func() {
-				defer func() {
-					out <- od
-				}()
 				rdr, e := r.fragRdr()
 				if err != nil {
-					od.i = num - 1
+					out <- outDat{
-					od.err = e
+						i:   num - 1,
+						err: e,
+					}
 					return
 				}
-				buf := make([]byte, r.sizes[num-1])
+				dat, e := io.ReadAll(rdr)
-				_, e = rdr.Read(buf)
+				out <- outDat{
-				od.i = num - 1
+					i:    num - 1,
-				od.err = e
+					err:  e,
-				od.data = buf
+					data: dat,
+				}
 				if clr, ok := rdr.(io.Closer); ok {
 					clr.Close()
 				}
 			}()
 			continue
 		}
-		go r.process(i, int64(offset), od, out)
+		go r.process(i, int64(offset), out)
 		offset += uint64(realSize(r.sizes[i]))
 	}
-	wt, ok := w.(io.WriterAt)
-	if !ok {
-		var cur int
 	cache := make(map[int]outDat)
 	var tmpN int
-		var dat *outDat
+	for cur := 0; cur < num; {
-		for cur < len(r.sizes) {
+		dat := <-out
-			dat = <-out
-			defer pol.Put(dat)
 		if dat.err != nil {
 			err = dat.err
 			return
 		}
 		if dat.i != cur {
-				cache[dat.i] = *dat
+			cache[dat.i] = dat
 			continue
 		}
 		tmpN, err = w.Write(dat.data)
@@ -229,13 +212,12 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 		}
 		cur++
 		var ok bool
-			var curDat outDat
 		for {
-				curDat, ok = cache[cur]
+			dat, ok = cache[cur]
 			if !ok {
 				break
 			}
-				tmpN, err = w.Write(curDat.data)
+			tmpN, err = w.Write(dat.data)
 			n += int64(tmpN)
 			if err != nil {
 				return
@@ -243,22 +225,5 @@ func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
 			cur++
 		}
 	}
-	} else {
-		var done int
-		var dat *outDat
-		for done < len(r.sizes) {
-			dat = <-out
-			defer pol.Put(dat)
-			if dat.err != nil {
-				err = dat.err
-				return
-			}
-			_, err = wt.WriteAt(dat.data, int64(dat.i*int(r.blockSize)))
-			if err != nil {
-				return
-			}
-			done++
-		}
-	}
 	return
 }

reader.go

@@ -18,6 +18,7 @@ import (
 type Reader struct {
 	*FS
 	con         *fuse.Conn
+	mountDone   chan struct{}
 	d           decompress.Decompressor
 	r           io.ReaderAt
 	fragEntries []fragEntry

reader_inode.go

@@ -70,7 +70,7 @@ func (r Reader) getReaders(i inode.Inode) (full *data.FullReader, rdr *data.Read
 			}
 			fragRdr = io.LimitReader(fragRdr, int64(fragSize))
 			return fragRdr, nil
-		}, fragSize)
+		})
 		var fragRdr io.Reader
 		fragRdr, err = r.fragReader(fragInd)
 		if err != nil {