vfs

type Disc ¶

type Disc struct {
	// contains filtered or unexported fields
}

Disc is one opened CD image: its volume header and the EFS filesystem inside it.

func OpenImage(path string) (*Disc, error)

func (d *Disc) Close() error

func (d *Disc) FS() *efs.FS

func (d *Disc) Header() *dvh.Header

type File ¶

type File interface {
	fs.File
	io.ReaderAt
	Size() int64
}

File is an opened regular file: a standard fs.File that also supports random access, which TFTP and instcmd need.

type LayerSpec ¶

type LayerSpec struct {
	Name  string
	Image string
	Dir   string
	Dist  string
	Boot  bool
}

LayerSpec is one ordered contribution to an install set: a source filesystem and the distribution directory within it to merge.

Exactly one of Image and Dir is set. Image is an SGI EFS disc image, opened once and shared across every view of it. Dir is a pre-extracted read-only directory, opened with os.OpenRoot so served paths cannot escape it through a symlink.

Dist names the distribution directory inside that source, and it always lands on the set's own dist. Ordinary media call it "dist", which is the default when Dist is empty. A version-stub disc keeps its real catalog somewhere else - "dist6.5" at the root, or "dist/dist6.5" hidden behind a .redirect - and naming it here rebases it, so inst only ever sees /<set>/dist however the media were laid out.

Boot marks the one layer per set whose stand directory is served at /<set>/stand, where the PROM fetches fx.64. Only a bootable set needs one; sa and the miniroot live under dist and merge like everything else.

Name identifies the layer in origins, collision winners, and the startup report.

type Metadata ¶

type Metadata struct {
	Ino    uint64
	UID    uint32
	GID    uint32
	Nlink  int
	Origin Origin
}

Metadata is FileInfo.Sys() for a tree path: the fields ls -l/-i and the recorder need beyond fs.FileInfo. Ino is the stable per-path inode.

type Origin ¶

type Origin struct {
	Kind   OriginKind
	Source string
	Path   string
}

Origin is the resolved provenance of one served path: which configured layer or generator produced its bytes, and where within that source the bytes live. Every file in the tree resolves to exactly one Origin - generated files included - so a caller (the served-file manifest log, the install recorder) can always name what it just read.

Source is the configured layer name (image and directory origins) or the generator name (generated origins). Path is the source-relative path - the in-image or in-directory path - and is empty for a generated file, whose bytes exist only in memory.

type OriginKind ¶

type OriginKind int

OriginKind is where a served file's bytes come from.

const (
	// OriginImage is a file inside a configured EFS disc image.
	OriginImage OriginKind = iota + 1
	// OriginDirectory is a file inside a configured read-only directory
	// layer, opened with os.OpenRoot.
	OriginDirectory
	// OriginGenerated is a file instigator synthesizes in memory: the
	// admin-source command file and .related_dists. It has
	// no backing media.
	OriginGenerated
)

func (k OriginKind) String() string

type SetSpec ¶

type SetSpec struct {
	Name       string
	Layers     []LayerSpec
	Collisions map[string]string
}

SetSpec is one logical install set: an ordered list of layers merged into /<Name>/dist, plus the exact collision winners that resolve differing files. A set with a boot layer also serves /<Name>/stand.

Layers merge in order. Directories union; a regular file present in more than one layer must be byte-identical (its origin then being the earliest contributing layer) unless Collisions names a winner. Collisions maps a full logical tree path (for example "applications/dist/inst.README") to the Name of the layer whose copy wins; a differing collision with no matching entry fails Build, so the served bytes are never guessed.

type Tree ¶

type Tree struct {
	// contains filtered or unexported fields
}

Tree is the assembled install-set filesystem: one directory per configured set, each the ordered merge of that set's layers, plus whatever instigator generates in memory. It is read-only and safe for concurrent use once Build returns.

Names are io/fs names throughout - "." for the root, no leading slash, no ".." - so a client can only ever address a path the build itself materialized. Protocol adapters strip or add the leading slash their wire format wants.

func Build(sets []SetSpec) (*Tree, error)

func (t *Tree) AddGenerated(name, generator string, content []byte) error

func (t *Tree) Close() error

func (t *Tree) Open(name string) (fs.File, error)

func (t *Tree) ReadDir(name string) ([]fs.DirEntry, error)

func (t *Tree) Resolve(name string) (Origin, error)

func (t *Tree) Stat(name string) (fs.FileInfo, error)