mirrors/stfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Decompose syscalls into pkg, start adding utility commands

Browse Source
This commit is contained in:
Felicitas Pojtinger
2021-11-19 00:39:28 +01:00
parent f41c96b59e
commit f426874cbd
35 changed files with 155 additions and 6100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
cmd/stfs-uvf-with-header/main.go → cmd/stfs-archive/main.go
View File

@@ -14,37 +14,23 @@ import (
"strconv"
"syscall"
"time"
"unsafe"
"github.com/pojntfx/stfs/pkg/controllers"
"golang.org/x/sys/unix"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCTOP = 0x40086d01 // Do magnetic tape operation
MTEOM = 12 // Goto end of recorded media (for appending files)
MTBSR = 4 // Backward space record
stfsVersionPAX = "STFS.Version"
stfsVersion = 1
STFSVersionPAX = "STFS.Version"
STFSVersion = 1
stfsActionPAX = "STFS.Action"
stfsActionCreate = "CREATE"
stfsActionUpdate = "UPDATE"
stfsActionDelete = "DELETE"
STFSActionPAX = "STFS.Action"
STFSActionCreate = "CREATE"
STFSActionUpdate = "UPDATE"
STFSActionDelete = "DELETE"
STFSReplacesPAX = "STFS.Replaces"
blockSize = 512
stfsReplacesPAX = "STFS.Replaces"
)
// Operation is struct for MTIOCTOP
type Operation struct {
Op int16 // Operation ID
Pad int16 // Padding to match C structures
Count int32 // Operation count
}
func main() {
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
dir := flag.String("dir", ".", "Directory to add to the file")
@@ -88,7 +74,7 @@ func main() {
if !*overwrite {
// Go to end of tape
if err := goToEndOfTape(f); err != nil {
if err := controllers.GoToEndOfTape(f); err != nil {
panic(err)
}
}
@@ -99,7 +85,7 @@ func main() {
if isRegular {
tw = tar.NewWriter(f)
} else {
bw := bufio.NewWriterSize(f, blockSize**recordSize)
bw := bufio.NewWriterSize(f, controllers.BlockSize**recordSize)
tw = tar.NewWriter(bw)
}
defer tw.Close()
@@ -139,9 +125,9 @@ func main() {
hdr.Name = path
hdr.PAXRecords = map[string]string{
STFSVersionPAX: strconv.Itoa(STFSVersion),
STFSActionPAX: STFSActionUpdate,
STFSReplacesPAX: "",
stfsVersionPAX: strconv.Itoa(stfsVersion),
stfsActionPAX: stfsActionUpdate,
stfsReplacesPAX: "",
}
hdr.Format = tar.FormatPAX
@@ -166,7 +152,7 @@ func main() {
return err
}
} else {
buf := make([]byte, blockSize**recordSize)
buf := make([]byte, controllers.BlockSize**recordSize)
if _, err := io.CopyBuffer(tw, file, buf); err != nil {
return err
}
@@ -177,20 +163,3 @@ func main() {
panic(err)
}
}
func goToEndOfTape(f *os.File) error {
if _, _, err := syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCTOP,
uintptr(unsafe.Pointer(
&Operation{
Op: MTEOM,
},
)),
); err != 0 {
return err
}
return nil
}

44
cmd/stfs-eod/main.go
View File

@@ -1,44 +0,0 @@
package main
import (
"flag"
"os"
"syscall"
"unsafe"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCTOP = 0x40086d01 // Do magnetic tape operation
MTEOM = 12 // Goto end of recorded media (for appending files)
)
// Operation is struct for MTIOCTOP
type Operation struct {
Op int16 // Operation ID
Pad int16 // Padding to match C structures
Count int32 // Operation count
}
func main() {
file := flag.String("file", "/dev/nst0", "File of tape drive to open")
flag.Parse()
f, err := os.OpenFile(*file, os.O_RDONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
defer f.Close()
syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCTOP,
uintptr(unsafe.Pointer(
&Operation{
Op: MTEOM,
},
)),
)
}

58
cmd/stfs-fuse/main.go
View File

@@ -1,58 +0,0 @@
package main
import (
"context"
"flag"
"log"
"github.com/hanwen/go-fuse/v2/fs"
"github.com/hanwen/go-fuse/v2/fuse"
)
type FileSystem struct {
fs.Inode
}
func (f *FileSystem) OnAdd(ctx context.Context) {
f.AddChild(
"hello_world.txt",
f.NewPersistentInode(
ctx,
&fs.MemRegularFile{
Data: []byte("Hello, world!"),
Attr: fuse.Attr{
Mode: 0644,
},
},
fs.StableAttr{},
),
false,
)
}
func main() {
mountpoint := flag.String("mountpoint", ".", "Directory to mount the FUSE in")
verbose := flag.Bool("verbose", false, "Enable verbose logging")
flag.Parse()
server, err := fs.Mount(
*mountpoint,
&FileSystem{},
&fs.Options{
Logger: func() *log.Logger {
if *verbose {
return log.Default()
}
return nil
}(),
},
)
if err != nil {
panic(err)
}
defer server.Unmount()
server.Wait()
}

55
cmd/stfs-jacobsa-fuse/main.go
View File

@@ -1,55 +0,0 @@
package main
import (
"context"
"flag"
"log"
"os"
"github.com/jacobsa/fuse"
"github.com/jacobsa/fuse/fuseops"
"github.com/jacobsa/fuse/fuseutil"
)
type FileSystem struct {
fuseutil.NotImplementedFileSystem
}
func (f *FileSystem) GetInodeAttributes(ctx context.Context, op *fuseops.GetInodeAttributesOp) error {
op.Attributes = fuseops.InodeAttributes{
Nlink: 1,
Mode: 0555 | os.ModeDir,
}
log.Println(op.Inode)
return nil
}
func main() {
mountpoint := flag.String("mountpoint", ".", "Directory to mount the FUSE in")
verbose := flag.Bool("verbose", false, "Enable verbose logging")
flag.Parse()
srv, err := fuse.Mount(
*mountpoint,
fuseutil.NewFileSystemServer(&FileSystem{}),
&fuse.MountConfig{
DebugLogger: func() *log.Logger {
if *verbose {
return log.Default()
}
return nil
}(),
},
)
if err != nil {
panic(err)
}
if err := srv.Join(context.Background()); err != nil {
panic(err)
}
}

94
cmd/stfs-tvf-simple/main.go → cmd/stfs-list/main.go
View File

@@ -7,45 +7,11 @@ import (
"io"
"log"
"os"
"syscall"
"unsafe"
"github.com/pojntfx/stfs/pkg/controllers"
"github.com/pojntfx/stfs/pkg/readers"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCPOS = 0x80086d03 // Get tape position
MTIOCTOP = 0x40086d01 // Do magnetic tape operation
MTFSF = 1 // Forward space over FileMark, position at first record of next file
blockSize = 512
)
// Position is struct for MTIOCPOS
type Position struct {
BlkNo int64 // Current block number
}
// Operation is struct for MTIOCTOP
type Operation struct {
Op int16 // Operation ID
Pad int16 // Padding to match C structures
Count int32 // Operation count
}
type Counter struct {
Reader io.Reader
BytesRead int
}
func (r *Counter) Read(p []byte) (n int, err error) {
n, err = r.Reader.Read(p)
r.BytesRead += n
return n, err
}
func main() {
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
recordSize := flag.Int("recordSize", 20, "Amount of 512-bit blocks per record")
@@ -82,7 +48,7 @@ func main() {
hdr, err := tr.Next()
if err != nil {
// Seek right after the next two blocks to skip the trailer
if _, err := f.Seek((int64(*recordSize)*blockSize*record)+(block+1)*blockSize, io.SeekStart); err == nil {
if _, err := f.Seek((int64(*recordSize)*controllers.BlockSize*record)+(block+1)*controllers.BlockSize, io.SeekStart); err == nil {
tr = tar.NewReader(f)
hdr, err = tr.Next()
@@ -117,7 +83,7 @@ func main() {
panic(err)
}
nextTotalBlocks := (curr + hdr.Size) / blockSize
nextTotalBlocks := (curr + hdr.Size) / controllers.BlockSize
record = nextTotalBlocks / int64(*recordSize)
if record == 0 && block == 0 || record == firstRecordOfArchive {
@@ -132,9 +98,9 @@ func main() {
}
}
} else {
br := bufio.NewReaderSize(f, blockSize**recordSize)
br := bufio.NewReaderSize(f, controllers.BlockSize**recordSize)
counter := &Counter{Reader: br}
counter := &readers.Counter{Reader: br}
lastBytesRead := 0
dirty := false
@@ -152,19 +118,19 @@ func main() {
break
}
if err := goToNextFileOnTape(f); err != nil {
if err := controllers.GoToNextFileOnTape(f); err != nil {
// EOD
break
}
currentRecord, err := getCurrentRecordFromTape(f)
currentRecord, err := controllers.GetCurrentRecordFromTape(f)
if err != nil {
panic(err)
}
br = bufio.NewReaderSize(f, blockSize**recordSize)
counter = &Counter{Reader: br, BytesRead: (int(currentRecord) * *recordSize * blockSize)} // We asume we are at record n, block 0
br = bufio.NewReaderSize(f, controllers.BlockSize**recordSize)
counter = &readers.Counter{Reader: br, BytesRead: (int(currentRecord) * *recordSize * controllers.BlockSize)} // We asume we are at record n, block 0
dirty = true
}
@@ -184,42 +150,10 @@ func main() {
log.Println("Record:", record, "Block:", block, "Header:", hdr)
nextBytes := int64(counter.BytesRead) + hdr.Size + blockSize - 1
nextBytes := int64(counter.BytesRead) + hdr.Size + controllers.BlockSize - 1
record = nextBytes / (blockSize * int64(*recordSize))
block = (nextBytes - (record * int64(*recordSize) * blockSize)) / blockSize
record = nextBytes / (controllers.BlockSize * int64(*recordSize))
block = (nextBytes - (record * int64(*recordSize) * controllers.BlockSize)) / controllers.BlockSize
}
}
}
func goToNextFileOnTape(f *os.File) error {
if _, _, err := syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCTOP,
uintptr(unsafe.Pointer(
&Operation{
Op: MTFSF,
Count: 1,
},
)),
); err != 0 {
return err
}
return nil
}
func getCurrentRecordFromTape(f *os.File) (int64, error) {
pos := &Position{}
if _, _, err := syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCPOS,
uintptr(unsafe.Pointer(pos)),
); err != 0 {
return 0, err
}
return pos.BlkNo, nil
}

68
cmd/stfs-ls/main.go
View File

@@ -1,68 +0,0 @@
package main
import (
"archive/tar"
"bufio"
"flag"
"fmt"
"io"
"os"
)
func main() {
file := flag.String("file", "/dev/st0", "File (tape drive or tar file) to open")
blockSize := flag.Int("blockSize", 512, "Size of a block in the tar stream")
blockSizeMulitlier := flag.Int("blockSizeMultiplier", 20, "Amount of blocks to read from the tar stream at once")
flag.Parse()
fileDescription, err := os.Stat(*file)
if err != nil {
panic(err)
}
var f *os.File
if fileDescription.Mode().IsRegular() {
f, err = os.Open(*file)
if err != nil {
panic(err)
}
} else {
f, err = os.OpenFile(*file, os.O_RDONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
}
defer f.Close()
br := bufio.NewReaderSize(f, *blockSize**blockSizeMulitlier)
tr := tar.NewReader(br)
for {
header, err := tr.Next()
if err == io.EOF {
break
}
if err != nil {
panic(err)
}
fmt.Printf(
"%v %v %v %v %v %v %v %v %v\n",
header.Mode,
header.Gname,
header.Uid,
header.Gid,
header.Size,
header.ModTime,
header.AccessTime,
header.ChangeTime,
header.Name,
)
}
}

191
cmd/stfs-metadata-with-header/main.go
View File

@@ -1,191 +0,0 @@
package main
//go:generate sqlboiler sqlite3 -o ../../pkg/db/sqlite/models/metadata -c ../../configs/sqlboiler/metadata.toml
//go:generate go-bindata -pkg metadata -o ../../pkg/db/sqlite/migrations/metadata/migrations.go ../../db/sqlite/migrations/metadata
import (
"archive/tar"
"bytes"
"context"
"database/sql"
"encoding/base64"
"flag"
"fmt"
"io"
"log"
"os"
"path/filepath"
_ "github.com/mattn/go-sqlite3"
api "github.com/pojntfx/stfs/pkg/api/proto/v1"
"github.com/pojntfx/stfs/pkg/db/sqlite/migrations/metadata"
models "github.com/pojntfx/stfs/pkg/db/sqlite/models/metadata"
migrate "github.com/rubenv/sql-migrate"
"github.com/volatiletech/sqlboiler/v4/boil"
"google.golang.org/protobuf/proto"
)
const (
blockSize = 512
STFSVersion = 1
)
type HeaderInBlock struct {
Record int
Block int
Header string
}
func main() {
dbPath := flag.String("db", "/tmp/stfs-metadata.sqlite", "Database file to use")
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
recordSize := flag.Int("recordSize", 20, "Amount of 512-bit blocks per record")
checkpoint := flag.Int("checkpoint", 0, "Log current record after checkpoint kilobytes have been read")
flag.Parse()
leading, _ := filepath.Split(*dbPath)
if err := os.MkdirAll(leading, os.ModePerm); err != nil {
panic(err)
}
db, err := sql.Open("sqlite3", *dbPath)
if err != nil {
panic(err)
}
if _, err := migrate.Exec(
db,
"sqlite3",
migrate.AssetMigrationSource{
Asset: metadata.Asset,
AssetDir: metadata.AssetDir,
Dir: "../../db/sqlite/migrations/metadata",
},
migrate.Up,
); err != nil {
panic(err)
}
fileDescription, err := os.Stat(*file)
if err != nil {
panic(err)
}
var f *os.File
if fileDescription.Mode().IsRegular() {
f, err = os.Open(*file)
if err != nil {
panic(err)
}
} else {
f, err = os.OpenFile(*file, os.O_RDONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
}
defer f.Close()
record := 0
for {
// Lock the current record if requested
if *checkpoint > 0 && record%*checkpoint == 0 {
log.Println("Checkpoint:", record)
}
// Read exactly one record
bf := make([]byte, *recordSize*blockSize)
if _, err := io.ReadFull(f, bf); err != nil {
if err == io.EOF {
break
}
// Missing trailer (expected for concatenated tars)
if err == io.ErrUnexpectedEOF {
break
}
panic(err)
}
// Get the headers from the record
headerToAppendTo := []byte{}
for i := 0; i < *recordSize; i++ {
rawHeader := append(headerToAppendTo, bf[blockSize*i:blockSize*(i+1)]...)
if len(headerToAppendTo) > 0 {
// log.Println(string(rawHeader))
}
tr := tar.NewReader(bytes.NewReader(rawHeader))
hdr, err := tr.Next()
if err != nil {
log.Println(string(rawHeader))
continue
}
if hdr.Format == tar.FormatUnknown {
// EOF
break
}
log.Println(hdr)
rawWrapper, err := base64.StdEncoding.DecodeString(hdr.Name)
if err != nil {
panic(err)
}
wrapper := &api.Wrapper{}
if err := proto.Unmarshal(rawWrapper, wrapper); err != nil {
log.Println("Appending compound headers ...", err)
headerToAppendTo = rawHeader
continue
}
headerToAppendTo = []byte{}
if wrapper.Version != STFSVersion {
panic(fmt.Sprintf(`could not parse header: got unsupported STFS version "%v"`, wrapper.Version))
}
switch wrapper.Header.Action {
case api.Action_CREATE:
dbhdr := &models.Header{
Typeflag: int64(hdr.Typeflag),
Name: wrapper.Header.Name,
Linkname: hdr.Linkname,
Size: hdr.Size,
Mode: hdr.Mode,
UID: int64(hdr.Uid),
Gid: int64(hdr.Gid),
Uname: hdr.Uname,
Gname: hdr.Gname,
Modtime: hdr.ModTime,
Accesstime: hdr.AccessTime,
Changetime: hdr.ChangeTime,
Devmajor: hdr.Devmajor,
Devminor: hdr.Devminor,
Format: int64(hdr.Format),
Record: int64(record),
Block: int64(i),
}
if err := dbhdr.Insert(context.Background(), db, boil.Infer()); err != nil {
panic(err)
}
fmt.Println(dbhdr)
default:
panic(fmt.Sprintf(`could not interpret header: got unsupported STFS action "%v"`, wrapper.Header.Action))
}
}
record++
}
}

149
cmd/stfs-metadata/main.go
View File

@@ -1,149 +0,0 @@
package main
//go:generate sqlboiler sqlite3 -o ../../pkg/db/sqlite/models/metadata -c ../../configs/sqlboiler/metadata.toml
//go:generate go-bindata -pkg metadata -o ../../pkg/db/sqlite/migrations/metadata/migrations.go ../../db/sqlite/migrations/metadata
import (
"archive/tar"
"bytes"
"context"
"database/sql"
"flag"
"fmt"
"io"
"log"
"os"
"path/filepath"
_ "github.com/mattn/go-sqlite3"
"github.com/pojntfx/stfs/pkg/db/sqlite/migrations/metadata"
models "github.com/pojntfx/stfs/pkg/db/sqlite/models/metadata"
migrate "github.com/rubenv/sql-migrate"
"github.com/volatiletech/sqlboiler/v4/boil"
)
const (
blockSize = 512
)
type HeaderInBlock struct {
Record int
Block int
Header string
}
func main() {
dbPath := flag.String("db", "/tmp/stfs-metadata.sqlite", "Database file to use")
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
recordSize := flag.Int("recordSize", 20, "Amount of 512-bit blocks per record")
checkpoint := flag.Int("checkpoint", 0, "Log current record after checkpoint kilobytes have been read")
flag.Parse()
leading, _ := filepath.Split(*dbPath)
if err := os.MkdirAll(leading, os.ModePerm); err != nil {
panic(err)
}
db, err := sql.Open("sqlite3", *dbPath)
if err != nil {
panic(err)
}
if _, err := migrate.Exec(
db,
"sqlite3",
migrate.AssetMigrationSource{
Asset: metadata.Asset,
AssetDir: metadata.AssetDir,
Dir: "../../db/sqlite/migrations/metadata",
},
migrate.Up,
); err != nil {
panic(err)
}
fileDescription, err := os.Stat(*file)
if err != nil {
panic(err)
}
var f *os.File
if fileDescription.Mode().IsRegular() {
f, err = os.Open(*file)
if err != nil {
panic(err)
}
} else {
f, err = os.OpenFile(*file, os.O_RDONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
}
defer f.Close()
record := 0
for {
// Lock the current record if requested
if *checkpoint > 0 && record%*checkpoint == 0 {
log.Println("Checkpoint:", record)
}
// Read exactly one record
bf := make([]byte, *recordSize*blockSize)
if _, err := io.ReadFull(f, bf); err != nil {
if err == io.EOF {
break
}
// Missing trailer (expected for concatenated tars)
if err == io.ErrUnexpectedEOF {
break
}
panic(err)
}
// Get the headers from the record
for i := 0; i < *recordSize; i++ {
tr := tar.NewReader(bytes.NewReader(bf[blockSize*i : blockSize*(i+1)]))
hdr, err := tr.Next()
if err != nil {
continue
}
if hdr.Format == tar.FormatUnknown {
// EOF
break
}
dbhdr := &models.Header{
Typeflag: int64(hdr.Typeflag),
Name: hdr.Name,
Linkname: hdr.Linkname,
Size: hdr.Size,
Mode: hdr.Mode,
UID: int64(hdr.Uid),
Gid: int64(hdr.Gid),
Uname: hdr.Uname,
Gname: hdr.Gname,
Modtime: hdr.ModTime,
Accesstime: hdr.AccessTime,
Changetime: hdr.ChangeTime,
Devmajor: hdr.Devmajor,
Devminor: hdr.Devminor,
Format: int64(hdr.Format),
Record: int64(record),
Block: int64(i),
}
if err := dbhdr.Insert(context.Background(), db, boil.Infer()); err != nil {
panic(err)
}
fmt.Println(dbhdr)
}
record++
}
}

51
cmd/stfs-seek/main.go
View File

@@ -6,31 +6,10 @@ import (
"flag"
"log"
"os"
"syscall"
"unsafe"
"github.com/pojntfx/stfs/pkg/controllers"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCTOP = 0x40086d01 // Do magnetic tape operation
MTSEEK = 22 // Seek to block
MTIOCPOS = 0x80086d03 // Get tape position
blockSize = 512
)
// Operation is struct for MTIOCTOP
type Operation struct {
Op int16 // Operation ID
Pad int16 // Padding to match C structures
Count int32 // Operation count
}
// Position is struct for MTIOCPOS
type Position struct {
BlkNo int64 // Current block number
}
func main() {
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
recordSize := flag.Int("recordSize", 20, "Amount of 512-bit blocks per record")
@@ -62,20 +41,20 @@ func main() {
var tr *tar.Reader
if fileDescription.Mode().IsRegular() {
// Seek to record and block
if _, err := f.Seek(int64((*recordSize*blockSize**record)+*block*blockSize), 0); err != nil {
if _, err := f.Seek(int64((*recordSize*controllers.BlockSize**record)+*block*controllers.BlockSize), 0); err != nil {
panic(err)
}
tr = tar.NewReader(f)
} else {
// Seek to record
if err := seekToRecordOnTape(f, int32(*record)); err != nil {
if err := controllers.SeekToRecordOnTape(f, int32(*record)); err != nil {
panic(err)
}
// Seek to block
br := bufio.NewReaderSize(f, blockSize**recordSize)
if _, err := br.Read(make([]byte, *block*blockSize)); err != nil {
br := bufio.NewReaderSize(f, controllers.BlockSize**recordSize)
if _, err := br.Read(make([]byte, *block*controllers.BlockSize)); err != nil {
panic(err)
}
@@ -91,21 +70,3 @@ func main() {
log.Println(hdr)
}
}
func seekToRecordOnTape(f *os.File, record int32) error {
if _, _, err := syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCTOP,
uintptr(unsafe.Pointer(
&Operation{
Op: MTSEEK,
Count: record,
},
)),
); err != 0 {
return err
}
return nil
}

28
cmd/stfs-tell/main.go
View File

@@ -4,20 +4,10 @@ import (
"flag"
"fmt"
"os"
"syscall"
"unsafe"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCPOS = 0x80086d03 // Get tape position
"github.com/pojntfx/stfs/pkg/controllers"
)
// Position is struct for MTIOCPOS
type Position struct {
BlkNo int64 // Current block number
}
func main() {
file := flag.String("file", "/dev/nst0", "File of tape drive to open")
@@ -29,24 +19,10 @@ func main() {
}
defer f.Close()
currentRecord, err := getCurrentRecordFromTape(f)
currentRecord, err := controllers.GetCurrentRecordFromTape(f)
if err != nil {
panic(err)
}
fmt.Println(currentRecord)
}
func getCurrentRecordFromTape(f *os.File) (int64, error) {
pos := &Position{}
if _, _, err := syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCPOS,
uintptr(unsafe.Pointer(pos)),
); err != 0 {
return 0, err
}
return pos.BlkNo, nil
}

91
cmd/stfs-tvf/main.go
View File

@@ -1,91 +0,0 @@
package main
import (
"archive/tar"
"bytes"
"flag"
"fmt"
"io"
"log"
"os"
)
const (
blockSize = 512
)
type Wrapper struct {
Record int64
Block int64
Header string
}
func main() {
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
recordSize := flag.Int("recordSize", 20, "Amount of 512-bit blocks per record")
flag.Parse()
fileDescription, err := os.Stat(*file)
if err != nil {
panic(err)
}
var f *os.File
if fileDescription.Mode().IsRegular() {
f, err = os.Open(*file)
if err != nil {
panic(err)
}
} else {
f, err = os.OpenFile(*file, os.O_RDONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
}
defer f.Close()
record := int64(0)
block := int64(0)
for {
// Read exactly one record
bf := make([]byte, *recordSize*blockSize)
if _, err := io.ReadFull(f, bf); err != nil {
if err == io.EOF {
break
}
panic(err)
}
// Get the headers from the record
for currentBlock := 0; currentBlock < *recordSize; currentBlock++ {
tr := tar.NewReader(bytes.NewReader(bf[blockSize*currentBlock : blockSize*(currentBlock+1)]))
hdr, err := tr.Next() // TODO: Read PAX header info by a plain `tar tvf` before; reads should still be efficient even when seeking back as reads are cached
if err != nil {
continue
}
wrapper := &Wrapper{
Record: record,
Block: block,
Header: fmt.Sprintf("%v", hdr),
}
log.Println(wrapper)
curr := (record * int64(*recordSize) * blockSize) + int64(currentBlock)*blockSize
nextTotalBlocks := (curr + hdr.Size) / blockSize
record := nextTotalBlocks / int64(*recordSize)
block = nextTotalBlocks - (record * int64(*recordSize)) + 1
if block > int64(*recordSize) {
record++
block = 0
}
}
record++
}
}

140
cmd/stfs-uvf/main.go
View File

@@ -1,140 +0,0 @@
package main
import (
"archive/tar"
"flag"
"io"
"io/fs"
"log"
"os"
"path/filepath"
"syscall"
"time"
"unsafe"
"golang.org/x/sys/unix"
)
// See https://github.com/benmcclelland/mtio
const (
MTIOCTOP = 0x40086d01 // Do magnetic tape operation
MTEOM = 12 // Goto end of recorded media (for appending files)
)
// Operation is struct for MTIOCTOP
type Operation struct {
Op int16 // Operation ID
Pad int16 // Padding to match C structures
Count int32 // Operation count
}
func main() {
file := flag.String("file", "/dev/nst0", "File (tape drive or tar file) to open")
dir := flag.String("dir", ".", "Directory to add to the file")
flag.Parse()
isRegular := true
stat, err := os.Stat(*file)
if err == nil {
isRegular = stat.Mode().IsRegular()
} else {
if os.IsNotExist(err) {
isRegular = true
} else {
panic(err)
}
}
var f *os.File
if isRegular {
f, err = os.OpenFile(*file, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
if err != nil {
panic(err)
}
// No need to go to end manually due to `os.O_APPEND`
} else {
// Go to end of file
syscall.Syscall(
syscall.SYS_IOCTL,
f.Fd(),
MTIOCTOP,
uintptr(unsafe.Pointer(
&Operation{
Op: MTEOM,
},
)),
)
f, err = os.OpenFile(*file, os.O_APPEND|os.O_WRONLY, os.ModeCharDevice)
if err != nil {
panic(err)
}
}
defer f.Close()
tw := tar.NewWriter(f) // We are not closing the tar writer to prevent writing the trailer
if err := filepath.Walk(*dir, func(path string, info fs.FileInfo, err error) error {
if err != nil {
return err
}
link := ""
if info.Mode()&os.ModeSymlink == os.ModeSymlink {
if link, err = os.Readlink(path); err != nil {
return err
}
}
hdr, err := tar.FileInfoHeader(info, link)
if err != nil {
return err
}
hdr.Format = tar.FormatGNU // Required for AccessTime, ChangeTime etc.
var unixStat syscall.Stat_t
if err := syscall.Stat(path, &unixStat); err != nil {
return err
}
mtimesec, mtimensec := unixStat.Mtim.Unix()
atimesec, atimensec := unixStat.Atim.Unix()
ctimesec, ctimensec := unixStat.Ctim.Unix()
hdr.ModTime = time.Unix(mtimesec, mtimensec)
hdr.AccessTime = time.Unix(atimesec, atimensec)
hdr.ChangeTime = time.Unix(ctimesec, ctimensec)
hdr.Devmajor = int64(unix.Major(unixStat.Dev))
hdr.Devminor = int64(unix.Minor(unixStat.Dev))
hdr.Name = path
log.Println(hdr)
if err := tw.WriteHeader(hdr); err != nil {
return err
}
if !info.Mode().IsRegular() {
return nil
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
if _, err := io.Copy(tw, file); err != nil {
return err
}
return nil
}); err != nil {
panic(err)
}
}