devmapper_test.go 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152
  1. // +build linux
  2. package devmapper
  3. import (
  4. "fmt"
  5. "os"
  6. "syscall"
  7. "testing"
  8. "time"
  9. "github.com/docker/docker/daemon/graphdriver"
  10. "github.com/docker/docker/daemon/graphdriver/graphtest"
  11. )
  12. func init() {
  13. // Reduce the size of the base fs and loopback for the tests
  14. defaultDataLoopbackSize = 300 * 1024 * 1024
  15. defaultMetaDataLoopbackSize = 200 * 1024 * 1024
  16. defaultBaseFsSize = 300 * 1024 * 1024
  17. defaultUdevSyncOverride = true
  18. if err := initLoopbacks(); err != nil {
  19. panic(err)
  20. }
  21. }
  22. // initLoopbacks ensures that the loopback devices are properly created within
  23. // the system running the device mapper tests.
  24. func initLoopbacks() error {
  25. statT, err := getBaseLoopStats()
  26. if err != nil {
  27. return err
  28. }
  29. // create at least 8 loopback files, ya, that is a good number
  30. for i := 0; i < 8; i++ {
  31. loopPath := fmt.Sprintf("/dev/loop%d", i)
  32. // only create new loopback files if they don't exist
  33. if _, err := os.Stat(loopPath); err != nil {
  34. if mkerr := syscall.Mknod(loopPath,
  35. uint32(statT.Mode|syscall.S_IFBLK), int((7<<8)|(i&0xff)|((i&0xfff00)<<12))); mkerr != nil {
  36. return mkerr
  37. }
  38. os.Chown(loopPath, int(statT.Uid), int(statT.Gid))
  39. }
  40. }
  41. return nil
  42. }
  43. // getBaseLoopStats inspects /dev/loop0 to collect uid,gid, and mode for the
  44. // loop0 device on the system. If it does not exist we assume 0,0,0660 for the
  45. // stat data
  46. func getBaseLoopStats() (*syscall.Stat_t, error) {
  47. loop0, err := os.Stat("/dev/loop0")
  48. if err != nil {
  49. if os.IsNotExist(err) {
  50. return &syscall.Stat_t{
  51. Uid: 0,
  52. Gid: 0,
  53. Mode: 0660,
  54. }, nil
  55. }
  56. return nil, err
  57. }
  58. return loop0.Sys().(*syscall.Stat_t), nil
  59. }
  60. // This avoids creating a new driver for each test if all tests are run
  61. // Make sure to put new tests between TestDevmapperSetup and TestDevmapperTeardown
  62. func TestDevmapperSetup(t *testing.T) {
  63. graphtest.GetDriver(t, "devicemapper")
  64. }
  65. func TestDevmapperCreateEmpty(t *testing.T) {
  66. graphtest.DriverTestCreateEmpty(t, "devicemapper")
  67. }
  68. func TestDevmapperCreateBase(t *testing.T) {
  69. graphtest.DriverTestCreateBase(t, "devicemapper")
  70. }
  71. func TestDevmapperCreateSnap(t *testing.T) {
  72. graphtest.DriverTestCreateSnap(t, "devicemapper")
  73. }
  74. func TestDevmapperTeardown(t *testing.T) {
  75. graphtest.PutDriver(t)
  76. }
  77. func TestDevmapperReduceLoopBackSize(t *testing.T) {
  78. tenMB := int64(10 * 1024 * 1024)
  79. testChangeLoopBackSize(t, -tenMB, defaultDataLoopbackSize, defaultMetaDataLoopbackSize)
  80. }
  81. func TestDevmapperIncreaseLoopBackSize(t *testing.T) {
  82. tenMB := int64(10 * 1024 * 1024)
  83. testChangeLoopBackSize(t, tenMB, defaultDataLoopbackSize+tenMB, defaultMetaDataLoopbackSize+tenMB)
  84. }
  85. func testChangeLoopBackSize(t *testing.T, delta, expectDataSize, expectMetaDataSize int64) {
  86. driver := graphtest.GetDriver(t, "devicemapper").(*graphtest.Driver).Driver.(*graphdriver.NaiveDiffDriver).ProtoDriver.(*Driver)
  87. defer graphtest.PutDriver(t)
  88. // make sure data or metadata loopback size are the default size
  89. if s := driver.DeviceSet.Status(); s.Data.Total != uint64(defaultDataLoopbackSize) || s.Metadata.Total != uint64(defaultMetaDataLoopbackSize) {
  90. t.Fatal("data or metadata loop back size is incorrect")
  91. }
  92. if err := driver.Cleanup(); err != nil {
  93. t.Fatal(err)
  94. }
  95. //Reload
  96. d, err := Init(driver.home, []string{
  97. fmt.Sprintf("dm.loopdatasize=%d", defaultDataLoopbackSize+delta),
  98. fmt.Sprintf("dm.loopmetadatasize=%d", defaultMetaDataLoopbackSize+delta),
  99. }, nil, nil)
  100. if err != nil {
  101. t.Fatalf("error creating devicemapper driver: %v", err)
  102. }
  103. driver = d.(*graphdriver.NaiveDiffDriver).ProtoDriver.(*Driver)
  104. if s := driver.DeviceSet.Status(); s.Data.Total != uint64(expectDataSize) || s.Metadata.Total != uint64(expectMetaDataSize) {
  105. t.Fatal("data or metadata loop back size is incorrect")
  106. }
  107. if err := driver.Cleanup(); err != nil {
  108. t.Fatal(err)
  109. }
  110. }
  111. // Make sure devices.Lock() has been release upon return from cleanupDeletedDevices() function
  112. func TestDevmapperLockReleasedDeviceDeletion(t *testing.T) {
  113. driver := graphtest.GetDriver(t, "devicemapper").(*graphtest.Driver).Driver.(*graphdriver.NaiveDiffDriver).ProtoDriver.(*Driver)
  114. defer graphtest.PutDriver(t)
  115. // Call cleanupDeletedDevices() and after the call take and release
  116. // DeviceSet Lock. If lock has not been released, this will hang.
  117. driver.DeviceSet.cleanupDeletedDevices()
  118. doneChan := make(chan bool)
  119. go func() {
  120. driver.DeviceSet.Lock()
  121. defer driver.DeviceSet.Unlock()
  122. doneChan <- true
  123. }()
  124. select {
  125. case <-time.After(time.Second * 5):
  126. // Timer expired. That means lock was not released upon
  127. // function return and we are deadlocked. Release lock
  128. // here so that cleanup could succeed and fail the test.
  129. driver.DeviceSet.Unlock()
  130. t.Fatal("Could not acquire devices lock after call to cleanupDeletedDevices()")
  131. case <-doneChan:
  132. }
  133. }