nixo
/
guix-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

linux-initrd: Rewrite using gexps. 

* gnu/system/linux-initrd.scm (expression->initrd): Rename 'inputs'
  parameter to 'to-copy'.  Remove 'files-to-copy'.  Rewrite 'builder' as
  a gexp, and use 'gexp->derivation'.
  (qemu-initrd): Adjust accordingly.
This commit is contained in:
Ludovic Courtès 2014-04-27 23:06:15 +02:00
parent 8c35bfb68c
commit 0c21d92b1c
1 changed files with 137 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

298
gnu/system/linux-initrd.scm
View File

@ -18,6 +18,7 @@
(define-module (gnu system linux-initrd) (define-module (gnu system linux-initrd)
#:use-module (guix monads) #:use-module (guix monads)
#:use-module (guix gexp)
#:use-module (guix utils) #:use-module (guix utils)
#:use-module ((guix store) #:use-module ((guix store)
#:select (%store-prefix)) #:select (%store-prefix))
@ -52,14 +53,14 @@
(name "guile-initrd") (name "guile-initrd")
(system (%current-system)) (system (%current-system))
(modules '()) (modules '())
(inputs '()) (to-copy '())
(linux #f) (linux #f)
(linux-modules '())) (linux-modules '()))
"Return a package that contains a Linux initrd (a gzipped cpio archive) "Return a package that contains a Linux initrd (a gzipped cpio archive)
containing GUILE and that evaluates EXP upon booting. LINUX-MODULES is a list containing GUILE and that evaluates EXP upon booting. LINUX-MODULES is a list
of `.ko' file names to be copied from LINUX into the initrd. INPUTS is a list of `.ko' file names to be copied from LINUX into the initrd. TO-COPY is a
of additional inputs to be copied in the initrd. MODULES is a list of Guile list of additional derivations or packages to copy to the initrd. MODULES is
module names to be embedded in the initrd." a list of Guile module names to be embedded in the initrd."
;; General Linux overview in `Documentation/early-userspace/README' and ;; General Linux overview in `Documentation/early-userspace/README' and
;; `Documentation/filesystems/ramfs-rootfs-initramfs.txt'. ;; `Documentation/filesystems/ramfs-rootfs-initramfs.txt'.
@ -68,154 +69,129 @@ module names to be embedded in the initrd."
;; Return a regexp that matches STR exactly. ;; Return a regexp that matches STR exactly.
(string-append "^" (regexp-quote str) "$")) (string-append "^" (regexp-quote str) "$"))
(define (files-to-copy) (mlet* %store-monad ((source (imported-modules modules))
(mlet %store-monad ((inputs (lower-inputs inputs))) (compiled (compiled-modules modules)))
(return (map (match-lambda (define builder
((_ drv) ;; TODO: Move most of this code to (guix build linux-initrd).
(derivation->output-path drv)) #~(begin
((_ drv sub-drv) (use-modules (guix build utils)
(derivation->output-path drv sub-drv))) (ice-9 pretty-print)
inputs)))) (ice-9 popen)
(ice-9 match)
(ice-9 ftw)
(srfi srfi-26)
(system base compile)
(rnrs bytevectors)
((system foreign) #:select (sizeof)))
(define (builder to-copy) (let ((cpio (string-append #$cpio "/bin/cpio"))
`(begin (gzip (string-append #$gzip "/bin/gzip"))
(use-modules (guix build utils) (modules #$source)
(ice-9 pretty-print) (gos #$compiled)
(ice-9 popen) (scm-dir (string-append "share/guile/" (effective-version)))
(ice-9 match) (go-dir (format #f ".cache/guile/ccache/~a-~a-~a-~a"
(ice-9 ftw) (effective-version)
(srfi srfi-26) (if (eq? (native-endianness) (endianness little))
(system base compile) "LE"
(rnrs bytevectors) "BE")
((system foreign) #:select (sizeof))) (sizeof '*)
(effective-version))))
(mkdir #$output)
(mkdir "contents")
(with-directory-excursion "contents"
(copy-recursively #$guile ".")
(call-with-output-file "init"
(lambda (p)
(format p "#!/bin/guile -ds~%!#~%" #$guile)
(pretty-print '#$exp p)))
(chmod "init" #o555)
(chmod "bin/guile" #o555)
(let ((guile (assoc-ref %build-inputs "guile")) ;; Copy Guile modules.
(cpio (string-append (assoc-ref %build-inputs "cpio") (chmod scm-dir #o777)
"/bin/cpio")) (copy-recursively modules scm-dir
(gzip (string-append (assoc-ref %build-inputs "gzip") #:follow-symlinks? #t)
"/bin/gzip")) (copy-recursively gos (string-append "lib/guile/"
(modules (assoc-ref %build-inputs "modules")) (effective-version) "/ccache")
(gos (assoc-ref %build-inputs "modules/compiled")) #:follow-symlinks? #t)
(scm-dir (string-append "share/guile/" (effective-version)))
(go-dir (format #f ".cache/guile/ccache/~a-~a-~a-~a"
(effective-version)
(if (eq? (native-endianness) (endianness little))
"LE"
"BE")
(sizeof '*)
(effective-version)))
(out (assoc-ref %outputs "out")))
(mkdir out)
(mkdir "contents")
(with-directory-excursion "contents"
(copy-recursively guile ".")
(call-with-output-file "init"
(lambda (p)
(format p "#!/bin/guile -ds~%!#~%" guile)
(pretty-print ',exp p)))
(chmod "init" #o555)
(chmod "bin/guile" #o555)
;; Copy Guile modules. ;; Compile `init'.
(chmod scm-dir #o777) (mkdir-p go-dir)
(copy-recursively modules scm-dir (set! %load-path (cons modules %load-path))
#:follow-symlinks? #t) (set! %load-compiled-path (cons gos %load-compiled-path))
(copy-recursively gos (string-append "lib/guile/" (compile-file "init"
(effective-version) "/ccache") #:opts %auto-compilation-options
#:follow-symlinks? #t) #:output-file (string-append go-dir "/init.go"))
;; Compile `init'. ;; Copy Linux modules.
(mkdir-p go-dir) (let* ((linux #$linux)
(set! %load-path (cons modules %load-path)) (module-dir (and linux
(set! %load-compiled-path (cons gos %load-compiled-path)) (string-append linux "/lib/modules"))))
(compile-file "init" (mkdir "modules")
#:opts %auto-compilation-options #$@(map (lambda (module)
#:output-file (string-append go-dir "/init.go")) #~(match (find-files module-dir
#$(string->regexp module))
((file)
(format #t "copying '~a'...~%" file)
(copy-file file (string-append "modules/"
#$module)))
(()
(error "module not found" #$module module-dir))
((_ ...)
(error "several modules by that name"
#$module module-dir))))
linux-modules))
;; Copy Linux modules. (let ((store #$(string-append "." (%store-prefix)))
(let* ((linux (assoc-ref %build-inputs "linux")) (to-copy '#$to-copy))
(module-dir (and linux (unless (null? to-copy)
(string-append linux "/lib/modules")))) (mkdir-p store))
(mkdir "modules") ;; XXX: Should we do export-references-graph?
,@(map (lambda (module) (for-each (lambda (input)
`(match (find-files module-dir (let ((target
,(string->regexp module)) (string-append store "/"
((file) (basename input))))
(format #t "copying '~a'...~%" file) (copy-recursively input target)))
(copy-file file (string-append "modules/" to-copy))
,module)))
(()
(error "module not found" ,module module-dir))
((_ ...)
(error "several modules by that name"
,module module-dir))))
linux-modules))
,@(if (null? to-copy) ;; Reset the timestamps of all the files that will make it in the
'() ;; initrd.
`((let ((store ,(string-append "." (%store-prefix)))) (for-each (cut utime <> 0 0 0 0)
(mkdir-p store) (find-files "." ".*"))
;; XXX: Should we do export-references-graph?
(for-each (lambda (input)
(let ((target
(string-append store "/"
(basename input))))
(copy-recursively input target)))
',to-copy))))
;; Reset the timestamps of all the files that will make it in the (system* cpio "--version")
;; initrd. (let ((pipe (open-pipe* OPEN_WRITE cpio "-o"
(for-each (cut utime <> 0 0 0 0) "-O" (string-append #$output "/initrd")
(find-files "." ".*")) "-H" "newc" "--null")))
(define print0
(let ((len (string-length "./")))
(lambda (file)
(format pipe "~a\0" (string-drop file len)))))
(system* cpio "--version") ;; Note: as per `ramfs-rootfs-initramfs.txt', always add
(let ((pipe (open-pipe* OPEN_WRITE cpio "-o" ;; directory entries before the files that are inside of it: "The
"-O" (string-append out "/initrd") ;; Linux kernel cpio extractor won't create files in a directory
"-H" "newc" "--null"))) ;; that doesn't exist, so the directory entries must go before
(define print0 ;; the files that go in those directories."
(let ((len (string-length "./"))) (file-system-fold (const #t)
(lambda (file) (lambda (file stat result) ; leaf
(format pipe "~a\0" (string-drop file len))))) (print0 file))
(lambda (dir stat result) ; down
(unless (string=? dir ".")
(print0 dir)))
(const #f) ; up
(const #f) ; skip
(const #f)
#f
".")
;; Note: as per `ramfs-rootfs-initramfs.txt', always add (and (zero? (close-pipe pipe))
;; directory entries before the files that are inside of it: "The (with-directory-excursion #$output
;; Linux kernel cpio extractor won't create files in a directory (and (zero? (system* gzip "--best" "initrd"))
;; that doesn't exist, so the directory entries must go before (rename-file "initrd.gz" "initrd")))))))))
;; the files that go in those directories."
(file-system-fold (const #t)
(lambda (file stat result) ; leaf
(print0 file))
(lambda (dir stat result) ; down
(unless (string=? dir ".")
(print0 dir)))
(const #f) ; up
(const #f) ; skip
(const #f)
#f
".")
(and (zero? (close-pipe pipe)) (gexp->derivation name builder
(with-directory-excursion out #:modules '((guix build utils)))))
(and (zero? (system* gzip "--best" "initrd"))
(rename-file "initrd.gz" "initrd")))))))))
(mlet* %store-monad
((source (imported-modules modules))
(compiled (compiled-modules modules))
(inputs (lower-inputs
`(("guile" ,guile)
("cpio" ,cpio)
("gzip" ,gzip)
("modules" ,source)
("modules/compiled" ,compiled)
,@(if linux
`(("linux" ,linux))
'())
,@inputs)))
(to-copy (files-to-copy)))
(derivation-expression name (builder to-copy)
#:modules '((guix build utils))
#:inputs inputs)))
(define* (qemu-initrd #:key (define* (qemu-initrd #:key
guile-modules-in-chroot? guile-modules-in-chroot?
@ -257,26 +233,26 @@ to it are lost."
'("fuse.ko") '("fuse.ko")
'()))) '())))
(mlet %store-monad (expression->initrd
((unionfs (package-file unionfs-fuse/static "bin/unionfs"))) #~(begin
(expression->initrd (use-modules (guix build linux-initrd)
`(begin (srfi srfi-26))
(use-modules (guix build linux-initrd))
(boot-system #:mounts ',mounts (boot-system #:mounts '#$mounts
#:linux-modules ',linux-modules #:linux-modules '#$linux-modules
#:qemu-guest-networking? #t #:qemu-guest-networking? #t
#:guile-modules-in-chroot? ',guile-modules-in-chroot? #:guile-modules-in-chroot? '#$guile-modules-in-chroot?
#:unionfs ,unionfs #:unionfs (and=> #$(and volatile-root? unionfs-fuse/static)
#:volatile-root? ',volatile-root?)) (cut string-append <> "/bin/unionfs"))
#:name "qemu-initrd" #:volatile-root? '#$volatile-root?))
#:modules '((guix build utils) #:name "qemu-initrd"
(guix build linux-initrd)) #:modules '((guix build utils)
#:linux linux-libre (guix build linux-initrd))
#:linux-modules linux-modules #:to-copy (if volatile-root?
#:inputs (if volatile-root? (list unionfs-fuse/static)
`(("unionfs" ,unionfs-fuse/static)) '())
'())))) #:linux linux-libre
#:linux-modules linux-modules))
(define (gnu-system-initrd) (define (gnu-system-initrd)
"Initrd for the GNU system itself, with nothing QEMU-specific." "Initrd for the GNU system itself, with nothing QEMU-specific."