all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
blob 296066e68f043672ce2e7d49349695d19ca7b15e 6039 bytes (raw)
name: gnu/tests/linux-modules.scm 	 # note: path name is non-authoritative(*)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2019 Jakob L. Kreuze <zerodaysfordays@sdf.org>
;;; Copyright © 2020 Danny Milosavljevic <dannym@scratchpost.org>
;;; Copyright © 2020 Brice Waegeneire <brice@waegenei.re>
;;;
;;; 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 tests linux-modules)
  #:use-module (gnu packages linux)
  #:use-module (gnu services)
  #:use-module (gnu services linux)
  #:use-module (gnu system)
  #:use-module (gnu system vm)
  #:use-module (gnu tests)
  #:use-module (guix derivations)
  #:use-module (guix gexp)
  #:use-module (guix modules)
  #:use-module (guix packages)
  #:use-module (guix monads)
  #:use-module (guix store)
  #:use-module (guix utils)
  #:use-module (srfi srfi-1)
  #:export (%test-loadable-kernel-modules-0
            %test-loadable-kernel-modules-1
            %test-loadable-kernel-modules-2))

;;; Commentary:
;;;
;;; Test <operating-system> kernel-loadable-modules.
;;;
;;; Code:

(define* (modules-loaded?-program os modules)
  "Return an executable store item that, upon being evaluated, will verify
that MODULES are actually loaded."
  (program-file
   "verify-kernel-modules-loaded.scm"
   #~(begin
     (use-modules (ice-9 rdelim)
                  (ice-9 popen)
                  (srfi srfi-1)
                  (srfi srfi-13))
     (let* ((port (open-input-pipe (string-append #$kmod "/bin/lsmod")))
            (lines (string-split (read-string port) #\newline))
            (separators (char-set #\space #\tab))
            (modules (map (lambda (line)
                            (string-take line
                                         (or (string-index line separators)
                                             0)))
                          lines))
            (status (close-pipe port)))
       (and (= status 0)
            (and-map (lambda (module)
                       (member module modules string=?))
                     '#$modules))))))

(define* (run-loadable-kernel-modules-test modules)
  "Run a test of an OS having MODULES and verify that they are loaded in
memory."
  (define os
    (marionette-operating-system
     (operating-system
       (inherit (simple-operating-system))
       (services (cons* (service kernel-module-loader-service-type)
                        (service kernel-module-configuration-service-type
                                 modules)
                        (operating-system-user-services
                         (simple-operating-system)))))
     #:imported-modules '((guix combinators))))
  (define vm (virtual-machine os))
  (define (test script)
    (with-imported-modules '((gnu build marionette))
      #~(begin
          (use-modules (gnu build marionette)
                       (srfi srfi-64))
          (define marionette
            (make-marionette (list #$vm)))
          (mkdir #$output)
          (chdir #$output)
          (test-begin "loadable-kernel-modules")
          (test-assert "script successfully evaluated"
            (marionette-eval
             '(primitive-load #$script)
             marionette))
          (test-end)
          (exit (= (test-runner-fail-count (test-runner-current)) 0)))))
  (let ((modules (filter-map (lambda (module)
                               (if (kernel-module-load? module)
                                   (kernel-module-name module)
                                   #f))
                      modules)))
    (gexp->derivation "loadable-kernel-modules"
                      (test (modules-loaded?-program os modules)))))

(define %test-loadable-kernel-modules-0
  (system-test
   (name "loadable-kernel-modules-0")
   (description "Tests loadable kernel modules facility of <operating-system>
with no extra modules.")
   (value (run-loadable-kernel-modules-test '()))))

(define %test-loadable-kernel-modules-1
  (system-test
   (name "loadable-kernel-modules-1")
   (description "Tests loadable kernel modules facility of <operating-system>
with one extra module.")
   (value (run-loadable-kernel-modules-test
           (list (kernel-module
                  (name "ddcci")
                  (package ddcci-driver-linux)
                  (options '("delay=606"))
                  (load? #t)))))))

(define %test-loadable-kernel-modules-2
  (system-test
   (name "loadable-kernel-modules-2")
   (description "Tests loadable kernel modules facility of <operating-system>
with two extra modules.")
   (value (run-loadable-kernel-modules-test
           (list (kernel-module
                  (name "ddcci")
                  ;; XXX Verify that kernel modules are built with the correct
                  ;; kernel
                  (package (package
                             (inherit ddcci-driver-linux)
                             (arguments
                              `(#:linux #f
                                ,@(strip-keyword-arguments '(#:linux)
                                                           (package-arguments
                                                            ddcci-driver-linux))))))
                  (load? #t))
                 (kernel-module
                  (name "acpi_call")
                  (package acpi-call-linux-module)
                  (load? #t))
                 ;; TODO Test that a module isn't loaded
                 (kernel-module
                  (name "radeon")
                  (blacklist? #t)))))))

debug log:

solving 296066e68f ...
found 296066e68f in https://yhetil.org/guix/20200704185431.13739-7-brice@waegenei.re/
found 22e9a0c65c in https://yhetil.org/guix/20200704185431.13739-3-brice@waegenei.re/
found 953b132ef7 in https://git.savannah.gnu.org/cgit/guix.git
preparing index
index prepared:
100644 953b132ef7be4fba1c818a8231e904df4f8b924d	gnu/tests/linux-modules.scm

applying [1/2] https://yhetil.org/guix/20200704185431.13739-3-brice@waegenei.re/
diff --git a/gnu/tests/linux-modules.scm b/gnu/tests/linux-modules.scm
index 953b132ef7..22e9a0c65c 100644


applying [2/2] https://yhetil.org/guix/20200704185431.13739-7-brice@waegenei.re/
diff --git a/gnu/tests/linux-modules.scm b/gnu/tests/linux-modules.scm
index 22e9a0c65c..296066e68f 100644

Checking patch gnu/tests/linux-modules.scm...
Applied patch gnu/tests/linux-modules.scm cleanly.
Checking patch gnu/tests/linux-modules.scm...
Applied patch gnu/tests/linux-modules.scm cleanly.

index at:
100644 296066e68f043672ce2e7d49349695d19ca7b15e	gnu/tests/linux-modules.scm

(*) Git path names are given by the tree(s) the blob belongs to.
    Blobs themselves have no identifier aside from the hash of its contents.^

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.