gnu/system/mapped-devices.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2014, 2015, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
   3 ;;; Copyright © 2016 Andreas Enge <andreas@enge.fr>
   4 ;;; Copyright © 2017, 2018 Mark H Weaver <mhw@netris.org>
   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)
  22   #:use-module (guix gexp)
  23   #:use-module (guix records)
  24   #:use-module ((guix modules) #:hide (file-name->module-name))
  25   #:use-module (guix i18n)
  26   #:use-module ((guix utils)
  27                 #:select (source-properties->location
  28                           &fix-hint
  29                           &error-location))
  30   #:use-module (gnu services)
  31   #:use-module (gnu services shepherd)
  32   #:use-module (gnu system uuid)
  33   #:autoload   (gnu build file-systems) (find-partition-by-luks-uuid)
  34   #:autoload   (gnu build linux-modules)
  35                  (device-module-aliases matching-modules known-module-aliases
  36                   normalize-module-name file-name->module-name)
  37   #:autoload   (gnu packages cryptsetup) (cryptsetup-static)
  38   #:autoload   (gnu packages linux) (mdadm-static)
  39   #:use-module (srfi srfi-1)
  40   #:use-module (srfi srfi-26)
  41   #:use-module (srfi srfi-34)
  42   #:use-module (srfi srfi-35)
  43   #:use-module (ice-9 match)
  44   #:export (mapped-device
  45             mapped-device?
  46             mapped-device-source
  47             mapped-device-target
  48             mapped-device-type
  49             mapped-device-location
  50
  51             mapped-device-kind
  52             mapped-device-kind?
  53             mapped-device-kind-open
  54             mapped-device-kind-close
  55             mapped-device-kind-check
  56
  57             device-mapping-service-type
  58             device-mapping-service
  59
  60             check-device-initrd-modules           ;XXX: needs a better place
  61
  62             luks-device-mapping
  63             raid-device-mapping))
  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?
  75   (source    mapped-device-source)                ;string | list of strings
  76   (target    mapped-device-target)                ;string
  77   (type      mapped-device-type)                  ;<mapped-device-kind>
  78   (location  mapped-device-location
  79              (default (current-source-location)) (innate)))
  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
  86              (default (const #~(const #f))))
  87   (check     mapped-device-kind-check             ;source -> Boolean
  88              (default (const #t))))
  89
  90 \f
  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
  99      (($ <mapped-device> source target
 100                          ($ <mapped-device-type> open close))
 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.")
 105        (start #~(lambda () #$(open source target)))
 106        (stop #~(lambda _ (not #$(close source target))))
 107        (respawn? #f))))))
 108
 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))
 112
 113 \f
 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
 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)
 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.
 145         (raise (condition
 146                 (&message
 147                  (message (format #f (G_ "you may need these modules \
 148 in the initrd for ~a:~{ ~a~}")
 149                                   device missing)))
 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)))
 160 @end example\n")
 161                                missing)))
 162                 (&error-location
 163                  (location (source-properties->location location)))))))))
 164
 165 \f
 166 ;;;
 167 ;;; Common device mappings.
 168 ;;;
 169
 170 (define (open-luks-device source target)
 171   "Return a gexp that maps SOURCE to TARGET as a LUKS device, using
 172 'cryptsetup'."
 173   (with-imported-modules (source-module-closure
 174                           '((gnu build file-systems)))
 175     #~(let ((source #$(if (uuid? source)
 176                           (uuid-bytevector source)
 177                           source)))
 178         ;; XXX: 'use-modules' should be at the top level.
 179         (use-modules (rnrs bytevectors)           ;bytevector?
 180                      ((gnu build file-systems)
 181                       #:select (find-partition-by-luks-uuid)))
 182
 183         ;; Use 'cryptsetup-static', not 'cryptsetup', to avoid pulling the
 184         ;; whole world inside the initrd (for when we're in an initrd).
 185         (zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
 186                         "open" "--type" "luks"
 187
 188                         ;; Note: We cannot use the "UUID=source" syntax here
 189                         ;; because 'cryptsetup' implements it by searching the
 190                         ;; udev-populated /dev/disk/by-id directory but udev may
 191                         ;; be unavailable at the time we run this.
 192                         (if (bytevector? source)
 193                             (or (let loop ((tries-left 10))
 194                                   (and (positive? tries-left)
 195                                        (or (find-partition-by-luks-uuid source)
 196                                            ;; If the underlying partition is
 197                                            ;; not found, try again after
 198                                            ;; waiting a second, up to ten
 199                                            ;; times.  FIXME: This should be
 200                                            ;; dealt with in a more robust way.
 201                                            (begin (sleep 1)
 202                                                   (loop (- tries-left 1))))))
 203                                 (error "LUKS partition not found" source))
 204                             source)
 205
 206                         #$target)))))
 207
 208 (define (close-luks-device source target)
 209   "Return a gexp that closes TARGET, a LUKS device."
 210   #~(zero? (system* #$(file-append cryptsetup-static "/sbin/cryptsetup")
 211                     "close" #$target)))
 212
 213 (define* (check-luks-device md #:key
 214                             needed-for-boot?
 215                             (initrd-modules '())
 216                             #:allow-other-keys
 217                             #:rest rest)
 218   "Ensure the source of MD is valid."
 219   (let ((source   (mapped-device-source md))
 220         (location (mapped-device-location md)))
 221     (or (not (zero? (getuid)))
 222         (if (uuid? source)
 223             (match (find-partition-by-luks-uuid (uuid-bytevector source))
 224               (#f
 225                (raise (condition
 226                        (&message
 227                         (message (format #f (G_ "no LUKS partition with UUID '~a'")
 228                                          (uuid->string source))))
 229                        (&error-location
 230                         (location (source-properties->location
 231                                    (mapped-device-location md)))))))
 232               ((? string? device)
 233                (check-device-initrd-modules device initrd-modules location)))
 234             (check-device-initrd-modules source initrd-modules location)))))
 235
 236 (define luks-device-mapping
 237   ;; The type of LUKS mapped devices.
 238   (mapped-device-kind
 239    (open open-luks-device)
 240    (close close-luks-device)
 241    (check check-luks-device)))
 242
 243 (define (open-raid-device sources target)
 244   "Return a gexp that assembles SOURCES (a list of devices) to the RAID device
 245 TARGET (e.g., \"/dev/md0\"), using 'mdadm'."
 246   #~(let ((sources '#$sources)
 247
 248           ;; XXX: We're not at the top level here.  We could use a
 249           ;; non-top-level 'use-modules' form but that doesn't work when the
 250           ;; code is eval'd, like the Shepherd does.
 251           (every   (@ (srfi srfi-1) every))
 252           (format  (@ (ice-9 format) format)))
 253       (let loop ((attempts 0))
 254         (unless (every file-exists? sources)
 255           (when (> attempts 20)
 256             (error "RAID devices did not show up; bailing out"
 257                    sources))
 258
 259           (format #t "waiting for RAID source devices~{ ~a~}...~%"
 260                   sources)
 261           (sleep 1)
 262           (loop (+ 1 attempts))))
 263
 264       ;; Use 'mdadm-static' rather than 'mdadm' to avoid pulling its whole
 265       ;; closure (80 MiB) in the initrd when a RAID device is needed for boot.
 266       (zero? (apply system* #$(file-append mdadm-static "/sbin/mdadm")
 267                     "--assemble" #$target sources))))
 268
 269 (define (close-raid-device sources target)
 270   "Return a gexp that stops the RAID device TARGET."
 271   #~(zero? (system* #$(file-append mdadm-static "/sbin/mdadm")
 272                     "--stop" #$target)))
 273
 274 (define raid-device-mapping
 275   ;; The type of RAID mapped devices.
 276   (mapped-device-kind
 277    (open open-raid-device)
 278    (close close-raid-device)))
 279
 280 ;;; mapped-devices.scm ends here