[jackhill/guix/guix.git] / gnu / system / mapped-devices.scm

;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014, 2015, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2016 Andreas Enge <andreas@enge.fr>
;;; Copyright © 2017, 2018 Mark H Weaver <mhw@netris.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu system mapped-devices)
  #:use-module (guix gexp)
  #:use-module (guix records)
  #:use-module ((guix modules) #:hide (file-name->module-name))
  #:use-module (guix i18n)
  #:use-module ((guix utils)
                #:select (source-properties->location
                          &fix-hint
                          &error-location))
  #:use-module (gnu services)
  #:use-module (gnu services shepherd)
  #:use-module (gnu system uuid)
  #:autoload   (gnu build file-systems) (find-partition-by-luks-uuid)
  #:autoload   (gnu build linux-modules)
                 (device-module-aliases matching-modules known-module-aliases
                  normalize-module-name file-name->module-name)
  #:autoload   (gnu packages cryptsetup) (cryptsetup-static)
  #:autoload   (gnu packages linux) (mdadm-static)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:use-module (srfi srfi-34)
  #:use-module (srfi srfi-35)
  #:use-module (ice-9 match)
  #:export (mapped-device
            mapped-device?
            mapped-device-source
            mapped-device-target
            mapped-device-type
            mapped-device-location

            mapped-device-kind
            mapped-device-kind?
            mapped-device-kind-open
            mapped-device-kind-close
            mapped-device-kind-check

            device-mapping-service-type
            device-mapping-service

            check-device-initrd-modules           ;XXX: needs a better place

            luks-device-mapping
            raid-device-mapping))

;;; Commentary:
;;;
;;; This module supports "device mapping", a concept implemented by Linux's
;;; device-mapper.
;;;
;;; Code:

(define-record-type* <mapped-device> mapped-device
  make-mapped-device
  mapped-device?
  (source    mapped-device-source)                ;string | list of strings
  (target    mapped-device-target)                ;string
  (type      mapped-device-type)                  ;<mapped-device-kind>
  (location  mapped-device-location
             (default (current-source-location)) (innate)))

