windows.go 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745
  1. //+build windows
  2. package windows
  3. import (
  4. "bufio"
  5. "crypto/sha512"
  6. "encoding/json"
  7. "fmt"
  8. "io"
  9. "io/ioutil"
  10. "os"
  11. "path"
  12. "path/filepath"
  13. "strings"
  14. "syscall"
  15. "time"
  16. "github.com/Microsoft/go-winio"
  17. "github.com/Microsoft/go-winio/archive/tar"
  18. "github.com/Microsoft/go-winio/backuptar"
  19. "github.com/Microsoft/hcsshim"
  20. "github.com/Sirupsen/logrus"
  21. "github.com/docker/docker/daemon/graphdriver"
  22. "github.com/docker/docker/pkg/archive"
  23. "github.com/docker/docker/pkg/chrootarchive"
  24. "github.com/docker/docker/pkg/idtools"
  25. "github.com/docker/docker/pkg/ioutils"
  26. "github.com/vbatts/tar-split/tar/storage"
  27. )
  28. // init registers the windows graph drivers to the register.
  29. func init() {
  30. graphdriver.Register("windowsfilter", InitFilter)
  31. graphdriver.Register("windowsdiff", InitDiff)
  32. }
  33. const (
  34. // diffDriver is an hcsshim driver type
  35. diffDriver = iota
  36. // filterDriver is an hcsshim driver type
  37. filterDriver
  38. )
  39. // Driver represents a windows graph driver.
  40. type Driver struct {
  41. // info stores the shim driver information
  42. info hcsshim.DriverInfo
  43. }
  44. var _ graphdriver.DiffGetterDriver = &Driver{}
  45. // InitFilter returns a new Windows storage filter driver.
  46. func InitFilter(home string, options []string, uidMaps, gidMaps []idtools.IDMap) (graphdriver.Driver, error) {
  47. logrus.Debugf("WindowsGraphDriver InitFilter at %s", home)
  48. d := &Driver{
  49. info: hcsshim.DriverInfo{
  50. HomeDir: home,
  51. Flavour: filterDriver,
  52. },
  53. }
  54. return d, nil
  55. }
  56. // InitDiff returns a new Windows differencing disk driver.
  57. func InitDiff(home string, options []string, uidMaps, gidMaps []idtools.IDMap) (graphdriver.Driver, error) {
  58. logrus.Debugf("WindowsGraphDriver InitDiff at %s", home)
  59. d := &Driver{
  60. info: hcsshim.DriverInfo{
  61. HomeDir: home,
  62. Flavour: diffDriver,
  63. },
  64. }
  65. return d, nil
  66. }
  67. // String returns the string representation of a driver.
  68. func (d *Driver) String() string {
  69. switch d.info.Flavour {
  70. case diffDriver:
  71. return "windowsdiff"
  72. case filterDriver:
  73. return "windowsfilter"
  74. default:
  75. return "Unknown driver flavour"
  76. }
  77. }
  78. // Status returns the status of the driver.
  79. func (d *Driver) Status() [][2]string {
  80. return [][2]string{
  81. {"Windows", ""},
  82. }
  83. }
  84. // Exists returns true if the given id is registered with this driver.
  85. func (d *Driver) Exists(id string) bool {
  86. rID, err := d.resolveID(id)
  87. if err != nil {
  88. return false
  89. }
  90. result, err := hcsshim.LayerExists(d.info, rID)
  91. if err != nil {
  92. return false
  93. }
  94. return result
  95. }
  96. // Create creates a new layer with the given id.
  97. func (d *Driver) Create(id, parent, mountLabel string) error {
  98. rPId, err := d.resolveID(parent)
  99. if err != nil {
  100. return err
  101. }
  102. parentChain, err := d.getLayerChain(rPId)
  103. if err != nil {
  104. return err
  105. }
  106. var layerChain []string
  107. parentIsInit := strings.HasSuffix(rPId, "-init")
  108. if !parentIsInit && rPId != "" {
  109. parentPath, err := hcsshim.GetLayerMountPath(d.info, rPId)
  110. if err != nil {
  111. return err
  112. }
  113. layerChain = []string{parentPath}
  114. }
  115. layerChain = append(layerChain, parentChain...)
  116. if parentIsInit {
  117. if len(layerChain) == 0 {
  118. return fmt.Errorf("Cannot create a read/write layer without a parent layer.")
  119. }
  120. if err := hcsshim.CreateSandboxLayer(d.info, id, layerChain[0], layerChain); err != nil {
  121. return err
  122. }
  123. } else {
  124. if err := hcsshim.CreateLayer(d.info, id, rPId); err != nil {
  125. return err
  126. }
  127. }
  128. if _, err := os.Lstat(d.dir(parent)); err != nil {
  129. if err2 := hcsshim.DestroyLayer(d.info, id); err2 != nil {
  130. logrus.Warnf("Failed to DestroyLayer %s: %s", id, err2)
  131. }
  132. return fmt.Errorf("Cannot create layer with missing parent %s: %s", parent, err)
  133. }
  134. if err := d.setLayerChain(id, layerChain); err != nil {
  135. if err2 := hcsshim.DestroyLayer(d.info, id); err2 != nil {
  136. logrus.Warnf("Failed to DestroyLayer %s: %s", id, err2)
  137. }
  138. return err
  139. }
  140. return nil
  141. }
  142. // dir returns the absolute path to the layer.
  143. func (d *Driver) dir(id string) string {
  144. return filepath.Join(d.info.HomeDir, filepath.Base(id))
  145. }
  146. // Remove unmounts and removes the dir information.
  147. func (d *Driver) Remove(id string) error {
  148. rID, err := d.resolveID(id)
  149. if err != nil {
  150. return err
  151. }
  152. os.RemoveAll(filepath.Join(d.info.HomeDir, "sysfile-backups", rID)) // ok to fail
  153. return hcsshim.DestroyLayer(d.info, rID)
  154. }
  155. // Get returns the rootfs path for the id. This will mount the dir at it's given path.
  156. func (d *Driver) Get(id, mountLabel string) (string, error) {
  157. logrus.Debugf("WindowsGraphDriver Get() id %s mountLabel %s", id, mountLabel)
  158. var dir string
  159. rID, err := d.resolveID(id)
  160. if err != nil {
  161. return "", err
  162. }
  163. // Getting the layer paths must be done outside of the lock.
  164. layerChain, err := d.getLayerChain(rID)
  165. if err != nil {
  166. return "", err
  167. }
  168. if err := hcsshim.ActivateLayer(d.info, rID); err != nil {
  169. return "", err
  170. }
  171. if err := hcsshim.PrepareLayer(d.info, rID, layerChain); err != nil {
  172. if err2 := hcsshim.DeactivateLayer(d.info, rID); err2 != nil {
  173. logrus.Warnf("Failed to Deactivate %s: %s", id, err)
  174. }
  175. return "", err
  176. }
  177. mountPath, err := hcsshim.GetLayerMountPath(d.info, rID)
  178. if err != nil {
  179. if err2 := hcsshim.DeactivateLayer(d.info, rID); err2 != nil {
  180. logrus.Warnf("Failed to Deactivate %s: %s", id, err)
  181. }
  182. return "", err
  183. }
  184. // If the layer has a mount path, use that. Otherwise, use the
  185. // folder path.
  186. if mountPath != "" {
  187. dir = mountPath
  188. } else {
  189. dir = d.dir(id)
  190. }
  191. return dir, nil
  192. }
  193. // Put adds a new layer to the driver.
  194. func (d *Driver) Put(id string) error {
  195. logrus.Debugf("WindowsGraphDriver Put() id %s", id)
  196. rID, err := d.resolveID(id)
  197. if err != nil {
  198. return err
  199. }
  200. if err := hcsshim.UnprepareLayer(d.info, rID); err != nil {
  201. return err
  202. }
  203. return hcsshim.DeactivateLayer(d.info, rID)
  204. }
  205. // Cleanup ensures the information the driver stores is properly removed.
  206. func (d *Driver) Cleanup() error {
  207. return nil
  208. }
  209. // Diff produces an archive of the changes between the specified
  210. // layer and its parent layer which may be "".
  211. // The layer should be mounted when calling this function
  212. func (d *Driver) Diff(id, parent string) (_ archive.Archive, err error) {
  213. rID, err := d.resolveID(id)
  214. if err != nil {
  215. return
  216. }
  217. layerChain, err := d.getLayerChain(rID)
  218. if err != nil {
  219. return
  220. }
  221. // this is assuming that the layer is unmounted
  222. if err := hcsshim.UnprepareLayer(d.info, rID); err != nil {
  223. return nil, err
  224. }
  225. defer func() {
  226. if err := hcsshim.PrepareLayer(d.info, rID, layerChain); err != nil {
  227. logrus.Warnf("Failed to Deactivate %s: %s", rID, err)
  228. }
  229. }()
  230. arch, err := d.exportLayer(rID, layerChain)
  231. if err != nil {
  232. return
  233. }
  234. return ioutils.NewReadCloserWrapper(arch, func() error {
  235. return arch.Close()
  236. }), nil
  237. }
  238. // Changes produces a list of changes between the specified layer
  239. // and its parent layer. If parent is "", then all changes will be ADD changes.
  240. // The layer should be mounted when calling this function
  241. func (d *Driver) Changes(id, parent string) ([]archive.Change, error) {
  242. rID, err := d.resolveID(id)
  243. if err != nil {
  244. return nil, err
  245. }
  246. parentChain, err := d.getLayerChain(rID)
  247. if err != nil {
  248. return nil, err
  249. }
  250. // this is assuming that the layer is unmounted
  251. if err := hcsshim.UnprepareLayer(d.info, rID); err != nil {
  252. return nil, err
  253. }
  254. defer func() {
  255. if err := hcsshim.PrepareLayer(d.info, rID, parentChain); err != nil {
  256. logrus.Warnf("Failed to Deactivate %s: %s", rID, err)
  257. }
  258. }()
  259. r, err := hcsshim.NewLayerReader(d.info, id, parentChain)
  260. if err != nil {
  261. return nil, err
  262. }
  263. defer r.Close()
  264. var changes []archive.Change
  265. for {
  266. name, _, fileInfo, err := r.Next()
  267. if err == io.EOF {
  268. break
  269. }
  270. if err != nil {
  271. return nil, err
  272. }
  273. name = filepath.ToSlash(name)
  274. if fileInfo == nil {
  275. changes = append(changes, archive.Change{name, archive.ChangeDelete})
  276. } else {
  277. // Currently there is no way to tell between an add and a modify.
  278. changes = append(changes, archive.Change{name, archive.ChangeModify})
  279. }
  280. }
  281. return changes, nil
  282. }
  283. // ApplyDiff extracts the changeset from the given diff into the
  284. // layer with the specified id and parent, returning the size of the
  285. // new layer in bytes.
  286. // The layer should not be mounted when calling this function
  287. func (d *Driver) ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error) {
  288. rPId, err := d.resolveID(parent)
  289. if err != nil {
  290. return
  291. }
  292. if d.info.Flavour == diffDriver {
  293. start := time.Now().UTC()
  294. logrus.Debugf("WindowsGraphDriver ApplyDiff: Start untar layer")
  295. destination := d.dir(id)
  296. destination = filepath.Dir(destination)
  297. if size, err = chrootarchive.ApplyUncompressedLayer(destination, diff, nil); err != nil {
  298. return
  299. }
  300. logrus.Debugf("WindowsGraphDriver ApplyDiff: Untar time: %vs", time.Now().UTC().Sub(start).Seconds())
  301. return
  302. }
  303. parentChain, err := d.getLayerChain(rPId)
  304. if err != nil {
  305. return
  306. }
  307. parentPath, err := hcsshim.GetLayerMountPath(d.info, rPId)
  308. if err != nil {
  309. return
  310. }
  311. layerChain := []string{parentPath}
  312. layerChain = append(layerChain, parentChain...)
  313. if size, err = d.importLayer(id, diff, layerChain); err != nil {
  314. return
  315. }
  316. if err = d.setLayerChain(id, layerChain); err != nil {
  317. return
  318. }
  319. return
  320. }
  321. // DiffSize calculates the changes between the specified layer
  322. // and its parent and returns the size in bytes of the changes
  323. // relative to its base filesystem directory.
  324. func (d *Driver) DiffSize(id, parent string) (size int64, err error) {
  325. rPId, err := d.resolveID(parent)
  326. if err != nil {
  327. return
  328. }
  329. changes, err := d.Changes(id, rPId)
  330. if err != nil {
  331. return
  332. }
  333. layerFs, err := d.Get(id, "")
  334. if err != nil {
  335. return
  336. }
  337. defer d.Put(id)
  338. return archive.ChangesSize(layerFs, changes), nil
  339. }
  340. // CustomImageInfo is the object returned by the driver describing the base
  341. // image.
  342. type CustomImageInfo struct {
  343. ID string
  344. Name string
  345. Version string
  346. Path string
  347. Size int64
  348. CreatedTime time.Time
  349. }
  350. // GetCustomImageInfos returns the image infos for window specific
  351. // base images which should always be present.
  352. func (d *Driver) GetCustomImageInfos() ([]CustomImageInfo, error) {
  353. strData, err := hcsshim.GetSharedBaseImages()
  354. if err != nil {
  355. return nil, fmt.Errorf("Failed to restore base images: %s", err)
  356. }
  357. type customImageInfoList struct {
  358. Images []CustomImageInfo
  359. }
  360. var infoData customImageInfoList
  361. if err = json.Unmarshal([]byte(strData), &infoData); err != nil {
  362. err = fmt.Errorf("JSON unmarshal returned error=%s", err)
  363. logrus.Error(err)
  364. return nil, err
  365. }
  366. var images []CustomImageInfo
  367. for _, imageData := range infoData.Images {
  368. folderName := filepath.Base(imageData.Path)
  369. // Use crypto hash of the foldername to generate a docker style id.
  370. h := sha512.Sum384([]byte(folderName))
  371. id := fmt.Sprintf("%x", h[:32])
  372. if err := d.Create(id, "", ""); err != nil {
  373. return nil, err
  374. }
  375. // Create the alternate ID file.
  376. if err := d.setID(id, folderName); err != nil {
  377. return nil, err
  378. }
  379. imageData.ID = id
  380. images = append(images, imageData)
  381. }
  382. return images, nil
  383. }
  384. // GetMetadata returns custom driver information.
  385. func (d *Driver) GetMetadata(id string) (map[string]string, error) {
  386. m := make(map[string]string)
  387. m["dir"] = d.dir(id)
  388. return m, nil
  389. }
  390. func writeTarFromLayer(r hcsshim.LayerReader, w io.Writer) error {
  391. t := tar.NewWriter(w)
  392. for {
  393. name, size, fileInfo, err := r.Next()
  394. if err == io.EOF {
  395. break
  396. }
  397. if err != nil {
  398. return err
  399. }
  400. if fileInfo == nil {
  401. // Write a whiteout file.
  402. hdr := &tar.Header{
  403. Name: filepath.ToSlash(filepath.Join(filepath.Dir(name), archive.WhiteoutPrefix+filepath.Base(name))),
  404. }
  405. err := t.WriteHeader(hdr)
  406. if err != nil {
  407. return err
  408. }
  409. } else {
  410. err = backuptar.WriteTarFileFromBackupStream(t, r, name, size, fileInfo)
  411. if err != nil {
  412. return err
  413. }
  414. }
  415. }
  416. return t.Close()
  417. }
  418. // exportLayer generates an archive from a layer based on the given ID.
  419. func (d *Driver) exportLayer(id string, parentLayerPaths []string) (archive.Archive, error) {
  420. if hcsshim.IsTP4() {
  421. // Export in TP4 format to maintain compatibility with existing images and
  422. // because ExportLayer is somewhat broken on TP4 and can't work with the new
  423. // scheme.
  424. tempFolder, err := ioutil.TempDir("", "hcs")
  425. if err != nil {
  426. return nil, err
  427. }
  428. defer func() {
  429. if err != nil {
  430. os.RemoveAll(tempFolder)
  431. }
  432. }()
  433. if err = hcsshim.ExportLayer(d.info, id, tempFolder, parentLayerPaths); err != nil {
  434. return nil, err
  435. }
  436. archive, err := archive.Tar(tempFolder, archive.Uncompressed)
  437. if err != nil {
  438. return nil, err
  439. }
  440. return ioutils.NewReadCloserWrapper(archive, func() error {
  441. err := archive.Close()
  442. os.RemoveAll(tempFolder)
  443. return err
  444. }), nil
  445. }
  446. var r hcsshim.LayerReader
  447. r, err := hcsshim.NewLayerReader(d.info, id, parentLayerPaths)
  448. if err != nil {
  449. return nil, err
  450. }
  451. archive, w := io.Pipe()
  452. go func() {
  453. err := writeTarFromLayer(r, w)
  454. cerr := r.Close()
  455. if err == nil {
  456. err = cerr
  457. }
  458. w.CloseWithError(err)
  459. }()
  460. return archive, nil
  461. }
  462. func writeLayerFromTar(r archive.Reader, w hcsshim.LayerWriter) (int64, error) {
  463. t := tar.NewReader(r)
  464. hdr, err := t.Next()
  465. totalSize := int64(0)
  466. buf := bufio.NewWriter(nil)
  467. for err == nil {
  468. base := path.Base(hdr.Name)
  469. if strings.HasPrefix(base, archive.WhiteoutPrefix) {
  470. name := path.Join(path.Dir(hdr.Name), base[len(archive.WhiteoutPrefix):])
  471. err = w.Remove(filepath.FromSlash(name))
  472. if err != nil {
  473. return 0, err
  474. }
  475. hdr, err = t.Next()
  476. } else {
  477. var (
  478. name string
  479. size int64
  480. fileInfo *winio.FileBasicInfo
  481. )
  482. name, size, fileInfo, err = backuptar.FileInfoFromHeader(hdr)
  483. if err != nil {
  484. return 0, err
  485. }
  486. err = w.Add(filepath.FromSlash(name), fileInfo)
  487. if err != nil {
  488. return 0, err
  489. }
  490. buf.Reset(w)
  491. hdr, err = backuptar.WriteBackupStreamFromTarFile(buf, t, hdr)
  492. ferr := buf.Flush()
  493. if ferr != nil {
  494. err = ferr
  495. }
  496. totalSize += size
  497. }
  498. }
  499. if err != io.EOF {
  500. return 0, err
  501. }
  502. return totalSize, nil
  503. }
  504. // importLayer adds a new layer to the tag and graph store based on the given data.
  505. func (d *Driver) importLayer(id string, layerData archive.Reader, parentLayerPaths []string) (size int64, err error) {
  506. if hcsshim.IsTP4() {
  507. // Import from TP4 format to maintain compatibility with existing images.
  508. var tempFolder string
  509. tempFolder, err = ioutil.TempDir("", "hcs")
  510. if err != nil {
  511. return
  512. }
  513. defer os.RemoveAll(tempFolder)
  514. if size, err = chrootarchive.ApplyLayer(tempFolder, layerData); err != nil {
  515. return
  516. }
  517. if err = hcsshim.ImportLayer(d.info, id, tempFolder, parentLayerPaths); err != nil {
  518. return
  519. }
  520. return
  521. }
  522. var w hcsshim.LayerWriter
  523. w, err = hcsshim.NewLayerWriter(d.info, id, parentLayerPaths)
  524. if err != nil {
  525. return
  526. }
  527. size, err = writeLayerFromTar(layerData, w)
  528. if err != nil {
  529. w.Close()
  530. return
  531. }
  532. err = w.Close()
  533. if err != nil {
  534. return
  535. }
  536. return
  537. }
  538. // resolveID computes the layerID information based on the given id.
  539. func (d *Driver) resolveID(id string) (string, error) {
  540. content, err := ioutil.ReadFile(filepath.Join(d.dir(id), "layerID"))
  541. if os.IsNotExist(err) {
  542. return id, nil
  543. } else if err != nil {
  544. return "", err
  545. }
  546. return string(content), nil
  547. }
  548. // setID stores the layerId in disk.
  549. func (d *Driver) setID(id, altID string) error {
  550. err := ioutil.WriteFile(filepath.Join(d.dir(id), "layerId"), []byte(altID), 0600)
  551. if err != nil {
  552. return err
  553. }
  554. return nil
  555. }
  556. // getLayerChain returns the layer chain information.
  557. func (d *Driver) getLayerChain(id string) ([]string, error) {
  558. jPath := filepath.Join(d.dir(id), "layerchain.json")
  559. content, err := ioutil.ReadFile(jPath)
  560. if os.IsNotExist(err) {
  561. return nil, nil
  562. } else if err != nil {
  563. return nil, fmt.Errorf("Unable to read layerchain file - %s", err)
  564. }
  565. var layerChain []string
  566. err = json.Unmarshal(content, &layerChain)
  567. if err != nil {
  568. return nil, fmt.Errorf("Failed to unmarshall layerchain json - %s", err)
  569. }
  570. return layerChain, nil
  571. }
  572. // setLayerChain stores the layer chain information in disk.
  573. func (d *Driver) setLayerChain(id string, chain []string) error {
  574. content, err := json.Marshal(&chain)
  575. if err != nil {
  576. return fmt.Errorf("Failed to marshall layerchain json - %s", err)
  577. }
  578. jPath := filepath.Join(d.dir(id), "layerchain.json")
  579. err = ioutil.WriteFile(jPath, content, 0600)
  580. if err != nil {
  581. return fmt.Errorf("Unable to write layerchain file - %s", err)
  582. }
  583. return nil
  584. }
  585. type fileGetCloserWithBackupPrivileges struct {
  586. path string
  587. }
  588. func (fg *fileGetCloserWithBackupPrivileges) Get(filename string) (io.ReadCloser, error) {
  589. var f *os.File
  590. // Open the file while holding the Windows backup privilege. This ensures that the
  591. // file can be opened even if the caller does not actually have access to it according
  592. // to the security descriptor.
  593. err := winio.RunWithPrivilege(winio.SeBackupPrivilege, func() error {
  594. path := filepath.Join(fg.path, filename)
  595. p, err := syscall.UTF16FromString(path)
  596. if err != nil {
  597. return err
  598. }
  599. h, err := syscall.CreateFile(&p[0], syscall.GENERIC_READ, syscall.FILE_SHARE_READ, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS, 0)
  600. if err != nil {
  601. return &os.PathError{Op: "open", Path: path, Err: err}
  602. }
  603. f = os.NewFile(uintptr(h), path)
  604. return nil
  605. })
  606. return f, err
  607. }
  608. func (fg *fileGetCloserWithBackupPrivileges) Close() error {
  609. return nil
  610. }
  611. type fileGetDestroyCloser struct {
  612. storage.FileGetter
  613. path string
  614. }
  615. func (f *fileGetDestroyCloser) Close() error {
  616. // TODO: activate layers and release here?
  617. return os.RemoveAll(f.path)
  618. }
  619. // DiffGetter returns a FileGetCloser that can read files from the directory that
  620. // contains files for the layer differences. Used for direct access for tar-split.
  621. func (d *Driver) DiffGetter(id string) (graphdriver.FileGetCloser, error) {
  622. id, err := d.resolveID(id)
  623. if err != nil {
  624. return nil, err
  625. }
  626. if hcsshim.IsTP4() {
  627. // The export format for TP4 is different from the contents of the layer, so
  628. // fall back to exporting the layer and getting file contents from there.
  629. layerChain, err := d.getLayerChain(id)
  630. if err != nil {
  631. return nil, err
  632. }
  633. var tempFolder string
  634. tempFolder, err = ioutil.TempDir("", "hcs")
  635. if err != nil {
  636. return nil, err
  637. }
  638. defer func() {
  639. if err != nil {
  640. os.RemoveAll(tempFolder)
  641. }
  642. }()
  643. if err = hcsshim.ExportLayer(d.info, id, tempFolder, layerChain); err != nil {
  644. return nil, err
  645. }
  646. return &fileGetDestroyCloser{storage.NewPathFileGetter(tempFolder), tempFolder}, nil
  647. }
  648. return &fileGetCloserWithBackupPrivileges{d.dir(id)}, nil
  649. }