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

Merge pull request #29 from carmark/refactor

Browse Source 
some doc fix and refactor for the packages
This commit is contained in:
Le Zhang
2016-11-28 22:53:00 -06:00
committed by GitHub
parent c5f96b7af4 d3c3a96920
commit 3016122284
40 changed files with 608 additions and 2552 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -42,8 +42,7 @@ _testmain.go
# intellij idea configure # intellij idea configure
.idea .idea
/citadm /gotgt
/citd
*.out *.out
examples/* examples/*
*.bak *.bak

29
.travis.yml
View File

@@ -27,7 +27,7 @@ script:
- dd if=/dev/zero of=/var/tmp/disk.img bs=1024 count=10240 - dd if=/dev/zero of=/var/tmp/disk.img bs=1024 count=10240
- mkdir ${HOME}/.gotgt - mkdir ${HOME}/.gotgt
- echo '{"storages":[{"deviceID":1000,"path":"file:/var/tmp/disk.img","online":true}],"iscsiportals":[{"id":0,"portal":"127.0.0.1:3260"}],"iscsitargets":{"iqn.2016-09.com.gotgt.gostor:example_tgt_0":{"tpgts":{"1":[0]},"luns":{"0":1000}}}}' > ${HOME}/.gotgt/config.json - echo '{"storages":[{"deviceID":1000,"path":"file:/var/tmp/disk.img","online":true}],"iscsiportals":[{"id":0,"portal":"127.0.0.1:3260"}],"iscsitargets":{"iqn.2016-09.com.gotgt.gostor:example_tgt_0":{"tpgts":{"1":[0]},"luns":{"0":1000}}}}' > ${HOME}/.gotgt/config.json
- ./citd -v 4 1>/dev/null 2>&1 & - ./gotgt daemon --log debug 1>/dev/null 2>&1 &
# libiscsi test # libiscsi test
- mkdir ${HOME}/libiscsi - mkdir ${HOME}/libiscsi
- git clone https://github.com/gostor/libiscsi ${HOME}/libiscsi - git clone https://github.com/gostor/libiscsi ${HOME}/libiscsi
@@ -36,18 +36,21 @@ script:
- ./autogen.sh - ./autogen.sh
- ./configure - ./configure
- make - make
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.TestUnitReady iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.TestUnitReady iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.ReadCapacity10 iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.ReadCapacity10 iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.ReadCapacity16 iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.ReadCapacity16 iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Read10.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Read10.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Write10.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Write10.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Read16.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Read16.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Write16.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Write16.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Read32.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Read32.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.Write32.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.Write32.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.WriteVerify10.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.WriteVerify10.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.WriteVerify16.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.WriteVerify16.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -f --test=SCSI.WriteVerify32.Simple iscsi://127.0.0.1:3260/${TARGET}/0 - ./test-tool/iscsi-test-cu -d -A --test=SCSI.WriteVerify32.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -A --test=SCSI.Verify10.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -A --test=SCSI.Verify12.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./test-tool/iscsi-test-cu -d -A --test=SCSI.Verify16.Simple iscsi://127.0.0.1:3260/${TARGET}/0
- ./utils/iscsi-ls -s iscsi://127.0.0.1:3260/${TARGET} - ./utils/iscsi-ls -s iscsi://127.0.0.1:3260/${TARGET}
- ./utils/iscsi-inq iscsi://127.0.0.1:3260/${TARGET}/0 - ./utils/iscsi-inq iscsi://127.0.0.1:3260/${TARGET}/0
- ./utils/iscsi-readcapacity16 iscsi://127.0.0.1:3260/${TARGET}/0 - ./utils/iscsi-readcapacity16 iscsi://127.0.0.1:3260/${TARGET}/0

4
Godeps/Godeps.json generated
View File

@@ -26,10 +26,6 @@
"Comment": "v0.2.0-8-g990a1a1", "Comment": "v0.2.0-8-g990a1a1",
"Rev": "990a1a1a70b0da4c4cb70e117971a4f0babfbf1a" "Rev": "990a1a1a70b0da4c4cb70e117971a4f0babfbf1a"
}, },
{
"ImportPath": "github.com/golang/glog",
"Rev": "23def4e6c14b4da8ac2ed8007337bc5eb5007998"
},
{ {
"ImportPath": "github.com/gorilla/context", "ImportPath": "github.com/gorilla/context",
"Rev": "215affda49addc4c8ef7e2534915df2c8c35c6cd" "Rev": "215affda49addc4c8ef7e2534915df2c8c35c6cd"

191
Godeps/_workspace/src/github.com/golang/glog/LICENSE generated vendored
View File

@@ -1,191 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and
distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright
owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities
that control, are controlled by, or are under common control with that entity.
For the purposes of this definition, "control" means (i) the power, direct or
indirect, to cause the direction or management of such entity, whether by
contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising
permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including
but not limited to software source code, documentation source, and configuration
files.
"Object" form shall mean any form resulting from mechanical transformation or
translation of a Source form, including but not limited to compiled object code,
generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made
available under the License, as indicated by a copyright notice that is included
in or attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that
is based on (or derived from) the Work and for which the editorial revisions,
annotations, elaborations, or other modifications represent, as a whole, an
original work of authorship. For the purposes of this License, Derivative Works
shall not include works that remain separable from, or merely link (or bind by
name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version
of the Work and any modifications or additions to that Work or Derivative Works
thereof, that is intentionally submitted to Licensor for inclusion in the Work
by the copyright owner or by an individual or Legal Entity authorized to submit
on behalf of the copyright owner. For the purposes of this definition,
"submitted" means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems, and
issue tracking systems that are managed by, or on behalf of, the Licensor for
the purpose of discussing and improving the Work, but excluding communication
that is conspicuously marked or otherwise designated in writing by the copyright
owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
of whom a Contribution has been received by Licensor and subsequently
incorporated within the Work.
2. Grant of Copyright License.
Subject to the terms and conditions of this License, each Contributor hereby
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
irrevocable copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the Work and such
Derivative Works in Source or Object form.
3. Grant of Patent License.
Subject to the terms and conditions of this License, each Contributor hereby
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
irrevocable (except as stated in this section) patent license to make, have
made, use, offer to sell, sell, import, and otherwise transfer the Work, where
such license applies only to those patent claims licensable by such Contributor
that are necessarily infringed by their Contribution(s) alone or by combination
of their Contribution(s) with the Work to which such Contribution(s) was
submitted. If You institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work or a
Contribution incorporated within the Work constitutes direct or contributory
patent infringement, then any patent licenses granted to You under this License
for that Work shall terminate as of the date such litigation is filed.
4. Redistribution.
You may reproduce and distribute copies of the Work or Derivative Works thereof
in any medium, with or without modifications, and in Source or Object form,
provided that You meet the following conditions:
You must give any other recipients of the Work or Derivative Works a copy of
this License; and
You must cause any modified files to carry prominent notices stating that You
changed the files; and
You must retain, in the Source form of any Derivative Works that You distribute,
all copyright, patent, trademark, and attribution notices from the Source form
of the Work, excluding those notices that do not pertain to any part of the
Derivative Works; and
If the Work includes a "NOTICE" text file as part of its distribution, then any
Derivative Works that You distribute must include a readable copy of the
attribution notices contained within such NOTICE file, excluding those notices
that do not pertain to any part of the Derivative Works, in at least one of the
following places: within a NOTICE text file distributed as part of the
Derivative Works; within the Source form or documentation, if provided along
with the Derivative Works; or, within a display generated by the Derivative
Works, if and wherever such third-party notices normally appear. The contents of
the NOTICE file are for informational purposes only and do not modify the
License. You may add Your own attribution notices within Derivative Works that
You distribute, alongside or as an addendum to the NOTICE text from the Work,
provided that such additional attribution notices cannot be construed as
modifying the License.
You may add Your own copyright statement to Your modifications and may provide
additional or different license terms and conditions for use, reproduction, or
distribution of Your modifications, or for any such Derivative Works as a whole,
provided Your use, reproduction, and distribution of the Work otherwise complies
with the conditions stated in this License.
5. Submission of Contributions.
Unless You explicitly state otherwise, any Contribution intentionally submitted
for inclusion in the Work by You to the Licensor shall be under the terms and
conditions of this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify the terms of
any separate license agreement you may have executed with Licensor regarding
such Contributions.
6. Trademarks.
This License does not grant permission to use the trade names, trademarks,
service marks, or product names of the Licensor, except as required for
reasonable and customary use in describing the origin of the Work and
reproducing the content of the NOTICE file.
7. Disclaimer of Warranty.
Unless required by applicable law or agreed to in writing, Licensor provides the
Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
including, without limitation, any warranties or conditions of TITLE,
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
solely responsible for determining the appropriateness of using or
redistributing the Work and assume any risks associated with Your exercise of
permissions under this License.
8. Limitation of Liability.
In no event and under no legal theory, whether in tort (including negligence),
contract, or otherwise, unless required by applicable law (such as deliberate
and grossly negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special, incidental,
or consequential damages of any character arising as a result of this License or
out of the use or inability to use the Work (including but not limited to
damages for loss of goodwill, work stoppage, computer failure or malfunction, or
any and all other commercial damages or losses), even if such Contributor has
been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability.
While redistributing the Work or Derivative Works thereof, You may choose to
offer, and charge a fee for, acceptance of support, warranty, indemnity, or
other liability obligations and/or rights consistent with this License. However,
in accepting such obligations, You may act only on Your own behalf and on Your
sole responsibility, not on behalf of any other Contributor, and only if You
agree to indemnify, defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason of your
accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work
To apply the Apache License to your work, attach the following boilerplate
notice, with the fields enclosed by brackets "[]" replaced with your own
identifying information. (Don't include the brackets!) The text should be
enclosed in the appropriate comment syntax for the file format. We also
recommend that a file or class name and description of purpose be included on
the same "printed page" as the copyright notice for easier identification within
third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

44
Godeps/_workspace/src/github.com/golang/glog/README generated vendored
View File

@@ -1,44 +0,0 @@
glog
====
Leveled execution logs for Go.
This is an efficient pure Go implementation of leveled logs in the
manner of the open source C++ package
https://github.com/google/glog
By binding methods to booleans it is possible to use the log package
without paying the expense of evaluating the arguments to the log.
Through the -vmodule flag, the package also provides fine-grained
control over logging at the file level.
The comment from glog.go introduces the ideas:
Package glog implements logging analogous to the Google-internal
C++ INFO/ERROR/V setup. It provides functions Info, Warning,
Error, Fatal, plus formatting variants such as Infof. It
also provides V-style logging controlled by the -v and
-vmodule=file=2 flags.
Basic examples:
glog.Info("Prepare to repel boarders")
glog.Fatalf("Initialization failed: %s", err)
See the documentation for the V function for an explanation
of these examples:
if glog.V(2) {
glog.Info("Starting transaction...")
}
glog.V(2).Infoln("Processed", nItems, "elements")
The repository contains an open source version of the log package
used inside Google. The master copy of the source lives inside
Google, not here. The code in this repo is for export only and is not itself
under development. Feature requests will be ignored.
Send bug reports to golang-nuts@googlegroups.com.

1180
Godeps/_workspace/src/github.com/golang/glog/glog.go generated vendored
View File

File diff suppressed because it is too large Load Diff

124
Godeps/_workspace/src/github.com/golang/glog/glog_file.go generated vendored
View File

@@ -1,124 +0,0 @@
// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
//
// Copyright 2013 Google Inc. 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.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// File I/O for logs.
package glog
import (
"errors"
"flag"
"fmt"
"os"
"os/user"
"path/filepath"
"strings"
"sync"
"time"
)
// MaxSize is the maximum size of a log file in bytes.
var MaxSize uint64 = 1024 * 1024 * 1800
// logDirs lists the candidate directories for new log files.
var logDirs []string
// If non-empty, overrides the choice of directory in which to write logs.
// See createLogDirs for the full list of possible destinations.
var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
func createLogDirs() {
if *logDir != "" {
logDirs = append(logDirs, *logDir)
}
logDirs = append(logDirs, os.TempDir())
}
var (
pid = os.Getpid()
program = filepath.Base(os.Args[0])
host = "unknownhost"
userName = "unknownuser"
)
func init() {
h, err := os.Hostname()
if err == nil {
host = shortHostname(h)
}
current, err := user.Current()
if err == nil {
userName = current.Username
}
// Sanitize userName since it may contain filepath separators on Windows.
userName = strings.Replace(userName, `\`, "_", -1)
}
// shortHostname returns its argument, truncating at the first period.
// For instance, given "www.google.com" it returns "www".
func shortHostname(hostname string) string {
if i := strings.Index(hostname, "."); i >= 0 {
return hostname[:i]
}
return hostname
}
// logName returns a new log file name containing tag, with start time t, and
// the name for the symlink for tag.
func logName(tag string, t time.Time) (name, link string) {
name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d",
program,
host,
userName,
tag,
t.Year(),
t.Month(),
t.Day(),
t.Hour(),
t.Minute(),
t.Second(),
pid)
return name, program + "." + tag
}
var onceLogDirs sync.Once
// create creates a new log file and returns the file and its filename, which
// contains tag ("INFO", "FATAL", etc.) and t. If the file is created
// successfully, create also attempts to update the symlink for that tag, ignoring
// errors.
func create(tag string, t time.Time) (f *os.File, filename string, err error) {
onceLogDirs.Do(createLogDirs)
if len(logDirs) == 0 {
return nil, "", errors.New("log: no log dirs")
}
name, link := logName(tag, t)
var lastErr error
for _, dir := range logDirs {
fname := filepath.Join(dir, name)
f, err := os.Create(fname)
if err == nil {
symlink := filepath.Join(dir, link)
os.Remove(symlink) // ignore err
os.Symlink(name, symlink) // ignore err
return f, fname, nil
}
lastErr = err
}
return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr)
}

415
Godeps/_workspace/src/github.com/golang/glog/glog_test.go generated vendored
View File

@@ -1,415 +0,0 @@
// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
//
// Copyright 2013 Google Inc. 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.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package glog
import (
"bytes"
"fmt"
stdLog "log"
"path/filepath"
"runtime"
"strconv"
"strings"
"testing"
"time"
)
// Test that shortHostname works as advertised.
func TestShortHostname(t *testing.T) {
for hostname, expect := range map[string]string{
"": "",
"host": "host",
"host.google.com": "host",
} {
if got := shortHostname(hostname); expect != got {
t.Errorf("shortHostname(%q): expected %q, got %q", hostname, expect, got)
}
}
}
// flushBuffer wraps a bytes.Buffer to satisfy flushSyncWriter.
type flushBuffer struct {
bytes.Buffer
}
func (f *flushBuffer) Flush() error {
return nil
}
func (f *flushBuffer) Sync() error {
return nil
}
// swap sets the log writers and returns the old array.
func (l *loggingT) swap(writers [numSeverity]flushSyncWriter) (old [numSeverity]flushSyncWriter) {
l.mu.Lock()
defer l.mu.Unlock()
old = l.file
for i, w := range writers {
logging.file[i] = w
}
return
}
// newBuffers sets the log writers to all new byte buffers and returns the old array.
func (l *loggingT) newBuffers() [numSeverity]flushSyncWriter {
return l.swap([numSeverity]flushSyncWriter{new(flushBuffer), new(flushBuffer), new(flushBuffer), new(flushBuffer)})
}
// contents returns the specified log value as a string.
func contents(s severity) string {
return logging.file[s].(*flushBuffer).String()
}
// contains reports whether the string is contained in the log.
func contains(s severity, str string, t *testing.T) bool {
return strings.Contains(contents(s), str)
}
// setFlags configures the logging flags how the test expects them.
func setFlags() {
logging.toStderr = false
}
// Test that Info works as advertised.
func TestInfo(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
Info("test")
if !contains(infoLog, "I", t) {
t.Errorf("Info has wrong character: %q", contents(infoLog))
}
if !contains(infoLog, "test", t) {
t.Error("Info failed")
}
}
func TestInfoDepth(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
f := func() { InfoDepth(1, "depth-test1") }
// The next three lines must stay together
_, _, wantLine, _ := runtime.Caller(0)
InfoDepth(0, "depth-test0")
f()
msgs := strings.Split(strings.TrimSuffix(contents(infoLog), "\n"), "\n")
if len(msgs) != 2 {
t.Fatalf("Got %d lines, expected 2", len(msgs))
}
for i, m := range msgs {
if !strings.HasPrefix(m, "I") {
t.Errorf("InfoDepth[%d] has wrong character: %q", i, m)
}
w := fmt.Sprintf("depth-test%d", i)
if !strings.Contains(m, w) {
t.Errorf("InfoDepth[%d] missing %q: %q", i, w, m)
}
// pull out the line number (between : and ])
msg := m[strings.LastIndex(m, ":")+1:]
x := strings.Index(msg, "]")
if x < 0 {
t.Errorf("InfoDepth[%d]: missing ']': %q", i, m)
continue
}
line, err := strconv.Atoi(msg[:x])
if err != nil {
t.Errorf("InfoDepth[%d]: bad line number: %q", i, m)
continue
}
wantLine++
if wantLine != line {
t.Errorf("InfoDepth[%d]: got line %d, want %d", i, line, wantLine)
}
}
}
func init() {
CopyStandardLogTo("INFO")
}
// Test that CopyStandardLogTo panics on bad input.
func TestCopyStandardLogToPanic(t *testing.T) {
defer func() {
if s, ok := recover().(string); !ok || !strings.Contains(s, "LOG") {
t.Errorf(`CopyStandardLogTo("LOG") should have panicked: %v`, s)
}
}()
CopyStandardLogTo("LOG")
}
// Test that using the standard log package logs to INFO.
func TestStandardLog(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
stdLog.Print("test")
if !contains(infoLog, "I", t) {
t.Errorf("Info has wrong character: %q", contents(infoLog))
}
if !contains(infoLog, "test", t) {
t.Error("Info failed")
}
}
// Test that the header has the correct format.
func TestHeader(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
defer func(previous func() time.Time) { timeNow = previous }(timeNow)
timeNow = func() time.Time {
return time.Date(2006, 1, 2, 15, 4, 5, .067890e9, time.Local)
}
pid = 1234
Info("test")
var line int
format := "I0102 15:04:05.067890 1234 glog_test.go:%d] test\n"
n, err := fmt.Sscanf(contents(infoLog), format, &line)
if n != 1 || err != nil {
t.Errorf("log format error: %d elements, error %s:\n%s", n, err, contents(infoLog))
}
// Scanf treats multiple spaces as equivalent to a single space,
// so check for correct space-padding also.
want := fmt.Sprintf(format, line)
if contents(infoLog) != want {
t.Errorf("log format error: got:\n\t%q\nwant:\t%q", contents(infoLog), want)
}
}
// Test that an Error log goes to Warning and Info.
// Even in the Info log, the source character will be E, so the data should
// all be identical.
func TestError(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
Error("test")
if !contains(errorLog, "E", t) {
t.Errorf("Error has wrong character: %q", contents(errorLog))
}
if !contains(errorLog, "test", t) {
t.Error("Error failed")
}
str := contents(errorLog)
if !contains(warningLog, str, t) {
t.Error("Warning failed")
}
if !contains(infoLog, str, t) {
t.Error("Info failed")
}
}
// Test that a Warning log goes to Info.
// Even in the Info log, the source character will be W, so the data should
// all be identical.
func TestWarning(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
Warning("test")
if !contains(warningLog, "W", t) {
t.Errorf("Warning has wrong character: %q", contents(warningLog))
}
if !contains(warningLog, "test", t) {
t.Error("Warning failed")
}
str := contents(warningLog)
if !contains(infoLog, str, t) {
t.Error("Info failed")
}
}
// Test that a V log goes to Info.
func TestV(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
logging.verbosity.Set("2")
defer logging.verbosity.Set("0")
V(2).Info("test")
if !contains(infoLog, "I", t) {
t.Errorf("Info has wrong character: %q", contents(infoLog))
}
if !contains(infoLog, "test", t) {
t.Error("Info failed")
}
}
// Test that a vmodule enables a log in this file.
func TestVmoduleOn(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
logging.vmodule.Set("glog_test=2")
defer logging.vmodule.Set("")
if !V(1) {
t.Error("V not enabled for 1")
}
if !V(2) {
t.Error("V not enabled for 2")
}
if V(3) {
t.Error("V enabled for 3")
}
V(2).Info("test")
if !contains(infoLog, "I", t) {
t.Errorf("Info has wrong character: %q", contents(infoLog))
}
if !contains(infoLog, "test", t) {
t.Error("Info failed")
}
}
// Test that a vmodule of another file does not enable a log in this file.
func TestVmoduleOff(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
logging.vmodule.Set("notthisfile=2")
defer logging.vmodule.Set("")
for i := 1; i <= 3; i++ {
if V(Level(i)) {
t.Errorf("V enabled for %d", i)
}
}
V(2).Info("test")
if contents(infoLog) != "" {
t.Error("V logged incorrectly")
}
}
// vGlobs are patterns that match/don't match this file at V=2.
var vGlobs = map[string]bool{
// Easy to test the numeric match here.
"glog_test=1": false, // If -vmodule sets V to 1, V(2) will fail.
"glog_test=2": true,
"glog_test=3": true, // If -vmodule sets V to 1, V(3) will succeed.
// These all use 2 and check the patterns. All are true.
"*=2": true,
"?l*=2": true,
"????_*=2": true,
"??[mno]?_*t=2": true,
// These all use 2 and check the patterns. All are false.
"*x=2": false,
"m*=2": false,
"??_*=2": false,
"?[abc]?_*t=2": false,
}
// Test that vmodule globbing works as advertised.
func testVmoduleGlob(pat string, match bool, t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
defer logging.vmodule.Set("")
logging.vmodule.Set(pat)
if V(2) != Verbose(match) {
t.Errorf("incorrect match for %q: got %t expected %t", pat, V(2), match)
}
}
// Test that a vmodule globbing works as advertised.
func TestVmoduleGlob(t *testing.T) {
for glob, match := range vGlobs {
testVmoduleGlob(glob, match, t)
}
}
func TestRollover(t *testing.T) {
setFlags()
var err error
defer func(previous func(error)) { logExitFunc = previous }(logExitFunc)
logExitFunc = func(e error) {
err = e
}
defer func(previous uint64) { MaxSize = previous }(MaxSize)
MaxSize = 512
Info("x") // Be sure we have a file.
info, ok := logging.file[infoLog].(*syncBuffer)
if !ok {
t.Fatal("info wasn't created")
}
if err != nil {
t.Fatalf("info has initial error: %v", err)
}
fname0 := info.file.Name()
Info(strings.Repeat("x", int(MaxSize))) // force a rollover
if err != nil {
t.Fatalf("info has error after big write: %v", err)
}
// Make sure the next log file gets a file name with a different
// time stamp.
//
// TODO: determine whether we need to support subsecond log
// rotation. C++ does not appear to handle this case (nor does it
// handle Daylight Savings Time properly).
time.Sleep(1 * time.Second)
Info("x") // create a new file
if err != nil {
t.Fatalf("error after rotation: %v", err)
}
fname1 := info.file.Name()
if fname0 == fname1 {
t.Errorf("info.f.Name did not change: %v", fname0)
}
if info.nbytes >= MaxSize {
t.Errorf("file size was not reset: %d", info.nbytes)
}
}
func TestLogBacktraceAt(t *testing.T) {
setFlags()
defer logging.swap(logging.newBuffers())
// The peculiar style of this code simplifies line counting and maintenance of the
// tracing block below.
var infoLine string
setTraceLocation := func(file string, line int, ok bool, delta int) {
if !ok {
t.Fatal("could not get file:line")
}
_, file = filepath.Split(file)
infoLine = fmt.Sprintf("%s:%d", file, line+delta)
err := logging.traceLocation.Set(infoLine)
if err != nil {
t.Fatal("error setting log_backtrace_at: ", err)
}
}
{
// Start of tracing block. These lines know about each other's relative position.
_, file, line, ok := runtime.Caller(0)
setTraceLocation(file, line, ok, +2) // Two lines between Caller and Info calls.
Info("we want a stack trace here")
}
numAppearances := strings.Count(contents(infoLog), infoLine)
if numAppearances < 2 {
// Need 2 appearances, one in the log header and one in the trace:
// log_test.go:281: I0511 16:36:06.952398 02238 log_test.go:280] we want a stack trace here
// ...
// github.com/glog/glog_test.go:280 (0x41ba91)
// ...
// We could be more precise but that would require knowing the details
// of the traceback format, which may not be dependable.
t.Fatal("got no trace back; log is ", contents(infoLog))
}
}
func BenchmarkHeader(b *testing.B) {
for i := 0; i < b.N; i++ {
buf, _, _ := logging.header(infoLog, 0)
logging.putBuffer(buf)
}
}

13
Makefile.am
View File

@@ -1,13 +1,10 @@
export GOPATH:=$(abs_top_srcdir)/Godeps/_workspace:$(GOPATH) export GOPATH:=$(abs_top_srcdir)/Godeps/_workspace:$(GOPATH)
all-local: build-cli build-daemon all-local: build
clean-local: clean-local:
-rm -f citadm citd -rm -f gotgt
install-exec-local: install-exec-local:
$(INSTALL_PROGRAM) citadm $(bindir) $(INSTALL_PROGRAM) gotgt $(bindir)
$(INSTALL_PROGRAM) citd $(bindir)
build-cli: build:
go build citadm.go go build gotgt.go
build-daemon:
go build citd.go

6
README.md
View File

@@ -1,6 +1,6 @@
## gotgt [![Build Status](https://travis-ci.org/gostor/gotgt.svg)](https://travis-ci.org/gostor/gotgt) ## gotgt [![Build Status](https://travis-ci.org/gostor/gotgt.svg)](https://travis-ci.org/gostor/gotgt)
Simple Golang SCSI Target framework, this includes two binaries, one is `citadm` which is command line to config and control, the other is `citd` which is a target daemon. Simple Golang SCSI Target framework, this includes only one binary, you can start a daemon via `gotgt daemon` and control it via `gotgt list/create/rm`.
## Build ## Build
@@ -62,10 +62,6 @@ You can test this with [open-iscsi](http://www.open-iscsi.com/) or [libiscsi](ht
* SCSI Command Queue (p2) * SCSI Command Queue (p2)
* More SCSI commands * More SCSI commands
* SPC3/SAM2 * SPC3/SAM2
* Page83(Inquiry) (orzhang, p1)
* Page0 (Inquiry) (orzhang, p1)
* Define Device UUID
* Verify (carmark, p1)
* Support `Target Group` and `Target Port` (p3) * Support `Target Group` and `Target Port` (p3)
* Refactor (carmark, p1) * Refactor (carmark, p1)
* Command Line (carmark, p1) * Command Line (carmark, p1)

19
cmd/cmd.go
View File

@@ -1,3 +1,19 @@
/*
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.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd package cmd
import ( import (
@@ -10,7 +26,7 @@ import (
func NewCommand(cli *client.Client) *cobra.Command { func NewCommand(cli *client.Client) *cobra.Command {
var cmd = &cobra.Command{ var cmd = &cobra.Command{
Use: "citadm", Use: "gotgt",
Short: "Gotgt is a very fast and stable SCSI target framework", Short: "Gotgt is a very fast and stable SCSI target framework",
Long: ``, Long: ``,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
@@ -18,6 +34,7 @@ func NewCommand(cli *client.Client) *cobra.Command {
}, },
} }
cmd.AddCommand( cmd.AddCommand(
newDaemonCommand(cli),
newCreateCommand(cli), newCreateCommand(cli),
newRemoveCommand(cli), newRemoveCommand(cli),
newListCommand(cli), newListCommand(cli),

89
citd.go → cmd/daemon.go
View File

@@ -14,11 +14,9 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// SCSI target daemon package cmd
package main
import ( import (
"flag"
"fmt" "fmt"
"os" "os"
"os/signal" "os/signal"
@@ -26,54 +24,65 @@ import (
"strings" "strings"
"syscall" "syscall"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api/client"
"github.com/gostor/gotgt/pkg/apiserver" "github.com/gostor/gotgt/pkg/apiserver"
"github.com/gostor/gotgt/pkg/config" "github.com/gostor/gotgt/pkg/config"
"github.com/gostor/gotgt/pkg/port"
_ "github.com/gostor/gotgt/pkg/port/iscsit" _ "github.com/gostor/gotgt/pkg/port/iscsit"
"github.com/gostor/gotgt/pkg/scsi" "github.com/gostor/gotgt/pkg/scsi"
_ "github.com/gostor/gotgt/pkg/scsi/backingstore" _ "github.com/gostor/gotgt/pkg/scsi/backingstore"
"github.com/spf13/cobra"
) )
func main() { func newDaemonCommand(cli *client.Client) *cobra.Command {
var host string
flHelp := flag.Bool("help", false, "Print help message for Hyperd daemon") var driver string
flHost := flag.String("host", "tcp://127.0.0.1:23457", "Host for SCSI target daemon") var logLevel string
flDriver := flag.String("driver", "iscsi", "SCSI low level driver") var cmd = &cobra.Command{
flag.Usage = func() { *flHelp = true } Use: "daemon",
flag.Parse() Short: "Setup a daemon",
flag.Set("logtostderr", "true") Long: `Setup the Gotgt's daemon`,
if *flHelp == true { RunE: func(cmd *cobra.Command, args []string) error {
fmt.Println(`Usage: return createDaemon(host, driver, logLevel)
xxxd [OPTIONS] },
Application Options:
--host="" Host for SCSI target daemon
--driver=iscsi SCSI low level driver
Help Options:
-h, --help Show this help message
`)
return
} }
flags := cmd.Flags()
flags.StringVar(&logLevel, "log", "info", "Log level of SCSI target daemon")
flags.StringVar(&host, "host", "tcp://127.0.0.1:23457", "Host for SCSI target daemon")
flags.StringVar(&driver, "driver", "iscsi", "SCSI low level driver")
return cmd
}
func createDaemon(host, driver, level string) error {
switch level {
case "info":
log.SetLevel(log.InfoLevel)
case "warn":
log.SetLevel(log.WarnLevel)
case "debug":
log.SetLevel(log.DebugLevel)
case "panic", "fatal", "error":
log.SetLevel(log.ErrorLevel)
default:
return fmt.Errorf("unknown log level: %v", level)
}
config, err := config.Load(config.ConfigDir()) config, err := config.Load(config.ConfigDir())
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
os.Exit(1) return err
} }
err = scsi.InitSCSILUMap(config) err = scsi.InitSCSILUMap(config)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
os.Exit(1) return err
} }
scsiTarget := scsi.NewSCSITargetService() scsiTarget := scsi.NewSCSITargetService()
targetDriver, err := port.NewTargetService(*flDriver, scsiTarget) targetDriver, err := scsi.NewTargetDriver(driver, scsiTarget)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
os.Exit(1) return err
} }
for tgtname := range config.ISCSITargets { for tgtname := range config.ISCSITargets {
@@ -89,22 +98,23 @@ Help Options:
} }
hosts := []string{} hosts := []string{}
if *flHost != "" { if host != "" {
hosts = append(hosts, *flHost) hosts = append(hosts, host)
} }
for _, protoAddr := range hosts { for _, protoAddr := range hosts {
protoAddrParts := strings.SplitN(protoAddr, "://", 2) protoAddrParts := strings.SplitN(protoAddr, "://", 2)
if len(protoAddrParts) != 2 { if len(protoAddrParts) != 2 {
glog.Errorf("bad format %s, expected PROTO://ADDR", protoAddr) err = fmt.Errorf("bad format %s, expected PROTO://ADDR", protoAddr)
return log.Error(err)
return err
} }
serverConfig.Addrs = append(serverConfig.Addrs, apiserver.Addr{Proto: protoAddrParts[0], Addr: protoAddrParts[1]}) serverConfig.Addrs = append(serverConfig.Addrs, apiserver.Addr{Proto: protoAddrParts[0], Addr: protoAddrParts[1]})
} }
s, err := apiserver.New(serverConfig) s, err := apiserver.New(serverConfig)
if err != nil { if err != nil {
glog.Errorf(err.Error()) log.Error(err)
return return err
} }
s.InitRouters() s.InitRouters()
// The serve API routine never exits unless an error occurs // The serve API routine never exits unless an error occurs
@@ -123,10 +133,11 @@ Help Options:
// If we have an error here it is unique to API (as daemonErr would have // If we have an error here it is unique to API (as daemonErr would have
// exited the daemon process above) // exited the daemon process above)
if errAPI != nil { if errAPI != nil {
glog.Warningf("Shutting down due to ServeAPI error: %v", errAPI) log.Warnf("Shutting down due to ServeAPI error: %v", errAPI)
} }
case <-stopAll: case <-stopAll:
break break
} }
s.Close() s.Close()
return nil
} }

2
cmd/version.go
View File

@@ -14,7 +14,7 @@ func newVersionCommand(cli *client.Client) *cobra.Command {
Short: "Print the version number of gotgt", Short: "Print the version number of gotgt",
Long: `All software has versions. This is Gotgt 's`, Long: `All software has versions. This is Gotgt 's`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Gotgt %s -- HEAD\n", version.VERSION) fmt.Printf("Gotgt %s -- HEAD\n", version.Version)
}, },
} }
return cmd return cmd

4
citadm.go → gotgt.go
View File

@@ -25,9 +25,11 @@ import (
"github.com/docker/go-connections/sockets" "github.com/docker/go-connections/sockets"
"github.com/gostor/gotgt/cmd" "github.com/gostor/gotgt/cmd"
"github.com/gostor/gotgt/pkg/api/client" "github.com/gostor/gotgt/pkg/api/client"
"github.com/gostor/gotgt/pkg/version"
) )
func main() { func main() {
host := "tcp://127.0.0.1:23457" host := "tcp://127.0.0.1:23457"
httpClient, err := newHTTPClient(host) httpClient, err := newHTTPClient(host)
if err != nil { if err != nil {
@@ -35,7 +37,7 @@ func main() {
os.Exit(1) os.Exit(1)
} }
cli, err := client.NewClient(host, "0.1", httpClient, nil) cli, err := client.NewClient(host, version.Version, httpClient, nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%v", err) fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1) os.Exit(1)

23
pkg/api/types.go
View File

@@ -177,8 +177,10 @@ type SCSICommand struct {
} }
type ITNexus struct { type ITNexus struct {
ID uuid.UUID `json:"id"` /*UUIDv1*/ // UUID v1
Tag string `json:"Tag"` /*For protocal spec identifer*/ ID uuid.UUID `json:"id"`
// For protocal spec identifer
Tag string `json:"Tag"`
} }
type ITNexusLuInfo struct { type ITNexusLuInfo struct {
@@ -333,7 +335,10 @@ type BackingStore interface {
Init(dev *SCSILu, Opts string) error Init(dev *SCSILu, Opts string) error
Exit(dev *SCSILu) error Exit(dev *SCSILu) error
Size(dev *SCSILu) uint64 Size(dev *SCSILu) uint64
CommandSubmit(cmd *SCSICommand) error Read(offset, tl int64) ([]byte, error)
Write([]byte, int64) error
DataSync() error
DataAdvise(int64, int64, uint32) error
} }
type SCSIDeviceProtocol interface { type SCSIDeviceProtocol interface {
@@ -346,13 +351,17 @@ type SCSIDeviceProtocol interface {
ExitLu(lu *SCSILu) error ExitLu(lu *SCSILu) error
} }
type ModePage struct { type ModePage struct {
Pcode uint8 // Page code // Page code
SubPcode uint8 // Sub page code PageCode uint8
Data []byte // Rest of mode page info // Sub page code
SubPageCode uint8
// Rest of mode page info
Data []byte
} }
type SCSIReservation struct { type SCSIReservation struct {
ID uuid.UUID //Internal Reservation ID // Internal reservation ID
ID uuid.UUID
Key uint64 Key uint64
ITNexusID uuid.UUID ITNexusID uuid.UUID
Scope uint8 Scope uint8

24
pkg/apiserver/apiserver.go
View File

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// Package apiserver contains the code that provides a rest.ful api service. // Package apiserver contains the code that provides a rest.ful API service.
package apiserver package apiserver
import ( import (
@@ -25,9 +25,9 @@ import (
"strconv" "strconv"
"strings" "strings"
log "github.com/Sirupsen/logrus"
systemdActivation "github.com/coreos/go-systemd/activation" systemdActivation "github.com/coreos/go-systemd/activation"
"github.com/docker/go-connections/sockets" "github.com/docker/go-connections/sockets"
"github.com/golang/glog"
"github.com/gorilla/mux" "github.com/gorilla/mux"
"github.com/gostor/gotgt/pkg/apiserver/httputils" "github.com/gostor/gotgt/pkg/apiserver/httputils"
"github.com/gostor/gotgt/pkg/apiserver/router" "github.com/gostor/gotgt/pkg/apiserver/router"
@@ -79,7 +79,7 @@ func New(cfg *Config) (*Server, error) {
if err != nil { if err != nil {
return nil, err 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...) s.servers = append(s.servers, srv...)
} }
return s, nil return s, nil
@@ -89,7 +89,7 @@ func New(cfg *Config) (*Server, error) {
func (s *Server) Close() { func (s *Server) Close() {
for _, srv := range s.servers { for _, srv := range s.servers {
if err := srv.Close(); err != nil { 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 srv.srv.Handler = s.routerSwapper
go func(srv *HTTPServer) { go func(srv *HTTPServer) {
var err error 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") { if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
err = nil err = nil
} }
@@ -142,7 +142,7 @@ func (s *HTTPServer) Close() error {
func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) { func (s *Server) initTCPSocket(addr string) (l net.Listener, err error) {
if s.cfg.TLSConfig == nil || s.cfg.TLSConfig.ClientAuth != tls.RequireAndVerifyClientCert { 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 { if l, err = sockets.NewTCPSocket(addr, s.cfg.TLSConfig); err != nil {
return nil, err 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 { func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) {
// log the handler call // 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 // Define the context that we'll pass around to share info
// like the docker-request-id. // 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 { 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) httputils.WriteError(w, err)
} }
} }
@@ -195,12 +195,12 @@ func (s *Server) addRouter(r router.Router) {
func (s *Server) createMux() *mux.Router { func (s *Server) createMux() *mux.Router {
m := mux.NewRouter() m := mux.NewRouter()
glog.V(3).Infof("Registering routers") log.Infof("Registering routers")
for _, apiRouter := range s.routers { for _, apiRouter := range s.routers {
for _, r := range apiRouter.Routes() { for _, r := range apiRouter.Routes() {
f := s.makeHTTPHandler(r.Handler()) 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(versionMatcher + r.Path()).Methods(r.Method()).Handler(f)
m.Path(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. // the API execution.
func (s *Server) Wait(waitChan chan error) { func (s *Server) Wait(waitChan chan error) {
if err := s.serveAPI(); err != nil { if err := s.serveAPI(); err != nil {
glog.Errorf("ServeAPI error: %v", err) log.Errorf("ServeAPI error: %v", err)
waitChan <- err waitChan <- err
return return
} }
@@ -307,7 +307,7 @@ func listenFD(addr string, tlsConfig *tls.Config) ([]net.Listener, error) {
continue continue
} }
if err := ls.Close(); err != nil { 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 return []net.Listener{listeners[fdOffset]}, nil

6
pkg/apiserver/httputils/httputils.go
View File

@@ -13,6 +13,8 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// Package httputils contains a bunch of HTTP utility code, some generic
package httputils package httputils
import ( import (
@@ -157,11 +159,11 @@ func WriteJSON(w http.ResponseWriter, code int, v interface{}) error {
// It panics if the context value does not have version.Version type. // It panics if the context value does not have version.Version type.
func VersionFromContext(ctx context.Context) string { func VersionFromContext(ctx context.Context) string {
if ctx == nil { if ctx == nil {
return version.VERSION return version.Version
} }
val := ctx.Value(APIVersionKey) val := ctx.Value(APIVersionKey)
if val == nil { if val == nil {
return version.VERSION return version.Version
} }
return val.(string) return val.(string)
} }

1
pkg/config/config.go
View File

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// Package config contains how to get/save config parameters from file.
package config package config
import ( import (

72
pkg/port/interfaces.go
View File

@@ -1,72 +0,0 @@
/*
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.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package port
import "github.com/gostor/gotgt/pkg/api"
type SCSITargetDriver interface {
Init() error
Exit() error
CreateTarget(target *api.SCSITarget) error
DestroyTarget(target *api.SCSITarget) error
CreatePortal(name string) error
DestroyPortal(name string) error
CreateLu(lu *api.SCSILu) error
GetLu(lun uint8) (uint64, error)
CommandNotify(nid uint64, result int, cmd *api.SCSICommand) error
}
type fakeSCSITargetDriver struct {
api.SCSITargetDriverCommon
}
func (fake *fakeSCSITargetDriver) Init() error {
return nil
}
func (fake *fakeSCSITargetDriver) Exit() error {
return nil
}
func (fake *fakeSCSITargetDriver) CreateTarget(target *api.SCSITarget) error {
return nil
}
func (fake *fakeSCSITargetDriver) DestroyTarget(target *api.SCSITarget) error {
return nil
}
func (fake *fakeSCSITargetDriver) CreatePortal(name string) error {
return nil
}
func (fake *fakeSCSITargetDriver) DestroyPortal(name string) error {
return nil
}
func (fake *fakeSCSITargetDriver) CreateLu(lu *api.SCSILu) error {
return nil
}
func (fake *fakeSCSITargetDriver) GetLun(lun uint8) (uint64, error) {
return 0, nil
}
func (fake *fakeSCSITargetDriver) CommandNotify(nid uint64, result int, cmd *api.SCSICommand) error {
return nil
}

33
pkg/port/iscsit/cmd.go
View File

@@ -67,18 +67,27 @@ type ISCSICommand struct {
ExpCmdSN, MaxCmdSN uint32 ExpCmdSN, MaxCmdSN uint32
AHSLen int AHSLen int
ConnID uint16 // Connection ID. // Connection ID.
CmdSN uint32 // Command serial number. ConnID uint16
ExpStatSN uint32 // Expected status serial. // Command serial number.
CmdSN uint32
// Expected status serial.
ExpStatSN uint32
Read, Write bool Read, Write bool
LUN [8]uint8 LUN [8]uint8
Transit bool // Transit bit. // Transit bit.
Cont bool // Continue bit. Transit bool
CSG, NSG Stage // Current Stage, Next Stage. // Continue bit.
ISID uint64 // Initiator part of the SSID. Cont bool
TSIH uint16 // Target-assigned Session Identifying Handle. // Current Stage, Next Stage.
StatSN uint32 // Status serial number. CSG, NSG Stage
// Initiator part of the SSID.
ISID uint64
// Target-assigned Session Identifying Handle.
TSIH uint16
// Status serial number.
StatSN uint32
// For login response. // For login response.
StatusClass uint8 StatusClass uint8
@@ -252,6 +261,12 @@ func (m *ISCSICommand) scsiCmdRespBytes() []byte {
for i := 0; i < 3*4; i++ { for i := 0; i < 3*4; i++ {
buf.WriteByte(0x00) buf.WriteByte(0x00)
} }
buf.Write(m.RawData)
dl := len(m.RawData)
for dl%4 > 0 {
dl++
buf.WriteByte(0x00)
}
return buf.Bytes() return buf.Bytes()
} }

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

@@ -18,46 +18,44 @@ package iscsit
import ( import (
"bytes" "bytes"
"errors"
"fmt" "fmt"
"net" "net"
"os" "os"
"strconv" "strconv"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/config" "github.com/gostor/gotgt/pkg/config"
"github.com/gostor/gotgt/pkg/port"
"github.com/gostor/gotgt/pkg/scsi" "github.com/gostor/gotgt/pkg/scsi"
"github.com/gostor/gotgt/pkg/util" "github.com/gostor/gotgt/pkg/util"
"github.com/satori/go.uuid" "github.com/satori/go.uuid"
) )
type ISCSITargetService struct { type ISCSITargetDriver struct {
SCSI *scsi.SCSITargetService SCSI *scsi.SCSITargetService
Name string Name string
iSCSITargets map[string]*ISCSITarget iSCSITargets map[string]*ISCSITarget
} }
func init() { func init() {
port.RegisterTargetService("iscsi", NewISCSITargetService) scsi.RegisterTargetDriver("iscsi", NewISCSITargetDriver)
} }
func NewISCSITargetService(base *scsi.SCSITargetService) (port.SCSITargetService, error) { func NewISCSITargetDriver(base *scsi.SCSITargetService) (scsi.SCSITargetDriver, error) {
return &ISCSITargetService{ return &ISCSITargetDriver{
Name: "iscsi", Name: "iscsi",
iSCSITargets: map[string]*ISCSITarget{}, iSCSITargets: map[string]*ISCSITarget{},
SCSI: base, SCSI: base,
}, nil }, nil
} }
func (s *ISCSITargetService) NewTarget(tgtName string, configInfo *config.Config) (port.SCSITargetDriver, error) { func (s *ISCSITargetDriver) NewTarget(tgtName string, configInfo *config.Config) error {
if _, ok := s.iSCSITargets[tgtName]; ok { if _, ok := s.iSCSITargets[tgtName]; ok {
return nil, fmt.Errorf("target name has been existed") return fmt.Errorf("target name has been existed")
} }
stgt, err := s.SCSI.NewSCSITarget(len(s.iSCSITargets), "iscsi", tgtName) stgt, err := s.SCSI.NewSCSITarget(len(s.iSCSITargets), "iscsi", tgtName)
if err != nil { if err != nil {
return nil, err return err
} }
tgt := newISCSITarget(stgt) tgt := newISCSITarget(stgt)
s.iSCSITargets[tgtName] = tgt s.iSCSITargets[tgtName] = tgt
@@ -73,39 +71,35 @@ func (s *ISCSITargetService) NewTarget(tgtName string, configInfo *config.Config
s.AddiSCSIPortal(tgtName, uint16(tpgtNumber), portal.Portal) s.AddiSCSIPortal(tgtName, uint16(tpgtNumber), portal.Portal)
} }
} }
return tgt, nil return nil
} }
func (s *ISCSITargetService) AddiSCSIPortal(tgtName string, tpgt uint16, portal string) error { func (s *ISCSITargetDriver) AddiSCSIPortal(tgtName string, tpgt uint16, portal string) error {
var ( var (
ok bool ok bool
errMsg string
target *ISCSITarget target *ISCSITarget
tpgtInfo *iSCSITPGT tpgtInfo *iSCSITPGT
) )
if target, ok = s.iSCSITargets[tgtName]; !ok { if target, ok = s.iSCSITargets[tgtName]; !ok {
errMsg = fmt.Sprintf("no target %s", tgtName) return fmt.Errorf("no target %s", tgtName)
return errors.New(errMsg)
} }
if tpgtInfo, ok = target.TPGTs[tpgt]; !ok { if tpgtInfo, ok = target.TPGTs[tpgt]; !ok {
errMsg = fmt.Sprintf("no tpgt %d", tpgt) return fmt.Errorf("no tpgt %d", tpgt)
return errors.New(errMsg)
} }
tgtPortals := tpgtInfo.Portals tgtPortals := tpgtInfo.Portals
if _, ok = tgtPortals[portal]; !ok { if _, ok = tgtPortals[portal]; !ok {
tgtPortals[portal] = struct{}{} tgtPortals[portal] = struct{}{}
} else { } else {
errMsg := fmt.Sprintf("duplicate portal %s,in %s,%d", portal, tgtName, tpgt) return fmt.Errorf("duplicate portal %s,in %s,%d", portal, tgtName, tpgt)
return errors.New(errMsg)
} }
return nil return nil
} }
func (s *ISCSITargetService) HasPortal(tgtName string, tpgt uint16, portal string) bool { func (s *ISCSITargetDriver) HasPortal(tgtName string, tpgt uint16, portal string) bool {
var ( var (
ok bool ok bool
target *ISCSITarget target *ISCSITarget
@@ -127,51 +121,51 @@ func (s *ISCSITargetService) HasPortal(tgtName string, tpgt uint16, portal strin
} }
} }
func (s *ISCSITargetService) Run() error { func (s *ISCSITargetDriver) Run() error {
l, err := net.Listen("tcp", ":3260") l, err := net.Listen("tcp", ":3260")
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
os.Exit(1) os.Exit(1)
} }
defer l.Close() defer l.Close()
for { for {
glog.Info("Listening ...") log.Info("Listening ...")
conn, err := l.Accept() conn, err := l.Accept()
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
continue continue
} }
glog.Info(conn.LocalAddr().String()) log.Info(conn.LocalAddr().String())
glog.Info("Accepting ...") log.Info("Accepting ...")
iscsiConn := &iscsiConnection{conn: conn} iscsiConn := &iscsiConnection{conn: conn}
iscsiConn.init() iscsiConn.init()
iscsiConn.rxIOState = IOSTATE_RX_BHS 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 // start a new thread to do with this command
go s.handler(DATAIN, iscsiConn) go s.handler(DATAIN, iscsiConn)
} }
return nil return nil
} }
func (s *ISCSITargetService) handler(events byte, conn *iscsiConnection) { func (s *ISCSITargetDriver) handler(events byte, conn *iscsiConnection) {
if events&DATAIN != 0 { if events&DATAIN != 0 {
glog.V(1).Infof("rx handler processing...") log.Debug("rx handler processing...")
go s.rxHandler(conn) go s.rxHandler(conn)
} }
if conn.state != CONN_STATE_CLOSE && events&DATAOUT != 0 { if conn.state != CONN_STATE_CLOSE && events&DATAOUT != 0 {
glog.V(1).Infof("tx handler processing...") log.Debug("tx handler processing...")
s.txHandler(conn) s.txHandler(conn)
} }
if conn.state == CONN_STATE_CLOSE { if conn.state == CONN_STATE_CLOSE {
glog.Warningf("iscsi connection[%d] closed", conn.CID) log.Warningf("iscsi connection[%d] closed", conn.CID)
conn.close() conn.close()
} }
} }
func (s *ISCSITargetService) rxHandler(conn *iscsiConnection) { func (s *ISCSITargetDriver) rxHandler(conn *iscsiConnection) {
var ( var (
hdigest uint = 0 hdigest uint = 0
ddigest uint = 0 ddigest uint = 0
@@ -187,22 +181,22 @@ func (s *ISCSITargetService) rxHandler(conn *iscsiConnection) {
for { for {
switch conn.rxIOState { switch conn.rxIOState {
case IOSTATE_RX_BHS: 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) buf, length, err := conn.readData(BHS_SIZE)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
return return
} }
if length == 0 { if length == 0 {
glog.Warningf("set connection to close") log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
return return
} }
conn.rxBuffer = buf conn.rxBuffer = buf
cmd, err = parseHeader(buf) cmd, err = parseHeader(buf)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
glog.Warningf("set connection to close") log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
return return
} }
@@ -211,8 +205,8 @@ func (s *ISCSITargetService) rxHandler(conn *iscsiConnection) {
conn.rxIOState = IOSTATE_RX_INIT_AHS conn.rxIOState = IOSTATE_RX_INIT_AHS
break break
} }
glog.V(2).Infof("got command: \n%s", cmd.String()) log.Debugf("got command: \n%s", cmd.String())
glog.V(2).Infof("got buffer: %v", buf) log.Debugf("got buffer: %v", buf)
final = true final = true
case IOSTATE_RX_INIT_AHS: case IOSTATE_RX_INIT_AHS:
conn.rxIOState = IOSTATE_RX_DATA conn.rxIOState = IOSTATE_RX_DATA
@@ -233,24 +227,24 @@ func (s *ISCSITargetService) rxHandler(conn *iscsiConnection) {
for length < dl { for length < dl {
b, l, err := conn.readData(dl - length) b, l, err := conn.readData(dl - length)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
return return
} }
length += l length += l
buf = append(buf, b...) buf = append(buf, b...)
} }
if length != dl { if length != dl {
glog.V(2).Infof("get length is %d, but expected %d", length, dl) log.Debugf("get length is %d, but expected %d", length, dl)
glog.Warningf("set connection to close") log.Warning("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
return return
} }
cmd.RawData = buf[:length] cmd.RawData = buf[:length]
conn.rxBuffer = append(conn.rxBuffer, buf...) conn.rxBuffer = append(conn.rxBuffer, buf...)
final = true final = true
glog.Infof("got command: \n%s", cmd.String()) log.Debugf("got command: \n%s", cmd.String())
default: default:
glog.Errorf("error %d %d\n", conn.state, conn.rxIOState) log.Errorf("error %d %d\n", conn.state, conn.rxIOState)
return return
} }
@@ -266,34 +260,34 @@ func (s *ISCSITargetService) rxHandler(conn *iscsiConnection) {
conn.resp = &ISCSICommand{} conn.resp = &ISCSICommand{}
switch conn.req.OpCode { switch conn.req.OpCode {
case OpLoginReq: case OpLoginReq:
glog.Infof("OpLoginReq") log.Debug("OpLoginReq")
if err := s.iscsiExecLogin(conn); err != nil { if err := s.iscsiExecLogin(conn); err != nil {
glog.Error(err) log.Error(err)
glog.Warningf("set connection to close") log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
} }
case OpLogoutReq: case OpLogoutReq:
glog.Infof("OpLogoutReq") log.Debug("OpLogoutReq")
if err := iscsiExecLogout(conn); err != nil { if err := iscsiExecLogout(conn); err != nil {
glog.Warningf("set connection to close") log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
} }
case OpTextReq: case OpTextReq:
glog.Infof("OpTextReq") log.Debug("OpTextReq")
if err := s.iscsiExecText(conn); err != nil { if err := s.iscsiExecText(conn); err != nil {
glog.Warningf("set connection to close") log.Warningf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
} }
default: default:
iscsiExecReject(conn) iscsiExecReject(conn)
} }
glog.V(2).Infof("connection state is %v", conn.state) log.Debugf("connection state is %v", conn.state)
glog.V(2).Infof("%#v", conn.resp.String()) log.Debugf("%#v", conn.resp.String())
s.handler(DATAOUT, conn) s.handler(DATAOUT, conn)
} }
} }
func (s *ISCSITargetService) iscsiExecLogin(conn *iscsiConnection) error { func (s *ISCSITargetDriver) iscsiExecLogin(conn *iscsiConnection) error {
var ( var (
target *ISCSITarget target *ISCSITarget
cmd = conn.req cmd = conn.req
@@ -380,7 +374,7 @@ func (s *ISCSITargetService) iscsiExecLogin(conn *iscsiConnection) error {
// create a new session // create a new session
sess, err := s.NewISCSISession(conn, cmd.ISID) sess, err := s.NewISCSISession(conn, cmd.ISID)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
return err return err
} }
itnexus := &api.ITNexus{uuid.NewV1(), GeniSCSIITNexusID(sess)} itnexus := &api.ITNexus{uuid.NewV1(), GeniSCSIITNexusID(sess)}
@@ -412,15 +406,15 @@ func iscsiExecLogout(conn *iscsiConnection) error {
return nil return nil
} }
func (s *ISCSITargetService) iscsiExecText(conn *iscsiConnection) error { func (s *ISCSITargetDriver) iscsiExecText(conn *iscsiConnection) error {
var result = []util.KeyValue{} var result = []util.KeyValue{}
cmd := conn.req cmd := conn.req
keys := util.ParseKVText(cmd.RawData) keys := util.ParseKVText(cmd.RawData)
if st, ok := keys["SendTargets"]; ok { if st, ok := keys["SendTargets"]; ok {
if st == "All" { if st == "All" {
for name, tgt := range s.iSCSITargets { for name, tgt := range s.iSCSITargets {
glog.V(2).Infof("iscsi target: %v", name) log.Debugf("iscsi target: %v", name)
//glog.V(2).Infof("iscsi target portals: %v", tgt.Portals) //log.Debugf("iscsi target portals: %v", tgt.Portals)
result = append(result, util.KeyValue{"TargetName", name}) result = append(result, util.KeyValue{"TargetName", name})
for _, tpgt := range tgt.TPGTs { for _, tpgt := range tgt.TPGTs {
@@ -505,7 +499,7 @@ func iscsiExecR2T(conn *iscsiConnection) error {
return nil return nil
} }
func (s *ISCSITargetService) txHandler(conn *iscsiConnection) { func (s *ISCSITargetDriver) txHandler(conn *iscsiConnection) {
var ( var (
hdigest uint = 0 hdigest uint = 0
ddigest uint = 0 ddigest uint = 0
@@ -518,23 +512,23 @@ func (s *ISCSITargetService) txHandler(conn *iscsiConnection) {
if conn.state == CONN_STATE_SCSI && conn.txTask == nil { if conn.state == CONN_STATE_SCSI && conn.txTask == nil {
err := s.scsiCommandHandler(conn) err := s.scsiCommandHandler(conn)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
return return
} }
} }
for { for {
switch conn.txIOState { switch conn.txIOState {
case IOSTATE_TX_BHS: case IOSTATE_TX_BHS:
glog.V(2).Infof("ready to write response") log.Debug("ready to write response")
glog.V(2).Infof("%s", conn.resp.String()) log.Debugf("%s", conn.resp.String())
glog.V(2).Infof("length of RawData is %d", len(conn.resp.RawData)) log.Debugf("length of RawData is %d", len(conn.resp.RawData))
glog.V(2).Infof("length of resp is %d", len(conn.resp.Bytes())) log.Debugf("length of resp is %d", len(conn.resp.Bytes()))
if l, err := conn.write(conn.resp.Bytes()); err != nil { if l, err := conn.write(conn.resp.Bytes()); err != nil {
glog.Error(err) log.Error(err)
return return
} else { } else {
conn.txIOState = IOSTATE_TX_INIT_AHS 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: case IOSTATE_TX_INIT_AHS:
if hdigest != 0 { if hdigest != 0 {
@@ -553,7 +547,7 @@ func (s *ISCSITargetService) txHandler(conn *iscsiConnection) {
conn.txIOState = IOSTATE_TX_INIT_DDIGEST conn.txIOState = IOSTATE_TX_INIT_DDIGEST
} }
default: default:
glog.Errorf("error %d %d\n", conn.state, conn.txIOState) log.Errorf("error %d %d\n", conn.state, conn.txIOState)
return return
} }
@@ -562,41 +556,41 @@ func (s *ISCSITargetService) txHandler(conn *iscsiConnection) {
} }
} }
glog.V(3).Infof("connection state: %d", conn.state) log.Debugf("connection state: %d", conn.state)
switch conn.state { switch conn.state {
case CONN_STATE_CLOSE, CONN_STATE_EXIT: case CONN_STATE_CLOSE, CONN_STATE_EXIT:
glog.Warningf("set connection to close") log.Warnf("set connection to close")
conn.state = CONN_STATE_CLOSE conn.state = CONN_STATE_CLOSE
case CONN_STATE_SECURITY_LOGIN: case CONN_STATE_SECURITY_LOGIN:
conn.state = CONN_STATE_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: case CONN_STATE_SECURITY_FULL, CONN_STATE_LOGIN_FULL:
if conn.sessionType == SESSION_NORMAL { if conn.sessionType == SESSION_NORMAL {
conn.state = CONN_STATE_KERNEL conn.state = CONN_STATE_KERNEL
glog.Infof("CONN_STATE_KERNEL") log.Infof("CONN_STATE_KERNEL")
conn.state = CONN_STATE_SCSI conn.state = CONN_STATE_SCSI
glog.V(3).Infof("CONN_STATE_SCSI") log.Debugf("CONN_STATE_SCSI")
} else { } else {
conn.state = CONN_STATE_FULL conn.state = CONN_STATE_FULL
glog.V(3).Infof("CONN_STATE_FULL") log.Debugf("CONN_STATE_FULL")
} }
conn.rxIOState = IOSTATE_RX_BHS conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn) s.handler(DATAIN, conn)
case CONN_STATE_SCSI: case CONN_STATE_SCSI:
conn.txTask = nil conn.txTask = nil
default: default:
glog.Warningf("unexpected connection state: %d", conn.state) log.Warnf("unexpected connection state: %d", conn.state)
conn.rxIOState = IOSTATE_RX_BHS conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn) s.handler(DATAIN, conn)
} }
glog.Infof("%d", conn.state) log.Infof("%d", conn.state)
} }
func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err error) { func (s *ISCSITargetDriver) scsiCommandHandler(conn *iscsiConnection) (err error) {
req := conn.req req := conn.req
switch req.OpCode { switch req.OpCode {
case OpSCSICmd: case OpSCSICmd:
glog.V(2).Infof("SCSI Command processing...") log.Debugf("SCSI Command processing...")
scmd := &api.SCSICommand{} scmd := &api.SCSICommand{}
task := &iscsiTask{conn: conn, cmd: conn.req, tag: conn.req.TaskTag, scmd: scmd} task := &iscsiTask{conn: conn, cmd: conn.req, tag: conn.req.TaskTag, scmd: scmd}
if req.Write { if req.Write {
@@ -605,7 +599,7 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
if !req.Final { if !req.Final {
task.unsolCount = 1 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 { if task.scmd.OutSDBBuffer.Buffer == nil {
task.scmd.OutSDBBuffer.Buffer = bytes.NewBuffer([]byte{}) task.scmd.OutSDBBuffer.Buffer = bytes.NewBuffer([]byte{})
@@ -673,7 +667,7 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
conn.txIOState = IOSTATE_TX_BHS conn.txIOState = IOSTATE_TX_BHS
iscsiExecTMFunction(conn) iscsiExecTMFunction(conn)
case OpSCSIOut: case OpSCSIOut:
glog.V(1).Infof("iSCSI Data-out processing...") log.Debugf("iSCSI Data-out processing...")
var task *iscsiTask var task *iscsiTask
for _, t := range conn.session.PendingTasks { for _, t := range conn.session.PendingTasks {
if t.tag == conn.req.TaskTag { if t.tag == conn.req.TaskTag {
@@ -682,16 +676,16 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
} }
if task == nil { if task == nil {
err = fmt.Errorf("Cannot find iSCSI task with tag[%v]", conn.req.TaskTag) err = fmt.Errorf("Cannot find iSCSI task with tag[%v]", conn.req.TaskTag)
glog.Error(err) log.Error(err)
return return
} }
task.offset = task.offset + conn.req.DataLen task.offset = task.offset + conn.req.DataLen
task.r2tCount = task.r2tCount - conn.req.DataLen task.r2tCount = task.r2tCount - conn.req.DataLen
task.scmd.OutSDBBuffer.Buffer.Write(conn.req.RawData) task.scmd.OutSDBBuffer.Buffer.Write(conn.req.RawData)
glog.V(2).Infof("Final: %v", conn.req.Final) log.Debugf("Final: %v", conn.req.Final)
glog.V(2).Infof("r2tCount: %v", task.r2tCount) log.Debugf("r2tCount: %v", task.r2tCount)
if !conn.req.Final { 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 conn.rxIOState = IOSTATE_RX_BHS
s.handler(DATAIN, conn) s.handler(DATAIN, conn)
return nil return nil
@@ -703,7 +697,7 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
break break
} }
task.offset = 0 task.offset = 0
glog.V(1).Infof("Process the Data-out package") log.Debugf("Process the Data-out package")
conn.rxTask = task conn.rxTask = task
if err = s.iscsiExecTask(task); err != nil { if err = s.iscsiExecTask(task); err != nil {
return return
@@ -736,11 +730,11 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
iscsiExecLogout(conn) iscsiExecLogout(conn)
case OpTextReq, OpSNACKReq: case OpTextReq, OpSNACKReq:
err = fmt.Errorf("Cannot handle yet %s", opCodeMap[conn.req.OpCode]) err = fmt.Errorf("Cannot handle yet %s", opCodeMap[conn.req.OpCode])
glog.Error(err) log.Error(err)
return return
default: default:
err = fmt.Errorf("Unknown op %s", opCodeMap[conn.req.OpCode]) err = fmt.Errorf("Unknown op %s", opCodeMap[conn.req.OpCode])
glog.Error(err) log.Error(err)
return return
} }
conn.rxIOState = IOSTATE_RX_BHS conn.rxIOState = IOSTATE_RX_BHS
@@ -748,7 +742,7 @@ func (s *ISCSITargetService) scsiCommandHandler(conn *iscsiConnection) (err erro
return nil return nil
} }
func (s *ISCSITargetService) iscsiTaskQueueHandler(task *iscsiTask) error { func (s *ISCSITargetDriver) iscsiTaskQueueHandler(task *iscsiTask) error {
conn := task.conn conn := task.conn
sess := conn.session sess := conn.session
cmd := task.cmd cmd := task.cmd
@@ -756,16 +750,16 @@ func (s *ISCSITargetService) iscsiTaskQueueHandler(task *iscsiTask) error {
return s.iscsiExecTask(task) return s.iscsiExecTask(task)
} }
cmdsn := cmd.CmdSN 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 { if cmdsn == sess.ExpCmdSN {
retry: retry:
cmdsn += 1 cmdsn += 1
sess.ExpCmdSN = cmdsn 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 { if err := s.iscsiExecTask(task); err != nil {
glog.Error(err) log.Error(err)
} }
if len(sess.PendingTasks) == 0 { if len(sess.PendingTasks) == 0 {
return nil return nil
@@ -781,10 +775,10 @@ func (s *ISCSITargetService) iscsiTaskQueueHandler(task *iscsiTask) error {
} else { } else {
if cmd.CmdSN < sess.ExpCmdSN { if cmd.CmdSN < sess.ExpCmdSN {
err := fmt.Errorf("unexpected cmd serial number: (%d, %d)", 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 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 // add this connection into queue and set this task as pending task
task.state = taskPending task.state = taskPending
sess.PendingTasks.Push(task) sess.PendingTasks.Push(task)
@@ -794,7 +788,7 @@ func (s *ISCSITargetService) iscsiTaskQueueHandler(task *iscsiTask) error {
return nil return nil
} }
func (s *ISCSITargetService) iscsiExecTask(task *iscsiTask) error { func (s *ISCSITargetDriver) iscsiExecTask(task *iscsiTask) error {
cmd := task.cmd cmd := task.cmd
switch cmd.OpCode { switch cmd.OpCode {
case OpSCSICmd, OpSCSIOut: case OpSCSICmd, OpSCSIOut:

13
pkg/port/iscsit/iscsit.go
View File

@@ -18,7 +18,6 @@ limitations under the License.
package iscsit package iscsit
import ( import (
"errors"
"fmt" "fmt"
"strings" "strings"
@@ -71,15 +70,18 @@ type ISCSIRedirectInfo struct {
} }
type iSCSITPGT struct { type iSCSITPGT struct {
TPGT uint16 /* Mapping to SCSI Reltive Target Port ID */ // Mapping to SCSI Reltive Target Port ID
TPGT uint16
Portals map[string]struct{} Portals map[string]struct{}
} }
type ISCSITarget struct { type ISCSITarget struct {
api.SCSITarget api.SCSITarget
api.SCSITargetDriverCommon api.SCSITargetDriverCommon
TPGTs map[uint16]*iSCSITPGT /* Key is a TPGT number */ // TPGT number is the key
Sessions map[uint16]*ISCSISession /* Key is an TSIH */ TPGTs map[uint16]*iSCSITPGT
// TSIH is the key
Sessions map[uint16]*ISCSISession
SessionParam []ISCSISessionParam SessionParam []ISCSISessionParam
Alias string Alias string
MaxSessions int MaxSessions int
@@ -114,8 +116,7 @@ func (tgt *ISCSITarget) FindTPG(portal string) (uint16, error) {
} }
} }
} }
errMsg := fmt.Sprintf("No TPGT found with IP(%s)", portal) return 0, fmt.Errorf("No TPGT found with IP(%s)", portal)
return 0, errors.New(errMsg)
} }
func newISCSITarget(target *api.SCSITarget) *ISCSITarget { func newISCSITarget(target *api.SCSITarget) *ISCSITarget {

27
pkg/port/iscsit/session.go
View File

@@ -192,33 +192,8 @@ func (tq *taskQueue) Pop() interface{} {
return item return item
} }
// The BHS is 48 bytes long. The Opcode and DataSegmentLength fields
// appear in all iSCSI PDUs. In addition, when used, the Initiator Task
// Tag and Logical Unit Number always appear in the same location in the
// header.
type iscsiHeader struct {
opcode uint8
flags uint8 // Final bit
rsvd2 [2]uint8
hlength uint8 // AHSs total length
dlength [3]uint8 // Data length
lun [8]uint8
itt uint8 // Initiator Task Tag
ttt uint8 // Target Task Tag
statsn uint8
expStatSN uint8
maxStatSN uint8
other [12]uint8
}
type iscsiPdu struct {
bhs iscsiHeader
ahsSize uint
dataSize uint
}
// New creates a new session. // New creates a new session.
func (s *ISCSITargetService) NewISCSISession(conn *iscsiConnection, isid uint64) (*ISCSISession, error) { func (s *ISCSITargetDriver) NewISCSISession(conn *iscsiConnection, isid uint64) (*ISCSISession, error) {
var ( var (
target *ISCSITarget target *ISCSITarget
tsih uint64 tsih uint64

48
pkg/port/service.go
View File

@@ -1,48 +0,0 @@
/*
Copyright 2015 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.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package port
import (
"fmt"
"github.com/gostor/gotgt/pkg/config"
"github.com/gostor/gotgt/pkg/scsi"
)
type SCSITargetService interface {
Run() error
NewTarget(string, *config.Config) (SCSITargetDriver, error)
}
type TargetServiceFunc func(*scsi.SCSITargetService) (SCSITargetService, error)
var registeredPlugins = map[string](TargetServiceFunc){}
func RegisterTargetService(name string, f TargetServiceFunc) {
registeredPlugins[name] = f
}
func NewTargetService(targetDriverName string, s *scsi.SCSITargetService) (SCSITargetService, error) {
if targetDriverName == "" {
return nil, nil
}
targetInitFunc, ok := registeredPlugins[targetDriverName]
if !ok {
return nil, fmt.Errorf("SCSI target driver %s is not found.", targetDriverName)
}
return targetInitFunc(s)
}

164
pkg/scsi/backingstore.go
View File

@@ -17,9 +17,13 @@ limitations under the License.
package scsi package scsi
import ( import (
"bytes"
"fmt" "fmt"
"io"
log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/util"
) )
type BaseBackingStore struct { type BaseBackingStore struct {
@@ -30,43 +34,161 @@ type BaseBackingStore struct {
type BackingStoreFunc func() (api.BackingStore, error) type BackingStoreFunc func() (api.BackingStore, error)
var registeredPlugins = map[string](BackingStoreFunc){} var registeredBSPlugins = map[string](BackingStoreFunc){}
func RegisterBackingStore(name string, f BackingStoreFunc) { func RegisterBackingStore(name string, f BackingStoreFunc) {
registeredPlugins[name] = f registeredBSPlugins[name] = f
} }
func NewBackingStore(name string) (api.BackingStore, error) { func NewBackingStore(name string) (api.BackingStore, error) {
if name == "" { if name == "" {
return nil, nil return nil, nil
} }
f, ok := registeredPlugins[name] f, ok := registeredBSPlugins[name]
if !ok { if !ok {
return nil, fmt.Errorf("BackingStore %s is not found.", name) return nil, fmt.Errorf("Backend storage %s is not found.", name)
} }
return f() return f()
} }
type fakeBackingStore struct { func bsPerformCommand(bs api.BackingStore, cmd *api.SCSICommand) (err error) {
BaseBackingStore var (
} scb = cmd.SCB.Bytes()
offset = cmd.Offset
opcode = api.SCSICommandType(scb[0])
lu = cmd.Device
key = ILLEGAL_REQUEST
asc = ASC_INVALID_FIELD_IN_CDB
wbuf []byte = []byte{}
tl int64 = int64(cmd.TL)
rbuf = make([]byte, tl)
length int
doVerify bool = false
doWrite bool = false
)
switch opcode {
case api.ORWRITE_16:
tmpbuf := []byte{}
tmpbuf, err = bs.Read(int64(offset), tl)
if err != nil {
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
break
}
cmd.InSDBBuffer.Buffer = bytes.NewBuffer(tmpbuf)
func (fake *fakeBackingStore) Open(dev *api.SCSILu, path string) error { wbuf = cmd.OutSDBBuffer.Buffer.Bytes()
return nil doWrite = true
} goto write
case api.COMPARE_AND_WRITE:
// TODO
doWrite = true
goto write
case api.SYNCHRONIZE_CACHE, api.SYNCHRONIZE_CACHE_16:
if err = bs.DataSync(); err != nil {
panic(err)
}
break
case api.WRITE_VERIFY, api.WRITE_VERIFY_12, api.WRITE_VERIFY_16:
doVerify = true
case api.WRITE_6, api.WRITE_10, api.WRITE_12, api.WRITE_16:
wbuf = cmd.OutSDBBuffer.Buffer.Bytes()
doWrite = true
goto write
case api.WRITE_SAME, api.WRITE_SAME_16:
// TODO
break
case api.READ_6, api.READ_10, api.READ_12, api.READ_16:
rbuf, err = bs.Read(int64(offset), tl)
if err != nil && err != io.EOF {
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
break
}
length = len(rbuf)
for i := 0; i < int(tl)-length; i++ {
rbuf = append(rbuf, 0)
}
func (fake *fakeBackingStore) Close(dev *api.SCSILu) error { if (opcode != api.READ_6) && (scb[1]&0x10 != 0) {
return nil bs.DataAdvise(int64(offset), int64(length), util.POSIX_FADV_NOREUSE)
} }
cmd.InSDBBuffer.Buffer = bytes.NewBuffer(rbuf)
case api.PRE_FETCH_10, api.PRE_FETCH_16:
err = bs.DataAdvise(int64(offset), tl, util.POSIX_FADV_WILLNEED)
if err != nil {
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
}
case api.VERIFY_10, api.VERIFY_12, api.VERIFY_16:
doVerify = true
goto verify
case api.UNMAP:
// TODO
default:
break
}
write:
if doWrite {
// hack: wbuf = []byte("hello world!")
err = bs.Write(wbuf, int64(offset))
if err != nil {
log.Error(err)
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
goto sense
}
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 {
pg = &p
break
}
}
if pg == nil {
key = ILLEGAL_REQUEST
asc = ASC_INVALID_FIELD_IN_CDB
goto sense
}
if ((opcode != api.WRITE_6) && (scb[1]&0x8 != 0)) || (pg.Data[0]&0x04 == 0) {
if err = bs.DataSync(); err != nil {
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
goto sense
}
}
func (fake *fakeBackingStore) Init(dev *api.SCSILu, Opts string) error { if (opcode != api.WRITE_6) && (scb[1]&0x10 != 0) {
bs.DataAdvise(int64(offset), int64(length), util.POSIX_FADV_NOREUSE)
}
}
verify:
if doVerify {
rbuf, err = bs.Read(int64(offset), tl)
if err != nil {
key = MEDIUM_ERROR
asc = ASC_READ_ERROR
goto sense
}
if !bytes.Equal(cmd.OutSDBBuffer.Buffer.Bytes(), rbuf) {
err = fmt.Errorf("verify fail between out buffer and read buffer")
key = MISCOMPARE
asc = ASC_MISCOMPARE_DURING_VERIFY_OPERATION
goto sense
}
if scb[1]&0x10 != 0 {
bs.DataAdvise(int64(offset), int64(length), util.POSIX_FADV_WILLNEED)
}
}
log.Infof("io done %s", string(scb))
return nil return nil
} sense:
if err != nil {
log.Error(err)
return err
}
func (fake *fakeBackingStore) Exit(dev *api.SCSILu) error { err = fmt.Errorf("sense data encounter, key: %v, asc: %v", key, asc)
return nil return err
}
func (fake *fakeBackingStore) CommandSubmit(cmd *api.SCSICommand) error {
return nil
} }

11
pkg/port/iscsit/portal.go → pkg/scsi/backingstore/backingstore.go
View File

@@ -14,12 +14,5 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package iscsit // Package backingstore provides the plugin to connect backend storage.
package backingstore
type ISCSIPortal struct {
Address string
Port int
Tpgt int
Fd int
Af int
}

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

@@ -17,30 +17,32 @@ limitations under the License.
package backingstore package backingstore
import ( import (
"bytes"
"fmt" "fmt"
"io"
"os" "os"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/scsi" "github.com/gostor/gotgt/pkg/scsi"
"github.com/gostor/gotgt/pkg/util" "github.com/gostor/gotgt/pkg/util"
) )
const (
FileBackingStorage = "file"
)
func init() { func init() {
scsi.RegisterBackingStore("file", new) scsi.RegisterBackingStore(FileBackingStorage, new)
} }
type FileBackingStore struct { type FileBackingStore struct {
scsi.BaseBackingStore scsi.BaseBackingStore
File *os.File file *os.File
} }
func new() (api.BackingStore, error) { func new() (api.BackingStore, error) {
return &FileBackingStore{ return &FileBackingStore{
BaseBackingStore: scsi.BaseBackingStore{ BaseBackingStore: scsi.BaseBackingStore{
Name: "file", Name: FileBackingStorage,
DataSize: 0, DataSize: 0,
OflagsSupported: 0, OflagsSupported: 0,
}, },
@@ -57,12 +59,12 @@ func (bs *FileBackingStore) Open(dev *api.SCSILu, path string) error {
f, err := os.OpenFile(path, os.O_RDWR, os.ModePerm) f, err := os.OpenFile(path, os.O_RDWR, os.ModePerm)
bs.File = f bs.file = f
return err return err
} }
func (bs *FileBackingStore) Close(dev *api.SCSILu) error { func (bs *FileBackingStore) Close(dev *api.SCSILu) error {
return bs.File.Close() return bs.file.Close()
} }
func (bs *FileBackingStore) Init(dev *api.SCSILu, Opts string) error { func (bs *FileBackingStore) Init(dev *api.SCSILu, Opts string) error {
@@ -76,142 +78,38 @@ func (bs *FileBackingStore) Exit(dev *api.SCSILu) error {
func (bs *FileBackingStore) Size(dev *api.SCSILu) uint64 { func (bs *FileBackingStore) Size(dev *api.SCSILu) uint64 {
return bs.DataSize return bs.DataSize
} }
func (bs *FileBackingStore) CommandSubmit(cmd *api.SCSICommand) (err error) {
var (
scb = cmd.SCB.Bytes()
offset = cmd.Offset
opcode = api.SCSICommandType(scb[0])
lu = cmd.Device
key = scsi.ILLEGAL_REQUEST
asc = scsi.ASC_INVALID_FIELD_IN_CDB
wbuf []byte = []byte{}
rbuf = make([]byte, cmd.TL)
length int
doVerify bool = false
doWrite bool = false
)
switch opcode {
case api.ORWRITE_16:
tmpbuf := []byte{}
length, err = bs.File.ReadAt(tmpbuf, int64(offset))
if length != len(tmpbuf) {
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
break
}
cmd.InSDBBuffer.Buffer = bytes.NewBuffer(tmpbuf)
wbuf = cmd.OutSDBBuffer.Buffer.Bytes() func (bs *FileBackingStore) Read(offset, tl int64) ([]byte, error) {
doWrite = true if bs.file == nil {
goto write return nil, fmt.Errorf("Backend store is nil")
case api.COMPARE_AND_WRITE:
// TODO
doWrite = true
goto write
case api.SYNCHRONIZE_CACHE, api.SYNCHRONIZE_CACHE_16:
if err = util.Fdatasync(bs.File); err != nil {
panic(err)
}
break
case api.WRITE_VERIFY, api.WRITE_VERIFY_12, api.WRITE_VERIFY_16:
doVerify = true
case api.WRITE_6, api.WRITE_10, api.WRITE_12, api.WRITE_16:
wbuf = cmd.OutSDBBuffer.Buffer.Bytes()
doWrite = true
goto write
case api.WRITE_SAME, api.WRITE_SAME_16:
// TODO
break
case api.READ_6, api.READ_10, api.READ_12, api.READ_16:
length, err = bs.File.ReadAt(rbuf, int64(offset))
if err != nil && err != io.EOF {
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
break
}
for i := 0; i < int(cmd.TL)-length; i++ {
rbuf = append(rbuf, 0)
}
if (opcode != api.READ_6) && (scb[1]&0x10 != 0) {
util.Fadvise(bs.File, int64(offset), int64(length), util.POSIX_FADV_NOREUSE)
}
cmd.InSDBBuffer.Buffer = bytes.NewBuffer(rbuf)
case api.PRE_FETCH_10, api.PRE_FETCH_16:
err = util.Fadvise(bs.File, int64(offset), int64(cmd.TL), util.POSIX_FADV_WILLNEED)
if err != nil {
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
}
case api.VERIFY_10, api.VERIFY_12, api.VERIFY_16:
doVerify = true
goto verify
case api.UNMAP:
// TODO
default:
break
} }
write: tmpbuf := make([]byte, tl)
if doWrite { length, err := bs.file.ReadAt(tmpbuf, offset)
// hack: wbuf = []byte("hello world!")
length, err = bs.File.WriteAt(wbuf, int64(offset))
if err != nil || length != len(wbuf) {
glog.Error(err)
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
goto sense
}
glog.V(2).Infof("write data at %d for length %d", offset, length)
var pg *api.ModePage
for _, p := range lu.ModePages {
if p.Pcode == 0x08 && p.SubPcode == 0 {
pg = &p
break
}
}
if pg == nil {
key = scsi.ILLEGAL_REQUEST
asc = scsi.ASC_INVALID_FIELD_IN_CDB
goto sense
}
if ((opcode != api.WRITE_6) && (scb[1]&0x8 != 0)) || (pg.Data[0]&0x04 == 0) {
if err = util.Fdatasync(bs.File); err != nil {
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
goto sense
}
}
if (opcode != api.WRITE_6) && (scb[1]&0x10 != 0) {
util.Fadvise(bs.File, int64(offset), int64(length), util.POSIX_FADV_NOREUSE)
}
}
verify:
if doVerify {
length, err = bs.File.ReadAt(rbuf, int64(offset))
if length != len(rbuf) {
key = scsi.MEDIUM_ERROR
asc = scsi.ASC_READ_ERROR
goto sense
}
if !bytes.Equal(cmd.OutSDBBuffer.Buffer.Bytes(), rbuf) {
err = fmt.Errorf("verify fail between out buffer and read buffer")
key = scsi.MISCOMPARE
asc = scsi.ASC_MISCOMPARE_DURING_VERIFY_OPERATION
goto sense
}
if scb[1]&0x10 != 0 {
util.Fadvise(bs.File, int64(offset), int64(length), util.POSIX_FADV_WILLNEED)
}
}
glog.Infof("io done %s", string(scb))
return nil
sense:
if err != nil { if err != nil {
glog.Error(err) return nil, err
}
if length != len(tmpbuf) {
return nil, fmt.Errorf("read is not same length of length")
}
return tmpbuf, nil
}
func (bs *FileBackingStore) Write(wbuf []byte, offset int64) error {
length, err := bs.file.WriteAt(wbuf, offset)
if err != nil {
log.Error(err)
return err return err
} }
if length != len(wbuf) {
err = fmt.Errorf("sense data encounter, key: %v, asc: %v", key, asc) return fmt.Errorf("write is not same length of length")
return err }
return nil
}
func (bs *FileBackingStore) DataSync() error {
return util.Fdatasync(bs.file)
}
func (bs *FileBackingStore) DataAdvise(offset, length int64, advise uint32) error {
return util.Fadvise(bs.file, offset, length, advise)
} }

17
pkg/scsi/backingstore/null.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -59,7 +59,18 @@ func (bs *NullBackingStore) Size(dev *api.SCSILu) uint64 {
return 0 return 0
} }
func (bs *NullBackingStore) CommandSubmit(cmd *api.SCSICommand) error { func (bs *NullBackingStore) Read(offset, tl int64) ([]byte, error) {
cmd.Result = api.SAM_STAT_GOOD return nil, nil
}
func (bs *NullBackingStore) Write(wbuf []byte, offset int64) error {
return nil
}
func (bs *NullBackingStore) DataSync() error {
return nil
}
func (bs *NullBackingStore) DataAdvise(offset, length int64, advise uint32) error {
return nil return nil
} }

34
pkg/scsi/cmd.go
View File

@@ -21,13 +21,13 @@ import (
) )
const ( const (
/* PERSISTENT_RESERVE_IN service action codes */ // PERSISTENT_RESERVE_IN service action codes
PR_IN_READ_KEYS byte = 0x00 PR_IN_READ_KEYS byte = 0x00
PR_IN_READ_RESERVATION byte = 0x01 PR_IN_READ_RESERVATION byte = 0x01
PR_IN_REPORT_CAPABILITIES byte = 0x02 PR_IN_REPORT_CAPABILITIES byte = 0x02
PR_IN_READ_FULL_STATUS byte = 0x03 PR_IN_READ_FULL_STATUS byte = 0x03
/* PERSISTENT_RESERVE_OUT service action codes */ // PERSISTENT_RESERVE_OUT service action codes
PR_OUT_REGISTER byte = 0x00 PR_OUT_REGISTER byte = 0x00
PR_OUT_RESERVE byte = 0x01 PR_OUT_RESERVE byte = 0x01
PR_OUT_RELEASE byte = 0x02 PR_OUT_RELEASE byte = 0x02
@@ -40,7 +40,7 @@ const (
// Persistent Reservation scope // Persistent Reservation scope
PR_LU_SCOPE byte = 0x00 PR_LU_SCOPE byte = 0x00
/* Persistent Reservation Type Mask format */ // Persistent Reservation Type Mask format
PR_TYPE_WRITE_EXCLUSIVE byte = 0x01 PR_TYPE_WRITE_EXCLUSIVE byte = 0x01
PR_TYPE_EXCLUSIVE_ACCESS byte = 0x03 PR_TYPE_EXCLUSIVE_ACCESS byte = 0x03
PR_TYPE_WRITE_EXCLUSIVE_REGONLY byte = 0x05 PR_TYPE_WRITE_EXCLUSIVE_REGONLY byte = 0x05
@@ -50,14 +50,22 @@ const (
) )
const ( const (
CDB_GROUPID_0 = 6 /* 6-byte commands */ // 6-byte commands
CDB_GROUPID_1 = 10 /* 10-byte commands */ CDB_GROUPID_0 = 6
CDB_GROUPID_2 = 10 /* 10-byte commands */ // 10-byte commands
CDB_GROUPID_3 = 0 /* reserved */ CDB_GROUPID_1 = 10
CDB_GROUPID_4 = 16 /* 16-byte commands */ // 10-byte commands
CDB_GROUPID_5 = 12 /* 12-byte commands */ CDB_GROUPID_2 = 10
CDB_GROUPID_6 = 0 /* vendor specific */ // reserved
CDB_GROUPID_7 = 0 /* vendor specific */ CDB_GROUPID_3 = 0
// 16-byte commands
CDB_GROUPID_4 = 16
// 12-byte commands
CDB_GROUPID_5 = 12
// vendor specific
CDB_GROUPID_6 = 0
// vendor specific
CDB_GROUPID_7 = 0
) )
func SCSICDBGroupID(opcode byte) byte { func SCSICDBGroupID(opcode byte) byte {
@@ -106,7 +114,6 @@ const (
* 2 - Designator field contains ASCII printable chars * 2 - Designator field contains ASCII printable chars
* 3 - Designaotor field contains UTF-8 * 3 - Designaotor field contains UTF-8
*/ */
const ( const (
INQ_CODE_BIN = byte(1) INQ_CODE_BIN = byte(1)
INQ_CODE_ASCII = byte(2) INQ_CODE_ASCII = byte(2)
@@ -121,7 +128,6 @@ const (
* 10b - Associated with SCSI Target device * 10b - Associated with SCSI Target device
* 11b - Reserved * 11b - Reserved
*/ */
const ( const (
ASS_LU = byte(0x00) ASS_LU = byte(0x00)
ASS_TGT_PORT = byte(0x01) ASS_TGT_PORT = byte(0x01)
@@ -147,7 +153,6 @@ const (
* device type values are reserved for this peripheral qualifier. * device type values are reserved for this peripheral qualifier.
* 100b to 111b Vendor specific * 100b to 111b Vendor specific
*/ */
const ( const (
PQ_DEVICE_CONNECTED = byte(0x00 << 5) PQ_DEVICE_CONNECTED = byte(0x00 << 5)
PQ_DEVICE_NOT_CONNECT = byte(0x01 << 5) PQ_DEVICE_NOT_CONNECT = byte(0x01 << 5)
@@ -204,7 +209,6 @@ const (
* 7 - MD5 logical unit identifier - 7.6.3.10 * 7 - MD5 logical unit identifier - 7.6.3.10
* 8 - SCSI name string - 7.6.3.11 * 8 - SCSI name string - 7.6.3.11
*/ */
const ( const (
DESG_VENDOR = iota DESG_VENDOR = iota
DESG_T10 DESG_T10

32
pkg/scsi/drivers.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -16,3 +16,33 @@ limitations under the License.
// Target Driver Interface // Target Driver Interface
package scsi package scsi
import (
"fmt"
"github.com/gostor/gotgt/pkg/config"
)
type SCSITargetDriver interface {
Run() error
NewTarget(string, *config.Config) error
}
type TargetDriverFunc func(*SCSITargetService) (SCSITargetDriver, error)
var registeredPlugins = map[string](TargetDriverFunc){}
func RegisterTargetDriver(name string, f TargetDriverFunc) {
registeredPlugins[name] = f
}
func NewTargetDriver(tgtDriver string, s *SCSITargetService) (SCSITargetDriver, error) {
if tgtDriver == "" {
return nil, nil
}
targetInitFunc, ok := registeredPlugins[tgtDriver]
if !ok {
return nil, fmt.Errorf("SCSI target driver %s is not found.", tgtDriver)
}
return targetInitFunc(s)
}

22
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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@ import "errors"
type SCSIError struct { type SCSIError struct {
errno byte errno byte
Err error err error
} }
var ( var (
@@ -58,7 +58,7 @@ var (
type SCSISubError uint16 type SCSISubError uint16
var ( var (
/* Key 0: No Sense Errors */ // Key 0: No Sense Errors
NO_ADDITIONAL_SENSE SCSISubError = 0x0000 NO_ADDITIONAL_SENSE SCSISubError = 0x0000
ASC_MARK SCSISubError = 0x0001 ASC_MARK SCSISubError = 0x0001
ASC_EOM SCSISubError = 0x0002 ASC_EOM SCSISubError = 0x0002
@@ -67,14 +67,14 @@ var (
ASC_OP_IN_PROGRESS SCSISubError = 0x0016 ASC_OP_IN_PROGRESS SCSISubError = 0x0016
ASC_DRIVE_REQUIRES_CLEANING SCSISubError = 0x8282 ASC_DRIVE_REQUIRES_CLEANING SCSISubError = 0x8282
/* Key 1: Recovered Errors */ // Key 1: Recovered Errors
ASC_WRITE_ERROR SCSISubError = 0x0c00 ASC_WRITE_ERROR SCSISubError = 0x0c00
ASC_READ_ERROR SCSISubError = 0x1100 ASC_READ_ERROR SCSISubError = 0x1100
ASC_RECOVERED_WITH_RETRYS SCSISubError = 0x1701 ASC_RECOVERED_WITH_RETRYS SCSISubError = 0x1701
ASC_MEDIA_LOAD_EJECT_ERROR SCSISubError = 0x5300 ASC_MEDIA_LOAD_EJECT_ERROR SCSISubError = 0x5300
ASC_FAILURE_PREDICTION SCSISubError = 0x5d00 ASC_FAILURE_PREDICTION SCSISubError = 0x5d00
/* Key 2: Not ready */ // Key 2: Not ready
ASC_CAUSE_NOT_REPORTABLE SCSISubError = 0x0400 ASC_CAUSE_NOT_REPORTABLE SCSISubError = 0x0400
ASC_BECOMING_READY SCSISubError = 0x0401 ASC_BECOMING_READY SCSISubError = 0x0401
ASC_INITIALIZING_REQUIRED SCSISubError = 0x0402 ASC_INITIALIZING_REQUIRED SCSISubError = 0x0402
@@ -83,7 +83,7 @@ var (
ASC_MEDIUM_NOT_PRESENT SCSISubError = 0x3a00 ASC_MEDIUM_NOT_PRESENT SCSISubError = 0x3a00
ASC_LOGICAL_UNIT_NOT_CONFIG SCSISubError = 0x3e00 ASC_LOGICAL_UNIT_NOT_CONFIG SCSISubError = 0x3e00
/* Key 3: Medium Errors */ // Key 3: Medium Errors
ASC_UNRECOVERED_READ SCSISubError = 0x1100 ASC_UNRECOVERED_READ SCSISubError = 0x1100
ASC_RECORDED_ENTITY_NOT_FOUND SCSISubError = 0x1400 ASC_RECORDED_ENTITY_NOT_FOUND SCSISubError = 0x1400
ASC_UNKNOWN_FORMAT SCSISubError = 0x3001 ASC_UNKNOWN_FORMAT SCSISubError = 0x3001
@@ -94,7 +94,7 @@ var (
ASC_CARTRIDGE_FAULT SCSISubError = 0x5200 ASC_CARTRIDGE_FAULT SCSISubError = 0x5200
ASC_MEDIA_LOAD_OR_EJECT_FAILED SCSISubError = 0x5300 ASC_MEDIA_LOAD_OR_EJECT_FAILED SCSISubError = 0x5300
/* Key 4: Hardware Failure */ // Key 4: Hardware Failure
ASC_COMPRESSION_CHECK SCSISubError = 0x0c04 ASC_COMPRESSION_CHECK SCSISubError = 0x0c04
ASC_DECOMPRESSION_CRC SCSISubError = 0x110d ASC_DECOMPRESSION_CRC SCSISubError = 0x110d
ASC_MECHANICAL_POSITIONING_ERROR SCSISubError = 0x1501 ASC_MECHANICAL_POSITIONING_ERROR SCSISubError = 0x1501
@@ -103,7 +103,7 @@ var (
ASC_INTERNAL_TGT_FAILURE SCSISubError = 0x4400 ASC_INTERNAL_TGT_FAILURE SCSISubError = 0x4400
ASC_ERASE_FAILURE SCSISubError = 0x5100 ASC_ERASE_FAILURE SCSISubError = 0x5100
/* Key 5: Illegal Request */ // Key 5: Illegal Request
ASC_PARAMETER_LIST_LENGTH_ERR SCSISubError = 0x1a00 ASC_PARAMETER_LIST_LENGTH_ERR SCSISubError = 0x1a00
ASC_INVALID_OP_CODE SCSISubError = 0x2000 ASC_INVALID_OP_CODE SCSISubError = 0x2000
ASC_LBA_OUT_OF_RANGE SCSISubError = 0x2100 ASC_LBA_OUT_OF_RANGE SCSISubError = 0x2100
@@ -120,7 +120,7 @@ var (
ASC_INSUFFICENT_REGISTRATION_RESOURCES SCSISubError = 0x5504 ASC_INSUFFICENT_REGISTRATION_RESOURCES SCSISubError = 0x5504
ASC_BAD_MICROCODE_DETECTED SCSISubError = 0x8283 ASC_BAD_MICROCODE_DETECTED SCSISubError = 0x8283
/* Key 6: Unit Attention */ // Key 6: Unit Attention
ASC_NOT_READY_TO_TRANSITION SCSISubError = 0x2800 ASC_NOT_READY_TO_TRANSITION SCSISubError = 0x2800
ASC_POWERON_RESET SCSISubError = 0x2900 ASC_POWERON_RESET SCSISubError = 0x2900
ASC_I_T_NEXUS_LOSS_OCCURRED SCSISubError = 0x2907 ASC_I_T_NEXUS_LOSS_OCCURRED SCSISubError = 0x2907
@@ -134,10 +134,10 @@ var (
ASC_REPORTED_LUNS_DATA_HAS_CHANGED SCSISubError = 0x3f0e ASC_REPORTED_LUNS_DATA_HAS_CHANGED SCSISubError = 0x3f0e
ASC_FAILURE_PREDICTION_FALSE SCSISubError = 0x5dff ASC_FAILURE_PREDICTION_FALSE SCSISubError = 0x5dff
/* Data Protect */ // Data Protect
ASC_WRITE_PROTECT SCSISubError = 0x2700 ASC_WRITE_PROTECT SCSISubError = 0x2700
ASC_MEDIUM_OVERWRITE_ATTEMPTED SCSISubError = 0x300c ASC_MEDIUM_OVERWRITE_ATTEMPTED SCSISubError = 0x300c
/* Miscompare */ // Miscompare
ASC_MISCOMPARE_DURING_VERIFY_OPERATION SCSISubError = 0x1d00 ASC_MISCOMPARE_DURING_VERIFY_OPERATION SCSISubError = 0x1d00
) )

9
pkg/scsi/lun.go
View File

@@ -22,10 +22,8 @@ import (
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
) )
/* // NewSCSILu: create a new SCSI LU
* path format <protocol>:/absolute/file/path // path format <protocol>:/absolute/file/path
*/
func NewSCSILu(device_uuid uint64, path string, online bool) (*api.SCSILu, error) { func NewSCSILu(device_uuid uint64, path string, online bool) (*api.SCSILu, error) {
pathinfo := strings.SplitN(path, ":", 2) pathinfo := strings.SplitN(path, ":", 2)
@@ -60,6 +58,7 @@ func NewSCSILu(device_uuid uint64, path string, online bool) (*api.SCSILu, error
return lu, nil return lu, nil
} }
// NewLUN0: create a new fake SCSI LU
func NewLUN0() *api.SCSILu { func NewLUN0() *api.SCSILu {
sbc := NewSBCDevice(api.TYPE_UNKNOWN) sbc := NewSBCDevice(api.TYPE_UNKNOWN)
@@ -88,7 +87,7 @@ func luPerformCommand(tid int, cmd *api.SCSICommand) api.SAMStat {
fn := cmd.Device.DeviceProtocol.PerformCommand(op) fn := cmd.Device.DeviceProtocol.PerformCommand(op)
if fn != nil { if fn != nil {
fnop := fn.(SCSIDeviceOperation) fnop := fn.(SCSIDeviceOperation)
// host := cmd.ITNexus.Host // TODO host := cmd.ITNexus.Host
host := 0 host := 0
return fnop.CommandPerformFunc(host, cmd) return fnop.CommandPerformFunc(host, cmd)
} }

56
pkg/scsi/sbc.go
View File

@@ -22,7 +22,7 @@ import (
"encoding/binary" "encoding/binary"
"unsafe" "unsafe"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/gostor/gotgt/pkg/util" "github.com/gostor/gotgt/pkg/util"
"github.com/gostor/gotgt/pkg/version" "github.com/gostor/gotgt/pkg/version"
@@ -66,7 +66,7 @@ func (sbc SBCSCSIDeviceProtocol) InitLu(lu *api.SCSILu) error {
lu.Attrs.SenseFormat = false lu.Attrs.SenseFormat = false
lu.Attrs.VendorID = SCSIVendorID lu.Attrs.VendorID = SCSIVendorID
lu.Attrs.ProductID = SCSIProductID lu.Attrs.ProductID = SCSIProductID
lu.Attrs.ProductRev = version.SCSI_VERSION lu.Attrs.ProductRev = version.SCSIVersion
/* /*
SCSIID for PAGE83 T10 VENDOR IDENTIFICATION field SCSIID for PAGE83 T10 VENDOR IDENTIFICATION field
@@ -331,7 +331,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
if dev.Attrs.Removable && !dev.Attrs.Online { if dev.Attrs.Removable && !dev.Attrs.Online {
key = NOT_READY key = NOT_READY
asc = ASC_MEDIUM_NOT_PRESENT asc = ASC_MEDIUM_NOT_PRESENT
glog.Warningf("sense") log.Warnf("sense")
goto sense goto sense
} }
@@ -343,7 +343,7 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
if scb[1]&0xe0 != 0 { if scb[1]&0xe0 != 0 {
key = ILLEGAL_REQUEST key = ILLEGAL_REQUEST
asc = ASC_INVALID_FIELD_IN_CDB asc = ASC_INVALID_FIELD_IN_CDB
glog.Warningf("sense") log.Warnf("sense")
goto 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: api.PRE_FETCH_10, api.PRE_FETCH_16, api.COMPARE_AND_WRITE:
key = DATA_PROTECT key = DATA_PROTECT
asc = ASC_WRITE_PROTECT asc = ASC_WRITE_PROTECT
glog.Warningf("sense") log.Warnf("sense")
goto 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 { if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE 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 goto sense
} }
} else { } else {
if lba >= dev.Size>>dev.BlockShift { if lba >= dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE asc = ASC_LBA_OUT_OF_RANGE
glog.Warningf("sense") log.Warnf("sense")
goto sense goto sense
} }
} }
@@ -435,9 +435,9 @@ func SBCReadWrite(host int, cmd *api.SCSICommand) api.SAMStat {
*/ */
} }
err = dev.Storage.CommandSubmit(cmd) err = bsPerformCommand(dev.Storage, cmd)
if err != nil { if err != nil {
glog.Error(err) log.Error(err)
key = HARDWARE_ERROR key = HARDWARE_ERROR
asc = ASC_INTERNAL_TGT_FAILURE asc = ASC_INTERNAL_TGT_FAILURE
} else { } else {
@@ -532,8 +532,13 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
var ( var (
key = ILLEGAL_REQUEST key = ILLEGAL_REQUEST
asc = ASC_INVALID_FIELD_IN_CDB asc = ASC_INVALID_FIELD_IN_CDB
dev = cmd.Device
scb = cmd.SCB.Bytes()
lba uint64
tl uint32
err error
) )
if cmd.Device.Attrs.Removable && !cmd.Device.Attrs.Online { if dev.Attrs.Removable && !dev.Attrs.Online {
key = NOT_READY key = NOT_READY
asc = ASC_MEDIUM_NOT_PRESENT asc = ASC_MEDIUM_NOT_PRESENT
goto sense goto sense
@@ -550,7 +555,36 @@ func SBCVerify(host int, cmd *api.SCSICommand) api.SAMStat {
// no data compare with the media // no data compare with the media
return api.SAMStatGood return api.SAMStatGood
} }
// TODO lba = getSCSIReadWriteOffset(scb)
tl = getSCSIReadWriteCount(scb)
// Verify that we are not doing i/o beyond the end-of-lun
if tl != 0 {
if lba+uint64(tl) < lba || lba+uint64(tl) > dev.Size>>dev.BlockShift {
key = ILLEGAL_REQUEST
asc = ASC_LBA_OUT_OF_RANGE
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
log.Warnf("sense")
goto sense
}
}
cmd.Offset = lba << dev.BlockShift
cmd.TL = tl << dev.BlockShift
err = bsPerformCommand(dev.Storage, cmd)
if err != nil {
log.Error(err)
key = HARDWARE_ERROR
asc = ASC_INTERNAL_TGT_FAILURE
} else {
return api.SAMStatGood
}
sense: sense:
cmd.InSDBBuffer.Resid = 0 cmd.InSDBBuffer.Resid = 0
BuildSenseData(cmd, key, asc) BuildSenseData(cmd, key, asc)

12
pkg/scsi/scsi.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ import (
"sync" "sync"
"unsafe" "unsafe"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/satori/go.uuid" "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)) lun := *(*uint64)(unsafe.Pointer(&scmd.Lun))
scmd.Device = target.Devices[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 { if scmd.Device == nil {
scmd.Device = target.LUN0 scmd.Device = target.LUN0
if lun != 0 { if lun != 0 {
BuildSenseData(scmd, ILLEGAL_REQUEST, ASC_INVALID_FIELD_IN_CDB) BuildSenseData(scmd, ILLEGAL_REQUEST, ASC_INVALID_FIELD_IN_CDB)
scmd.Result = api.SAMStatCheckCondition.Stat scmd.Result = api.SAMStatCheckCondition.Stat
glog.Warningf("%v", api.SAMStatCheckCondition.Err) log.Warnf("%v", api.SAMStatCheckCondition.Err)
return nil return nil
} }
} }
result := scmd.Device.PerformCommand(tid, scmd) result := scmd.Device.PerformCommand(tid, scmd)
if result != api.SAMStatGood { if result != api.SAMStatGood {
scmd.Result = result.Stat scmd.Result = result.Stat
glog.Warningf("%v", result.Err) log.Warnf("%v", result.Err)
} }
return nil return nil
} }
@@ -162,7 +162,7 @@ func BuildSenseData(cmd *api.SCSICommand, key byte, asc SCSISubError) {
senseBuffer.Truncate(int(inBufLen)) senseBuffer.Truncate(int(inBufLen))
} }
} else { } 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.Result = key
cmd.SenseBuffer = senseBuffer cmd.SenseBuffer = senseBuffer

16
pkg/scsi/scsi_pr.go
View File

@@ -1,3 +1,19 @@
/*
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.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package scsi package scsi
import ( import (

18
pkg/scsi/scsilumap.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@ limitations under the License.
package scsi package scsi
import ( import (
"errors" "fmt"
"strconv" "strconv"
"sync" "sync"
@@ -28,9 +28,11 @@ import (
type BackendType string type BackendType string
type SCSILUMap struct { type SCSILUMap struct {
mutex sync.RWMutex mutex sync.RWMutex
AllDevices api.LUNMap /* use UUID as the key for all LUs*/ // use UUID as the key for all LUs
TargetsLUNMap map[string]api.LUNMap /* use target name as the key for target's LUN map*/ AllDevices api.LUNMap
// use target name as the key for target's LUN map
TargetsLUNMap map[string]api.LUNMap
} }
var globalSCSILUMap = SCSILUMap{AllDevices: make(api.LUNMap), TargetsLUNMap: make(map[string]api.LUNMap)} var globalSCSILUMap = SCSILUMap{AllDevices: make(api.LUNMap), TargetsLUNMap: make(map[string]api.LUNMap)}
@@ -73,7 +75,7 @@ func InitSCSILUMap(config *config.Config) error {
for _, bs := range config.Storages { for _, bs := range config.Storages {
lu, err := NewSCSILu(bs.DeviceID, bs.Path, bs.Online) lu, err := NewSCSILu(bs.DeviceID, bs.Path, bs.Online)
if err != nil { 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 globalSCSILUMap.AllDevices[bs.DeviceID] = lu
} }
@@ -82,10 +84,10 @@ func InitSCSILUMap(config *config.Config) error {
for lunstr, deviceID := range tgt.LUNs { for lunstr, deviceID := range tgt.LUNs {
lun, err := strconv.ParseUint(lunstr, 10, 64) lun, err := strconv.ParseUint(lunstr, 10, 64)
if err != nil { 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) mappingLUN(deviceID, lun, tgtName)
//Init SCSISimpleReservationOperator // Init SCSISimpleReservationOperator
op := GetSCSIReservationOperator() op := GetSCSIReservationOperator()
if simpleOp, ok = op.(*SCSISimpleReservationOperator); ok { if simpleOp, ok = op.(*SCSISimpleReservationOperator); ok {
simpleOp.InitLUReservation(tgtName, deviceID) simpleOp.InitLUReservation(tgtName, deviceID)

16
pkg/scsi/spc.go
View File

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

8
pkg/scsi/target.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@ import (
"fmt" "fmt"
"unsafe" "unsafe"
"github.com/golang/glog" log "github.com/Sirupsen/logrus"
"github.com/gostor/gotgt/pkg/api" "github.com/gostor/gotgt/pkg/api"
"github.com/satori/go.uuid" "github.com/satori/go.uuid"
) )
@@ -97,12 +97,12 @@ func deviceReserve(cmd *api.SCSICommand) error {
} }
} }
if lu == nil { 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 return nil
} }
if !uuid.Equal(lu.ReserveID, uuid.Nil) && uuid.Equal(lu.ReserveID, cmd.ITNexusID) { 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") return fmt.Errorf("already reserved")
} }
lu.ReserveID = cmd.ITNexusID lu.ReserveID = cmd.ITNexusID

5
pkg/util/util.go
View File

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// Package util provides some basic util functions.
package util package util
import ( import (
@@ -121,9 +122,9 @@ const (
POSIX_FADV_NOREUSE POSIX_FADV_NOREUSE
) )
func Fadvise(file *os.File, off, length int64, advice uint32) error { func Fadvise(file *os.File, off, length int64, advise uint32) error {
// syscall.SYS_FADVISE64 = 221 // syscall.SYS_FADVISE64 = 221
_, _, err := syscall.Syscall6(221, file.Fd(), uintptr(off), uintptr(length), uintptr(advice), 0, 0) _, _, err := syscall.Syscall6(221, file.Fd(), uintptr(off), uintptr(length), uintptr(advise), 0, 0)
if err != 0 { if err != 0 {
return err return err
} }

8
pkg/version/version.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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@@ -14,9 +14,11 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
// Package version provides the Version information.
package version package version
const ( const (
VERSION = "0.1" Version = "0.1"
SCSI_VERSION = "0.1" /* SCSI version string MUST be shorter than 4 characters*/ // SCSI version string MUST be shorter than 4 characters
SCSIVersion = "0.1"
) )