github.com/lmars/docker@v1.6.0-rc2/daemon/graphdriver/devmapper/driver.go (about)

     1  // +build linux
     2  
     3  package devmapper
     4  
     5  import (
     6  	"fmt"
     7  	"io/ioutil"
     8  	"os"
     9  	"path"
    10  
    11  	log "github.com/Sirupsen/logrus"
    12  	"github.com/docker/docker/daemon/graphdriver"
    13  	"github.com/docker/docker/pkg/devicemapper"
    14  	"github.com/docker/docker/pkg/mount"
    15  	"github.com/docker/docker/pkg/units"
    16  )
    17  
    18  func init() {
    19  	graphdriver.Register("devicemapper", Init)
    20  }
    21  
    22  // Placeholder interfaces, to be replaced
    23  // at integration.
    24  
    25  // End of placeholder interfaces.
    26  
    27  type Driver struct {
    28  	*DeviceSet
    29  	home string
    30  }
    31  
    32  var backingFs = "<unknown>"
    33  
    34  func Init(home string, options []string) (graphdriver.Driver, error) {
    35  	fsMagic, err := graphdriver.GetFSMagic(home)
    36  	if err != nil {
    37  		return nil, err
    38  	}
    39  	if fsName, ok := graphdriver.FsNames[fsMagic]; ok {
    40  		backingFs = fsName
    41  	}
    42  
    43  	deviceSet, err := NewDeviceSet(home, true, options)
    44  	if err != nil {
    45  		return nil, err
    46  	}
    47  
    48  	if err := mount.MakePrivate(home); err != nil {
    49  		return nil, err
    50  	}
    51  
    52  	d := &Driver{
    53  		DeviceSet: deviceSet,
    54  		home:      home,
    55  	}
    56  
    57  	return graphdriver.NaiveDiffDriver(d), nil
    58  }
    59  
    60  func (d *Driver) String() string {
    61  	return "devicemapper"
    62  }
    63  
    64  func (d *Driver) Status() [][2]string {
    65  	s := d.DeviceSet.Status()
    66  
    67  	status := [][2]string{
    68  		{"Pool Name", s.PoolName},
    69  		{"Pool Blocksize", fmt.Sprintf("%s", units.HumanSize(float64(s.SectorSize)))},
    70  		{"Backing Filesystem", backingFs},
    71  		{"Data file", s.DataFile},
    72  		{"Metadata file", s.MetadataFile},
    73  		{"Data Space Used", fmt.Sprintf("%s", units.HumanSize(float64(s.Data.Used)))},
    74  		{"Data Space Total", fmt.Sprintf("%s", units.HumanSize(float64(s.Data.Total)))},
    75  		{"Data Space Available", fmt.Sprintf("%s", units.HumanSize(float64(s.Data.Available)))},
    76  		{"Metadata Space Used", fmt.Sprintf("%s", units.HumanSize(float64(s.Metadata.Used)))},
    77  		{"Metadata Space Total", fmt.Sprintf("%s", units.HumanSize(float64(s.Metadata.Total)))},
    78  		{"Metadata Space Available", fmt.Sprintf("%s", units.HumanSize(float64(s.Metadata.Available)))},
    79  		{"Udev Sync Supported", fmt.Sprintf("%v", s.UdevSyncSupported)},
    80  	}
    81  	if len(s.DataLoopback) > 0 {
    82  		status = append(status, [2]string{"Data loop file", s.DataLoopback})
    83  	}
    84  	if len(s.MetadataLoopback) > 0 {
    85  		status = append(status, [2]string{"Metadata loop file", s.MetadataLoopback})
    86  	}
    87  	if vStr, err := devicemapper.GetLibraryVersion(); err == nil {
    88  		status = append(status, [2]string{"Library Version", vStr})
    89  	}
    90  	return status
    91  }
    92  
    93  func (d *Driver) Cleanup() error {
    94  	err := d.DeviceSet.Shutdown()
    95  
    96  	if err2 := mount.Unmount(d.home); err == nil {
    97  		err = err2
    98  	}
    99  
   100  	return err
   101  }
   102  
   103  func (d *Driver) Create(id, parent string) error {
   104  	if err := d.DeviceSet.AddDevice(id, parent); err != nil {
   105  		return err
   106  	}
   107  
   108  	return nil
   109  }
   110  
   111  func (d *Driver) Remove(id string) error {
   112  	if !d.DeviceSet.HasDevice(id) {
   113  		// Consider removing a non-existing device a no-op
   114  		// This is useful to be able to progress on container removal
   115  		// if the underlying device has gone away due to earlier errors
   116  		return nil
   117  	}
   118  
   119  	// This assumes the device has been properly Get/Put:ed and thus is unmounted
   120  	if err := d.DeviceSet.DeleteDevice(id); err != nil {
   121  		return err
   122  	}
   123  
   124  	mp := path.Join(d.home, "mnt", id)
   125  	if err := os.RemoveAll(mp); err != nil && !os.IsNotExist(err) {
   126  		return err
   127  	}
   128  
   129  	return nil
   130  }
   131  
   132  func (d *Driver) Get(id, mountLabel string) (string, error) {
   133  	mp := path.Join(d.home, "mnt", id)
   134  
   135  	// Create the target directories if they don't exist
   136  	if err := os.MkdirAll(mp, 0755); err != nil && !os.IsExist(err) {
   137  		return "", err
   138  	}
   139  
   140  	// Mount the device
   141  	if err := d.DeviceSet.MountDevice(id, mp, mountLabel); err != nil {
   142  		return "", err
   143  	}
   144  
   145  	rootFs := path.Join(mp, "rootfs")
   146  	if err := os.MkdirAll(rootFs, 0755); err != nil && !os.IsExist(err) {
   147  		d.DeviceSet.UnmountDevice(id)
   148  		return "", err
   149  	}
   150  
   151  	idFile := path.Join(mp, "id")
   152  	if _, err := os.Stat(idFile); err != nil && os.IsNotExist(err) {
   153  		// Create an "id" file with the container/image id in it to help reconscruct this in case
   154  		// of later problems
   155  		if err := ioutil.WriteFile(idFile, []byte(id), 0600); err != nil {
   156  			d.DeviceSet.UnmountDevice(id)
   157  			return "", err
   158  		}
   159  	}
   160  
   161  	return rootFs, nil
   162  }
   163  
   164  func (d *Driver) Put(id string) error {
   165  	err := d.DeviceSet.UnmountDevice(id)
   166  	if err != nil {
   167  		log.Errorf("Error unmounting device %s: %s", id, err)
   168  	}
   169  	return err
   170  }
   171  
   172  func (d *Driver) Exists(id string) bool {
   173  	return d.DeviceSet.HasDevice(id)
   174  }