kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Small fixes

Browse source
This commit is contained in:
Guillaume J. Charmes 2013-10-03 18:00:24 -07:00
parent b843998718
commit f29c500d8d
No known key found for this signature in database
GPG key ID: B33E4642CB6E3FF3
4 changed files with 172 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
deviceset.go
View file

@ -12,62 +12,3 @@ type DeviceSet interface {
HasActivatedDevice(hash string) bool
Shutdown() error
}
type DeviceSetWrapper struct {
wrapped DeviceSet
prefix string
}
func (wrapper *DeviceSetWrapper) wrap(hash string) string {
if hash != "" {
hash = wrapper.prefix + "-" + hash
}
return hash
}
func (wrapper *DeviceSetWrapper) AddDevice(hash, baseHash string) error {
return wrapper.wrapped.AddDevice(wrapper.wrap(hash), wrapper.wrap(baseHash))
}
func (wrapper *DeviceSetWrapper) SetInitialized(hash string) error {
return wrapper.wrapped.SetInitialized(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) DeactivateDevice(hash string) error {
return wrapper.wrapped.DeactivateDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) Shutdown() error {
return nil
}
func (wrapper *DeviceSetWrapper) RemoveDevice(hash string) error {
return wrapper.wrapped.RemoveDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) MountDevice(hash, path string) error {
return wrapper.wrapped.MountDevice(wrapper.wrap(hash), path)
}
func (wrapper *DeviceSetWrapper) UnmountDevice(hash, path string) error {
return wrapper.wrapped.UnmountDevice(wrapper.wrap(hash), path)
}
func (wrapper *DeviceSetWrapper) HasDevice(hash string) bool {
return wrapper.wrapped.HasDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) HasInitializedDevice(hash string) bool {
return wrapper.wrapped.HasInitializedDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) HasActivatedDevice(hash string) bool {
return wrapper.wrapped.HasActivatedDevice(wrapper.wrap(hash))
}
func NewDeviceSetWrapper(wrapped DeviceSet, prefix string) DeviceSet {
return &DeviceSetWrapper{
wrapped: wrapped,
prefix: prefix,
}
}

1
devmapper/deviceset_devmapper.go
View file

@ -442,6 +442,7 @@ func (devices *DeviceSetDM) registerDevice(id int, hash string, size uint64) (*D
}
func (devices *DeviceSetDM) activateDeviceIfNeeded(hash string) error {
utils.Debugf("activateDeviceIfNeeded()")
info := devices.Devices[hash]
if info == nil {
return fmt.Errorf("Unknown device %s", hash)

182
devmapper/devmapper.go
View file

@ -14,14 +14,13 @@ package devmapper
#include <linux/fs.h>
#include <errno.h>
static char *
attach_loop_device(const char *filename, int *loop_fd_out)
char* attach_loop_device(const char *filename, int *loop_fd_out)
{
struct loop_info64 loopinfo = { 0 };
struct stat st;
char buf[64];
int i, loop_fd, fd, start_index;
char *loopname;
struct loop_info64 loopinfo = {0};
struct stat st;
char buf[64];
int i, loop_fd, fd, start_index;
char* loopname;
*loop_fd_out = -1;
@ -37,6 +36,7 @@ attach_loop_device(const char *filename, int *loop_fd_out)
fd = open(filename, O_RDWR);
if (fd < 0) {
perror("open");
return NULL;
}
@ -44,6 +44,7 @@ attach_loop_device(const char *filename, int *loop_fd_out)
for (i = start_index ; loop_fd < 0 ; i++ ) {
if (sprintf(buf, "/dev/loop%d", i) < 0) {
close(fd);
perror("sprintf");
return NULL;
}
@ -55,12 +56,14 @@ attach_loop_device(const char *filename, int *loop_fd_out)
loop_fd = open(buf, O_RDWR);
if (loop_fd < 0 && errno == ENOENT) {
close(fd);
perror("open");
fprintf (stderr, "no available loopback device!");
return NULL;
} else if (loop_fd < 0)
continue;
if (ioctl (loop_fd, LOOP_SET_FD, (void *)(size_t)fd) < 0) {
perror("ioctl");
close(loop_fd);
loop_fd = -1;
if (errno != EBUSY) {
@ -78,7 +81,10 @@ attach_loop_device(const char *filename, int *loop_fd_out)
loopinfo.lo_flags = LO_FLAGS_AUTOCLEAR;
if (ioctl(loop_fd, LOOP_SET_STATUS64, &loopinfo) < 0) {
ioctl(loop_fd, LOOP_CLR_FD, 0);
perror("ioctl1");
if (ioctl(loop_fd, LOOP_CLR_FD, 0) < 0) {
perror("ioctl2");
}
close(loop_fd);
fprintf (stderr, "cannot set up loopback device info");
return NULL;
@ -105,39 +111,19 @@ get_block_size(int fd)
return (int64_t)size;
}
*/
import "C"
import (
"errors"
"fmt"
"github.com/dotcloud/docker/utils"
"os"
"runtime"
"syscall"
"unsafe"
)
func SetDevDir(dir string) error {
c_dir := C.CString(dir)
defer C.free(unsafe.Pointer(c_dir))
if res := C.dm_set_dev_dir(c_dir); res != 1 {
utils.Debugf("Error dm_set_dev_dir")
return fmt.Errorf("dm_set_dev_dir failed")
}
return nil
}
func GetLibraryVersion() (string, error) {
buffer := make([]byte, 128)
if res := C.dm_get_library_version((*C.char)(unsafe.Pointer(&buffer)), 128); res != 1 {
return "", fmt.Errorf("dm_get_library_version failed")
}
return string(buffer), nil
}
type TaskType int
const (
DeviceCreate TaskType = iota
DeviceReload
@ -160,22 +146,41 @@ const (
DeviceSetGeometry
)
type Task struct {
unmanaged *C.struct_dm_task
}
var (
ErrTaskRun = errors.New("dm_task_run failed")
ErrTaskSetName = errors.New("dm_task_set_name failed")
ErrTaskSetMessage = errors.New("dm_task_set_message failed")
ErrTaskSetAddNode = errors.New("dm_task_set_add_node failed")
ErrTaskSetRO = errors.New("dm_task_set_ro failed")
ErrTaskAddTarget = errors.New("dm_task_add_target failed")
ErrGetDriverVersion = errors.New("dm_task_get_driver_version failed")
ErrAttachLoopbackDevice = errors.New("loopback mounting failed")
ErrGetBlockSize = errors.New("Can't get block size")
ErrUdevWait = errors.New("wait on udev cookie failed")
ErrSetDevDir = errors.New("dm_set_dev_dir failed")
ErrGetLibraryVersion = errors.New("dm_get_library_version failed")
ErrCreateRemoveTask = errors.New("Can't create task of type DeviceRemove")
ErrRunRemoveDevice = errors.New("running removeDevice failed")
)
type Info struct {
Exists int
Suspended int
LiveTable int
InactiveTable int
OpenCount int32
EventNr uint32
Major uint32
Minor uint32
ReadOnly int
TargetCount int32
}
type (
Task struct {
unmanaged *C.struct_dm_task
}
Info struct {
Exists int
Suspended int
LiveTable int
InactiveTable int
OpenCount int32
EventNr uint32
Major uint32
Minor uint32
ReadOnly int
TargetCount int32
}
TaskType int
)
func (t *Task) destroy() {
if t != nil {
@ -196,37 +201,37 @@ func TaskCreate(tasktype TaskType) *Task {
func (t *Task) Run() error {
if res := C.dm_task_run(t.unmanaged); res != 1 {
return fmt.Errorf("dm_task_run failed")
return ErrTaskRun
}
return nil
}
func (t *Task) SetName(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
defer free(c_name)
if res := C.dm_task_set_name(t.unmanaged, c_name); res != 1 {
if os.Getenv("DEBUG") != "" {
C.perror(C.CString(fmt.Sprintf("[debug] Error dm_task_set_name(%s, %#v)", name, t.unmanaged)))
}
return fmt.Errorf("dm_task_set_name failed")
return ErrTaskSetName
}
return nil
}
func (t *Task) SetMessage(message string) error {
c_message := C.CString(message)
defer C.free(unsafe.Pointer(c_message))
defer free(c_message)
if res := C.dm_task_set_message(t.unmanaged, c_message); res != 1 {
return fmt.Errorf("dm_task_set_message failed")
return ErrTaskSetMessage
}
return nil
}
func (t *Task) SetSector(sector uint64) error {
if res := C.dm_task_set_sector(t.unmanaged, C.uint64_t(sector)); res != 1 {
return fmt.Errorf("dm_task_set_add_node failed")
return ErrTaskSetAddNode
}
return nil
}
@ -234,7 +239,7 @@ func (t *Task) SetSector(sector uint64) error {
func (t *Task) SetCookie(cookie *uint32, flags uint16) error {
c_cookie := C.uint32_t(*cookie)
if res := C.dm_task_set_cookie(t.unmanaged, &c_cookie, C.uint16_t(flags)); res != 1 {
return fmt.Errorf("dm_task_set_add_node failed")
return ErrTaskSetAddNode
}
*cookie = uint32(c_cookie)
return nil
@ -242,30 +247,30 @@ func (t *Task) SetCookie(cookie *uint32, flags uint16) error {
func (t *Task) SetRo() error {
if res := C.dm_task_set_ro(t.unmanaged); res != 1 {
return fmt.Errorf("dm_task_set_ro failed")
return ErrTaskSetRO
}
return nil
}
func (t *Task) AddTarget(start uint64, size uint64, ttype string, params string) error {
c_ttype := C.CString(ttype)
defer C.free(unsafe.Pointer(c_ttype))
defer free(c_ttype)
c_params := C.CString(params)
defer C.free(unsafe.Pointer(c_params))
defer free(c_params)
if res := C.dm_task_add_target(t.unmanaged, C.uint64_t(start), C.uint64_t(size), c_ttype, c_params); res != 1 {
return fmt.Errorf("dm_task_add_target failed")
return ErrTaskAddTarget
}
return nil
}
func (t *Task) GetDriverVersion() (string, error) {
buffer := (*C.char)(C.malloc(128))
defer C.free(unsafe.Pointer(buffer))
buffer := C.CString(string(make([]byte, 128)))
defer free(buffer)
if res := C.dm_task_get_driver_version(t.unmanaged, buffer, 128); res != 1 {
return "", fmt.Errorf("dm_task_get_driver_version")
return "", ErrGetDriverVersion
}
return C.GoString(buffer), nil
}
@ -273,7 +278,7 @@ func (t *Task) GetDriverVersion() (string, error) {
func (t *Task) GetInfo() (*Info, error) {
c_info := C.struct_dm_info{}
if res := C.dm_task_get_info(t.unmanaged, &c_info); res != 1 {
return nil, fmt.Errorf("dm_task_get_driver_version")
return nil, ErrGetDriverVersion
}
return &Info{
Exists: int(c_info.exists),
@ -301,29 +306,40 @@ func (t *Task) GetNextTarget(next uintptr) (uintptr, uint64, uint64, string, str
func AttachLoopDevice(filename string) (*os.File, error) {
c_filename := C.CString(filename)
defer C.free(unsafe.Pointer(c_filename))
defer free(c_filename)
var fd C.int
res := C.attach_loop_device(c_filename, &fd)
if res == nil {
return nil, fmt.Errorf("error loopback mounting")
return nil, ErrAttachLoopbackDevice
}
defer C.free(unsafe.Pointer(res))
defer free(res)
return os.NewFile(uintptr(fd), C.GoString(res)), nil
}
func getBlockSize(fd uintptr) int {
var size uint64
if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64, uintptr(unsafe.Pointer(&size))); err != 0 {
utils.Debugf("Error ioctl: %s", err)
return -1
}
return int(size)
}
func GetBlockDeviceSize(file *os.File) (uint64, error) {
if size := C.get_block_size(C.int(file.Fd())); size == -1 {
return 0, fmt.Errorf("Can't get block size")
return 0, ErrGetBlockSize
} else {
return uint64(size), nil
}
}
func UdevWait(cookie uint32) error {
res := C.dm_udev_wait(C.uint32_t(cookie))
if res != 1 {
return fmt.Errorf("Failed to wait on udev cookie %d", cookie)
if res := C.dm_udev_wait(C.uint32_t(cookie)); res != 1 {
utils.Debugf("Failed to wait on udev cookie %d", cookie)
return ErrUdevWait
}
return nil
}
@ -332,17 +348,43 @@ func LogInitVerbose(level int) {
C.dm_log_init_verbose(C.int(level))
}
func SetDevDir(dir string) error {
c_dir := C.CString(dir)
defer free(c_dir)
if res := C.dm_set_dev_dir(c_dir); res != 1 {
utils.Debugf("Error dm_set_dev_dir")
return ErrSetDevDir
}
return nil
}
func GetLibraryVersion() (string, error) {
buffer := C.CString(string(make([]byte, 128)))
defer free(buffer)
if res := C.dm_get_library_version(buffer, 128); res != 1 {
return "", ErrGetLibraryVersion
}
return C.GoString(buffer), nil
}
// Useful helper for cleanup
func RemoveDevice(name string) error {
task := TaskCreate(DeviceRemove)
if task == nil {
return fmt.Errorf("Can't create task of type DeviceRemove")
return ErrCreateRemoveTask
}
if err := task.SetName(name); err != nil {
return fmt.Errorf("Can't set task name %s", name)
utils.Debugf("Can't set task name %s", name)
return err
}
if err := task.Run(); err != nil {
return fmt.Errorf("Error running removeDevice")
return ErrRunRemoveDevice
}
return nil
}
func free(p *C.char) {
C.free(unsafe.Pointer(p))
}

59
utils_test.go
View file

@ -319,3 +319,62 @@ func TestParseLxcConfOpt(t *testing.T) {
}
}
}
type DeviceSetWrapper struct {
wrapped DeviceSet
prefix string
}
func (wrapper *DeviceSetWrapper) wrap(hash string) string {
if hash != "" {
hash = wrapper.prefix + "-" + hash
}
return hash
}
func (wrapper *DeviceSetWrapper) AddDevice(hash, baseHash string) error {
return wrapper.wrapped.AddDevice(wrapper.wrap(hash), wrapper.wrap(baseHash))
}
func (wrapper *DeviceSetWrapper) SetInitialized(hash string) error {
return wrapper.wrapped.SetInitialized(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) DeactivateDevice(hash string) error {
return wrapper.wrapped.DeactivateDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) Shutdown() error {
return nil
}
func (wrapper *DeviceSetWrapper) RemoveDevice(hash string) error {
return wrapper.wrapped.RemoveDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) MountDevice(hash, path string) error {
return wrapper.wrapped.MountDevice(wrapper.wrap(hash), path)
}
func (wrapper *DeviceSetWrapper) UnmountDevice(hash, path string) error {
return wrapper.wrapped.UnmountDevice(wrapper.wrap(hash), path)
}
func (wrapper *DeviceSetWrapper) HasDevice(hash string) bool {
return wrapper.wrapped.HasDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) HasInitializedDevice(hash string) bool {
return wrapper.wrapped.HasInitializedDevice(wrapper.wrap(hash))
}
func (wrapper *DeviceSetWrapper) HasActivatedDevice(hash string) bool {
return wrapper.wrapped.HasActivatedDevice(wrapper.wrap(hash))
}
func NewDeviceSetWrapper(wrapped DeviceSet, prefix string) DeviceSet {
return &DeviceSetWrapper{
wrapped: wrapped,
prefix: prefix,
}
}