admin/gotgt
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

delete cit to use new gotgt as main cmd, use logrus instead of glog

Browse Source
This commit is contained in:
Lei Xue
2016-11-29 11:21:40 +08:00
parent 18e1419b06
commit d3c3a96920
23 changed files with 193 additions and 2124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
pkg/apiserver/apiserver.go
View File

@@ -25,9 +25,9 @@ import (
"strconv"
"strings"
log "github.com/Sirupsen/logrus"
systemdActivation "github.com/coreos/go-systemd/activation"
"github.com/docker/go-connections/sockets"
"github.com/golang/glog"
"github.com/gorilla/mux"
"github.com/gostor/gotgt/pkg/apiserver/httputils"
"github.com/gostor/gotgt/pkg/apiserver/router"
@@ -79,7 +79,7 @@ func New(cfg *Config) (*Server, error) {
if err != nil {
return nil, err
}
glog.V(3).Infof("Server created for HTTP on %s (%s)", addr.Proto, addr.Addr)
log.Infof("Server created for HTTP on %s (%s)", addr.Proto, addr.Addr)
s.servers = append(s.servers, srv...)
}
return s, nil
@@ -89,7 +89,7 @@ func New(cfg *Config) (*Server, error) {
func (s *Server) Close() {
for _, srv := range s.servers {
if err := srv.Close(); err != nil {
glog.Error(err)
log.Error(err)
}
}
}
@@ -104,7 +104,7 @@ func (s *Server) serveAPI() error {
srv.srv.Handler = s.routerSwapper
go func(srv *HTTPServer) {
var err error
glog.V(3).Infof("API listen on %s", srv.l.Addr())
log.Infof("API listen on %s", srv.l.Addr())
if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
err = nil
}
@@ -142,7 +142,7 @@ func (s *HTTPServer) Close() error {
func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) {
if s.cfg.TLSConfig == nil || s.cfg.TLSConfig.ClientAuth != tls.RequireAndVerifyClientCert {
glog.Warning("/!\\ DON'T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
log.Warning("/!\\ DON'T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
}
if l, err = sockets.NewTCPSocket(addr, s.cfg.TLSConfig); err != nil {
return nil, err
@@ -154,7 +154,7 @@ func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) {
func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// log the handler call
glog.V(3).Infof("Calling %s %s", r.Method, r.URL.Path)
log.Infof("Calling %s %s", r.Method, r.URL.Path)
// Define the context that we'll pass around to share info
// like the docker-request-id.
@@ -172,7 +172,7 @@ func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
}
if err := handlerFunc(ctx, w, r, vars); err != nil {
glog.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
log.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
httputils.WriteError(w, err)
}
}
@@ -195,12 +195,12 @@ func (s *Server) addRouter(r router.Router) {
func (s *Server) createMux() *mux.Router {
m := mux.NewRouter()
glog.V(3).Infof("Registering routers")
log.Infof("Registering routers")
for _, apiRouter := range s.routers {
for _, r := range apiRouter.Routes() {
f := s.makeHTTPHandler(r.Handler())
glog.V(3).Infof("Registering %s, %s", r.Method(), r.Path())
log.Infof("Registering %s, %s", r.Method(), r.Path())
m.Path(versionMatcher + r.Path()).Methods(r.Method()).Handler(f)
m.Path(r.Path()).Methods(r.Method()).Handler(f)
}
@@ -214,7 +214,7 @@ func (s *Server) createMux() *mux.Router {
// the API execution.
func (s *Server) Wait(waitChan chan error) {
if err := s.serveAPI(); err != nil {
glog.Errorf("ServeAPI error: %v", err)
log.Errorf("ServeAPI error: %v", err)
waitChan <- err
return
}
@@ -307,7 +307,7 @@ func listenFD(addr string, tlsConfig *tls.Config) ([]net.Listener, error) {
continue
}
if err := ls.Close(); err != nil {
glog.Errorf("Failed to close systemd activated file at fd %d: %v", fdOffset+3, err)
log.Errorf("Failed to close systemd activated file at fd %d: %v", fdOffset+3, err)
}
}
return []net.Listener{listeners[fdOffset]}, nil

132
pkg/port/iscsit/iscsid.go
View File

@@ -23,7 +23,7 @@ import (
"os"
"strconv"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/config"
"github.com/gostor/gotgt/pkg/scsi"
@@ -124,25 +124,25 @@ func (s *ISCSITargetDriver) HasPortal(tgtName string, tpgt uint16, portal string
func (s *ISCSITargetDriver) Run() error {
l, err := net.Listen("tcp", ":3260")
if err != nil {
glog.Error(err)
log.Error(err)
os.Exit(1)
}
defer l.Close()
for {
glog.Info("Listening ...")
log.Info("Listening ...")
conn, err := l.Accept()
if err != nil {
glog.Error(err)
log.Error(err)
continue
}
glog.Info(conn.LocalAddr().String())
glog.Info("Accepting ...")
log.Info(conn.LocalAddr().String())
log.Info("Accepting ...")
iscsiConn := &iscsiConnection{conn: conn}
iscsiConn.init()
iscsiConn.rxIOState = IOSTATE_RX_BHS
glog.Infof("connection is connected from %s...\n", conn.RemoteAddr().String())
log.Infof("connection is connected from %s...\n", conn.RemoteAddr().String())
// start a new thread to do with this command
go s.handler(DATAIN, iscsiConn)
}
@@ -152,15 +152,15 @@ func (s *ISCSITargetDriver) Run() error {
func (s *ISCSITargetDriver) handler(events byte, conn *iscsiConnection) {
if events&DATAIN != 0 {
glog.V(1).Infof("rx handler processing...")
log.Debug("rx handler processing...")
go s.rxHandler(conn)
}
if conn.state != CONN_STATE_CLOSE && events&DATAOUT != 0 {
glog.V(1).Infof("tx handler processing...")
log.Debug("tx handler processing...")
s.txHandler(conn)
}
if conn.state == CONN_STATE_CLOSE {
glog.Warningf("iscsi connection[%d] closed", conn.CID)
log.Warningf("iscsi connection[%d] closed", conn.CID)
conn.close()
}
}
@@ -181,22 +181,22 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
for {
switch conn.rxIOState {
case IOSTATE_RX_BHS:
glog.Infof("rx handler: IOSTATE_RX_BHS")
log.Debug("rx handler: IOSTATE_RX_BHS")
buf, length, err := conn.readData(BHS_SIZE)
if err != nil {
glog.Error(err)
log.Error(err)
return
}
if length == 0 {
glog.Warningf("set connection to close")
log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE
return
}
conn.rxBuffer = buf
cmd, err = parseHeader(buf)
if err != nil {
glog.Error(err)
glog.Warningf("set connection to close")
log.Error(err)
log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE
return
}
@@ -205,8 +205,8 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
conn.rxIOState = IOSTATE_RX_INIT_AHS
break
}
glog.V(2).Infof("got command: \n%s", cmd.String())
glog.V(2).Infof("got buffer: %v", buf)
log.Debugf("got command: \n%s", cmd.String())
log.Debugf("got buffer: %v", buf)
final = true
case IOSTATE_RX_INIT_AHS:
conn.rxIOState = IOSTATE_RX_DATA
@@ -227,24 +227,24 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
for length < dl {
b, l, err := conn.readData(dl - length)
if err != nil {
glog.Error(err)
log.Error(err)
return
}
length += l
buf = append(buf, b...)
}
if length != dl {
glog.V(2).Infof("get length is %d, but expected %d", length, dl)
glog.Warningf("set connection to close")
log.Debugf("get length is %d, but expected %d", length, dl)
log.Warning("set connection to close")
conn.state = CONN_STATE_CLOSE
return
}
cmd.RawData = buf[:length]
conn.rxBuffer = append(conn.rxBuffer, buf...)
final = true
glog.Infof("got command: \n%s", cmd.String())
log.Debugf("got command: \n%s", cmd.String())
default:
glog.Errorf("error %d %d\n", conn.state, conn.rxIOState)
log.Errorf("error %d %d\n", conn.state, conn.rxIOState)
return
}
@@ -260,29 +260,29 @@ func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
conn.resp = &ISCSICommand{}
switch conn.req.OpCode {
case OpLoginReq:
glog.Infof("OpLoginReq")
log.Debug("OpLoginReq")
if err := s.iscsiExecLogin(conn); err != nil {
glog.Error(err)
glog.Warningf("set connection to close")
log.Error(err)
log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE
}
case OpLogoutReq:
glog.Infof("OpLogoutReq")
log.Debug("OpLogoutReq")
if err := iscsiExecLogout(conn); err != nil {
glog.Warningf("set connection to close")
log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE
}
case OpTextReq:
glog.Infof("OpTextReq")
log.Debug("OpTextReq")
if err := s.iscsiExecText(conn); err != nil {
glog.Warningf("set connection to close")
log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE
}
default:
iscsiExecReject(conn)
}
glog.V(2).Infof("connection state is %v", conn.state)
glog.V(2).Infof("%#v", conn.resp.String())
log.Debugf("connection state is %v", conn.state)
log.Debugf("%#v", conn.resp.String())
s.handler(DATAOUT, conn)
}
}
@@ -374,7 +374,7 @@ func (s *ISCSITargetDriver) iscsiExecLogin(conn *iscsiConnection) error {
// create a new session
sess, err := s.NewISCSISession(conn, cmd.ISID)
if err != nil {
glog.Error(err)
log.Error(err)
return err
}
itnexus := &api.ITNexus{uuid.NewV1(), GeniSCSIITNexusID(sess)}
@@ -413,8 +413,8 @@ func (s *ISCSITargetDriver) iscsiExecText(conn *iscsiConnection) error {
if st, ok := keys["SendTargets"]; ok {
if st == "All" {
for name, tgt := range s.iSCSITargets {
glog.V(2).Infof("iscsi target: %v", name)
//glog.V(2).Infof("iscsi target portals: %v", tgt.Portals)
log.Debugf("iscsi target: %v", name)
//log.Debugf("iscsi target portals: %v", tgt.Portals)
result = append(result, util.KeyValue{"TargetName", name})
for _, tpgt := range tgt.TPGTs {
@@ -512,23 +512,23 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
if conn.state == CONN_STATE_SCSI && conn.txTask == nil {
err := s.scsiCommandHandler(conn)
if err != nil {
glog.Error(err)
log.Error(err)
return
}
}
for {
switch conn.txIOState {
case IOSTATE_TX_BHS:
glog.V(2).Infof("ready to write response")
glog.V(2).Infof("%s", conn.resp.String())
glog.V(2).Infof("length of RawData is %d", len(conn.resp.RawData))
glog.V(2).Infof("length of resp is %d", len(conn.resp.Bytes()))
log.Debug("ready to write response")
log.Debugf("%s", conn.resp.String())
log.Debugf("length of RawData is %d", len(conn.resp.RawData))
log.Debugf("length of resp is %d", len(conn.resp.Bytes()))
if l, err := conn.write(conn.resp.Bytes()); err != nil {
glog.Error(err)
log.Error(err)
return
} else {
conn.txIOState = IOSTATE_TX_INIT_AHS
glog.V(2).Infof("success to write %d length", l)
log.Debugf("success to write %d length", l)
}
case IOSTATE_TX_INIT_AHS:
if hdigest != 0 {
@@ -547,7 +547,7 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
conn.txIOState = IOSTATE_TX_INIT_DDIGEST
}
default:
glog.Errorf("error %d %d\n", conn.state, conn.txIOState)
log.Errorf("error %d %d\n", conn.state, conn.txIOState)
return
}
@@ -556,41 +556,41 @@ func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
}
}
glog.V(3).Infof("connection state: %d", conn.state)
log.Debugf("connection state: %d", conn.state)
switch conn.state {
case CONN_STATE_CLOSE, CONN_STATE_EXIT:
glog.Warningf("set connection to close")
log.Warnf("set connection to close")
conn.state = CONN_STATE_CLOSE
case CONN_STATE_SECURITY_LOGIN:
conn.state = CONN_STATE_LOGIN
glog.V(3).Infof("CONN_STATE_LOGIN")
log.Debugf("CONN_STATE_LOGIN")
case CONN_STATE_SECURITY_FULL, CONN_STATE_LOGIN_FULL:
if conn.sessionType == SESSION_NORMAL {
conn.state = CONN_STATE_KERNEL
glog.Infof("CONN_STATE_KERNEL")
log.Infof("CONN_STATE_KERNEL")
conn.state = CONN_STATE_SCSI
glog.V(3).Infof("CONN_STATE_SCSI")
log.Debugf("CONN_STATE_SCSI")
} else {
conn.state = CONN_STATE_FULL
glog.V(3).Infof("CONN_STATE_FULL")
log.Debugf("CONN_STATE_FULL")
}
conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn)
case CONN_STATE_SCSI:
conn.txTask = nil
default:
glog.Warningf("unexpected connection state: %d", conn.state)
log.Warnf("unexpected connection state: %d", conn.state)
conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn)
}
glog.Infof("%d", conn.state)
log.Infof("%d", conn.state)
}
func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error) {
req := conn.req
switch req.OpCode {
case OpSCSICmd:
glog.V(2).Infof("SCSI Command processing...")
log.Debugf("SCSI Command processing...")
scmd := &api.SCSICommand{}
task := &iscsiTask{conn: conn, cmd: conn.req, tag: conn.req.TaskTag, scmd: scmd}
if req.Write {
@@ -599,7 +599,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
if !req.Final {
task.unsolCount = 1
}
glog.V(2).Infof("SCSI write, R2T count: %d, unsol Count: %d, offset: %d", task.r2tCount, task.unsolCount, task.offset)
log.Debugf("SCSI write, R2T count: %d, unsol Count: %d, offset: %d", task.r2tCount, task.unsolCount, task.offset)
if task.scmd.OutSDBBuffer.Buffer == nil {
task.scmd.OutSDBBuffer.Buffer = bytes.NewBuffer([]byte{})
@@ -667,7 +667,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
conn.txIOState = IOSTATE_TX_BHS
iscsiExecTMFunction(conn)
case OpSCSIOut:
glog.V(1).Infof("iSCSI Data-out processing...")
log.Debugf("iSCSI Data-out processing...")
var task *iscsiTask
for _, t := range conn.session.PendingTasks {
if t.tag == conn.req.TaskTag {
@@ -676,16 +676,16 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
}
if task == nil {
err = fmt.Errorf("Cannot find iSCSI task with tag[%v]", conn.req.TaskTag)
glog.Error(err)
log.Error(err)
return
}
task.offset = task.offset + conn.req.DataLen
task.r2tCount = task.r2tCount - conn.req.DataLen
task.scmd.OutSDBBuffer.Buffer.Write(conn.req.RawData)
glog.V(2).Infof("Final: %v", conn.req.Final)
glog.V(2).Infof("r2tCount: %v", task.r2tCount)
log.Debugf("Final: %v", conn.req.Final)
log.Debugf("r2tCount: %v", task.r2tCount)
if !conn.req.Final {
glog.V(1).Infof("Not ready to exec the task")
log.Debugf("Not ready to exec the task")
conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn)
return nil
@@ -697,7 +697,7 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
break
}
task.offset = 0
glog.V(1).Infof("Process the Data-out package")
log.Debugf("Process the Data-out package")
conn.rxTask = task
if err = s.iscsiExecTask(task); err != nil {
return
@@ -730,11 +730,11 @@ func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error
iscsiExecLogout(conn)
case OpTextReq, OpSNACKReq:
err = fmt.Errorf("Cannot handle yet %s", opCodeMap[conn.req.OpCode])
glog.Error(err)
log.Error(err)
return
default:
err = fmt.Errorf("Unknown op %s", opCodeMap[conn.req.OpCode])
glog.Error(err)
log.Error(err)
return
}
conn.rxIOState = IOSTATE_RX_BHS
@@ -750,16 +750,16 @@ func (s *ISCSITargetDriver) iscsiTaskQueueHandler(task *iscsiTask) error {
return s.iscsiExecTask(task)
}
cmdsn := cmd.CmdSN
glog.V(2).Infof("CmdSN of command is %d, ExpCmdSN of session is %d", cmdsn, sess.ExpCmdSN)
log.Debugf("CmdSN of command is %d, ExpCmdSN of session is %d", cmdsn, sess.ExpCmdSN)
if cmdsn == sess.ExpCmdSN {
retry:
cmdsn += 1
sess.ExpCmdSN = cmdsn
glog.V(2).Infof("session's ExpCmdSN is %d", cmdsn)
log.Debugf("session's ExpCmdSN is %d", cmdsn)
glog.V(2).Infof("process task(%d)", task.cmd.CmdSN)
log.Debugf("process task(%d)", task.cmd.CmdSN)
if err := s.iscsiExecTask(task); err != nil {
glog.Error(err)
log.Error(err)
}
if len(sess.PendingTasks) == 0 {
return nil
@@ -775,10 +775,10 @@ func (s *ISCSITargetDriver) iscsiTaskQueueHandler(task *iscsiTask) error {
} else {
if cmd.CmdSN < sess.ExpCmdSN {
err := fmt.Errorf("unexpected cmd serial number: (%d, %d)", cmd.CmdSN, sess.ExpCmdSN)
glog.Error(err)
log.Error(err)
return err
}
glog.V(1).Infof("add task(%d) into task queue", task.cmd.CmdSN)
log.Debugf("add task(%d) into task queue", task.cmd.CmdSN)
// add this connection into queue and set this task as pending task
task.state = taskPending
sess.PendingTasks.Push(task)

10
pkg/scsi/backingstore.go
View File

@@ -21,7 +21,7 @@ import (
"fmt"
"io"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/util"
)
@@ -133,12 +133,12 @@ write:
// hack: wbuf = []byte("hello world!")
err = bs.Write(wbuf, int64(offset))
if err != nil {
glog.Error(err)
log.Error(err)
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
goto sense
}
glog.V(2).Infof("write data at %d for length %d", offset, len(wbuf))
log.Debugf("write data at %d for length %d", offset, len(wbuf))
var pg *api.ModePage
for _, p := range lu.ModePages {
if p.PageCode == 0x08 && p.SubPageCode == 0 {
@@ -181,11 +181,11 @@ verify:
bs.DataAdvise(int64(offset), int64(length), util.POSIX_FADV_WILLNEED)
}
}
glog.Infof("io done %s", string(scb))
log.Infof("io done %s", string(scb))
return nil
sense:
if err != nil {
glog.Error(err)
log.Error(err)
return err
}

4
pkg/scsi/backingstore/common.go
View File

@@ -20,7 +20,7 @@ import (
"fmt"
"os"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/scsi"
"github.com/gostor/gotgt/pkg/util"
@@ -97,7 +97,7 @@ func (bs *FileBackingStore) Read(offset, tl int64) ([]byte, error) {
func (bs *FileBackingStore) Write(wbuf []byte, offset int64) error {
length, err := bs.file.WriteAt(wbuf, offset)
if err != nil {
glog.Error(err)
log.Error(err)
return err
}
if length != len(wbuf) {

2
pkg/scsi/error.go
View File

@@ -1,5 +1,5 @@
/*
Copyright 2015 The GoStor Authors All rights reserved.
Copyright 2016 The GoStor Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.

20
pkg/scsi/sbc.go
View File

@@ -22,7 +22,7 @@ import (
"encoding/binary"
"unsafe"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/util"
"github.com/gostor/gotgt/pkg/version"
@@ -331,7 +331,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
if dev.Attrs.Removable && !dev.Attrs.Online {
key = NOT_READY
asc = ASC_MEDIUM_NOT_PRESENT
glog.Warningf("sense")
log.Warnf("sense")
goto sense
}
@@ -343,7 +343,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
if scb[1]&0xe0 != 0 {
key = ILLEGAL_REQUEST
asc = ASC_INVALID_FIELD_IN_CDB
glog.Warningf("sense")
log.Warnf("sense")
goto sense
}
*/
@@ -384,7 +384,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
api.PRE_FETCH_10, api.PRE_FETCH_16, api.COMPARE_AND_WRITE:
key = DATA_PROTECT
asc = ASC_WRITE_PROTECT
glog.Warningf("sense")
log.Warnf("sense")
goto sense
}
}
@@ -397,14 +397,14 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE
glog.Warningf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
log.Warnf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
goto sense
}
} else {
if lba >= dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE
glog.Warningf("sense")
log.Warnf("sense")
goto sense
}
}
@@ -437,7 +437,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
err = bsPerformCommand(dev.Storage, cmd)
if err != nil {
glog.Error(err)
log.Error(err)
key = HARDWARE_ERROR
asc = ASC_INTERNAL_TGT_FAILURE
} else {
@@ -563,14 +563,14 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE
glog.Warningf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
log.Warnf("sense: lba: %d, tl: %d, size: %d", lba, tl, dev.Size>>dev.BlockShift)
goto sense
}
} else {
if lba >= dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE
glog.Warningf("sense")
log.Warnf("sense")
goto sense
}
}
@@ -579,7 +579,7 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
cmd.TL = tl << dev.BlockShift
err = bsPerformCommand(dev.Storage, cmd)
if err != nil {
glog.Error(err)
log.Error(err)
key = HARDWARE_ERROR
asc = ASC_INTERNAL_TGT_FAILURE
} else {

10
pkg/scsi/scsi.go
View File

@@ -23,7 +23,7 @@ import (
"sync"
"unsafe"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/satori/go.uuid"
)
@@ -80,21 +80,21 @@ func (s *SCSITargetService) AddCommandQueue(tid int, scmd *api.SCSICommand) erro
lun := *(*uint64)(unsafe.Pointer(&scmd.Lun))
scmd.Device = target.Devices[lun]
glog.V(2).Infof("scsi opcode: 0x%x, LUN: %d", int(scmd.SCB.Bytes()[0]), binary.LittleEndian.Uint64(scmd.Lun[:]))
log.Debugf("scsi opcode: 0x%x, LUN: %d", int(scmd.SCB.Bytes()[0]), binary.LittleEndian.Uint64(scmd.Lun[:]))
if scmd.Device == nil {
scmd.Device = target.LUN0
if lun != 0 {
BuildSenseData(scmd, ILLEGAL_REQUEST, ASC_INVALID_FIELD_IN_CDB)
scmd.Result = api.SAMStatCheckCondition.Stat
glog.Warningf("%v", api.SAMStatCheckCondition.Err)
log.Warnf("%v", api.SAMStatCheckCondition.Err)
return nil
}
}
result := scmd.Device.PerformCommand(tid, scmd)
if result != api.SAMStatGood {
scmd.Result = result.Stat
glog.Warningf("%v", result.Err)
log.Warnf("%v", result.Err)
}
return nil
}
@@ -162,7 +162,7 @@ func BuildSenseData(cmd *api.SCSICommand, key byte, asc SCSISubError) {
senseBuffer.Truncate(int(inBufLen))
}
} else {
glog.V(2).Infof("cannot calc cbd alloc length. truncate failed")
log.Debugf("cannot calc cbd alloc length. truncate failed")
}
cmd.Result = key
cmd.SenseBuffer = senseBuffer

6
pkg/scsi/scsilumap.go
View File

@@ -17,7 +17,7 @@ limitations under the License.
package scsi
import (
"errors"
"fmt"
"strconv"
"sync"
@@ -75,7 +75,7 @@ func InitSCSILUMap(config *config.Config) error {
for _, bs := range config.Storages {
lu, err := NewSCSILu(bs.DeviceID, bs.Path, bs.Online)
if err != nil {
return errors.New("Init SCSI LU map error.")
return fmt.Errorf("Init SCSI LU map error: %v", err)
}
globalSCSILUMap.AllDevices[bs.DeviceID] = lu
}
@@ -84,7 +84,7 @@ func InitSCSILUMap(config *config.Config) error {
for lunstr, deviceID := range tgt.LUNs {
lun, err := strconv.ParseUint(lunstr, 10, 64)
if err != nil {
return errors.New("LU Number must be a number")
return fmt.Errorf("LU Number must be a number")
}
mappingLUN(deviceID, lun, tgtName)
// Init SCSISimpleReservationOperator

16
pkg/scsi/spc.go
View File

@@ -22,7 +22,7 @@ import (
"encoding/binary"
"fmt"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/util"
"github.com/satori/go.uuid"
@@ -341,7 +341,7 @@ func SPCReportLuns(host int, cmd *api.SCSICommand) api.SAMStat {
// Get Allocation Length
allocationLength = util.GetUnalignedUint32(scb.Bytes()[6:10])
if allocationLength < 16 {
glog.Warningf("goto sense, allocationLength < 16")
log.Warn("goto sense, allocationLength < 16")
goto sense
}
@@ -577,24 +577,24 @@ func SPCReportSupportedOperationCodes(host int, cmd *api.SCSICommand) api.SAMSta
rsa := util.GetUnalignedUint16(scb[4:])
switch reporting_options {
case 0x00: /* report all */
glog.V(3).Infof("Service Action: report all")
log.Debugf("Service Action: report all")
err := reportOpcodesAll(cmd, rctd)
if err != nil {
glog.Error(err)
log.Error(err)
goto sense
}
case 0x01: /* report one no service action*/
glog.V(3).Infof("Service Action: report one no service action")
log.Debugf("Service Action: report one no service action")
err := reportOpcodeOne(cmd, rctd, opcode, rsa, false)
if err != nil {
glog.Error(err)
log.Error(err)
goto sense
}
case 0x02: /* report one service action */
glog.V(3).Infof("Service Action: report one service action")
log.Debugf("Service Action: report one service action")
err := reportOpcodeOne(cmd, rctd, opcode, rsa, true)
if err != nil {
glog.Error(err)
log.Error(err)
goto sense
}
default:

6
pkg/scsi/target.go
View File

@@ -20,7 +20,7 @@ import (
"fmt"
"unsafe"
"github.com/golang/glog"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api"
"github.com/satori/go.uuid"
)
@@ -97,12 +97,12 @@ func deviceReserve(cmd *api.SCSICommand) error {
}
}
if lu == nil {
glog.Errorf("invalid target and lun %d %s", cmd.Target.TID, lun)
log.Errorf("invalid target and lun %d %s", cmd.Target.TID, lun)
return nil
}
if !uuid.Equal(lu.ReserveID, uuid.Nil) && uuid.Equal(lu.ReserveID, cmd.ITNexusID) {
glog.Errorf("already reserved %d, %d", lu.ReserveID, cmd.ITNexusID)
log.Errorf("already reserved %d, %d", lu.ReserveID, cmd.ITNexusID)
return fmt.Errorf("already reserved")
}
lu.ReserveID = cmd.ITNexusID