commit ca17ed8e160f470286f1d2bc1b77dd426f142f65
parent 9a378c874e3eab72b585a8d67c738ec60babb95b
Author: Matsuda Kenji <info@mtkn.jp>
Date: Mon, 14 Aug 2023 12:45:21 +0900
add clunk
Diffstat:
| M | fcall.go | | | 62 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- |
| M | fs.go | | | 3 | --- |
| M | parse.go | | | 5 | ++++- |
| M | server.go | | | 29 | ++++++++++++++++++++++++----- |
4 files changed, 88 insertions(+), 11 deletions(-)
diff --git a/fcall.go b/fcall.go
@@ -455,7 +455,6 @@ func newTWalk(buf []byte) *TWalk {
nwname := gbit16(buf[cur : cur+2])
cur += 2
msg.wname = make([]string, nwname)
- fmt.Printf("nwname: %d\n", nwname)
for i := 0; i < int(nwname); i++ {
size := int(gbit16(buf[cur : cur+2]))
cur += 2
@@ -747,14 +746,73 @@ func (msg *RRead) String() string {
s := fmt.Sprintf("Rread tag %d count %d '",
msg.Tag(), msg.Count())
data := msg.Data()
- for i := 0; i < len(data) && i < 64; i += 4 {
+ i := 0
+ for ; i + 4 < len(data) && i < 64; i += 4 {
s += fmt.Sprintf(" %02x%02x%02x%02x", uint8(data[i]), uint8(data[i+1]),
uint8(data[i+2]), uint8(data[i+3]))
}
+ if i != len(data) && i != 64 {
+ s += " "
+ }
+ for ; i < len(data) && i < 64; i++ {
+ s += fmt.Sprintf("%02x", uint8(data[i]))
+ }
s += "'"
return s
}
+type TClunk struct {
+ size uint32
+ tag uint16
+ fid uint32
+}
+
+func newTClunk(buf []byte) *TClunk {
+ msg := new(TClunk)
+ msg.size = gbit32(buf[0:4])
+ msg.tag = gbit16(buf[5:7])
+ msg.fid = gbit32(buf[7:11])
+ return msg
+}
+
+func (msg *TClunk) Size() uint32 { return msg.size }
+func (msg *TClunk) Type() MsgType { return Tclunk }
+func (msg *TClunk) Tag() uint16 { return msg.tag }
+func (msg *TClunk) Fid() uint32 { return msg.fid }
+func (msg *TClunk) marshal() []byte {
+ m := make([]byte, msg.Size())
+ pbit32(m[0:4], msg.Size())
+ m[4] = uint8(Tclunk)
+ pbit16(m[5:7], msg.Tag())
+ pbit32(m[7:11], msg.Fid())
+ return m
+}
+func (msg *TClunk) String() string {
+ return fmt.Sprintf("Tclunk tag %d fid %d",
+ msg.Tag(), msg.Fid())
+}
+
+type RClunk struct {
+ tag uint16
+}
+
+func newRClunk(buf []byte) *RClunk { panic("not implemented") }
+func (msg *RClunk) Size() uint32 { return 7 }
+func (msg *RClunk) Type() MsgType { return Rclunk }
+func (msg *RClunk) Tag() uint16 { return msg.tag }
+func (msg *RClunk) marshal() []byte {
+ m := make([]byte, msg.Size())
+ pbit32(m[0:4], msg.Size())
+ m[4] = uint8(Rclunk)
+ pbit16(m[5:7], msg.Tag())
+ return m
+}
+func (msg *RClunk) String() string {
+ return fmt.Sprintf("Rclunk tag %d", msg.Tag())
+}
+
+
+
type TStat struct {
size uint32
tag uint16
diff --git a/fs.go b/fs.go
@@ -4,7 +4,6 @@ import (
"fmt"
"io/fs"
"path"
- "log"
)
type FS struct {
@@ -31,12 +30,10 @@ func (fsys *FS) Open(name string) (*File, error) {
}
func (fsys *FS) walk(root string, wnames []string) ([]*Qid, error) {
- log.Printf("wnames: %v\n", wnames)
wqids := make([]*Qid, len(wnames))
curName := root
for i, name := range wnames {
curName = path.Join(curName, name)
- log.Printf("curName: %s\n", curName)
f, err := fsys.Open(curName)
if err != nil {
return wqids, err
diff --git a/parse.go b/parse.go
@@ -49,7 +49,6 @@ func unmarshal(buf []byte) (Msg, error) {
case Rerror:
return newRError(buf), nil
case Twalk:
- fmt.Printf("Twalk: %v\n", buf)
return newTWalk(buf), nil
case Rwalk:
return newRWalk(buf), nil
@@ -59,6 +58,10 @@ func unmarshal(buf []byte) (Msg, error) {
return newTRead(buf), nil
case Rread:
return newRRead(buf), nil
+ case Tclunk:
+ return newTClunk(buf), nil
+ case Rclunk:
+ return newRClunk(buf), nil
case Tstat:
return newTStat(buf), nil
case Rstat:
diff --git a/server.go b/server.go
@@ -276,6 +276,7 @@ func sOpen(s *Server, r *Req) {
fidStruct.OMode = ifcall.Mode()
r.ofcall = &ROpen{
+ tag: ifcall.Tag(),
qid: fidStruct.Qid,
iounit: s.MSize - 23,
}
@@ -338,7 +339,8 @@ func sRead(s *Server, r *Req) {
}
} else {
n, err = fid.File.ReadAt(data, int64(ifcall.Offset()))
- if err != nil {
+ if err != io.EOF && err != nil {
+ log.Printf("sRead: %v\n", err)
respond(r, err)
return
}
@@ -353,6 +355,22 @@ func sRead(s *Server, r *Req) {
}
func rRead(r *Req, err error) {}
+func sClunk(s *Server, r *Req) {
+ ifcall := r.ifcall.(*TClunk)
+ _, ok := s.fPool.lookupFid(ifcall.Fid())
+ if !ok {
+ respond(r, fmt.Errorf("unknown fid"))
+ return
+ }
+ s.fPool.removeFid(ifcall.Fid())
+ r.ofcall = &RClunk{
+ tag: ifcall.Tag(),
+ }
+ respond(r, nil)
+}
+
+func rClunk(r *Req, err error) {}
+
func rError(r *Req, err error) {
ofcall := &RError{
tag: r.ifcall.Tag(),
@@ -362,10 +380,7 @@ func rError(r *Req, err error) {
}
func sStat(s *Server, r *Req) {
- ifcall, ok := r.ifcall.(*TStat)
- if !ok {
- panic("not TStat")
- }
+ ifcall := r.ifcall.(*TStat)
fidNum := ifcall.Fid()
fidStruct, ok := s.fPool.lookupFid(fidNum)
if !ok {
@@ -420,6 +435,8 @@ func (s *Server) Serve() {
sOpen(s, r)
case *TRead:
sRead(s, r)
+ case *TClunk:
+ sClunk(s, r)
case *TStat:
sStat(s, r)
}
@@ -455,6 +472,8 @@ func respond(r *Req, err error) {
rOpen(r, err)
case *RRead:
rRead(r, err)
+ case *RClunk:
+ rClunk(r, err)
case *RStat:
rStat(r, err)
}
