src/bin/lttng-sessiond/modprobe.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; only version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA  02111-1307, USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/wait.h>
  22
  23 #include <common/common.h>
  24
  25 #include "modprobe.h"
  26 #include "kern-modules.h"
  27
  28 /* MUST be loaded first */
  29 const struct kern_modules_param kern_modules_control[] = {
  30         { "lttng-tracer", 1 },
  31 };
  32
  33 /* LTTng kernel tracer modules list */
  34 const struct kern_modules_param kern_modules_list[] = {
  35         { "lttng-ftrace", 0 },
  36         { "lttng-kprobes", 0 },
  37         { "lttng-kretprobes", 0 },
  38         { "lttng-lib-ring-buffer", 1 },
  39         { "lttng-ring-buffer-client-discard", 1 },
  40         { "lttng-ring-buffer-client-overwrite", 1 },
  41         { "lttng-ring-buffer-metadata-client", 1 },
  42         { "lttng-ring-buffer-client-mmap-discard", 1 },
  43         { "lttng-ring-buffer-client-mmap-overwrite", 1 },
  44         { "lttng-ring-buffer-metadata-mmap-client", 1 },
  45         { "lttng-probe-lttng", 1 },
  46         { "lttng-types", 0 },
  47         { "lttng-probe-block", 0 },
  48         { "lttng-probe-irq", 0 },
  49         { "lttng-probe-kvm", 0 },
  50         { "lttng-probe-sched", 0 },
  51         { "lttng-probe-statedump", 0 },
  52 };
  53
  54 /*
  55  * Remove control kernel module(s) in reverse load order.
  56  */
  57 void modprobe_remove_lttng_control(void)
  58 {
  59         int ret = 0, i;
  60         char modprobe[256];
  61
  62         for (i = ARRAY_SIZE(kern_modules_control) - 1; i >= 0; i--) {
  63                 ret = snprintf(modprobe, sizeof(modprobe),
  64                                 "/sbin/modprobe -r -q %s",
  65                                 kern_modules_control[i].name);
  66                 if (ret < 0) {
  67                         PERROR("snprintf modprobe -r");
  68                         goto error;
  69                 }
  70                 modprobe[sizeof(modprobe) - 1] = '\0';
  71                 ret = system(modprobe);
  72                 if (ret == -1) {
  73                         ERR("Unable to launch modprobe -r for module %s",
  74                                         kern_modules_control[i].name);
  75                 } else if (kern_modules_control[i].required
  76                                 && WEXITSTATUS(ret) != 0) {
  77                         ERR("Unable to remove module %s",
  78                                         kern_modules_control[i].name);
  79                 } else {
  80                         DBG("Modprobe removal successful %s",
  81                                         kern_modules_control[i].name);
  82                 }
  83         }
  84
  85 error:
  86         return;
  87 }
  88
  89 /*
  90  * Remove data kernel modules in reverse load order.
  91  */
  92 void modprobe_remove_lttng_data(void)
  93 {
  94         int ret = 0, i;
  95         char modprobe[256];
  96
  97         for (i = ARRAY_SIZE(kern_modules_list) - 1; i >= 0; i--) {
  98                 ret = snprintf(modprobe, sizeof(modprobe),
  99                                 "/sbin/modprobe -r -q %s",
 100                                 kern_modules_list[i].name);
 101                 if (ret < 0) {
 102                         perror("snprintf modprobe -r");
 103                         goto error;
 104                 }
 105                 modprobe[sizeof(modprobe) - 1] = '\0';
 106                 ret = system(modprobe);
 107                 if (ret == -1) {
 108                         ERR("Unable to launch modprobe -r for module %s",
 109                                         kern_modules_list[i].name);
 110                 } else if (kern_modules_list[i].required
 111                                 && WEXITSTATUS(ret) != 0) {
 112                         ERR("Unable to remove module %s",
 113                                         kern_modules_list[i].name);
 114                 } else {
 115                         DBG("Modprobe removal successful %s",
 116                                         kern_modules_list[i].name);
 117                 }
 118         }
 119
 120 error:
 121         return;
 122 }
 123
 124 /*
 125  * Remove all kernel modules in reverse order.
 126  */
 127 void modprobe_remove_lttng_all(void)
 128 {
 129         modprobe_remove_lttng_data();
 130         modprobe_remove_lttng_control();
 131 }
 132
 133 /*
 134  * Load control kernel module(s).
 135  */
 136 int modprobe_lttng_control(void)
 137 {
 138         int ret = 0, i;
 139         char modprobe[256];
 140
 141         for (i = 0; i < ARRAY_SIZE(kern_modules_control); i++) {
 142                 ret = snprintf(modprobe, sizeof(modprobe),
 143                                 "/sbin/modprobe %s%s",
 144                                 kern_modules_control[i].required ? "" : "-q ",
 145                                 kern_modules_control[i].name);
 146                 if (ret < 0) {
 147                         PERROR("snprintf modprobe");
 148                         goto error;
 149                 }
 150                 modprobe[sizeof(modprobe) - 1] = '\0';
 151                 ret = system(modprobe);
 152                 if (ret == -1) {
 153                         ERR("Unable to launch modprobe for module %s",
 154                                         kern_modules_control[i].name);
 155                 } else if (kern_modules_control[i].required
 156                                 && WEXITSTATUS(ret) != 0) {
 157                         ERR("Unable to load module %s",
 158                                         kern_modules_control[i].name);
 159                 } else {
 160                         DBG("Modprobe successfully %s",
 161                                         kern_modules_control[i].name);
 162                 }
 163         }
 164
 165 error:
 166         return ret;
 167 }
 168
 169 /*
 170  * Load data kernel module(s).
 171  */
 172 int modprobe_lttng_data(void)
 173 {
 174         int ret = 0, i;
 175         char modprobe[256];
 176
 177         for (i = 0; i < ARRAY_SIZE(kern_modules_list); i++) {
 178                 ret = snprintf(modprobe, sizeof(modprobe),
 179                                 "/sbin/modprobe %s%s",
 180                                 kern_modules_list[i].required ? "" : "-q ",
 181                                 kern_modules_list[i].name);
 182                 if (ret < 0) {
 183                         perror("snprintf modprobe");
 184                         goto error;
 185                 }
 186                 modprobe[sizeof(modprobe) - 1] = '\0';
 187                 ret = system(modprobe);
 188                 if (ret == -1) {
 189                         ERR("Unable to launch modprobe for module %s",
 190                                         kern_modules_list[i].name);
 191                 } else if (kern_modules_list[i].required
 192                                 && WEXITSTATUS(ret) != 0) {
 193                         ERR("Unable to load module %s",
 194                                         kern_modules_list[i].name);
 195                 } else {
 196                         DBG("Modprobe successfully %s",
 197                                         kern_modules_list[i].name);
 198                 }
 199         }
 200
 201 error:
 202         return ret;
 203 }
 204
 205 /*
 206  * Load all lttng kernel modules.
 207  */
 208 int modprobe_lttng_all(void)
 209 {
 210         int ret;
 211
 212         ret = modprobe_lttng_control();
 213         if (ret < 0) {
 214                 goto error;
 215         }
 216
 217         ret = modprobe_lttng_data();
 218         if (ret < 0) {
 219                 goto error;
 220         }
 221
 222 error:
 223         return ret;
 224 }