seaweedfs/weed/storage/volume_super_block.go

154 lines
4.2 KiB
Go
Raw Normal View History

package storage
import (
"fmt"
"os"
2019-10-25 06:41:32 +00:00
"github.com/chrislusf/seaweedfs/weed/storage/backend/memory_map"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
"github.com/chrislusf/seaweedfs/weed/util"
2019-10-22 06:03:48 +00:00
"github.com/golang/protobuf/proto"
)
const (
2018-06-24 18:37:08 +00:00
_SuperBlockSize = 8
)
2014-09-01 06:25:54 +00:00
/*
* Super block currently has 8 bytes allocated for each volume.
* Byte 0: version, 1 or 2
* Byte 1: Replica Placement strategy, 000, 001, 002, 010, etc
* Byte 2 and byte 3: Time to live. See TTL for definition
* Byte 4 and byte 5: The number of times the volume has been compacted.
* Rest bytes: Reserved
2014-09-01 06:25:54 +00:00
*/
type SuperBlock struct {
version needle.Version
ReplicaPlacement *ReplicaPlacement
Ttl *needle.TTL
CompactionRevision uint16
Extra *master_pb.SuperBlockExtra
extraSize uint16
}
2018-06-24 18:37:08 +00:00
func (s *SuperBlock) BlockSize() int {
2018-06-24 22:37:54 +00:00
switch s.version {
2019-04-19 04:43:36 +00:00
case needle.Version2, needle.Version3:
2018-06-24 22:19:57 +00:00
return _SuperBlockSize + int(s.extraSize)
}
2018-06-24 18:37:08 +00:00
return _SuperBlockSize
}
2019-04-19 04:43:36 +00:00
func (s *SuperBlock) Version() needle.Version {
return s.version
}
func (s *SuperBlock) Bytes() []byte {
2018-06-24 18:37:08 +00:00
header := make([]byte, _SuperBlockSize)
header[0] = byte(s.version)
header[1] = s.ReplicaPlacement.Byte()
s.Ttl.ToBytes(header[2:4])
util.Uint16toBytes(header[4:6], s.CompactionRevision)
2018-06-24 22:19:57 +00:00
if s.Extra != nil {
extraData, err := proto.Marshal(s.Extra)
if err != nil {
glog.Fatalf("cannot marshal super block extra %+v: %v", s.Extra, err)
}
extraSize := len(extraData)
if extraSize > 256*256-2 {
// reserve a couple of bits for future extension
2018-06-24 23:12:41 +00:00
glog.Fatalf("super block extra size is %d bigger than %d", extraSize, 256*256-2)
2018-06-24 22:19:57 +00:00
}
s.extraSize = uint16(extraSize)
util.Uint16toBytes(header[6:8], s.extraSize)
header = append(header, extraData...)
}
return header
}
func (s *SuperBlock) Initialized() bool {
2019-10-09 07:07:18 +00:00
return s.ReplicaPlacement != nil && s.Ttl != nil
}
func (v *Volume) maybeWriteSuperBlock() error {
mMap, exists := memory_map.FileMemoryMap[v.dataFile.Name()]
if exists {
if mMap.End_of_file == -1 {
v.SuperBlock.version = needle.CurrentVersion
mMap.WriteMemory(0, uint64(len(v.SuperBlock.Bytes())), v.SuperBlock.Bytes())
}
return nil
} else {
stat, e := v.dataFile.Stat()
if e != nil {
glog.V(0).Infof("failed to stat datafile %s: %v", v.dataFile.Name(), e)
return e
}
if stat.Size() == 0 {
v.SuperBlock.version = needle.CurrentVersion
_, e = v.dataFile.WriteAt(v.SuperBlock.Bytes(), 0)
if e != nil && os.IsPermission(e) {
//read-only, but zero length - recreate it!
if v.dataFile, e = os.Create(v.dataFile.Name()); e == nil {
if _, e = v.dataFile.Write(v.SuperBlock.Bytes()); e == nil {
v.readOnly = false
}
}
}
}
return e
}
}
2018-06-24 18:37:08 +00:00
func (v *Volume) readSuperBlock() (err error) {
2018-06-24 18:37:08 +00:00
v.SuperBlock, err = ReadSuperBlock(v.dataFile)
return err
}
2018-06-24 18:37:08 +00:00
// ReadSuperBlock reads from data file and load it into volume's super block
func ReadSuperBlock(dataFile *os.File) (superBlock SuperBlock, err error) {
2018-06-24 18:37:08 +00:00
header := make([]byte, _SuperBlockSize)
mMap, exists := memory_map.FileMemoryMap[dataFile.Name()]
if exists {
header, err = mMap.ReadMemory(0, _SuperBlockSize)
if err != nil {
err = fmt.Errorf("cannot read volume %s super block: %v", dataFile.Name(), err)
return
}
} else {
if _, e := dataFile.ReadAt(header, 0); e != nil {
err = fmt.Errorf("cannot read volume %s super block: %v", dataFile.Name(), e)
return
}
2018-06-24 18:37:08 +00:00
}
2019-04-19 04:43:36 +00:00
superBlock.version = needle.Version(header[0])
2018-06-24 22:19:57 +00:00
if superBlock.ReplicaPlacement, err = NewReplicaPlacementFromByte(header[1]); err != nil {
err = fmt.Errorf("cannot read replica type: %s", err.Error())
return
}
2019-04-19 04:43:36 +00:00
superBlock.Ttl = needle.LoadTTLFromBytes(header[2:4])
superBlock.CompactionRevision = util.BytesToUint16(header[4:6])
2018-06-24 22:19:57 +00:00
superBlock.extraSize = util.BytesToUint16(header[6:8])
if superBlock.extraSize > 0 {
// read more
extraData := make([]byte, int(superBlock.extraSize))
superBlock.Extra = &master_pb.SuperBlockExtra{}
err = proto.Unmarshal(extraData, superBlock.Extra)
if err != nil {
2018-06-24 22:37:54 +00:00
err = fmt.Errorf("cannot read volume %s super block extra: %v", dataFile.Name(), err)
2018-06-24 22:19:57 +00:00
return
}
}
return
2018-06-24 18:37:08 +00:00
}