src/bin/lttng-sessiond/modprobe.cpp

   1 /*
   2  * Copyright (C) 2011 David Goulet <dgoulet@efficios.com>
   3  * Copyright (C) 2014 Jan Glauber <jan.glauber@gmail.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 /**
  10  * @file modprobe.c
  11  *
  12  * @brief modprobe related functions.
  13  *
  14  */
  15
  16 #define _LGPL_SOURCE
  17 #include "kern-modules.hpp"
  18 #include "lttng-sessiond.hpp"
  19 #include "modprobe.hpp"
  20
  21 #include <common/common.hpp>
  22 #include <common/utils.hpp>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <sys/wait.h>
  27
  28 /* LTTng kernel tracer mandatory core modules list */
  29 struct kern_modules_param kern_modules_control_core[] = {
  30         {
  31                 .name = (char *) "lttng-ring-buffer-client-discard",
  32                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  33                 .loaded = false,
  34         },
  35         {
  36                 .name = (char *) "lttng-ring-buffer-client-overwrite",
  37                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  38                 .loaded = false,
  39         },
  40         {
  41                 .name = (char *) "lttng-ring-buffer-metadata-client",
  42                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  43                 .loaded = false,
  44         },
  45         {
  46                 .name = (char *) "lttng-ring-buffer-client-mmap-discard",
  47                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  48                 .loaded = false,
  49         },
  50         {
  51                 .name = (char *) "lttng-ring-buffer-client-mmap-overwrite",
  52                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  53                 .loaded = false,
  54         },
  55         {
  56                 .name = (char *) "lttng-ring-buffer-metadata-mmap-client",
  57                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED,
  58                 .loaded = false,
  59         },
  60         {
  61                 .name = (char *) "lttng-ring-buffer-event_notifier-client",
  62                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  63                 .loaded = false,
  64         },
  65         {
  66                 .name = (char *) "lttng-counter-client-percpu-64-modular",
  67                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  68                 .loaded = false,
  69         },
  70         {
  71                 .name = (char *) "lttng-counter-client-percpu-32-modular",
  72                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  73                 .loaded = false,
  74         },
  75 };
  76
  77 /* LTTng kerneltracer probe modules list */
  78 struct kern_modules_param kern_modules_probes_default[] = {
  79         {
  80                 .name = (char *) "lttng-probe-asoc",
  81                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  82                 .loaded = false,
  83         },
  84         {
  85                 .name = (char *) "lttng-probe-block",
  86                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  87                 .loaded = false,
  88         },
  89         {
  90                 .name = (char *) "lttng-probe-btrfs",
  91                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  92                 .loaded = false,
  93         },
  94         {
  95                 .name = (char *) "lttng-probe-compaction",
  96                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
  97                 .loaded = false,
  98         },
  99         {
 100                 .name = (char *) "lttng-probe-ext3",
 101                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 102                 .loaded = false,
 103         },
 104         {
 105                 .name = (char *) "lttng-probe-ext4",
 106                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 107                 .loaded = false,
 108         },
 109         {
 110                 .name = (char *) "lttng-probe-gpio",
 111                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 112                 .loaded = false,
 113         },
 114         {
 115                 .name = (char *) "lttng-probe-i2c",
 116                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 117                 .loaded = false,
 118         },
 119         {
 120                 .name = (char *) "lttng-probe-irq",
 121                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 122                 .loaded = false,
 123         },
 124         {
 125                 .name = (char *) "lttng-probe-jbd",
 126                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 127                 .loaded = false,
 128         },
 129         {
 130                 .name = (char *) "lttng-probe-jbd2",
 131                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 132                 .loaded = false,
 133         },
 134         {
 135                 .name = (char *) "lttng-probe-kmem",
 136                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 137                 .loaded = false,
 138         },
 139         {
 140                 .name = (char *) "lttng-probe-kvm",
 141                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 142                 .loaded = false,
 143         },
 144         {
 145                 .name = (char *) "lttng-probe-kvm-x86",
 146                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 147                 .loaded = false,
 148         },
 149         {
 150                 .name = (char *) "lttng-probe-kvm-x86-mmu",
 151                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 152                 .loaded = false,
 153         },
 154         {
 155                 .name = (char *) "lttng-probe-lock",
 156                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 157                 .loaded = false,
 158         },
 159         {
 160                 .name = (char *) "lttng-probe-module",
 161                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 162                 .loaded = false,
 163         },
 164         {
 165                 .name = (char *) "lttng-probe-napi",
 166                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 167                 .loaded = false,
 168         },
 169         {
 170                 .name = (char *) "lttng-probe-net",
 171                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 172                 .loaded = false,
 173         },
 174         {
 175                 .name = (char *) "lttng-probe-power",
 176                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 177                 .loaded = false,
 178         },
 179         {
 180                 .name = (char *) "lttng-probe-preemptirq",
 181                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 182                 .loaded = false,
 183         },
 184         {
 185                 .name = (char *) "lttng-probe-printk",
 186                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 187                 .loaded = false,
 188         },
 189         {
 190                 .name = (char *) "lttng-probe-random",
 191                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 192                 .loaded = false,
 193         },
 194         {
 195                 .name = (char *) "lttng-probe-rcu",
 196                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 197                 .loaded = false,
 198         },
 199         {
 200                 .name = (char *) "lttng-probe-regmap",
 201                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 202                 .loaded = false,
 203         },
 204         {
 205                 .name = (char *) "lttng-probe-regulator",
 206                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 207                 .loaded = false,
 208         },
 209         {
 210                 .name = (char *) "lttng-probe-rpm",
 211                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 212                 .loaded = false,
 213         },
 214         {
 215                 .name = (char *) "lttng-probe-sched",
 216                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 217                 .loaded = false,
 218         },
 219         {
 220                 .name = (char *) "lttng-probe-scsi",
 221                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 222                 .loaded = false,
 223         },
 224         {
 225                 .name = (char *) "lttng-probe-signal",
 226                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 227                 .loaded = false,
 228         },
 229         {
 230                 .name = (char *) "lttng-probe-skb",
 231                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 232                 .loaded = false,
 233         },
 234         {
 235                 .name = (char *) "lttng-probe-sock",
 236                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 237                 .loaded = false,
 238         },
 239         {
 240                 .name = (char *) "lttng-probe-statedump",
 241                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 242                 .loaded = false,
 243         },
 244         {
 245                 .name = (char *) "lttng-probe-sunrpc",
 246                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 247                 .loaded = false,
 248         },
 249         {
 250                 .name = (char *) "lttng-probe-timer",
 251                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 252                 .loaded = false,
 253         },
 254         {
 255                 .name = (char *) "lttng-probe-udp",
 256                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 257                 .loaded = false,
 258         },
 259         {
 260                 .name = (char *) "lttng-probe-vmscan",
 261                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 262                 .loaded = false,
 263         },
 264         {
 265                 .name = (char *) "lttng-probe-v4l2",
 266                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 267                 .loaded = false,
 268         },
 269         {
 270                 .name = (char *) "lttng-probe-workqueue",
 271                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 272                 .loaded = false,
 273         },
 274         {
 275                 .name = (char *) "lttng-probe-writeback",
 276                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 277                 .loaded = false,
 278         },
 279         {
 280                 .name = (char *) "lttng-probe-x86-irq-vectors",
 281                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 282                 .loaded = false,
 283         },
 284         {
 285                 .name = (char *) "lttng-probe-x86-exceptions",
 286                 .load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL,
 287                 .loaded = false,
 288         },
 289 };
 290
 291 /* dynamic probe modules list */
 292 static struct kern_modules_param *probes;
 293 static int nr_probes;
 294 static int probes_capacity;
 295
 296 #ifdef HAVE_KMOD
 297 #include <libkmod.h>
 298
 299 /**
 300  * @brief Logging function for libkmod integration.
 301  */
 302 static ATTR_FORMAT_PRINTF(6, 0) void log_kmod(void *data __attribute__((unused)),
 303                                               int priority __attribute__((unused)),
 304                                               const char *file __attribute__((unused)),
 305                                               int line __attribute__((unused)),
 306                                               const char *fn __attribute__((unused)),
 307                                               const char *format,
 308                                               va_list args)
 309 {
 310         char *str;
 311
 312         if (vasprintf(&str, format, args) < 0) {
 313                 return;
 314         }
 315
 316         DBG("libkmod: %s", str);
 317         free(str);
 318 }
 319
 320 /**
 321  * @brief Setup the libkmod context.
 322  *
 323  * Create the context, add a custom logging function and preload the
 324  * ressources for faster operation.
 325  *
 326  * @returns     \c 0 on success
 327  *              \c < 0 on error
 328  */
 329 static int setup_kmod_ctx(struct kmod_ctx **ctx)
 330 {
 331         int ret = 0;
 332
 333         *ctx = kmod_new(nullptr, nullptr);
 334         if (!ctx) {
 335                 PERROR("Unable to create kmod library context");
 336                 ret = -ENOMEM;
 337                 goto error;
 338         }
 339
 340         /*
 341          * Parameter 2 of kmod_set_log_fn generates a
 342          * -Wsuggest-attribute=formatkmod_set_log_fn warning that we can't fix,
 343          * ignore it.
 344          */
 345         DIAGNOSTIC_PUSH
 346         DIAGNOSTIC_IGNORE_SUGGEST_ATTRIBUTE_FORMAT
 347         kmod_set_log_fn(*ctx, log_kmod, nullptr);
 348         DIAGNOSTIC_POP
 349         ret = kmod_load_resources(*ctx);
 350         if (ret < 0) {
 351                 ERR("Failed to load kmod library resources");
 352                 goto error;
 353         }
 354
 355 error:
 356         return ret;
 357 }
 358
 359 /**
 360  * @brief Loads the kernel modules in \p modules
 361  *
 362  * @param modules       List of modules to load
 363  * @param entries       Number of modules in the list
 364  *
 365  * If the modules are required, we will return with error after the
 366  * first failed module load, otherwise we continue loading.
 367  *
 368  * @returns             \c 0 on success
 369  *                      \c < 0 on error
 370  */
 371 static int modprobe_lttng(struct kern_modules_param *modules, int entries)
 372 {
 373         int ret = 0, i;
 374         struct kmod_ctx *ctx;
 375
 376         ret = setup_kmod_ctx(&ctx);
 377         if (ret < 0) {
 378                 goto error;
 379         }
 380
 381         for (i = 0; i < entries; i++) {
 382                 struct kmod_module *mod = nullptr;
 383
 384                 ret = kmod_module_new_from_name(ctx, modules[i].name, &mod);
 385                 if (ret < 0) {
 386                         PERROR("Failed to create kmod module for %s", modules[i].name);
 387                         goto error;
 388                 }
 389
 390                 ret = kmod_module_probe_insert_module(mod, 0, nullptr, nullptr, nullptr, nullptr);
 391                 if (ret == -EEXIST) {
 392                         DBG("Module %s is already loaded", modules[i].name);
 393                         ret = 0;
 394                 } else if (ret < 0) {
 395                         if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
 396                                 PERROR("Unable to load required module `%s`", modules[i].name)
 397                                 goto error;
 398                         } else {
 399                                 PERROR("Unable to load optional module `%s`; continuing",
 400                                        modules[i].name);
 401                                 ret = 0;
 402                         }
 403                 } else {
 404                         DBG("Modprobe successfully %s", modules[i].name);
 405                         modules[i].loaded = true;
 406                 }
 407
 408                 kmod_module_unref(mod);
 409         }
 410
 411 error:
 412         if (ctx) {
 413                 kmod_unref(ctx);
 414         }
 415         return ret;
 416 }
 417
 418 /**
 419  * @brief Recursively unload modules.
 420  *
 421  * This function implements the same modules unloading behavior as
 422  * 'modprobe -r' or rmmod, it will recursevily go trought the \p module
 423  * dependencies and unload modules with a refcount of 0.
 424  *
 425  * @param mod           The module to unload
 426  *
 427  * @returns             \c 0 on success
 428  *                      \c < 0 on error
 429  */
 430 static int rmmod_recurse(struct kmod_module *mod)
 431 {
 432         int ret = 0;
 433         struct kmod_list *deps, *itr;
 434
 435         if (kmod_module_get_initstate(mod) == KMOD_MODULE_BUILTIN) {
 436                 DBG("Module %s is builtin", kmod_module_get_name(mod));
 437                 return ret;
 438         }
 439
 440         ret = kmod_module_remove_module(mod, 0);
 441
 442         deps = kmod_module_get_dependencies(mod);
 443         if (deps != nullptr) {
 444                 kmod_list_foreach(itr, deps)
 445                 {
 446                         struct kmod_module *dep = kmod_module_get_module(itr);
 447                         if (kmod_module_get_refcnt(dep) == 0) {
 448                                 DBG("Recursive remove module %s", kmod_module_get_name(dep));
 449                                 rmmod_recurse(dep);
 450                         }
 451                         kmod_module_unref(dep);
 452                 }
 453                 kmod_module_unref_list(deps);
 454         }
 455
 456         return ret;
 457 }
 458
 459 /**
 460  * @brief Unloads the kernel modules in \p modules
 461  *
 462  * @param modules       List of modules to unload
 463  * @param entries       Number of modules in the list
 464  *
 465  */
 466 static void modprobe_remove_lttng(const struct kern_modules_param *modules, int entries)
 467 {
 468         int ret = 0, i;
 469         struct kmod_ctx *ctx;
 470
 471         ret = setup_kmod_ctx(&ctx);
 472         if (ret < 0) {
 473                 goto error;
 474         }
 475
 476         for (i = entries - 1; i >= 0; i--) {
 477                 struct kmod_module *mod = nullptr;
 478
 479                 if (!modules[i].loaded) {
 480                         continue;
 481                 }
 482
 483                 ret = kmod_module_new_from_name(ctx, modules[i].name, &mod);
 484                 if (ret < 0) {
 485                         PERROR("Failed to create kmod module for %s", modules[i].name);
 486                         goto error;
 487                 }
 488
 489                 ret = rmmod_recurse(mod);
 490                 if (ret == -EEXIST) {
 491                         DBG("Module %s is not in kernel.", modules[i].name);
 492                 } else if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED &&
 493                            ret < 0) {
 494                         PERROR("Unable to remove module `%s`", modules[i].name);
 495                 } else {
 496                         DBG("Modprobe removal successful %s", modules[i].name);
 497                 }
 498
 499                 kmod_module_unref(mod);
 500         }
 501
 502 error:
 503         if (ctx) {
 504                 kmod_unref(ctx);
 505         }
 506 }
 507
 508 #else /* HAVE_KMOD */
 509
 510 static int modprobe_lttng(struct kern_modules_param *modules, int entries)
 511 {
 512         int ret = 0, i;
 513         char modprobe[256];
 514
 515         for (i = 0; i < entries; i++) {
 516                 ret = snprintf(modprobe,
 517                                sizeof(modprobe),
 518                                "/sbin/modprobe %s%s",
 519                                modules[i].load_policy ==
 520                                                KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED ?
 521                                        "" :
 522                                        "-q ",
 523                                modules[i].name);
 524                 if (ret < 0) {
 525                         PERROR("snprintf modprobe");
 526                         goto error;
 527                 }
 528                 modprobe[sizeof(modprobe) - 1] = '\0';
 529                 ret = system(modprobe);
 530                 if (ret == -1) {
 531                         if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
 532                                 ERR("Unable to launch modprobe for required module %s",
 533                                     modules[i].name);
 534                                 goto error;
 535                         } else {
 536                                 DBG("Unable to launch modprobe for optional module %s; continuing",
 537                                     modules[i].name);
 538                                 ret = 0;
 539                         }
 540                 } else if (WEXITSTATUS(ret) != 0) {
 541                         if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
 542                                 ERR("Unable to load required module %s", modules[i].name);
 543                                 /* Force negative return code */
 544                                 if (ret > 0) {
 545                                         ret = -ret;
 546                                 }
 547                                 goto error;
 548                         } else {
 549                                 DBG("Unable to load optional module %s; continuing",
 550                                     modules[i].name);
 551                                 ret = 0;
 552                         }
 553                 } else {
 554                         DBG("Modprobe successfully %s", modules[i].name);
 555                         modules[i].loaded = true;
 556                 }
 557         }
 558
 559 error:
 560         return ret;
 561 }
 562
 563 static void modprobe_remove_lttng(const struct kern_modules_param *modules, int entries)
 564 {
 565         int ret = 0, i;
 566         char modprobe[256];
 567
 568         for (i = entries - 1; i >= 0; i--) {
 569                 if (!modules[i].loaded) {
 570                         continue;
 571                 }
 572                 ret = snprintf(
 573                         modprobe, sizeof(modprobe), "/sbin/modprobe -r -q %s", modules[i].name);
 574                 if (ret < 0) {
 575                         PERROR("snprintf modprobe -r");
 576                         return;
 577                 }
 578                 modprobe[sizeof(modprobe) - 1] = '\0';
 579                 ret = system(modprobe);
 580                 if (ret == -1) {
 581                         if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
 582                                 ERR("Unable to launch modprobe -r for required module %s",
 583                                     modules[i].name);
 584                         } else {
 585                                 DBG("Unable to launch modprobe -r for optional module %s",
 586                                     modules[i].name);
 587                         }
 588                 } else if (WEXITSTATUS(ret) != 0) {
 589                         if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
 590                                 ERR("Unable to remove required module %s", modules[i].name);
 591                         } else {
 592                                 DBG("Unable to remove optional module %s", modules[i].name);
 593                         }
 594                 } else {
 595                         DBG("Modprobe removal successful %s", modules[i].name);
 596                 }
 597         }
 598 }
 599
 600 #endif /* HAVE_KMOD */
 601
 602 /*
 603  * Remove control kernel module(s) in reverse load order.
 604  */
 605 void modprobe_remove_lttng_control()
 606 {
 607         modprobe_remove_lttng(kern_modules_control_core, ARRAY_SIZE(kern_modules_control_core));
 608 }
 609
 610 static void free_probes()
 611 {
 612         int i;
 613
 614         if (!probes) {
 615                 return;
 616         }
 617         for (i = 0; i < nr_probes; ++i) {
 618                 free(probes[i].name);
 619         }
 620         free(probes);
 621         probes = nullptr;
 622         nr_probes = 0;
 623 }
 624
 625 /*
 626  * Remove data kernel modules in reverse load order.
 627  */
 628 void modprobe_remove_lttng_data()
 629 {
 630         if (!probes) {
 631                 return;
 632         }
 633
 634         modprobe_remove_lttng(probes, nr_probes);
 635         free_probes();
 636 }
 637
 638 /*
 639  * Remove all kernel modules in reverse order.
 640  */
 641 void modprobe_remove_lttng_all()
 642 {
 643         modprobe_remove_lttng_data();
 644         modprobe_remove_lttng_control();
 645 }
 646
 647 /*
 648  * Load control kernel module(s).
 649  */
 650 int modprobe_lttng_control()
 651 {
 652         return modprobe_lttng(kern_modules_control_core, ARRAY_SIZE(kern_modules_control_core));
 653 }
 654
 655 /**
 656  * Grow global list of probes (double capacity or set it to 1 if
 657  * currently 0 and copy existing data).
 658  */
 659 static int grow_probes()
 660 {
 661         int i;
 662         struct kern_modules_param *tmp_probes;
 663
 664         /* Initialize capacity to 1 if 0. */
 665         if (probes_capacity == 0) {
 666                 probes = zmalloc<kern_modules_param>();
 667                 if (!probes) {
 668                         PERROR("malloc probe list");
 669                         return -ENOMEM;
 670                 }
 671
 672                 probes_capacity = 1;
 673                 return 0;
 674         }
 675
 676         /* Double size. */
 677         probes_capacity *= 2;
 678
 679         tmp_probes = calloc<kern_modules_param>(probes_capacity);
 680         if (!tmp_probes) {
 681                 PERROR("malloc probe list");
 682                 return -ENOMEM;
 683         }
 684
 685         for (i = 0; i < nr_probes; ++i) {
 686                 /* Ownership of 'name' field is transferred. */
 687                 tmp_probes[i] = probes[i];
 688         }
 689
 690         /* Replace probes with larger copy. */
 691         free(probes);
 692         probes = tmp_probes;
 693
 694         return 0;
 695 }
 696
 697 /*
 698  * Appends a comma-separated list of probes to the global list
 699  * of probes.
 700  */
 701 static int append_list_to_probes(const char *list)
 702 {
 703         char *next;
 704         int ret;
 705         char *tmp_list, *cur_list, *saveptr;
 706
 707         LTTNG_ASSERT(list);
 708
 709         cur_list = tmp_list = strdup(list);
 710         if (!tmp_list) {
 711                 PERROR("strdup temp list");
 712                 return -ENOMEM;
 713         }
 714
 715         for (;;) {
 716                 size_t name_len;
 717                 struct kern_modules_param *cur_mod;
 718
 719                 next = strtok_r(cur_list, ",", &saveptr);
 720                 if (!next) {
 721                         break;
 722                 }
 723                 cur_list = nullptr;
 724
 725                 /* filter leading spaces */
 726                 while (*next == ' ') {
 727                         next++;
 728                 }
 729
 730                 if (probes_capacity <= nr_probes) {
 731                         ret = grow_probes();
 732                         if (ret) {
 733                                 goto error;
 734                         }
 735                 }
 736
 737                 /* Length 13 is "lttng-probe-" + \0 */
 738                 name_len = strlen(next) + 13;
 739
 740                 cur_mod = &probes[nr_probes];
 741                 cur_mod->name = calloc<char>(name_len);
 742                 if (!cur_mod->name) {
 743                         PERROR("malloc probe list");
 744                         ret = -ENOMEM;
 745                         goto error;
 746                 }
 747
 748                 ret = snprintf(cur_mod->name, name_len, "lttng-probe-%s", next);
 749                 if (ret < 0) {
 750                         PERROR("snprintf modprobe name");
 751                         ret = -ENOMEM;
 752                         goto error;
 753                 }
 754
 755                 cur_mod->load_policy = KERNEL_MODULE_PROPERTY_LOAD_POLICY_OPTIONAL;
 756
 757                 nr_probes++;
 758         }
 759
 760         free(tmp_list);
 761         return 0;
 762
 763 error:
 764         free(tmp_list);
 765         free_probes();
 766         return ret;
 767 }
 768
 769 /*
 770  * Load data kernel module(s).
 771  */
 772 int modprobe_lttng_data()
 773 {
 774         int ret, i;
 775         char *list;
 776
 777         /*
 778          * Base probes: either from command line option, environment
 779          * variable or default list.
 780          */
 781         list = the_config.kmod_probes_list.value;
 782         if (list) {
 783                 /* User-specified probes. */
 784                 ret = append_list_to_probes(list);
 785                 if (ret) {
 786                         return ret;
 787                 }
 788         } else {
 789                 /* Default probes. */
 790                 int def_len = ARRAY_SIZE(kern_modules_probes_default);
 791
 792                 probes = calloc<kern_modules_param>(def_len);
 793                 if (!probes) {
 794                         PERROR("malloc probe list");
 795                         return -ENOMEM;
 796                 }
 797
 798                 nr_probes = probes_capacity = def_len;
 799
 800                 for (i = 0; i < def_len; ++i) {
 801                         char *name = strdup(kern_modules_probes_default[i].name);
 802
 803                         if (!name) {
 804                                 PERROR("strdup probe item");
 805                                 ret = -ENOMEM;
 806                                 goto error;
 807                         }
 808
 809                         probes[i].name = name;
 810                         probes[i].load_policy = kern_modules_probes_default[i].load_policy;
 811                 }
 812         }
 813
 814         /*
 815          * Extra modules? Append them to current probes list.
 816          */
 817         list = the_config.kmod_extra_probes_list.value;
 818         if (list) {
 819                 ret = append_list_to_probes(list);
 820                 if (ret) {
 821                         goto error;
 822                 }
 823         }
 824
 825         /*
 826          * Load probes modules now.
 827          */
 828         ret = modprobe_lttng(probes, nr_probes);
 829         if (ret) {
 830                 goto error;
 831         }
 832         return ret;
 833
 834 error:
 835         free_probes();
 836         return ret;
 837 }