From 6fc5d416a289235dd4bb56d29fb96c5a003ea89f Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Sat, 11 Jun 2022 22:30:35 -0600 Subject: use %v when possible Exceptions are - the occasional %x when the type is a basic int - %w - %q - %T - whenever print_tree.go needs to be dumb for compatibility with C --- pkg/binstruct/binint/builtins.go | 2 +- pkg/binstruct/structs.go | 20 +++--- pkg/btrfs/btrfsitem/items.go | 2 +- pkg/btrfs/internal/objid.go | 2 +- pkg/btrfs/io1_device.go | 6 +- pkg/btrfs/io2_fs.go | 30 ++++----- pkg/btrfs/types_btree.go | 44 ++++++------- pkg/btrfs/types_superblock.go | 2 +- pkg/btrfsmisc/fsck.go | 4 +- pkg/btrfsmisc/print_tree.go | 138 +++++++++++++++++++-------------------- pkg/util/bitfield.go | 2 +- pkg/util/fmt.go | 4 +- pkg/util/ref.go | 2 +- 13 files changed, 129 insertions(+), 129 deletions(-) (limited to 'pkg') diff --git a/pkg/binstruct/binint/builtins.go b/pkg/binstruct/binint/builtins.go index 9af3c35..04fc477 100644 --- a/pkg/binstruct/binint/builtins.go +++ b/pkg/binstruct/binint/builtins.go @@ -7,7 +7,7 @@ import ( func needNBytes(t interface{}, dat []byte, n int) error { if len(dat) < n { - return fmt.Errorf("%T.UnmarshalBinary: need at least %d bytes, only have %d", t, n, len(dat)) + return fmt.Errorf("%T.UnmarshalBinary: need at least %v bytes, only have %v", t, n, len(dat)) } return nil } diff --git a/pkg/binstruct/structs.go b/pkg/binstruct/structs.go index 8ecea6a..ec2bb7d 100644 --- a/pkg/binstruct/structs.go +++ b/pkg/binstruct/structs.go @@ -76,11 +76,11 @@ func (sh structHandler) Unmarshal(dat []byte, dst reflect.Value) (int, error) { if _n >= 0 { n += _n } - return n, fmt.Errorf("struct %q field %d %q: %w", + return n, fmt.Errorf("struct %q field %v %q: %w", sh.name, i, field.name, err) } if _n != field.siz { - return n, fmt.Errorf("struct %q field %d %q: consumed %d bytes but should have consumed %d bytes", + return n, fmt.Errorf("struct %q field %v %q: consumed %v bytes but should have consumed %v bytes", sh.name, i, field.name, _n, field.siz) } n += _n @@ -97,7 +97,7 @@ func (sh structHandler) Marshal(val reflect.Value) ([]byte, error) { bs, err := Marshal(val.Field(i).Interface()) ret = append(ret, bs...) if err != nil { - return ret, fmt.Errorf("struct %q field %d %q: %w", + return ret, fmt.Errorf("struct %q field %v %q: %w", sh.name, i, field.name, err) } } @@ -115,13 +115,13 @@ func genStructHandler(structInfo reflect.Type) (structHandler, error) { if fieldInfo.Anonymous && fieldInfo.Type != endType { err := fmt.Errorf("binstruct does not support embedded fields") - return ret, fmt.Errorf("struct %q field %d %q: %w", + return ret, fmt.Errorf("struct %q field %v %q: %w", ret.name, i, fieldInfo.Name, err) } fieldTag, err := parseStructTag(fieldInfo.Tag.Get("bin")) if err != nil { - return ret, fmt.Errorf("struct %q field %d %q: %w", + return ret, fmt.Errorf("struct %q field %v %q: %w", ret.name, i, fieldInfo.Name, err) } if fieldTag.skip { @@ -133,8 +133,8 @@ func genStructHandler(structInfo reflect.Type) (structHandler, error) { } if fieldTag.off != curOffset { - err := fmt.Errorf("tag says off=0x%x but curOffset=0x%x", fieldTag.off, curOffset) - return ret, fmt.Errorf("struct %q field %d %q: %w", + err := fmt.Errorf("tag says off=%#x but curOffset=%#x", fieldTag.off, curOffset) + return ret, fmt.Errorf("struct %q field %v %q: %w", ret.name, i, fieldInfo.Name, err) } if fieldInfo.Type == endType { @@ -143,13 +143,13 @@ func genStructHandler(structInfo reflect.Type) (structHandler, error) { fieldSize, err := staticSize(fieldInfo.Type) if err != nil { - return ret, fmt.Errorf("struct %q field %d %q: %w", + return ret, fmt.Errorf("struct %q field %v %q: %w", ret.name, i, fieldInfo.Name, err) } if fieldTag.siz != fieldSize { - err := fmt.Errorf("tag says siz=0x%x but StaticSize(typ)=0x%x", fieldTag.siz, fieldSize) - return ret, fmt.Errorf("struct %q field %d %q: %w", + err := fmt.Errorf("tag says siz=%#x but StaticSize(typ)=%#x", fieldTag.siz, fieldSize) + return ret, fmt.Errorf("struct %q field %v %q: %w", ret.name, i, fieldInfo.Name, err) } curOffset += fieldTag.siz diff --git a/pkg/btrfs/btrfsitem/items.go b/pkg/btrfs/btrfsitem/items.go index c4ad7e9..1a3b883 100644 --- a/pkg/btrfs/btrfsitem/items.go +++ b/pkg/btrfs/btrfsitem/items.go @@ -65,7 +65,7 @@ func UnmarshalItem(key internal.Key, dat []byte) Item { if n < len(dat) { return Error{ Dat: dat, - Err: fmt.Errorf("btrfsitem.UnmarshalItem({ItemType:%v}, dat): left over data: got %d bytes but only consumed %d", + Err: fmt.Errorf("btrfsitem.UnmarshalItem({ItemType:%v}, dat): left over data: got %v bytes but only consumed %v", key.ItemType, len(dat), n), } } diff --git a/pkg/btrfs/internal/objid.go b/pkg/btrfs/internal/objid.go index a53d61f..b3f09f6 100644 --- a/pkg/btrfs/internal/objid.go +++ b/pkg/btrfs/internal/objid.go @@ -68,7 +68,7 @@ func (id ObjID) Format(typ ItemType) string { uint64(id)>>48, uint64(id)&((1<<48)-1)) case UUID_SUBVOL_KEY, UUID_RECEIVED_SUBVOL_KEY: - return fmt.Sprintf("0x%016x", uint64(id)) + return fmt.Sprintf("%#016x", uint64(id)) case DEV_ITEM_KEY: names := map[ObjID]string{ BALANCE_OBJECTID: "BALANCE", diff --git a/pkg/btrfs/io1_device.go b/pkg/btrfs/io1_device.go index 978d388..32070cd 100644 --- a/pkg/btrfs/io1_device.go +++ b/pkg/btrfs/io1_device.go @@ -56,7 +56,7 @@ func (dev *Device) Superblocks() ([]*util.Ref[PhysicalAddr, Superblock], error) Addr: addr, } if err := superblock.Read(); err != nil { - return nil, fmt.Errorf("superblock %d: %w", i, err) + return nil, fmt.Errorf("superblock %v: %w", i, err) } ret = append(ret, superblock) } @@ -79,11 +79,11 @@ func (dev *Device) Superblock() (*util.Ref[PhysicalAddr, Superblock], error) { for i, sb := range sbs { if err := sb.Data.ValidateChecksum(); err != nil { - return nil, fmt.Errorf("superblock %d: %w", i, err) + return nil, fmt.Errorf("superblock %v: %w", i, err) } if i > 0 { if !sb.Data.Equal(sbs[0].Data) { - return nil, fmt.Errorf("superblock %d and superblock %d disagree", 0, i) + return nil, fmt.Errorf("superblock %v and superblock %v disagree", 0, i) } } } diff --git a/pkg/btrfs/io2_fs.go b/pkg/btrfs/io2_fs.go index a59fec4..cb99d14 100644 --- a/pkg/btrfs/io2_fs.go +++ b/pkg/btrfs/io2_fs.go @@ -23,9 +23,9 @@ type FS struct { func (fs *FS) Name() string { sb, err := fs.Superblock() if err != nil { - return fmt.Sprintf("fs_uuid=%s", "(unreadable)") + return fmt.Sprintf("fs_uuid=%v", "(unreadable)") } - return fmt.Sprintf("fs_uuid=%s", sb.Data.FSUUID) + return fmt.Sprintf("fs_uuid=%v", sb.Data.FSUUID) } func (fs *FS) Size() (LogicalAddr, error) { @@ -76,13 +76,13 @@ func (fs *FS) Superblock() (*util.Ref[PhysicalAddr, Superblock], error) { } if err := sb.Data.ValidateChecksum(); err != nil { - return nil, fmt.Errorf("file %q superblock %d: %w", sb.File.Name(), sbi, err) + return nil, fmt.Errorf("file %q superblock %v: %w", sb.File.Name(), sbi, err) } if i > 0 { // This is probably wrong, but lots of my // multi-device code is probably wrong. if !sb.Data.Equal(sbs[0].Data) { - return nil, fmt.Errorf("file %q superblock %d and file %q superblock %d disagree", + return nil, fmt.Errorf("file %q superblock %v and file %q superblock %v disagree", sbs[0].File.Name(), 0, sb.File.Name(), sbi) } @@ -110,7 +110,7 @@ func (fs *FS) Init() error { b.Checksum = CSum{} b.Self = 0 if !reflect.DeepEqual(a, b) { - return fmt.Errorf("file %q: superblock %d disagrees with superblock 0", + return fmt.Errorf("file %q: superblock %v disagrees with superblock 0", dev.Name(), i+1) } } @@ -158,12 +158,12 @@ func (fs *FS) Resolve(laddr LogicalAddr) (paddrs map[QualifiedPhysicalAddr]struc maxlen = math.MaxUint64 for _, chunk := range fs.chunks { - low := chunk.Key.Offset - high := chunk.Key.Offset + uint64(chunk.Chunk.Head.Size) - match := low <= uint64(laddr) && uint64(laddr) < high + low := LogicalAddr(chunk.Key.Offset) + high := low + LogicalAddr(chunk.Chunk.Head.Size) + match := low <= laddr && laddr < high if dbg2 { - fmt.Printf("DBG: 0x%0x <= 0x%0x < 0x%0x : %v\n", - low, uint64(laddr), high, match) + fmt.Printf("DBG: %v <= %v < %v : %v\n", + low, laddr, high, match) } if match { offsetWithinChunk := uint64(laddr) - chunk.Key.Offset @@ -213,16 +213,16 @@ func (fs *FS) maybeShortReadAt(dat []byte, laddr LogicalAddr) (int, error) { for paddr := range paddrs { dev, ok := fs.uuid2dev[paddr.Dev] if !ok { - return 0, fmt.Errorf("device=%s does not exist", paddr.Dev) + return 0, fmt.Errorf("device=%v does not exist", paddr.Dev) } if _, err := dev.ReadAt(buf, paddr.Addr); err != nil { - return 0, fmt.Errorf("read device=%s paddr=%v: %w", paddr.Dev, paddr.Addr, err) + return 0, fmt.Errorf("read device=%v paddr=%v: %w", paddr.Dev, paddr.Addr, err) } if first { copy(dat, buf) } else { if !bytes.Equal(dat, buf) { - return 0, fmt.Errorf("inconsistent stripes at laddr=%v len=%d", laddr, len(dat)) + return 0, fmt.Errorf("inconsistent stripes at laddr=%v len=%v", laddr, len(dat)) } } } @@ -253,10 +253,10 @@ func (fs *FS) maybeShortWriteAt(dat []byte, laddr LogicalAddr) (int, error) { for paddr := range paddrs { dev, ok := fs.uuid2dev[paddr.Dev] if !ok { - return 0, fmt.Errorf("device=%s does not exist", paddr.Dev) + return 0, fmt.Errorf("device=%v does not exist", paddr.Dev) } if _, err := dev.WriteAt(dat, paddr.Addr); err != nil { - return 0, fmt.Errorf("write device=%s paddr=%v: %w", paddr.Dev, paddr.Addr, err) + return 0, fmt.Errorf("write device=%v paddr=%v: %w", paddr.Dev, paddr.Addr, err) } } return len(dat), nil diff --git a/pkg/btrfs/types_btree.go b/pkg/btrfs/types_btree.go index e58e33b..8a32d9d 100644 --- a/pkg/btrfs/types_btree.go +++ b/pkg/btrfs/types_btree.go @@ -104,7 +104,7 @@ func (node Node) ValidateChecksum() error { return err } if calced != stored { - return fmt.Errorf("node checksum mismatch: stored=%s calculated=%s", + return fmt.Errorf("node checksum mismatch: stored=%v calculated=%v", stored, calced) } return nil @@ -132,7 +132,7 @@ func (node *Node) UnmarshalBinary(nodeBuf []byte) (int, error) { } } if n != len(nodeBuf) { - return n, fmt.Errorf("btrfs.Node.UnmarshalBinary: left over data: got %d bytes but only consumed %d", + return n, fmt.Errorf("btrfs.Node.UnmarshalBinary: left over data: got %v bytes but only consumed %v", len(nodeBuf), n) } return n, nil @@ -143,7 +143,7 @@ func (node Node) MarshalBinary() ([]byte, error) { return nil, fmt.Errorf("btrfs.Node.MarshalBinary: .Size must be set") } if node.Size <= uint32(binstruct.StaticSize(NodeHeader{})) { - return nil, fmt.Errorf("btrfs.Node.MarshalBinary: .Size must be greater than %d", + return nil, fmt.Errorf("btrfs.Node.MarshalBinary: .Size must be greater than %v", binstruct.StaticSize(NodeHeader{})) } if node.Head.Level > 0 { @@ -157,7 +157,7 @@ func (node Node) MarshalBinary() ([]byte, error) { if bs, err := binstruct.Marshal(node.Head); err != nil { return buf, err } else if len(bs) != binstruct.StaticSize(NodeHeader{}) { - return nil, fmt.Errorf("btrfs.Node.MarshalBinary: header is %d bytes but expected %d", + return nil, fmt.Errorf("btrfs.Node.MarshalBinary: header is %v bytes but expected %v", len(bs), binstruct.StaticSize(NodeHeader{})) } else { copy(buf, bs) @@ -192,7 +192,7 @@ func (node *Node) unmarshalInternal(bodyBuf []byte) (int, error) { _n, err := binstruct.Unmarshal(bodyBuf[n:], &item) n += _n if err != nil { - return n, fmt.Errorf("item %d: %w", i, err) + return n, fmt.Errorf("item %v: %w", i, err) } node.BodyInternal = append(node.BodyInternal, item) } @@ -205,16 +205,16 @@ func (node *Node) marshalInternalTo(bodyBuf []byte) error { for i, item := range node.BodyInternal { bs, err := binstruct.Marshal(item) if err != nil { - return fmt.Errorf("item %d: %w", i, err) + return fmt.Errorf("item %v: %w", i, err) } if copy(bodyBuf[n:], bs) < len(bs) { - return fmt.Errorf("item %d: not enough space: need at least %d+%d=%d bytes, but only have %d", + return fmt.Errorf("item %v: not enough space: need at least %v+%v=%v bytes, but only have %v", i, n, len(bs), n+len(bs), len(bodyBuf)) } n += len(bs) } if copy(bodyBuf[n:], node.Padding) < len(node.Padding) { - return fmt.Errorf("padding: not enough space: need at least %d+%d=%d bytes, but only have %d", + return fmt.Errorf("padding: not enough space: need at least %v+%v=%v bytes, but only have %v", n, len(node.Padding), n+len(node.Padding), len(bodyBuf)) } return nil @@ -243,21 +243,21 @@ func (node *Node) unmarshalLeaf(bodyBuf []byte) (int, error) { n, err := binstruct.Unmarshal(bodyBuf[head:], &item.Head) head += n if err != nil { - return 0, fmt.Errorf("item %d: head: %w", i, err) + return 0, fmt.Errorf("item %v: head: %w", i, err) } if head > tail { - return 0, fmt.Errorf("item %d: head: end_offset=0x%0x is in the body section (offset>0x%0x)", + return 0, fmt.Errorf("item %v: head: end_offset=%#x is in the body section (offset>%#x)", i, head, tail) } dataOff := int(item.Head.DataOffset) if dataOff < head { - return 0, fmt.Errorf("item %d: body: beg_offset=0x%0x is in the head section (offset<0x%0x)", + return 0, fmt.Errorf("item %v: body: beg_offset=%#x is in the head section (offset<%#x)", i, dataOff, head) } dataSize := int(item.Head.DataSize) if dataOff+dataSize != tail { - return 0, fmt.Errorf("item %d: body: end_offset=0x%0x is not cur_tail=0x%0x)", + return 0, fmt.Errorf("item %v: body: end_offset=%#x is not cur_tail=%#x)", i, dataOff+dataSize, tail) } tail = dataOff @@ -277,17 +277,17 @@ func (node *Node) marshalLeafTo(bodyBuf []byte) error { for i, item := range node.BodyLeaf { itemBodyBuf, err := binstruct.Marshal(item.Body) if err != nil { - return fmt.Errorf("item %d: body: %w", i, err) + return fmt.Errorf("item %v: body: %w", i, err) } item.Head.DataSize = uint32(len(itemBodyBuf)) item.Head.DataOffset = uint32(tail - len(itemBodyBuf)) itemHeadBuf, err := binstruct.Marshal(item.Head) if err != nil { - return fmt.Errorf("item %d: head: %w", i, err) + return fmt.Errorf("item %v: head: %w", i, err) } if tail-head < len(itemHeadBuf)+len(itemBodyBuf) { - return fmt.Errorf("item %d: not enough space: need at least (head_len:%d)+(body_len:%d)=%d free bytes, but only have %d", + return fmt.Errorf("item %v: not enough space: need at least (head_len:%v)+(body_len:%v)=%v free bytes, but only have %v", i, len(itemHeadBuf), len(itemBodyBuf), len(itemHeadBuf)+len(itemBodyBuf), tail-head) } @@ -297,7 +297,7 @@ func (node *Node) marshalLeafTo(bodyBuf []byte) error { copy(bodyBuf[tail:], itemBodyBuf) } if copy(bodyBuf[head:tail], node.Padding) < len(node.Padding) { - return fmt.Errorf("padding: not enough space: need at least %d free bytes, but only have %d", + return fmt.Errorf("padding: not enough space: need at least %v free bytes, but only have %v", len(node.Padding), tail-head) } return nil @@ -333,32 +333,32 @@ func ReadNode[Addr ~int64](fs util.File[Addr], sb Superblock, addr Addr, laddrCB Addr: addr, } if _, err := binstruct.Unmarshal(nodeBuf, &nodeRef.Data.Head); err != nil { - return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%d: %w", addr, err) + return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%v: %w", addr, err) } // sanity checking if nodeRef.Data.Head.MetadataUUID != sb.EffectiveMetadataUUID() { - return nil, fmt.Errorf("btrfs.ReadNode: node@%d: %w", addr, ErrNotANode) + return nil, fmt.Errorf("btrfs.ReadNode: node@%v: %w", addr, ErrNotANode) } stored := nodeRef.Data.Head.Checksum calced := CRC32c(nodeBuf[binstruct.StaticSize(CSum{}):]) if stored != calced { - return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%d: looks like a node but is corrupt: checksum mismatch: stored=%s calculated=%s", + return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%v: looks like a node but is corrupt: checksum mismatch: stored=%v calculated=%v", addr, stored, calced) } if laddrCB != nil { if err := laddrCB(nodeRef.Data.Head.Addr); err != nil { - return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%d: %w", addr, err) + return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%v: %w", addr, err) } } // parse (main) if _, err := nodeRef.Data.UnmarshalBinary(nodeBuf); err != nil { - return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%d: %w", addr, err) + return nodeRef, fmt.Errorf("btrfs.ReadNode: node@%v: %w", addr, err) } // return @@ -374,7 +374,7 @@ func (fs *FS) ReadNode(addr LogicalAddr) (*util.Ref[LogicalAddr, Node], error) { return ReadNode[LogicalAddr](fs, sb.Data, addr, func(claimAddr LogicalAddr) error { if claimAddr != addr { - return fmt.Errorf("read from laddr=%d but claims to be at laddr=%d", + return fmt.Errorf("read from laddr=%v but claims to be at laddr=%v", addr, claimAddr) } return nil diff --git a/pkg/btrfs/types_superblock.go b/pkg/btrfs/types_superblock.go index 7291869..0f63389 100644 --- a/pkg/btrfs/types_superblock.go +++ b/pkg/btrfs/types_superblock.go @@ -84,7 +84,7 @@ func (sb Superblock) ValidateChecksum() error { return err } if calced != stored { - return fmt.Errorf("superblock checksum mismatch: stored=%s calculated=%s", + return fmt.Errorf("superblock checksum mismatch: stored=%v calculated=%v", stored, calced) } return nil diff --git a/pkg/btrfsmisc/fsck.go b/pkg/btrfsmisc/fsck.go index 1334900..2c7085e 100644 --- a/pkg/btrfsmisc/fsck.go +++ b/pkg/btrfsmisc/fsck.go @@ -18,13 +18,13 @@ func ScanForNodes(dev *btrfs.Device, sb btrfs.Superblock, fn func(*util.Ref[btrf } if sb.NodeSize < sb.SectorSize { - return fmt.Errorf("node_size(%d) < sector_size(%d)", + return fmt.Errorf("node_size(%v) < sector_size(%v)", sb.NodeSize, sb.SectorSize) } for pos := btrfs.PhysicalAddr(0); pos+btrfs.PhysicalAddr(sb.NodeSize) < devSize; pos += btrfs.PhysicalAddr(sb.SectorSize) { if util.InSlice(pos, btrfs.SuperblockAddrs) { - //fmt.Printf("sector@%d is a superblock\n", pos) + //fmt.Printf("sector@%v is a superblock\n", pos) continue } diff --git a/pkg/btrfsmisc/print_tree.go b/pkg/btrfsmisc/print_tree.go index de216c2..41e86a0 100644 --- a/pkg/btrfsmisc/print_tree.go +++ b/pkg/btrfsmisc/print_tree.go @@ -25,7 +25,7 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { printHeaderInfo(node) if node.Head.Level > 0 { // internal for _, item := range node.BodyInternal { - fmt.Printf("\t%s block %d gen %d\n", + fmt.Printf("\t%v block %v gen %v\n", FmtKey(item.Key), item.BlockPtr, item.Generation) @@ -37,84 +37,84 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { } } else { // leaf for i, item := range node.BodyLeaf { - fmt.Printf("\titem %d %s itemoff %d itemsize %d\n", + fmt.Printf("\titem %v %v itemoff %v itemsize %v\n", i, FmtKey(item.Head.Key), item.Head.DataOffset, item.Head.DataSize) switch body := item.Body.(type) { case btrfsitem.FreeSpaceHeader: - fmt.Printf("\t\tlocation %s\n", FmtKey(body.Location)) - fmt.Printf("\t\tcache generation %d entries %d bitmaps %d\n", + fmt.Printf("\t\tlocation %v\n", FmtKey(body.Location)) + fmt.Printf("\t\tcache generation %v entries %v bitmaps %v\n", body.Generation, body.NumEntries, body.NumBitmaps) case btrfsitem.Inode: fmt.Printf(""+ - "\t\tgeneration %d transid %d size %d nbytes %d\n"+ - "\t\tblock group %d mode %o links %d uid %d gid %d rdev %d\n"+ - "\t\tsequence %d flags %v\n", + "\t\tgeneration %v transid %v size %v nbytes %v\n"+ + "\t\tblock group %v mode %o links %v uid %v gid %v rdev %v\n"+ + "\t\tsequence %v flags %v\n", body.Generation, body.TransID, body.Size, body.NumBytes, body.BlockGroup, body.Mode, body.NLink, body.UID, body.GID, body.RDev, body.Sequence, body.Flags) - fmt.Printf("\t\tatime %s\n", fmtTime(body.ATime)) - fmt.Printf("\t\tctime %s\n", fmtTime(body.CTime)) - fmt.Printf("\t\tmtime %s\n", fmtTime(body.MTime)) - fmt.Printf("\t\totime %s\n", fmtTime(body.OTime)) + fmt.Printf("\t\tatime %v\n", fmtTime(body.ATime)) + fmt.Printf("\t\tctime %v\n", fmtTime(body.CTime)) + fmt.Printf("\t\tmtime %v\n", fmtTime(body.MTime)) + fmt.Printf("\t\totime %v\n", fmtTime(body.OTime)) case btrfsitem.InodeRefList: for _, ref := range body { - fmt.Printf("\t\tindex %d namelen %d name: %s\n", + fmt.Printf("\t\tindex %v namelen %v name: %s\n", ref.Index, ref.NameLen, ref.Name) } //case btrfsitem.INODE_EXTREF_KEY: // // TODO case btrfsitem.DirList: for _, dir := range body { - fmt.Printf("\t\tlocation %s type %v\n", + fmt.Printf("\t\tlocation %v type %v\n", FmtKey(dir.Location), dir.Type) - fmt.Printf("\t\ttransid %d data_len %d name_len %d\n", + fmt.Printf("\t\ttransid %v data_len %v name_len %v\n", dir.TransID, dir.DataLen, dir.NameLen) fmt.Printf("\t\tname: %s\n", dir.Name) if len(dir.Data) > 0 { - fmt.Printf("\t\tdata %s\n", dir.Data) + fmt.Printf("\t\tdata %v\n", dir.Data) } } //case btrfsitem.DIR_LOG_INDEX_KEY, btrfsitem.DIR_LOG_ITEM_KEY: // // TODO case btrfsitem.Root: - fmt.Printf("\t\tgeneration %d root_dirid %d bytenr %d byte_limit %d bytes_used %d\n", + fmt.Printf("\t\tgeneration %v root_dirid %v bytenr %d byte_limit %v bytes_used %v\n", body.Generation, body.RootDirID, body.ByteNr, body.ByteLimit, body.BytesUsed) - fmt.Printf("\t\tlast_snapshot %d flags %s refs %d\n", + fmt.Printf("\t\tlast_snapshot %v flags %v refs %v\n", body.LastSnapshot, body.Flags, body.Refs) - fmt.Printf("\t\tdrop_progress %s drop_level %d\n", + fmt.Printf("\t\tdrop_progress %v drop_level %v\n", FmtKey(body.DropProgress), body.DropLevel) - fmt.Printf("\t\tlevel %d generation_v2 %d\n", + fmt.Printf("\t\tlevel %v generation_v2 %v\n", body.Level, body.GenerationV2) if body.Generation == body.GenerationV2 { - fmt.Printf("\t\tuuid %s\n", body.UUID) - fmt.Printf("\t\tparent_uuid %s\n", body.ParentUUID) - fmt.Printf("\t\treceived_uuid %s\n", body.ReceivedUUID) - fmt.Printf("\t\tctransid %d otransid %d stransid %d rtransid %d\n", + fmt.Printf("\t\tuuid %v\n", body.UUID) + fmt.Printf("\t\tparent_uuid %v\n", body.ParentUUID) + fmt.Printf("\t\treceived_uuid %v\n", body.ReceivedUUID) + fmt.Printf("\t\tctransid %v otransid %v stransid %v rtransid %v\n", body.CTransID, body.OTransID, body.STransID, body.RTransID) - fmt.Printf("\t\tctime %s\n", fmtTime(body.CTime)) - fmt.Printf("\t\totime %s\n", fmtTime(body.OTime)) - fmt.Printf("\t\tstime %s\n", fmtTime(body.STime)) - fmt.Printf("\t\trtime %s\n", fmtTime(body.RTime)) + fmt.Printf("\t\tctime %v\n", fmtTime(body.CTime)) + fmt.Printf("\t\totime %v\n", fmtTime(body.OTime)) + fmt.Printf("\t\tstime %v\n", fmtTime(body.STime)) + fmt.Printf("\t\trtime %v\n", fmtTime(body.RTime)) } //case btrfsitem.ROOT_REF_KEY: // // TODO //case btrfsitem.ROOT_BACKREF_KEY: // // TODO case btrfsitem.Extent: - fmt.Printf("\t\trefs %d gen %d flags %v\n", + fmt.Printf("\t\trefs %v gen %v flags %v\n", body.Head.Refs, body.Head.Generation, body.Head.Flags) if body.Head.Flags.Has(btrfsitem.EXTENT_FLAG_TREE_BLOCK) { - fmt.Printf("\t\ttree block %s level %d\n", + fmt.Printf("\t\ttree block %v level %v\n", FmtKey(body.Info.Key), body.Info.Level) } printExtentInlineRefs(body.Refs) case btrfsitem.Metadata: - fmt.Printf("\t\trefs %d gen %d flags %v\n", + fmt.Printf("\t\trefs %v gen %v flags %v\n", body.Head.Refs, body.Head.Generation, body.Head.Flags) - fmt.Printf("\t\ttree block skinny level %d\n", item.Head.Key.Offset) + fmt.Printf("\t\ttree block skinny level %v\n", item.Head.Key.Offset) printExtentInlineRefs(body.Refs) //case btrfsitem.EXTENT_DATA_REF_KEY: // // TODO @@ -123,24 +123,24 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { //case btrfsitem.EXTENT_CSUM_KEY: // // TODO case btrfsitem.FileExtent: - fmt.Printf("\t\tgeneration %d type %v\n", + fmt.Printf("\t\tgeneration %v type %v\n", body.Generation, body.Type) switch body.Type { case btrfsitem.FILE_EXTENT_INLINE: - fmt.Printf("\t\tinline extent data size %d ram_bytes %d compression %v\n", + fmt.Printf("\t\tinline extent data size %v ram_bytes %v compression %v\n", len(body.BodyInline), body.RAMBytes, body.Compression) case btrfsitem.FILE_EXTENT_PREALLOC: - fmt.Printf("\t\tprealloc data disk byte %d nr %d\n", + fmt.Printf("\t\tprealloc data disk byte %v nr %v\n", body.BodyPrealloc.DiskByteNr, body.BodyPrealloc.DiskNumBytes) - fmt.Printf("\t\tprealloc data offset %d nr %d\n", + fmt.Printf("\t\tprealloc data offset %v nr %v\n", body.BodyPrealloc.Offset, body.BodyPrealloc.NumBytes) case btrfsitem.FILE_EXTENT_REG: - fmt.Printf("\t\textent data disk byte %d nr %d\n", + fmt.Printf("\t\textent data disk byte %v nr %v\n", body.BodyReg.DiskByteNr, body.BodyReg.DiskNumBytes) - fmt.Printf("\t\textenti data offset %d nr %d ram %d\n", + fmt.Printf("\t\textenti data offset %v nr %v ram %v\n", body.BodyReg.Offset, body.BodyReg.NumBytes, body.RAMBytes) @@ -150,34 +150,34 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { fmt.Printf("\t\t(error) unknown file extent type %v", body.Type) } case btrfsitem.BlockGroup: - fmt.Printf("\t\tblock group used %d chunk_objectid %d flags %v\n", + fmt.Printf("\t\tblock group used %v chunk_objectid %v flags %v\n", body.Used, body.ChunkObjectID, body.Flags) case btrfsitem.FreeSpaceInfo: - fmt.Printf("\t\tfree space info extent count %d flags %d\n", + fmt.Printf("\t\tfree space info extent count %v flags %v\n", body.ExtentCount, body.Flags) case btrfsitem.FreeSpaceBitmap: fmt.Printf("\t\tfree space bitmap\n") case btrfsitem.Chunk: - fmt.Printf("\t\tlength %d owner %d stripe_len %d type %v\n", + fmt.Printf("\t\tlength %v owner %d stripe_len %v type %v\n", body.Head.Size, body.Head.Owner, body.Head.StripeLen, body.Head.Type) - fmt.Printf("\t\tio_align %d io_width %d sector_size %d\n", + fmt.Printf("\t\tio_align %v io_width %v sector_size %v\n", body.Head.IOOptimalAlign, body.Head.IOOptimalWidth, body.Head.IOMinSize) - fmt.Printf("\t\tnum_stripes %d sub_stripes %d\n", + fmt.Printf("\t\tnum_stripes %v sub_stripes %v\n", body.Head.NumStripes, body.Head.SubStripes) for i, stripe := range body.Stripes { - fmt.Printf("\t\t\tstripe %d devid %d offset %d\n", + fmt.Printf("\t\t\tstripe %v devid %d offset %d\n", i, stripe.DeviceID, stripe.Offset) - fmt.Printf("\t\t\tdev_uuid %s\n", + fmt.Printf("\t\t\tdev_uuid %v\n", stripe.DeviceUUID) } case btrfsitem.Dev: fmt.Printf(""+ - "\t\tdevid %d total_bytes %d bytes_used %d\n"+ - "\t\tio_align %d io_width %d sector_size %d type %d\n"+ - "\t\tgeneration %d start_offset %d dev_group %d\n"+ - "\t\tseek_speed %d bandwidth %d\n"+ - "\t\tuuid %s\n"+ - "\t\tfsid %s\n", + "\t\tdevid %d total_bytes %v bytes_used %v\n"+ + "\t\tio_align %v io_width %v sector_size %v type %v\n"+ + "\t\tgeneration %v start_offset %v dev_group %v\n"+ + "\t\tseek_speed %v bandwidth %v\n"+ + "\t\tuuid %v\n"+ + "\t\tfsid %v\n", body.DeviceID, body.NumBytes, body.NumBytesUsed, body.IOOptimalAlign, body.IOOptimalWidth, body.IOMinSize, body.Type, body.Generation, body.StartOffset, body.DevGroup, @@ -186,9 +186,9 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { body.FSUUID) case btrfsitem.DevExtent: fmt.Printf(""+ - "\t\tdev extent chunk_tree %d\n"+ - "\t\tchunk_objectid %d chunk_offset %d length %d\n"+ - "\t\tchunk_tree_uuid %s\n", + "\t\tdev extent chunk_tree %v\n"+ + "\t\tchunk_objectid %v chunk_offset %v length %v\n"+ + "\t\tchunk_tree_uuid %v\n", body.ChunkTree, body.ChunkObjectID, body.ChunkOffset, body.Length, body.ChunkTreeUUID) //case btrfsitem.QGROUP_STATUS_KEY: @@ -205,19 +205,19 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { //case btrfsitem.STRING_ITEM_KEY: // // TODO case btrfsitem.DevStats: - fmt.Printf("\t\tpersistent item objectid %s offset %d\n", + fmt.Printf("\t\tpersistent item objectid %v offset %v\n", item.Head.Key.ObjectID.Format(item.Head.Key.ItemType), item.Head.Key.Offset) switch item.Head.Key.ObjectID { case btrfs.DEV_STATS_OBJECTID: fmt.Printf("\t\tdevice stats\n") - fmt.Printf("\t\twrite_errs %d read_errs %d flush_errs %d corruption_errs %d generation %d\n", + fmt.Printf("\t\twrite_errs %v read_errs %v flush_errs %v corruption_errs %v generation %v\n", body.Values[btrfsitem.DEV_STAT_WRITE_ERRS], body.Values[btrfsitem.DEV_STAT_READ_ERRS], body.Values[btrfsitem.DEV_STAT_FLUSH_ERRS], body.Values[btrfsitem.DEV_STAT_CORRUPTION_ERRS], body.Values[btrfsitem.DEV_STAT_GENERATION_ERRS]) default: - fmt.Printf("\t\tunknown persistent item objectid %d\n", item.Head.Key.ObjectID) + fmt.Printf("\t\tunknown persistent item objectid %v\n", item.Head.Key.ObjectID) } //case btrfsitem.TEMPORARY_ITEM_KEY: // // TODO @@ -255,23 +255,23 @@ func printHeaderInfo(node btrfs.Node) { var typename string if node.Head.Level > 0 { // internal node typename = "node" - fmt.Printf("node %d level %d items %d free space %d", + fmt.Printf("node %v level %v items %v free space %v", node.Head.Addr, node.Head.Level, node.Head.NumItems, node.MaxItems()-node.Head.NumItems) } else { // leaf node typename = "leaf" - fmt.Printf("leaf %d items %d free space %d", + fmt.Printf("leaf %d items %v free space %v", node.Head.Addr, node.Head.NumItems, node.LeafFreeSpace()) } - fmt.Printf(" generation %d owner %v\n", + fmt.Printf(" generation %v owner %v\n", node.Head.Generation, node.Head.Owner) - fmt.Printf("%s %d flags %s backref revision %d\n", + fmt.Printf("%v %d flags %v backref revision %v\n", typename, node.Head.Addr, node.Head.Flags, @@ -284,8 +284,8 @@ func printHeaderInfo(node btrfs.Node) { fmt.Printf("checksum calced %v\n", calcSum) } - fmt.Printf("fs uuid %s\n", node.Head.MetadataUUID) - fmt.Printf("chunk uuid %s\n", node.Head.ChunkTreeUUID) + fmt.Printf("fs uuid %v\n", node.Head.MetadataUUID) + fmt.Printf("chunk uuid %v\n", node.Head.ChunkTreeUUID) } // printExtentInlineRefs mimics part of btrfs-progs kernel-shared/print-tree.c:print_extent_item() @@ -298,16 +298,16 @@ func printExtentInlineRefs(refs []btrfsitem.ExtentInlineRef) { fmt.Printf("\t\ttree block backref root %v\n", btrfs.ObjID(ref.Offset)) case btrfsitem.SHARED_BLOCK_REF_KEY: - fmt.Printf("\t\tshared block backref parent %d\n", + fmt.Printf("\t\tshared block backref parent %v\n", ref.Offset) default: fmt.Printf("\t\t(error) unexpected empty sub-item type: %v\n", ref.Type) } case btrfsitem.ExtentDataRef: - fmt.Printf("\t\textent data backref root %v objectid %d offset %d count %d\n", + fmt.Printf("\t\textent data backref root %v objectid %v offset %v count %v\n", subitem.Root, subitem.ObjectID, subitem.Offset, subitem.Count) case btrfsitem.SharedDataRef: - fmt.Printf("\t\tshared data backref parent %d count %d\n", + fmt.Printf("\t\tshared data backref parent %v count %v\n", ref.Offset, subitem.Count) default: fmt.Printf("\t\t(error) unexpected sub-item type: %T\n", subitem) @@ -318,25 +318,25 @@ func printExtentInlineRefs(refs []btrfsitem.ExtentInlineRef) { // mimics print-tree.c:btrfs_print_key() func FmtKey(key btrfs.Key) string { var out strings.Builder - fmt.Fprintf(&out, "key (%s %v", key.ObjectID.Format(key.ItemType), key.ItemType) + fmt.Fprintf(&out, "key (%v %v", key.ObjectID.Format(key.ItemType), key.ItemType) switch key.ItemType { case btrfsitem.QGROUP_RELATION_KEY: //TODO, btrfsitem.QGROUP_INFO_KEY, btrfsitem.QGROUP_LIMIT_KEY: panic("not implemented") case btrfsitem.UUID_SUBVOL_KEY, btrfsitem.UUID_RECEIVED_SUBVOL_KEY: - fmt.Fprintf(&out, " 0x%016x)", key.Offset) + fmt.Fprintf(&out, " %v)", btrfs.PhysicalAddr(key.Offset)) case btrfsitem.ROOT_ITEM_KEY: fmt.Fprintf(&out, " %v)", btrfs.ObjID(key.Offset)) default: if key.Offset == util.MaxUint64pp-1 { fmt.Fprintf(&out, " -1)") } else { - fmt.Fprintf(&out, " %d)", key.Offset) + fmt.Fprintf(&out, " %v)", key.Offset) } } return out.String() } func fmtTime(t btrfs.Time) string { - return fmt.Sprintf("%d.%d (%s)", + return fmt.Sprintf("%v.%v (%v)", t.Sec, t.NSec, t.ToStd().Format("2006-01-02 15:04:05")) } diff --git a/pkg/util/bitfield.go b/pkg/util/bitfield.go index 216837d..23da17a 100644 --- a/pkg/util/bitfield.go +++ b/pkg/util/bitfield.go @@ -36,7 +36,7 @@ func BitfieldString[T ~uint8 | ~uint16 | ~uint32 | ~uint64](bitfield T, bitnames if i < len(bitnames) { out.WriteString(bitnames[i]) } else { - fmt.Fprintf(&out, "(1<<%d)", i) + fmt.Fprintf(&out, "(1<<%v)", i) } first = false } diff --git a/pkg/util/fmt.go b/pkg/util/fmt.go index c0ff596..af7404c 100644 --- a/pkg/util/fmt.go +++ b/pkg/util/fmt.go @@ -16,13 +16,13 @@ func FmtStateString(st fmt.State, verb rune) string { } } if width, ok := st.Width(); ok { - fmt.Fprintf(&ret, "%d", width) + fmt.Fprintf(&ret, "%v", width) } if prec, ok := st.Precision(); ok { if prec == 0 { ret.WriteByte('.') } else { - fmt.Fprintf(&ret, ".%d", prec) + fmt.Fprintf(&ret, ".%v", prec) } } ret.WriteRune(verb) diff --git a/pkg/util/ref.go b/pkg/util/ref.go index 57f2eac..aecfb9f 100644 --- a/pkg/util/ref.go +++ b/pkg/util/ref.go @@ -36,7 +36,7 @@ func (r *Ref[A, T]) Read() error { return err } if n != size { - return fmt.Errorf("util.Ref[%T].Read: left over data: read %d bytes but only consumed %d", + return fmt.Errorf("util.Ref[%T].Read: left over data: read %v bytes but only consumed %v", r.Data, size, n) } return nil -- cgit v1.2.3-2-g168b