testsuite/test-modprobe.c

   1 /*
   2  * Copyright (C) 2012-2013  ProFUSION embedded systems
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <errno.h>
  19 #include <inttypes.h>
  20 #include <stddef.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #include "testsuite.h"
  27
  28 static noreturn int modprobe_show_depends(const struct test *t)
  29 {
  30         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
  31         const char *const args[] = {
  32                 progname,
  33                 "--show-depends", "mod-loop-a",
  34                 NULL,
  35         };
  36
  37         test_spawn_prog(progname, args);
  38         exit(EXIT_FAILURE);
  39 }
  40 DEFINE_TEST(modprobe_show_depends,
  41         .description = "check if output for modprobe --show-depends is correct for loaded modules",
  42         .config = {
  43                 [TC_UNAME_R] = "4.4.4",
  44                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/show-depends",
  45         },
  46         .output = {
  47                 .out = TESTSUITE_ROOTFS "test-modprobe/show-depends/correct.txt",
  48         });
  49
  50 static noreturn int modprobe_show_depends2(const struct test *t)
  51 {
  52         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
  53         const char *const args[] = {
  54                 progname,
  55                 "--show-depends", "mod-simple",
  56                 NULL,
  57         };
  58
  59         test_spawn_prog(progname, args);
  60         exit(EXIT_FAILURE);
  61 }
  62 DEFINE_TEST(modprobe_show_depends2,
  63         .description = "check if output for modprobe --show-depends is correct",
  64         .config = {
  65                 [TC_UNAME_R] = "4.4.4",
  66                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/show-depends",
  67         },
  68         .output = {
  69                 .out = TESTSUITE_ROOTFS "test-modprobe/show-depends/correct-mod-simple.txt",
  70         });
  71
  72
  73 static noreturn int modprobe_show_alias_to_none(const struct test *t)
  74 {
  75         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
  76         const char *const args[] = {
  77                 progname,
  78                 "--show-depends", "--ignore-install", "--quiet", "mod-simple",
  79                 NULL,
  80         };
  81
  82         test_spawn_prog(progname, args);
  83         exit(EXIT_FAILURE);
  84 }
  85 DEFINE_TEST(modprobe_show_alias_to_none,
  86         .description = "check if modprobe --show-depends doesn't explode with an alias to nothing",
  87         .config = {
  88                 [TC_UNAME_R] = "4.4.4",
  89                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/alias-to-none",
  90         },
  91         .output = {
  92                 .out = TESTSUITE_ROOTFS "test-modprobe/alias-to-none/correct.txt",
  93         },
  94         .modules_loaded = "",
  95         );
  96
  97
  98 static noreturn int modprobe_builtin(const struct test *t)
  99 {
 100         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 101         const char *const args[] = {
 102                 progname,
 103                 "unix",
 104                 NULL,
 105         };
 106
 107         test_spawn_prog(progname, args);
 108         exit(EXIT_FAILURE);
 109 }
 110 DEFINE_TEST(modprobe_builtin,
 111         .description = "check if modprobe return 0 for builtin",
 112         .config = {
 113                 [TC_UNAME_R] = "4.4.4",
 114                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/builtin",
 115         });
 116
 117 static noreturn int modprobe_builtin_lookup_only(const struct test *t)
 118 {
 119         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 120         const char *const args[] = {
 121                 progname,
 122                 "-R", "unix",
 123                 NULL,
 124         };
 125
 126         test_spawn_prog(progname, args);
 127         exit(EXIT_FAILURE);
 128 }
 129 DEFINE_TEST(modprobe_builtin_lookup_only,
 130         .description = "check if modprobe -R correctly returns the builtin module",
 131         .config = {
 132                 [TC_UNAME_R] = "4.4.4",
 133                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/builtin",
 134         },
 135         .output = {
 136                 .out = TESTSUITE_ROOTFS "test-modprobe/builtin/correct.txt",
 137         });
 138
 139 static noreturn int modprobe_softdep_loop(const struct test *t)
 140 {
 141         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 142         const char *const args[] = {
 143                 progname,
 144                 "mod-loop-b",
 145                 NULL,
 146         };
 147
 148         test_spawn_prog(progname, args);
 149         exit(EXIT_FAILURE);
 150 }
 151 DEFINE_TEST(modprobe_softdep_loop,
 152         .description = "check if modprobe breaks softdep loop",
 153         .config = {
 154                 [TC_UNAME_R] = "4.4.4",
 155                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/softdep-loop",
 156                 [TC_INIT_MODULE_RETCODES] = "",
 157         },
 158         .modules_loaded = "mod-loop-a,mod-loop-b",
 159         );
 160
 161 static noreturn int modprobe_install_cmd_loop(const struct test *t)
 162 {
 163         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 164         const char *const args[] = {
 165                 progname,
 166                 "mod-loop-a",
 167                 NULL,
 168         };
 169
 170         test_spawn_prog(progname, args);
 171         exit(EXIT_FAILURE);
 172 }
 173 DEFINE_TEST(modprobe_install_cmd_loop,
 174         .description = "check if modprobe breaks install-commands loop",
 175         .config = {
 176                 [TC_UNAME_R] = "4.4.4",
 177                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/install-cmd-loop",
 178                 [TC_INIT_MODULE_RETCODES] = "",
 179         },
 180         .env_vars = (const struct keyval[]) {
 181                 { "MODPROBE", ABS_TOP_BUILDDIR "/tools/modprobe" },
 182                 { }
 183                 },
 184         .modules_loaded = "mod-loop-b,mod-loop-a",
 185         );
 186
 187 static noreturn int modprobe_param_kcmdline(const struct test *t)
 188 {
 189         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 190         const char *const args[] = {
 191                 progname,
 192                 "--show-depends", "mod-simple",
 193                 NULL,
 194         };
 195
 196         test_spawn_prog(progname, args);
 197         exit(EXIT_FAILURE);
 198 }
 199 DEFINE_TEST(modprobe_param_kcmdline,
 200         .description = "check if params from kcmdline are passed in fact passed to (f)init_module call",
 201         .config = {
 202                 [TC_UNAME_R] = "4.4.4",
 203                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline",
 204         },
 205         .output = {
 206                 .out = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline/correct.txt",
 207         },
 208         .modules_loaded = "",
 209         );
 210
 211 static noreturn int modprobe_param_kcmdline2(const struct test *t)
 212 {
 213         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 214         const char *const args[] = {
 215                 progname,
 216                 "-c",
 217                 NULL,
 218         };
 219
 220         test_spawn_prog(progname, args);
 221         exit(EXIT_FAILURE);
 222 }
 223 DEFINE_TEST(modprobe_param_kcmdline2,
 224         .description = "check if params with no value are parsed correctly from kcmdline",
 225         .config = {
 226                 [TC_UNAME_R] = "4.4.4",
 227                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline2",
 228         },
 229         .output = {
 230                 .out = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline2/correct.txt",
 231         },
 232         .modules_loaded = "",
 233         );
 234
 235 static noreturn int modprobe_param_kcmdline3(const struct test *t)
 236 {
 237         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 238         const char *const args[] = {
 239                 progname,
 240                 "-c",
 241                 NULL,
 242         };
 243
 244         test_spawn_prog(progname, args);
 245         exit(EXIT_FAILURE);
 246 }
 247 DEFINE_TEST(modprobe_param_kcmdline3,
 248         .description = "check if unrelated strings in kcmdline are correctly ignored",
 249         .config = {
 250                 [TC_UNAME_R] = "4.4.4",
 251                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline3",
 252         },
 253         .output = {
 254                 .out = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline3/correct.txt",
 255         },
 256         .modules_loaded = "",
 257         );
 258
 259 static noreturn int modprobe_param_kcmdline4(const struct test *t)
 260 {
 261         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 262         const char *const args[] = {
 263                 progname,
 264                 "-c",
 265                 NULL,
 266         };
 267
 268         test_spawn_prog(progname, args);
 269         exit(EXIT_FAILURE);
 270 }
 271 DEFINE_TEST(modprobe_param_kcmdline4,
 272         .description = "check if unrelated strings in kcmdline are correctly ignored",
 273         .config = {
 274                 [TC_UNAME_R] = "4.4.4",
 275                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline4",
 276         },
 277         .output = {
 278                 .out = TESTSUITE_ROOTFS "test-modprobe/module-param-kcmdline4/correct.txt",
 279         },
 280         .modules_loaded = "",
 281         );
 282
 283 static noreturn int modprobe_force(const struct test *t)
 284 {
 285         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 286         const char *const args[] = {
 287                 progname,
 288                 "--force", "mod-simple",
 289                 NULL,
 290         };
 291
 292         test_spawn_prog(progname, args);
 293         exit(EXIT_FAILURE);
 294 }
 295 DEFINE_TEST(modprobe_force,
 296         .description = "check modprobe --force",
 297         .config = {
 298                 [TC_UNAME_R] = "4.4.4",
 299                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/force",
 300                 [TC_INIT_MODULE_RETCODES] = "",
 301         },
 302         .modules_loaded = "mod-simple",
 303         );
 304
 305 static noreturn int modprobe_oldkernel(const struct test *t)
 306 {
 307         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 308         const char *const args[] = {
 309                 progname,
 310                 "mod-simple",
 311                 NULL,
 312         };
 313
 314         test_spawn_prog(progname, args);
 315         exit(EXIT_FAILURE);
 316 }
 317 DEFINE_TEST(modprobe_oldkernel,
 318         .description = "check modprobe with kernel without finit_module()",
 319         .config = {
 320                 [TC_UNAME_R] = "3.3.3",
 321                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/oldkernel",
 322                 [TC_INIT_MODULE_RETCODES] = "",
 323         },
 324         .modules_loaded = "mod-simple",
 325         );
 326
 327 static noreturn int modprobe_oldkernel_force(const struct test *t)
 328 {
 329         const char *progname = ABS_TOP_BUILDDIR "/tools/modprobe";
 330         const char *const args[] = {
 331                 progname,
 332                 "--force", "mod-simple",
 333                 NULL,
 334         };
 335
 336         test_spawn_prog(progname, args);
 337         exit(EXIT_FAILURE);
 338 }
 339 DEFINE_TEST(modprobe_oldkernel_force,
 340         .description = "check modprobe --force with kernel without finit_module()",
 341         .config = {
 342                 [TC_UNAME_R] = "3.3.3",
 343                 [TC_ROOTFS] = TESTSUITE_ROOTFS "test-modprobe/oldkernel-force",
 344                 [TC_INIT_MODULE_RETCODES] = "",
 345         },
 346         .modules_loaded = "mod-simple",
 347         );
 348
 349 TESTSUITE_MAIN();