(define-record-type* <mapped-device-type> mapped-device-kind
  make-mapped-device-kind
  mapped-device-kind?
  (open      mapped-device-kind-open)             ;source target -> gexp
  (close     mapped-device-kind-close             ;source target -> gexp
             (default (const #~(const #f))))
  (check     mapped-device-kind-check             ;source -> Boolean
             (default (const #t))))

\f
;;;
;;; Device mapping as a Shepherd service.
;;;

(define device-mapping-service-type
  (shepherd-service-type
   'device-mapping
   (match-lambda
     (($ <mapped-device> source target
                         ($ <mapped-device-type> open close))
      (shepherd-service
       (provision (list (symbol-append 'device-mapping- (string->symbol target))))
       (requirement '(udev))
       (documentation "Map a device node using Linux's device mapper.")
       (start #~(lambda () #$(open source target)))
       (stop #~(lambda _ (not #$(close source target))))
       (respawn? #f))))))

(define (device-mapping-service mapped-device)
  "Return a service that sets up @var{mapped-device}."
  (service device-mapping-service-type mapped-device))

\f
;;;
;;; Static checks.
;;;

(define (check-device-initrd-modules device linux-modules location)
  "Raise an error if DEVICE needs modules beyond LINUX-MODULES to operate.
DEVICE must be a \"/dev\" file name."
  (define aliases
    ;; Attempt to load 'modules.alias' from the current kernel, assuming we're
    ;; on GuixSD, and assuming that corresponds to the kernel we'll be
    ;; installing.  Skip the whole thing if that file cannot be read.
    (catch 'system-error
      (lambda ()
        (known-module-aliases))
      (const #f)))

  (when aliases
    (let* ((modules  (delete-duplicates
                      (append-map (cut matching-modules <> aliases)
                                  (device-module-aliases device))))

           ;; Module names (not file names) are supposed to use underscores
           ;; instead of hyphens.  MODULES is a list of module names, whereas
           ;; LINUX-MODULES is file names without '.ko', so normalize them.
           (provided (map file-name->module-name linux-modules))
           (missing  (remove (cut member <> provided) modules)))
      (unless (null? missing)
        ;; Note: What we suggest here is a list of module names (e.g.,
        ;; "usb_storage"), not file names (e.g., "usb-storage.ko").  This is
        ;; OK because we have machinery that accepts both the hyphen and the
        ;; underscore version.
        (raise (condition
                (&message
                 (message (format #f (G_ "you may need these modules \
in the initrd for ~a:~{ ~a~}")
                                  device missing)))
                (&fix-hint
                 (hint (format #f (G_ "Try adding them to the
@code{initrd-modules} field of your @code{operating-system} declaration, along
these lines:

@example
 (operating-system
   ;; @dots{}
   (initrd-modules (append (list~{ ~s~})
                           %base-initrd-modules)))
@end example

If you think this diagnostic is inaccurate, use the @option{--skip-checks}
option of @command{guix system}.\n")
                               missing)))
                (&error-location
                 (location (source-properties->location location)))))))))

\f
;;;
;;; Common device mappings.
;;;

(define (open-luks-device source target)
  "Return a gexp that maps SOURCE to TARGET as a LUKS device, using
'cryptsetup'."
  (with-imported-modules (source-module-closure
                          '((gnu build file-systems)))
    #~(let ((source #$(if (uuid? source)
                          (uuid-bytevector source)
                          source)))
        ;; XXX: 'use-modules' should be at the top level.
        (use-modules (rnrs bytevectors)           ;bytevector?
                     ((gnu build file-systems)
                      #:select (find-partition-by-luks-uuid)))

        ;; Use 'cryptsetup-static', not 'cryptsetup', to avoid pulling the
        ;; whole world inside the initrd (for when we're in an initrd).
        (zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
                        "open" "--type" "luks"

                        ;; Note: We cannot use the "UUID=source" syntax here
                        ;; because 'cryptsetup' implements it by searching the
                        ;; udev-populated /dev/disk/by-id directory but udev may
                        ;; be unavailable at the time we run this.
                        (if (bytevector? source)
                            (or (let loop ((tries-left 10))
                                  (and (positive? tries-left)
                                       (or (find-partition-by-luks-uuid source)
                                           ;; If the underlying partition is
                                           ;; not found, try again after
                                           ;; waiting a second, up to ten
                                           ;; times.  FIXME: This should be
                                           ;; dealt with in a more robust way.
                                           (begin (sleep 1)
                                                  (loop (- tries-left 1))))))
                                (error "LUKS partition not found" source))
                            source)

                        #$target)))))

(define (close-luks-device source target)
  "Return a gexp that closes TARGET, a LUKS device."
  #~(zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
                    "close" #$target)))

(define* (check-luks-device md #:key
                            needed-for-boot?
                            (initrd-modules '())
                            #:allow-other-keys
                            #:rest rest)
  "Ensure the source of MD is valid."
  (let ((source   (mapped-device-source md))
        (location (mapped-device-location md)))
    (or (not (zero? (getuid)))
        (if (uuid? source)
            (match (find-partition-by-luks-uuid (uuid-bytevector source))
              (#f
               (raise (condition
                       (&message
                        (message (format #f (G_ "no LUKS partition with UUID '~a'")
                                         (uuid->string source))))
                       (&error-location
                        (location (source-properties->location
                                   (mapped-device-location md)))))))
              ((? string? device)
               (check-device-initrd-modules device initrd-modules location)))
            (check-device-initrd-modules source initrd-modules location)))))

(define luks-device-mapping
  ;; The type of LUKS mapped devices.
  (mapped-device-kind
   (open open-luks-device)
   (close close-luks-device)
   (check check-luks-device)))

(define (open-raid-device sources target)
  "Return a gexp that assembles SOURCES (a list of devices) to the RAID device
TARGET (e.g., \"/dev/md0\"), using 'mdadm'."
  #~(let ((sources '#$sources)

          ;; XXX: We're not at the top level here.  We could use a
          ;; non-top-level 'use-modules' form but that doesn't work when the
          ;; code is eval'd, like the Shepherd does.
          (every   (@ (srfi srfi-1) every))
          (format  (@ (ice-9 format) format)))
      (let loop ((attempts 0))
        (unless (every file-exists? sources)
          (when (> attempts 20)
            (error "RAID devices did not show up; bailing out"
                   sources))

          (format #t "waiting for RAID source devices~{ ~a~}...~%"
                  sources)
          (sleep 1)
          (loop (+ 1 attempts))))

      ;; Use 'mdadm-static' rather than 'mdadm' to avoid pulling its whole
      ;; closure (80 MiB) in the initrd when a RAID device is needed for boot.
      (zero? (apply system* #$(file-append mdadm-static "/sbin/mdadm")
                    "--assemble" #$target sources))))

(define (close-raid-device sources target)
  "Return a gexp that stops the RAID device TARGET."
  #~(zero? (system* #$(file-append mdadm-static "/sbin/mdadm")
                    "--stop" #$target)))

(define raid-device-mapping
  ;; The type of RAID mapped devices.
  (mapped-device-kind
   (open open-raid-device)
   (close close-raid-device)))

;;; mapped-devices.scm ends here
Commit	Line	Data
060d62a7	1	;;; GNU Guix --- Functional package management for GNU
424cea80	2	;;; Copyright © 2014, 2015, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
97c8aef1	3	;;; Copyright © 2016 Andreas Enge <andreas@enge.fr>
3e5783e2	4	;;; Copyright © 2017, 2018 Mark H Weaver <mhw@netris.org>
060d62a7 LC	5	;;;
	6	;;; This file is part of GNU Guix.
	7	;;;
	8	;;; GNU Guix is free software; you can redistribute it and/or modify it
	9	;;; under the terms of the GNU General Public License as published by
	10	;;; the Free Software Foundation; either version 3 of the License, or (at
	11	;;; your option) any later version.
	12	;;;
	13	;;; GNU Guix is distributed in the hope that it will be useful, but
	14	;;; WITHOUT ANY WARRANTY; without even the implied warranty of
	15	;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	;;; GNU General Public License for more details.
	17	;;;
	18	;;; You should have received a copy of the GNU General Public License
	19	;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
	20
	21	(define-module (gnu system mapped-devices)
374f14c2	22	#:use-module (guix gexp)
060d62a7	23	#:use-module (guix records)
d2a1cf45	24	#:use-module ((guix modules) #:hide (file-name->module-name))
42ff7d3b LC	25	#:use-module (guix i18n)
	26	#:use-module ((guix utils)
	27	#:select (source-properties->location
8ab10c19	28	&fix-hint
42ff7d3b	29	&error-location))
1ea507bc LC	30	#:use-module (gnu services)
1ea507bc LC	31	#:use-module (gnu services shepherd)
9b336338	32	#:use-module (gnu system uuid)
42ff7d3b	33	#:autoload (gnu build file-systems) (find-partition-by-luks-uuid)
8ab10c19	34	#:autoload (gnu build linux-modules)
411959be	35	(device-module-aliases matching-modules known-module-aliases
d2a1cf45	36	normalize-module-name file-name->module-name)
b7d408ec	37	#:autoload (gnu packages cryptsetup) (cryptsetup-static)
4ed2f515	38	#:autoload (gnu packages linux) (mdadm-static)
ffba7d49	39	#:use-module (srfi srfi-1)
424cea80	40	#:use-module (srfi srfi-26)
42ff7d3b LC	41	#:use-module (srfi srfi-34)
42ff7d3b LC	42	#:use-module (srfi srfi-35)
1ea507bc	43	#:use-module (ice-9 match)
060d62a7 LC	44	#:export (mapped-device
	45	mapped-device?
	46	mapped-device-source
	47	mapped-device-target
	48	mapped-device-type
4ca90ff5	49	mapped-device-location
060d62a7 LC	50
	51	mapped-device-kind
	52	mapped-device-kind?
	53	mapped-device-kind-open
374f14c2	54	mapped-device-kind-close
4ca90ff5	55	mapped-device-kind-check
374f14c2	56
1ea507bc LC	57	device-mapping-service-type
	58	device-mapping-service
	59
8ab10c19 LC	60	check-device-initrd-modules ;XXX: needs a better place
8ab10c19 LC	61
97c8aef1 AE	62	luks-device-mapping
97c8aef1 AE	63	raid-device-mapping))
060d62a7 LC	64
	65	;;; Commentary:
	66	;;;
	67	;;; This module supports "device mapping", a concept implemented by Linux's
	68	;;; device-mapper.
	69	;;;
	70	;;; Code:
	71
	72	(define-record-type* <mapped-device> mapped-device
	73	make-mapped-device
	74	mapped-device?
d6d1cea6	75	(source mapped-device-source) ;string \| list of strings
060d62a7	76	(target mapped-device-target) ;string
4ca90ff5 LC	77	(type mapped-device-type) ;<mapped-device-kind>
	78	(location mapped-device-location
	79	(default (current-source-location)) (innate)))
060d62a7 LC	80
	81	(define-record-type* <mapped-device-type> mapped-device-kind
	82	make-mapped-device-kind
	83	mapped-device-kind?
	84	(open mapped-device-kind-open) ;source target -> gexp
	85	(close mapped-device-kind-close ;source target -> gexp
4ca90ff5 LC	86	(default (const #~(const #f))))
	87	(check mapped-device-kind-check ;source -> Boolean
	88	(default (const #t))))
060d62a7	89
374f14c2	90	\f
1ea507bc LC	91	;;;
	92	;;; Device mapping as a Shepherd service.
	93	;;;
	94
	95	(define device-mapping-service-type
	96	(shepherd-service-type
	97	'device-mapping
	98	(match-lambda
4da8c19e LC	99	(($ <mapped-device> source target
4da8c19e LC	100	($ <mapped-device-type> open close))
1ea507bc LC	101	(shepherd-service
	102	(provision (list (symbol-append 'device-mapping- (string->symbol target))))
	103	(requirement '(udev))
	104	(documentation "Map a device node using Linux's device mapper.")
4da8c19e LC	105	(start #~(lambda () #$(open source target)))
4da8c19e LC	106	(stop #~(lambda _ (not #$(close source target))))
dfe06f6e	107	(respawn? #f))))))
1ea507bc	108
4da8c19e LC	109	(define (device-mapping-service mapped-device)
	110	"Return a service that sets up @var{mapped-device}."
	111	(service device-mapping-service-type mapped-device))
1ea507bc LC	112
1ea507bc LC	113	\f
8ab10c19 LC	114	;;;
	115	;;; Static checks.
	116	;;;
	117
	118	(define (check-device-initrd-modules device linux-modules location)
	119	"Raise an error if DEVICE needs modules beyond LINUX-MODULES to operate.
	120	DEVICE must be a \"/dev\" file name."
	121	(define aliases
	122	;; Attempt to load 'modules.alias' from the current kernel, assuming we're
	123	;; on GuixSD, and assuming that corresponds to the kernel we'll be
	124	;; installing. Skip the whole thing if that file cannot be read.
	125	(catch 'system-error
	126	(lambda ()
	127	(known-module-aliases))
	128	(const #f)))
	129
	130	(when aliases
99b78ba4 LC	131	(let* ((modules (delete-duplicates
	132	(append-map (cut matching-modules <> aliases)
	133	(device-module-aliases device))))
	134
	135	;; Module names (not file names) are supposed to use underscores
	136	;; instead of hyphens. MODULES is a list of module names, whereas
	137	;; LINUX-MODULES is file names without '.ko', so normalize them.
	138	(provided (map file-name->module-name linux-modules))
	139	(missing (remove (cut member <> provided) modules)))
	140	(unless (null? missing)
fcd068e9 LC	141	;; Note: What we suggest here is a list of module names (e.g.,
	142	;; "usb_storage"), not file names (e.g., "usb-storage.ko"). This is
	143	;; OK because we have machinery that accepts both the hyphen and the
	144	;; underscore version.
8ab10c19 LC	145	(raise (condition
	146	(&message
	147	(message (format #f (G_ "you may need these modules \
	148	in the initrd for ~a:~{ ~a~}")
99b78ba4	149	device missing)))
8ab10c19 LC	150	(&fix-hint
	151	(hint (format #f (G_ "Try adding them to the
	152	@code{initrd-modules} field of your @code{operating-system} declaration, along
	153	these lines:
	154
	155	@example
	156	(operating-system
	157	;; @dots{}
	158	(initrd-modules (append (list~{ ~s~})
	159	%base-initrd-modules)))
88600acc LC	160	@end example
	161
	162	If you think this diagnostic is inaccurate, use the @option{--skip-checks}
	163	option of @command{guix system}.\n")
99b78ba4	164	missing)))
8ab10c19 LC	165	(&error-location
	166	(location (source-properties->location location)))))))))
	167
	168	\f
374f14c2 LC	169	;;;
	170	;;; Common device mappings.
	171	;;;
	172
	173	(define (open-luks-device source target)
	174	"Return a gexp that maps SOURCE to TARGET as a LUKS device, using
	175	'cryptsetup'."
239c6e27 LC	176	(with-imported-modules (source-module-closure
239c6e27 LC	177	'((gnu build file-systems)))
9b336338 LC	178	#~(let ((source #$(if (uuid? source)
	179	(uuid-bytevector source)
	180	source)))
dfe06f6e LC	181	;; XXX: 'use-modules' should be at the top level.
	182	(use-modules (rnrs bytevectors) ;bytevector?
	183	((gnu build file-systems)
	184	#:select (find-partition-by-luks-uuid)))
	185
b7d408ec LC	186	;; Use 'cryptsetup-static', not 'cryptsetup', to avoid pulling the
	187	;; whole world inside the initrd (for when we're in an initrd).
	188	(zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
a91c3fc7 LC	189	"open" "--type" "luks"
	190
	191	;; Note: We cannot use the "UUID=source" syntax here
	192	;; because 'cryptsetup' implements it by searching the
	193	;; udev-populated /dev/disk/by-id directory but udev may
	194	;; be unavailable at the time we run this.
	195	(if (bytevector? source)
f45878a8 MW	196	(or (let loop ((tries-left 10))
	197	(and (positive? tries-left)
	198	(or (find-partition-by-luks-uuid source)
	199	;; If the underlying partition is
	200	;; not found, try again after
	201	;; waiting a second, up to ten
	202	;; times. FIXME: This should be
	203	;; dealt with in a more robust way.
	204	(begin (sleep 1)
	205	(loop (- tries-left 1))))))
a91c3fc7 LC	206	(error "LUKS partition not found" source))
	207	source)
	208
	209	#$target)))))
374f14c2 LC	210
	211	(define (close-luks-device source target)
	212	"Return a gexp that closes TARGET, a LUKS device."
b7d408ec	213	#~(zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
374f14c2 LC	214	"close" #$target)))
374f14c2 LC	215
424cea80 LC	216	(define* (check-luks-device md #:key
	217	needed-for-boot?
	218	(initrd-modules '())
	219	#:allow-other-keys
	220	#:rest rest)
42ff7d3b	221	"Ensure the source of MD is valid."
424cea80 LC	222	(let ((source (mapped-device-source md))
	223	(location (mapped-device-location md)))
	224	(or (not (zero? (getuid)))
	225	(if (uuid? source)
	226	(match (find-partition-by-luks-uuid (uuid-bytevector source))
	227	(#f
	228	(raise (condition
	229	(&message
	230	(message (format #f (G_ "no LUKS partition with UUID '~a'")
	231	(uuid->string source))))
	232	(&error-location
	233	(location (source-properties->location
	234	(mapped-device-location md)))))))
	235	((? string? device)
	236	(check-device-initrd-modules device initrd-modules location)))
	237	(check-device-initrd-modules source initrd-modules location)))))
42ff7d3b	238
374f14c2 LC	239	(define luks-device-mapping
	240	;; The type of LUKS mapped devices.
	241	(mapped-device-kind
	242	(open open-luks-device)
42ff7d3b LC	243	(close close-luks-device)
42ff7d3b LC	244	(check check-luks-device)))
374f14c2	245
7f8ad82b LC	246	(define (open-raid-device sources target)
	247	"Return a gexp that assembles SOURCES (a list of devices) to the RAID device
	248	TARGET (e.g., \"/dev/md0\"), using 'mdadm'."
10618627 LC	249	#~(let ((sources '#$sources)
	250
	251	;; XXX: We're not at the top level here. We could use a
	252	;; non-top-level 'use-modules' form but that doesn't work when the
	253	;; code is eval'd, like the Shepherd does.
	254	(every (@ (srfi srfi-1) every))
	255	(format (@ (ice-9 format) format)))
	256	(let loop ((attempts 0))
	257	(unless (every file-exists? sources)
	258	(when (> attempts 20)
	259	(error "RAID devices did not show up; bailing out"
	260	sources))
	261
	262	(format #t "waiting for RAID source devices~{ ~a~}...~%"
	263	sources)
	264	(sleep 1)
	265	(loop (+ 1 attempts))))
	266
4ed2f515 LC	267	;; Use 'mdadm-static' rather than 'mdadm' to avoid pulling its whole
	268	;; closure (80 MiB) in the initrd when a RAID device is needed for boot.
	269	(zero? (apply system* #$(file-append mdadm-static "/sbin/mdadm")
6e52376d	270	"--assemble" #$target sources))))
7f8ad82b LC	271
7f8ad82b LC	272	(define (close-raid-device sources target)
97c8aef1	273	"Return a gexp that stops the RAID device TARGET."
4ed2f515	274	#~(zero? (system* #$(file-append mdadm-static "/sbin/mdadm")
97c8aef1 AE	275	"--stop" #$target)))
	276
	277	(define raid-device-mapping
	278	;; The type of RAID mapped devices.
	279	(mapped-device-kind
	280	(open open-raid-device)
	281	(close close-raid-device)))
	282
060d62a7	283	;;; mapped-devices.scm ends here