src/sys/pkg/bin/pkgfs/pkgfs/metafar.go - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //go:build !build_with_native_toolchain
 // +build !build_with_native_toolchain

 package pkgfs

 import (
 	"encoding/binary"
 	"fmt"
 	"path/filepath"
 	"sort"
 	"strings"
 	"time"

 	"fidl/fuchsia/io"

 	"go.fuchsia.dev/fuchsia/src/lib/thinfs/fs"
 	"go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go"

 	"syscall"
 	"syscall/zx"
 	"syscall/zx/fdio"
 	zxio "syscall/zx/io"
 )

 func newMetaFar(blob string, fs *Filesystem) (*metaFar, error) {
 	mf := &metaFar{
 		blob: blob,
 		fs:   fs,
 	}
 	fr, err := mf.open()
 	if err != nil {
 		return nil, err
 	}

 	contents := fr.List()
 	fr.Close()

 	mf.contents = contents
 	return mf, nil
 }

 // metaFar is a shared reference to a meta.far or one or more of it's contents.
 type metaFar struct {
 	blob     string
 	contents []string

 	fs *Filesystem
 }

 func (mf *metaFar) open() (*far.Reader, error) {
 	f, err := mf.fs.blobfs.Open(mf.blob)
 	if err != nil {
 		return nil, err
 	}

 	fr, err := far.NewReader(f)
 	if err != nil {
 		f.Close()
 	}
 	return fr, err
 }

 func (mf *metaFar) list() []string {
 	return mf.contents
 }

 // metaFile is the package dir "meta" opened as a file, which on read returns
 // the merkleroot.
 type metaFile struct {
 	unsupportedFile

 	*metaFar

 	off   int64
 	flags fs.OpenFlags
 }

 func newMetaFile(mf *metaFar, flags fs.OpenFlags) *metaFile {
 	return &metaFile{
 		unsupportedFile("package/meta:" + mf.blob),
 		mf,
 		0,
 		flags,
 	}
 }

 func (f *metaFile) Close() error {
 	return nil
 }

 func (f *metaFile) GetOpenFlags() fs.OpenFlags {
 	return f.flags
 }

 func (f *metaFile) Stat() (int64, time.Time, time.Time, error) {
 	return int64(len(f.blob)), time.Time{}, time.Time{}, nil
 }

 func (f *metaFile) Read(p []byte, off int64, whence int) (int, error) {
 	if whence != fs.WhenceFromCurrent {
 		return 0, fs.ErrNotSupported
 	}
 	if f.off+off >= int64(len(f.blob)) {
 		return 0, fs.ErrEOF
 	}

 	n := copy(p, f.blob[f.off+off:])
 	f.off += off + int64(n)
 	return n, nil
 }

 var _ fs.Directory = (*metaFarDir)(nil)

 type metaFarDir struct {
 	unsupportedDirectory

 	*metaFar

 	path string
 }

 func newMetaFarDir(mf *metaFar) *metaFarDir {
 	return &metaFarDir{
 		unsupportedDirectory("package/meta:" + mf.blob),
 		mf,
 		"meta",
 	}
 }

 func newMetaFarDirAt(mf *metaFar, path string) *metaFarDir {
 	mfd := newMetaFarDir(mf)
 	mfd.path = path
 	return mfd
 }

 func (d *metaFarDir) Close() error {

 	return nil
 }

 func (d *metaFarDir) Dup() (fs.Directory, error) {
 	return d, nil
 }

 func (d *metaFarDir) Open(name string, flags fs.OpenFlags) (fs.File, fs.Directory, *fs.Remote, error) {
 	name = clean(name)

 	// Nothing in the meta directory is ever executable.
 	if flags.Execute() {
 		return nil, nil, nil, fs.ErrNotSupported
 	}

 	name = filepath.Join(d.path, name)

 	if name == "" {
 		if flags.File() || (!flags.Directory() && !flags.Path()) {
 			return newMetaFile(d.metaFar, flags), nil, nil, nil
 		}
 		return nil, d, nil, nil
 	}

 	if flags.Create() || flags.Truncate() || flags.Write() || flags.Append() {
 		return nil, nil, nil, fs.ErrNotSupported
 	}

 	contents := d.metaFar.list()

 	if n := sort.SearchStrings(contents, name); n != len(contents) && contents[n] == name {
 		mff, err := newMetaFarFile(d.metaFar, name, flags)
 		return mff, nil, nil, err
 	}

 	dname := name + "/"
 	for _, lname := range contents {
 		if strings.HasPrefix(lname, dname) {
 			return nil, newMetaFarDirAt(d.metaFar, name), nil, nil
 		}
 	}

 	return nil, nil, nil, fs.ErrNotFound
 }

 func (d *metaFarDir) Read() ([]fs.Dirent, error) {
 	contents := d.metaFar.list()

 	// TODO(raggi): improve efficiency
 	dirs := map[string]struct{}{}
 	dents := []fs.Dirent{}
 	dents = append(dents, dirDirEnt("."))

 	for _, name := range contents {
 		if !strings.HasPrefix(name, d.path+"/") {
 			continue
 		}
 		name = strings.TrimPrefix(name, d.path+"/")

 		parts := strings.SplitN(name, "/", 2)
 		if len(parts) == 2 {
 			if _, ok := dirs[parts[0]]; !ok {
 				dirs[parts[0]] = struct{}{}
 				dents = append(dents, dirDirEnt(parts[0]))
 			}

 		} else {
 			dents = append(dents, fileDirEnt(parts[0]))
 		}
 	}
 	return dents, nil
 }

 func (d *metaFarDir) Stat() (int64, time.Time, time.Time, error) {
 	// TODO(raggi): forward stat values from the index
 	contents := d.metaFar.list()
 	return int64(len(contents)), d.fs.mountTime, d.fs.mountTime, nil
 }

 var _ fs.File = (*metaFarFile)(nil)
 var _ fs.FileWithBackingMemory = (*metaFarFile)(nil)

 type metaFarFile struct {
 	unsupportedFile

 	*metaFar
 	fr *far.Reader
 	er *far.EntryReader

 	off   int64
 	path  string
 	flags fs.OpenFlags
 	// VMO representing this file's view of the archive.
 	vmo *zx.VMO

 	// VMO representing the blob backing this entire archive.
 	// TODO(fxbug.dev/52938): It would be more efficient to cache this VMO for all files
 	// within the same meta far to avoid calling GetBuffer() on the same blob
 	// for multiple files.
 	backingBlobVMO *zx.VMO
 }

 func newMetaFarFile(mf *metaFar, path string, flags fs.OpenFlags) (*metaFarFile, error) {
 	fr, err := mf.open()
 	if err != nil {
 		return nil, goErrToFSErr(err)
 	}
 	er, err := fr.Open(path)
 	if err != nil {
 		fr.Close()
 		return nil, goErrToFSErr(err)
 	}

 	return &metaFarFile{
 		unsupportedFile("package/meta:" + mf.blob + "/" + path),
 		mf,
 		fr,
 		er,
 		0,
 		path,
 		flags,
 		nil,
 		nil,
 	}, nil
 }

 func (f *metaFarFile) Close() error {
 	if f.vmo != nil {
 		f.vmo.Close()
 	}
 	if f.backingBlobVMO != nil {
 		f.backingBlobVMO.Close()
 	}
 	f.fr.Close()
 	return nil
 }

 func (f *metaFarFile) GetOpenFlags() fs.OpenFlags {
 	return f.flags
 }

 func (f *metaFarFile) Dup() (fs.File, error) {
 	fr, err := f.metaFar.open()
 	if err != nil {
 		return nil, goErrToFSErr(err)
 	}
 	er, err := fr.Open(f.path)
 	if err != nil {
 		fr.Close()
 		return nil, goErrToFSErr(err)
 	}

 	return &metaFarFile{
 		f.unsupportedFile,
 		f.metaFar,
 		fr,
 		er,
 		0,
 		f.path,
 		f.flags,
 		nil,
 		nil,
 	}, nil
 }

 func (f *metaFarFile) Read(p []byte, off int64, whence int) (int, error) {
 	// TODO(raggi): this could allocate less/be far more efficient

 	switch whence {
 	case fs.WhenceFromCurrent:
 		f.off += off
 		n, err := f.er.ReadAt(p, f.off)
 		f.off += int64(n)
 		return n, goErrToFSErr(err)
 	case fs.WhenceFromStart:
 		return f.er.ReadAt(p, off)
 	}
 	return 0, fs.ErrNotSupported
 }

 func (f *metaFarFile) Seek(offset int64, whence int) (int64, error) {
 	var err error
 	switch whence {
 	case fs.WhenceFromCurrent:
 		f.off = f.off + offset
 	case fs.WhenceFromStart:
 		f.off = offset
 	case fs.WhenceFromEnd:
 		f.off = int64(f.er.Length) + offset
 	default:
 		return 0, fs.ErrInvalidArgs
 	}
 	if err != nil {
 		return f.off, goErrToFSErr(err)
 	}
 	return f.off, nil
 }

 func (f *metaFarFile) Stat() (int64, time.Time, time.Time, error) {
 	return int64(f.er.Length), time.Time{}, time.Time{}, nil
 }

 func (mf *metaFarFile) getBackingBlobVMO() (*zx.VMO, error) {
 	if mf.backingBlobVMO != nil {
 		return mf.backingBlobVMO, nil
 	}
 	f, err := mf.fs.blobfs.Open(mf.blob)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()

 	fdioFile := syscall.FDIOForFD(int(f.Fd())).(*fdio.File)
 	result, err := fdioFile.GetBackingMemory(zxio.VmoFlagsRead)
 	if err != nil {
 		return nil, err
 	}
 	switch w := result.Which(); w {
 	case zxio.File2GetBackingMemoryResultErr:
 		return nil, &zx.Error{
 			Status: zx.Status(result.Err),
 			Text:   "File.GetBackingMemory",
 		}
 	case zxio.File2GetBackingMemoryResultResponse:
 		mf.backingBlobVMO = &result.Response.Vmo
 		return mf.backingBlobVMO, nil
 	default:
 		panic(fmt.Sprintf("unhandle variant %d", w))
 	}
 }

 func (f *metaFarFile) GetBackingMemory(flags io.VmoFlags) (*zx.VMO, uint64, error) {
 	size := f.er.Length
 	if f.vmo == nil {
 		parentVmo, err := f.getBackingBlobVMO()
 		if err != nil {
 			return nil, 0, fs.ErrIO
 		}
 		// All entries in a FAR are at 4096 byte offsets from the start of the
 		// file and are zero padded up to the next 4096 byte boundary:
 		// https://fuchsia.dev/fuchsia-src/concepts/source_code/archive_format#content_chunk
 		offset := f.er.Offset
 		options := zx.VMOChildOption(zx.VMOChildOptionSnapshotAtLeastOnWrite | zx.VMOChildOptionNoWrite)

 		vmo, err := parentVmo.CreateChild(options, offset, size)
 		if err != nil {
 			return nil, 0, fs.ErrIO
 		}
 		f.vmo = &vmo
 	}

 	rights := zx.RightsBasic | zx.RightMap | zx.RightsProperty

 	if flags&io.VmoFlagsRead != 0 {
 		rights |= zx.RightRead
 	}
 	if flags&io.VmoFlagsWrite != 0 {
 		// Contents of a meta directory are never writable.
 		return nil, 0, fs.ErrReadOnly
 	}
 	if flags&io.VmoFlagsExecute != 0 {
 		// Contents of a meta directory are never executable.
 		return nil, 0, fs.ErrPermission
 	}

 	if flags&io.VmoFlagsSharedBuffer != 0 {
 		return nil, 0, fs.ErrNotSupported
 	}

 	if flags&io.VmoFlagsPrivateClone != 0 {
 		// Create a separate VMO for the caller if they specified that they want a private copy.

 		options := zx.VMOChildOption(zx.VMOChildOptionSnapshotAtLeastOnWrite)
 		options |= zx.VMOChildOptionNoWrite
 		offset := uint64(0)
 		child, err := f.vmo.CreateChild(options, offset, size)
 		if err != nil {
 			return nil, 0, fs.ErrIO
 		}
 		return &child, size, nil
 	}

 	// Otherwise, just duplicate our VMO.
 	h, err := f.vmo.Handle().Duplicate(rights)
 	if err != nil {
 		return nil, 0, fs.ErrPermission
 	}
 	var sizeBytes [8]byte
 	binary.LittleEndian.PutUint64(sizeBytes[:], size)
 	if err := h.SetProperty(zx.PropVmoContentSize, sizeBytes[:]); err != nil {
 		return nil, 0, err
 	}
 	vmo := zx.VMO(h)
 	return &vmo, size, nil
 }
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//go:build !build_with_native_toolchain
	// +build !build_with_native_toolchain

	package pkgfs

	import (
	"encoding/binary"
	"fmt"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"fidl/fuchsia/io"

	"go.fuchsia.dev/fuchsia/src/lib/thinfs/fs"
	"go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go"

	"syscall"
	"syscall/zx"
	"syscall/zx/fdio"
	zxio "syscall/zx/io"
	)

	func newMetaFar(blob string, fs Filesystem) (metaFar, error) {
	mf := &metaFar{
	blob: blob,
	fs: fs,
	}
	fr, err := mf.open()
	if err != nil {
	return nil, err
	}

	contents := fr.List()
	fr.Close()

	mf.contents = contents
	return mf, nil
	}

	// metaFar is a shared reference to a meta.far or one or more of it's contents.
	type metaFar struct {
	blob string
	contents []string

	fs *Filesystem
	}

	func (mf metaFar) open() (far.Reader, error) {
	f, err := mf.fs.blobfs.Open(mf.blob)
	if err != nil {
	return nil, err
	}

	fr, err := far.NewReader(f)
	if err != nil {
	f.Close()
	}
	return fr, err
	}

	func (mf *metaFar) list() []string {
	return mf.contents
	}

	// metaFile is the package dir "meta" opened as a file, which on read returns
	// the merkleroot.
	type metaFile struct {
	unsupportedFile

	*metaFar

	off int64
	flags fs.OpenFlags
	}

	func newMetaFile(mf metaFar, flags fs.OpenFlags) metaFile {
	return &metaFile{
	unsupportedFile("package/meta:" + mf.blob),
	mf,
	0,
	flags,
	}
	}

	func (f *metaFile) Close() error {
	return nil
	}

	func (f *metaFile) GetOpenFlags() fs.OpenFlags {
	return f.flags
	}

	func (f *metaFile) Stat() (int64, time.Time, time.Time, error) {
	return int64(len(f.blob)), time.Time{}, time.Time{}, nil
	}

	func (f *metaFile) Read(p []byte, off int64, whence int) (int, error) {
	if whence != fs.WhenceFromCurrent {
	return 0, fs.ErrNotSupported
	}
	if f.off+off >= int64(len(f.blob)) {
	return 0, fs.ErrEOF
	}

	n := copy(p, f.blob[f.off+off:])
	f.off += off + int64(n)
	return n, nil
	}

	var _ fs.Directory = (*metaFarDir)(nil)

	type metaFarDir struct {
	unsupportedDirectory

	*metaFar

	path string
	}

	func newMetaFarDir(mf metaFar) metaFarDir {
	return &metaFarDir{
	unsupportedDirectory("package/meta:" + mf.blob),
	mf,
	"meta",
	}
	}

	func newMetaFarDirAt(mf metaFar, path string) metaFarDir {
	mfd := newMetaFarDir(mf)
	mfd.path = path
	return mfd
	}

	func (d *metaFarDir) Close() error {

	return nil
	}

	func (d *metaFarDir) Dup() (fs.Directory, error) {
	return d, nil
	}

	func (d metaFarDir) Open(name string, flags fs.OpenFlags) (fs.File, fs.Directory, fs.Remote, error) {
	name = clean(name)

	// Nothing in the meta directory is ever executable.
	if flags.Execute() {
	return nil, nil, nil, fs.ErrNotSupported
	}

	name = filepath.Join(d.path, name)

	if name == "" {
	if flags.File() \|\| (!flags.Directory() && !flags.Path()) {
	return newMetaFile(d.metaFar, flags), nil, nil, nil
	}
	return nil, d, nil, nil
	}

	if flags.Create() \|\| flags.Truncate() \|\| flags.Write() \|\| flags.Append() {
	return nil, nil, nil, fs.ErrNotSupported
	}

	contents := d.metaFar.list()

	if n := sort.SearchStrings(contents, name); n != len(contents) && contents[n] == name {
	mff, err := newMetaFarFile(d.metaFar, name, flags)
	return mff, nil, nil, err
	}

	dname := name + "/"
	for _, lname := range contents {
	if strings.HasPrefix(lname, dname) {
	return nil, newMetaFarDirAt(d.metaFar, name), nil, nil
	}
	}

	return nil, nil, nil, fs.ErrNotFound
	}

	func (d *metaFarDir) Read() ([]fs.Dirent, error) {
	contents := d.metaFar.list()

	// TODO(raggi): improve efficiency
	dirs := map[string]struct{}{}
	dents := []fs.Dirent{}
	dents = append(dents, dirDirEnt("."))

	for _, name := range contents {
	if !strings.HasPrefix(name, d.path+"/") {
	continue
	}
	name = strings.TrimPrefix(name, d.path+"/")

	parts := strings.SplitN(name, "/", 2)
	if len(parts) == 2 {
	if _, ok := dirs[parts[0]]; !ok {
	dirs[parts[0]] = struct{}{}
	dents = append(dents, dirDirEnt(parts[0]))
	}

	} else {
	dents = append(dents, fileDirEnt(parts[0]))
	}
	}
	return dents, nil
	}

	func (d *metaFarDir) Stat() (int64, time.Time, time.Time, error) {
	// TODO(raggi): forward stat values from the index
	contents := d.metaFar.list()
	return int64(len(contents)), d.fs.mountTime, d.fs.mountTime, nil
	}

	var _ fs.File = (*metaFarFile)(nil)
	var _ fs.FileWithBackingMemory = (*metaFarFile)(nil)

	type metaFarFile struct {
	unsupportedFile

	*metaFar
	fr *far.Reader
	er *far.EntryReader

	off int64
	path string
	flags fs.OpenFlags
	// VMO representing this file's view of the archive.
	vmo *zx.VMO

	// VMO representing the blob backing this entire archive.
	// TODO(fxbug.dev/52938): It would be more efficient to cache this VMO for all files
	// within the same meta far to avoid calling GetBuffer() on the same blob
	// for multiple files.
	backingBlobVMO *zx.VMO
	}

	func newMetaFarFile(mf metaFar, path string, flags fs.OpenFlags) (metaFarFile, error) {
	fr, err := mf.open()
	if err != nil {
	return nil, goErrToFSErr(err)
	}
	er, err := fr.Open(path)
	if err != nil {
	fr.Close()
	return nil, goErrToFSErr(err)
	}

	return &metaFarFile{
	unsupportedFile("package/meta:" + mf.blob + "/" + path),
	mf,
	fr,
	er,
	0,
	path,
	flags,
	nil,
	nil,
	}, nil
	}

	func (f *metaFarFile) Close() error {
	if f.vmo != nil {
	f.vmo.Close()
	}
	if f.backingBlobVMO != nil {
	f.backingBlobVMO.Close()
	}
	f.fr.Close()
	return nil
	}

	func (f *metaFarFile) GetOpenFlags() fs.OpenFlags {
	return f.flags
	}

	func (f *metaFarFile) Dup() (fs.File, error) {
	fr, err := f.metaFar.open()
	if err != nil {
	return nil, goErrToFSErr(err)
	}
	er, err := fr.Open(f.path)
	if err != nil {
	fr.Close()
	return nil, goErrToFSErr(err)
	}

	return &metaFarFile{
	f.unsupportedFile,
	f.metaFar,
	fr,
	er,
	0,
	f.path,
	f.flags,
	nil,
	nil,
	}, nil
	}

	func (f *metaFarFile) Read(p []byte, off int64, whence int) (int, error) {
	// TODO(raggi): this could allocate less/be far more efficient

	switch whence {
	case fs.WhenceFromCurrent:
	f.off += off
	n, err := f.er.ReadAt(p, f.off)
	f.off += int64(n)
	return n, goErrToFSErr(err)
	case fs.WhenceFromStart:
	return f.er.ReadAt(p, off)
	}
	return 0, fs.ErrNotSupported
	}

	func (f *metaFarFile) Seek(offset int64, whence int) (int64, error) {
	var err error
	switch whence {
	case fs.WhenceFromCurrent:
	f.off = f.off + offset
	case fs.WhenceFromStart:
	f.off = offset
	case fs.WhenceFromEnd:
	f.off = int64(f.er.Length) + offset
	default:
	return 0, fs.ErrInvalidArgs
	}
	if err != nil {
	return f.off, goErrToFSErr(err)
	}
	return f.off, nil
	}

	func (f *metaFarFile) Stat() (int64, time.Time, time.Time, error) {
	return int64(f.er.Length), time.Time{}, time.Time{}, nil
	}

	func (mf metaFarFile) getBackingBlobVMO() (zx.VMO, error) {
	if mf.backingBlobVMO != nil {
	return mf.backingBlobVMO, nil
	}
	f, err := mf.fs.blobfs.Open(mf.blob)
	if err != nil {
	return nil, err
	}
	defer f.Close()

	fdioFile := syscall.FDIOForFD(int(f.Fd())).(*fdio.File)
	result, err := fdioFile.GetBackingMemory(zxio.VmoFlagsRead)
	if err != nil {
	return nil, err
	}
	switch w := result.Which(); w {
	case zxio.File2GetBackingMemoryResultErr:
	return nil, &zx.Error{
	Status: zx.Status(result.Err),
	Text: "File.GetBackingMemory",
	}
	case zxio.File2GetBackingMemoryResultResponse:
	mf.backingBlobVMO = &result.Response.Vmo
	return mf.backingBlobVMO, nil
	default:
	panic(fmt.Sprintf("unhandle variant %d", w))
	}
	}

	func (f metaFarFile) GetBackingMemory(flags io.VmoFlags) (zx.VMO, uint64, error) {
	size := f.er.Length
	if f.vmo == nil {
	parentVmo, err := f.getBackingBlobVMO()
	if err != nil {
	return nil, 0, fs.ErrIO
	}
	// All entries in a FAR are at 4096 byte offsets from the start of the
	// file and are zero padded up to the next 4096 byte boundary:
	// https://fuchsia.dev/fuchsia-src/concepts/source_code/archive_format#content_chunk
	offset := f.er.Offset
	options := zx.VMOChildOption(zx.VMOChildOptionSnapshotAtLeastOnWrite \| zx.VMOChildOptionNoWrite)

	vmo, err := parentVmo.CreateChild(options, offset, size)
	if err != nil {
	return nil, 0, fs.ErrIO
	}
	f.vmo = &vmo
	}

	rights := zx.RightsBasic \| zx.RightMap \| zx.RightsProperty

	if flags&io.VmoFlagsRead != 0 {
	rights \|= zx.RightRead
	}
	if flags&io.VmoFlagsWrite != 0 {
	// Contents of a meta directory are never writable.
	return nil, 0, fs.ErrReadOnly
	}
	if flags&io.VmoFlagsExecute != 0 {
	// Contents of a meta directory are never executable.
	return nil, 0, fs.ErrPermission
	}

	if flags&io.VmoFlagsSharedBuffer != 0 {
	return nil, 0, fs.ErrNotSupported
	}

	if flags&io.VmoFlagsPrivateClone != 0 {
	// Create a separate VMO for the caller if they specified that they want a private copy.

	options := zx.VMOChildOption(zx.VMOChildOptionSnapshotAtLeastOnWrite)
	options \|= zx.VMOChildOptionNoWrite
	offset := uint64(0)
	child, err := f.vmo.CreateChild(options, offset, size)
	if err != nil {
	return nil, 0, fs.ErrIO
	}
	return &child, size, nil
	}

	// Otherwise, just duplicate our VMO.
	h, err := f.vmo.Handle().Duplicate(rights)
	if err != nil {
	return nil, 0, fs.ErrPermission
	}
	var sizeBytes [8]byte
	binary.LittleEndian.PutUint64(sizeBytes[:], size)
	if err := h.SetProperty(zx.PropVmoContentSize, sizeBytes[:]); err != nil {
	return nil, 0, err
	}
	vmo := zx.VMO(h)
	return &vmo, size, nil
	}