• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * libkmod - interface to kernel module operations
3  *
4  * Copyright (C) 2011-2013  ProFUSION embedded systems
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include <assert.h>
21 #include <ctype.h>
22 #include <dirent.h>
23 #include <errno.h>
24 #include <fnmatch.h>
25 #include <inttypes.h>
26 #include <limits.h>
27 #include <stdarg.h>
28 #include <stddef.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <sys/mman.h>
34 #include <sys/stat.h>
35 #include <sys/syscall.h>
36 #include <sys/types.h>
37 #include <sys/wait.h>
38 #ifdef HAVE_LINUX_MODULE_H
39 #include <linux/module.h>
40 #endif
41 
42 #include <shared/util.h>
43 
44 #include "libkmod.h"
45 #include "libkmod-internal.h"
46 
47 /**
48  * SECTION:libkmod-module
49  * @short_description: operate on kernel modules
50  */
51 
52 enum kmod_module_builtin {
53     KMOD_MODULE_BUILTIN_UNKNOWN,
54     KMOD_MODULE_BUILTIN_NO,
55     KMOD_MODULE_BUILTIN_YES,
56 };
57 
58 /**
59  * kmod_module:
60  *
61  * Opaque object representing a module.
62  */
63 struct kmod_module {
64 	struct kmod_ctx *ctx;
65 	char *hashkey;
66 	char *name;
67 	char *path;
68 	struct kmod_list *dep;
69 	char *options;
70 	const char *install_commands;	/* owned by kmod_config */
71 	const char *remove_commands;	/* owned by kmod_config */
72 	char *alias; /* only set if this module was created from an alias */
73 	struct kmod_file *file;
74 	int n_dep;
75 	int refcount;
76 	struct {
77 		bool dep : 1;
78 		bool options : 1;
79 		bool install_commands : 1;
80 		bool remove_commands : 1;
81 	} init;
82 
83 	/*
84 	 * mark if module is builtin, i.e. it's present on modules.builtin
85 	 * file. This is set as soon as it is needed or as soon as we know
86 	 * about it, i.e. the module was created from builtin lookup.
87 	 */
88 	enum kmod_module_builtin builtin;
89 
90 	/*
91 	 * private field used by kmod_module_get_probe_list() to detect
92 	 * dependency loops
93 	 */
94 	bool visited : 1;
95 
96 	/*
97 	 * set by kmod_module_get_probe_list: indicates for probe_insert()
98 	 * whether the module's command and softdep should be ignored
99 	 */
100 	bool ignorecmd : 1;
101 
102 	/*
103 	 * set by kmod_module_get_probe_list: indicates whether this is the
104 	 * module the user asked for or its dependency, or whether this
105 	 * is a softdep only
106 	 */
107 	bool required : 1;
108 };
109 
path_join(const char * path,size_t prefixlen,char buf[PATH_MAX])110 static inline const char *path_join(const char *path, size_t prefixlen,
111 							char buf[PATH_MAX])
112 {
113 	size_t pathlen;
114 
115 	if (path[0] == '/')
116 		return path;
117 
118 	pathlen = strlen(path);
119 	if (prefixlen + pathlen + 1 >= PATH_MAX)
120 		return NULL;
121 
122 	memcpy(buf + prefixlen, path, pathlen + 1);
123 	return buf;
124 }
125 
module_is_inkernel(struct kmod_module * mod)126 static inline bool module_is_inkernel(struct kmod_module *mod)
127 {
128 	int state = kmod_module_get_initstate(mod);
129 
130 	if (state == KMOD_MODULE_LIVE ||
131 			state == KMOD_MODULE_BUILTIN)
132 		return true;
133 
134 	return false;
135 }
136 
kmod_module_parse_depline(struct kmod_module * mod,char * line)137 int kmod_module_parse_depline(struct kmod_module *mod, char *line)
138 {
139 	struct kmod_ctx *ctx = mod->ctx;
140 	struct kmod_list *list = NULL;
141 	const char *dirname;
142 	char buf[PATH_MAX];
143 	char *p, *saveptr;
144 	int err = 0, n = 0;
145 	size_t dirnamelen;
146 
147 	if (mod->init.dep)
148 		return mod->n_dep;
149 	assert(mod->dep == NULL);
150 	mod->init.dep = true;
151 
152 	p = strchr(line, ':');
153 	if (p == NULL)
154 		return 0;
155 
156 	*p = '\0';
157 	dirname = kmod_get_dirname(mod->ctx);
158 	dirnamelen = strlen(dirname);
159 	if (dirnamelen + 2 >= PATH_MAX)
160 		return 0;
161 
162 	memcpy(buf, dirname, dirnamelen);
163 	buf[dirnamelen] = '/';
164 	dirnamelen++;
165 	buf[dirnamelen] = '\0';
166 
167 	if (mod->path == NULL) {
168 		const char *str = path_join(line, dirnamelen, buf);
169 		if (str == NULL)
170 			return 0;
171 		mod->path = strdup(str);
172 		if (mod->path == NULL)
173 			return 0;
174 	}
175 
176 	p++;
177 	for (p = strtok_r(p, " \t", &saveptr); p != NULL;
178 					p = strtok_r(NULL, " \t", &saveptr)) {
179 		struct kmod_module *depmod = NULL;
180 		const char *path;
181 
182 		path = path_join(p, dirnamelen, buf);
183 		if (path == NULL) {
184 			ERR(ctx, "could not join path '%s' and '%s'.\n",
185 			    dirname, p);
186 			goto fail;
187 		}
188 
189 		err = kmod_module_new_from_path(ctx, path, &depmod);
190 		if (err < 0) {
191 			ERR(ctx, "ctx=%p path=%s error=%s\n",
192 						ctx, path, strerror(-err));
193 			goto fail;
194 		}
195 
196 		DBG(ctx, "add dep: %s\n", path);
197 
198 		list = kmod_list_prepend(list, depmod);
199 		n++;
200 	}
201 
202 	DBG(ctx, "%d dependencies for %s\n", n, mod->name);
203 
204 	mod->dep = list;
205 	mod->n_dep = n;
206 	return n;
207 
208 fail:
209 	kmod_module_unref_list(list);
210 	mod->init.dep = false;
211 	return err;
212 }
213 
kmod_module_set_visited(struct kmod_module * mod,bool visited)214 void kmod_module_set_visited(struct kmod_module *mod, bool visited)
215 {
216 	mod->visited = visited;
217 }
218 
kmod_module_set_builtin(struct kmod_module * mod,bool builtin)219 void kmod_module_set_builtin(struct kmod_module *mod, bool builtin)
220 {
221 	mod->builtin =
222 		builtin ? KMOD_MODULE_BUILTIN_YES : KMOD_MODULE_BUILTIN_NO;
223 }
224 
kmod_module_set_required(struct kmod_module * mod,bool required)225 void kmod_module_set_required(struct kmod_module *mod, bool required)
226 {
227 	mod->required = required;
228 }
229 
kmod_module_is_builtin(struct kmod_module * mod)230 bool kmod_module_is_builtin(struct kmod_module *mod)
231 {
232 	if (mod->builtin == KMOD_MODULE_BUILTIN_UNKNOWN) {
233 		kmod_module_set_builtin(mod,
234 					kmod_lookup_alias_is_builtin(mod->ctx, mod->name));
235 	}
236 
237 	return mod->builtin == KMOD_MODULE_BUILTIN_YES;
238 }
239 /*
240  * Memory layout with alias:
241  *
242  * struct kmod_module {
243  *        hashkey -----.
244  *        alias -----. |
245  *        name ----. | |
246  * }               | | |
247  * name <----------' | |
248  * alias <-----------' |
249  * name\alias <--------'
250  *
251  * Memory layout without alias:
252  *
253  * struct kmod_module {
254  *        hashkey ---.
255  *        alias -----|----> NULL
256  *        name ----. |
257  * }               | |
258  * name <----------'-'
259  *
260  * @key is "name\alias" or "name" (in which case alias == NULL)
261  */
kmod_module_new(struct kmod_ctx * ctx,const char * key,const char * name,size_t namelen,const char * alias,size_t aliaslen,struct kmod_module ** mod)262 static int kmod_module_new(struct kmod_ctx *ctx, const char *key,
263 				const char *name, size_t namelen,
264 				const char *alias, size_t aliaslen,
265 				struct kmod_module **mod)
266 {
267 	struct kmod_module *m;
268 	size_t keylen;
269 
270 	m = kmod_pool_get_module(ctx, key);
271 	if (m != NULL) {
272 		*mod = kmod_module_ref(m);
273 		return 0;
274 	}
275 
276 	if (alias == NULL)
277 		keylen = namelen;
278 	else
279 		keylen = namelen + aliaslen + 1;
280 
281 	m = malloc(sizeof(*m) + (alias == NULL ? 1 : 2) * (keylen + 1));
282 	if (m == NULL)
283 		return -ENOMEM;
284 
285 	memset(m, 0, sizeof(*m));
286 
287 	m->ctx = kmod_ref(ctx);
288 	m->name = (char *)m + sizeof(*m);
289 	memcpy(m->name, key, keylen + 1);
290 	if (alias == NULL) {
291 		m->hashkey = m->name;
292 		m->alias = NULL;
293 	} else {
294 		m->name[namelen] = '\0';
295 		m->alias = m->name + namelen + 1;
296 		m->hashkey = m->name + keylen + 1;
297 		memcpy(m->hashkey, key, keylen + 1);
298 	}
299 
300 	m->refcount = 1;
301 	kmod_pool_add_module(ctx, m, m->hashkey);
302 	*mod = m;
303 
304 	return 0;
305 }
306 
307 /**
308  * kmod_module_new_from_name:
309  * @ctx: kmod library context
310  * @name: name of the module
311  * @mod: where to save the created struct kmod_module
312  *
313  * Create a new struct kmod_module using the module name. @name can not be an
314  * alias, file name or anything else; it must be a module name. There's no
315  * check if the module exists in the system.
316  *
317  * This function is also used internally by many others that return a new
318  * struct kmod_module or a new list of modules.
319  *
320  * The initial refcount is 1, and needs to be decremented to release the
321  * resources of the kmod_module. Since libkmod keeps track of all
322  * kmod_modules created, they are all released upon @ctx destruction too. Do
323  * not unref @ctx before all the desired operations with the returned
324  * kmod_module are done.
325  *
326  * Returns: 0 on success or < 0 otherwise. It fails if name is not a valid
327  * module name or if memory allocation failed.
328  */
kmod_module_new_from_name(struct kmod_ctx * ctx,const char * name,struct kmod_module ** mod)329 KMOD_EXPORT int kmod_module_new_from_name(struct kmod_ctx *ctx,
330 						const char *name,
331 						struct kmod_module **mod)
332 {
333 	size_t namelen;
334 	char name_norm[PATH_MAX];
335 
336 	if (ctx == NULL || name == NULL || mod == NULL)
337 		return -ENOENT;
338 
339 	modname_normalize(name, name_norm, &namelen);
340 
341 	return kmod_module_new(ctx, name_norm, name_norm, namelen, NULL, 0, mod);
342 }
343 
kmod_module_new_from_alias(struct kmod_ctx * ctx,const char * alias,const char * name,struct kmod_module ** mod)344 int kmod_module_new_from_alias(struct kmod_ctx *ctx, const char *alias,
345 				const char *name, struct kmod_module **mod)
346 {
347 	int err;
348 	char key[PATH_MAX];
349 	size_t namelen = strlen(name);
350 	size_t aliaslen = strlen(alias);
351 
352 	if (namelen + aliaslen + 2 > PATH_MAX)
353 		return -ENAMETOOLONG;
354 
355 	memcpy(key, name, namelen);
356 	memcpy(key + namelen + 1, alias, aliaslen + 1);
357 	key[namelen] = '\\';
358 
359 	err = kmod_module_new(ctx, key, name, namelen, alias, aliaslen, mod);
360 	if (err < 0)
361 		return err;
362 
363 	return 0;
364 }
365 
366 /**
367  * kmod_module_new_from_path:
368  * @ctx: kmod library context
369  * @path: path where to find the given module
370  * @mod: where to save the created struct kmod_module
371  *
372  * Create a new struct kmod_module using the module path. @path must be an
373  * existent file with in the filesystem and must be accessible to libkmod.
374  *
375  * The initial refcount is 1, and needs to be decremented to release the
376  * resources of the kmod_module. Since libkmod keeps track of all
377  * kmod_modules created, they are all released upon @ctx destruction too. Do
378  * not unref @ctx before all the desired operations with the returned
379  * kmod_module are done.
380  *
381  * If @path is relative, it's treated as relative to the current working
382  * directory. Otherwise, give an absolute path.
383  *
384  * Returns: 0 on success or < 0 otherwise. It fails if file does not exist, if
385  * it's not a valid file for a kmod_module or if memory allocation failed.
386  */
kmod_module_new_from_path(struct kmod_ctx * ctx,const char * path,struct kmod_module ** mod)387 KMOD_EXPORT int kmod_module_new_from_path(struct kmod_ctx *ctx,
388 						const char *path,
389 						struct kmod_module **mod)
390 {
391 	struct kmod_module *m;
392 	int err;
393 	struct stat st;
394 	char name[PATH_MAX];
395 	char *abspath;
396 	size_t namelen;
397 
398 	if (ctx == NULL || path == NULL || mod == NULL)
399 		return -ENOENT;
400 
401 	abspath = path_make_absolute_cwd(path);
402 	if (abspath == NULL) {
403 		DBG(ctx, "no absolute path for %s\n", path);
404 		return -ENOMEM;
405 	}
406 
407 	err = stat(abspath, &st);
408 	if (err < 0) {
409 		err = -errno;
410 		DBG(ctx, "stat %s: %s\n", path, strerror(errno));
411 		free(abspath);
412 		return err;
413 	}
414 
415 	if (path_to_modname(path, name, &namelen) == NULL) {
416 		DBG(ctx, "could not get modname from path %s\n", path);
417 		free(abspath);
418 		return -ENOENT;
419 	}
420 
421 	m = kmod_pool_get_module(ctx, name);
422 	if (m != NULL) {
423 		if (m->path == NULL)
424 			m->path = abspath;
425 		else if (streq(m->path, abspath))
426 			free(abspath);
427 		else {
428 			ERR(ctx, "kmod_module '%s' already exists with different path: new-path='%s' old-path='%s'\n",
429 							name, abspath, m->path);
430 			free(abspath);
431 			return -EEXIST;
432 		}
433 
434 		*mod = kmod_module_ref(m);
435 		return 0;
436 	}
437 
438 	err = kmod_module_new(ctx, name, name, namelen, NULL, 0, &m);
439 	if (err < 0) {
440 		free(abspath);
441 		return err;
442 	}
443 
444 	m->path = abspath;
445 	*mod = m;
446 
447 	return 0;
448 }
449 
450 /**
451  * kmod_module_unref:
452  * @mod: kmod module
453  *
454  * Drop a reference of the kmod module. If the refcount reaches zero, its
455  * resources are released.
456  *
457  * Returns: NULL if @mod is NULL or if the module was released. Otherwise it
458  * returns the passed @mod with its refcount decremented.
459  */
kmod_module_unref(struct kmod_module * mod)460 KMOD_EXPORT struct kmod_module *kmod_module_unref(struct kmod_module *mod)
461 {
462 	if (mod == NULL)
463 		return NULL;
464 
465 	if (--mod->refcount > 0)
466 		return mod;
467 
468 	DBG(mod->ctx, "kmod_module %p released\n", mod);
469 
470 	kmod_pool_del_module(mod->ctx, mod, mod->hashkey);
471 	kmod_module_unref_list(mod->dep);
472 
473 	if (mod->file)
474 		kmod_file_unref(mod->file);
475 
476 	kmod_unref(mod->ctx);
477 	free(mod->options);
478 	free(mod->path);
479 	free(mod);
480 	return NULL;
481 }
482 
483 /**
484  * kmod_module_ref:
485  * @mod: kmod module
486  *
487  * Take a reference of the kmod module, incrementing its refcount.
488  *
489  * Returns: the passed @module with its refcount incremented.
490  */
kmod_module_ref(struct kmod_module * mod)491 KMOD_EXPORT struct kmod_module *kmod_module_ref(struct kmod_module *mod)
492 {
493 	if (mod == NULL)
494 		return NULL;
495 
496 	mod->refcount++;
497 
498 	return mod;
499 }
500 
501 #define CHECK_ERR_AND_FINISH(_err, _label_err, _list, label_finish)	\
502 	do {								\
503 		if ((_err) < 0)						\
504 			goto _label_err;				\
505 		if (*(_list) != NULL)					\
506 			goto finish;					\
507 	} while (0)
508 
509 /**
510  * kmod_module_new_from_lookup:
511  * @ctx: kmod library context
512  * @given_alias: alias to look for
513  * @list: an empty list where to save the list of modules matching
514  * @given_alias
515  *
516  * Create a new list of kmod modules using an alias or module name and lookup
517  * libkmod's configuration files and indexes in order to find the module.
518  * Once it's found in one of the places, it stops searching and create the
519  * list of modules that is saved in @list.
520  *
521  * The search order is: 1. aliases in configuration file; 2. module names in
522  * modules.dep index; 3. symbol aliases in modules.symbols index; 4. aliases
523  * in modules.alias index.
524  *
525  * The initial refcount is 1, and needs to be decremented to release the
526  * resources of the kmod_module. The returned @list must be released by
527  * calling kmod_module_unref_list(). Since libkmod keeps track of all
528  * kmod_modules created, they are all released upon @ctx destruction too. Do
529  * not unref @ctx before all the desired operations with the returned list are
530  * completed.
531  *
532  * Returns: 0 on success or < 0 otherwise. It fails if any of the lookup
533  * methods failed, which is basically due to memory allocation fail. If module
534  * is not found, it still returns 0, but @list is an empty list.
535  */
kmod_module_new_from_lookup(struct kmod_ctx * ctx,const char * given_alias,struct kmod_list ** list)536 KMOD_EXPORT int kmod_module_new_from_lookup(struct kmod_ctx *ctx,
537 						const char *given_alias,
538 						struct kmod_list **list)
539 {
540 	int err;
541 	char alias[PATH_MAX];
542 
543 	if (ctx == NULL || given_alias == NULL)
544 		return -ENOENT;
545 
546 	if (list == NULL || *list != NULL) {
547 		ERR(ctx, "An empty list is needed to create lookup\n");
548 		return -ENOSYS;
549 	}
550 
551 	if (alias_normalize(given_alias, alias, NULL) < 0) {
552 		DBG(ctx, "invalid alias: %s\n", given_alias);
553 		return -EINVAL;
554 	}
555 
556 	DBG(ctx, "input alias=%s, normalized=%s\n", given_alias, alias);
557 
558 	/* Aliases from config file override all the others */
559 	err = kmod_lookup_alias_from_config(ctx, alias, list);
560 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
561 
562 	DBG(ctx, "lookup modules.dep %s\n", alias);
563 	err = kmod_lookup_alias_from_moddep_file(ctx, alias, list);
564 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
565 
566 	DBG(ctx, "lookup modules.symbols %s\n", alias);
567 	err = kmod_lookup_alias_from_symbols_file(ctx, alias, list);
568 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
569 
570 	DBG(ctx, "lookup install and remove commands %s\n", alias);
571 	err = kmod_lookup_alias_from_commands(ctx, alias, list);
572 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
573 
574 	DBG(ctx, "lookup modules.aliases %s\n", alias);
575 	err = kmod_lookup_alias_from_aliases_file(ctx, alias, list);
576 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
577 
578 	DBG(ctx, "lookup modules.builtin %s\n", alias);
579 	err = kmod_lookup_alias_from_builtin_file(ctx, alias, list);
580 	CHECK_ERR_AND_FINISH(err, fail, list, finish);
581 
582 finish:
583 	DBG(ctx, "lookup %s=%d, list=%p\n", alias, err, *list);
584 	return err;
585 fail:
586 	DBG(ctx, "Failed to lookup %s\n", alias);
587 	kmod_module_unref_list(*list);
588 	*list = NULL;
589 	return err;
590 }
591 #undef CHECK_ERR_AND_FINISH
592 
593 /**
594  * kmod_module_unref_list:
595  * @list: list of kmod modules
596  *
597  * Drop a reference of each kmod module in @list and releases the resources
598  * taken by the list itself.
599  *
600  * Returns: 0
601  */
kmod_module_unref_list(struct kmod_list * list)602 KMOD_EXPORT int kmod_module_unref_list(struct kmod_list *list)
603 {
604 	for (; list != NULL; list = kmod_list_remove(list))
605 		kmod_module_unref(list->data);
606 
607 	return 0;
608 }
609 
610 /**
611  * kmod_module_get_filtered_blacklist:
612  * @ctx: kmod library context
613  * @input: list of kmod_module to be filtered with blacklist
614  * @output: where to save the new list
615  *
616  * This function should not be used. Use kmod_module_apply_filter instead.
617  *
618  * Given a list @input, this function filter it out with config's blacklist
619  * and save it in @output.
620  *
621  * Returns: 0 on success or < 0 otherwise. @output is saved with the updated
622  * list.
623  */
kmod_module_get_filtered_blacklist(const struct kmod_ctx * ctx,const struct kmod_list * input,struct kmod_list ** output)624 KMOD_EXPORT int kmod_module_get_filtered_blacklist(const struct kmod_ctx *ctx,
625 						const struct kmod_list *input,
626 						struct kmod_list **output)
627 {
628 	return kmod_module_apply_filter(ctx, KMOD_FILTER_BLACKLIST, input, output);
629 }
630 
module_get_dependencies_noref(const struct kmod_module * mod)631 static const struct kmod_list *module_get_dependencies_noref(const struct kmod_module *mod)
632 {
633 	if (!mod->init.dep) {
634 		/* lazy init */
635 		char *line = kmod_search_moddep(mod->ctx, mod->name);
636 
637 		if (line == NULL)
638 			return NULL;
639 
640 		kmod_module_parse_depline((struct kmod_module *)mod, line);
641 		free(line);
642 
643 		if (!mod->init.dep)
644 			return NULL;
645 	}
646 
647 	return mod->dep;
648 }
649 
650 /**
651  * kmod_module_get_dependencies:
652  * @mod: kmod module
653  *
654  * Search the modules.dep index to find the dependencies of the given @mod.
655  * The result is cached in @mod, so subsequent calls to this function will
656  * return the already searched list of modules.
657  *
658  * Returns: NULL on failure. Otherwise it returns a list of kmod modules
659  * that can be released by calling kmod_module_unref_list().
660  */
kmod_module_get_dependencies(const struct kmod_module * mod)661 KMOD_EXPORT struct kmod_list *kmod_module_get_dependencies(const struct kmod_module *mod)
662 {
663 	struct kmod_list *l, *l_new, *list_new = NULL;
664 
665 	if (mod == NULL)
666 		return NULL;
667 
668 	module_get_dependencies_noref(mod);
669 
670 	kmod_list_foreach(l, mod->dep) {
671 		l_new = kmod_list_append(list_new, kmod_module_ref(l->data));
672 		if (l_new == NULL) {
673 			kmod_module_unref(l->data);
674 			goto fail;
675 		}
676 
677 		list_new = l_new;
678 	}
679 
680 	return list_new;
681 
682 fail:
683 	ERR(mod->ctx, "out of memory\n");
684 	kmod_module_unref_list(list_new);
685 	return NULL;
686 }
687 
688 /**
689  * kmod_module_get_module:
690  * @entry: an entry in a list of kmod modules.
691  *
692  * Get the kmod module of this @entry in the list, increasing its refcount.
693  * After it's used, unref it. Since the refcount is incremented upon return,
694  * you still have to call kmod_module_unref_list() to release the list of kmod
695  * modules.
696  *
697  * Returns: NULL on failure or the kmod_module contained in this list entry
698  * with its refcount incremented.
699  */
kmod_module_get_module(const struct kmod_list * entry)700 KMOD_EXPORT struct kmod_module *kmod_module_get_module(const struct kmod_list *entry)
701 {
702 	if (entry == NULL)
703 		return NULL;
704 
705 	return kmod_module_ref(entry->data);
706 }
707 
708 /**
709  * kmod_module_get_name:
710  * @mod: kmod module
711  *
712  * Get the name of this kmod module. Name is always available, independently
713  * if it was created by kmod_module_new_from_name() or another function and
714  * it's always normalized (dashes are replaced with underscores).
715  *
716  * Returns: the name of this kmod module.
717  */
kmod_module_get_name(const struct kmod_module * mod)718 KMOD_EXPORT const char *kmod_module_get_name(const struct kmod_module *mod)
719 {
720 	if (mod == NULL)
721 		return NULL;
722 
723 	return mod->name;
724 }
725 
726 /**
727  * kmod_module_get_path:
728  * @mod: kmod module
729  *
730  * Get the path of this kmod module. If this kmod module was not created by
731  * path, it can search the modules.dep index in order to find out the module
732  * under context's dirname.
733  *
734  * Returns: the path of this kmod module or NULL if such information is not
735  * available.
736  */
kmod_module_get_path(const struct kmod_module * mod)737 KMOD_EXPORT const char *kmod_module_get_path(const struct kmod_module *mod)
738 {
739 	char *line;
740 
741 	if (mod == NULL)
742 		return NULL;
743 
744 	DBG(mod->ctx, "name='%s' path='%s'\n", mod->name, mod->path);
745 
746 	if (mod->path != NULL)
747 		return mod->path;
748 	if (mod->init.dep)
749 		return NULL;
750 
751 	/* lazy init */
752 	line = kmod_search_moddep(mod->ctx, mod->name);
753 	if (line == NULL)
754 		return NULL;
755 
756 	kmod_module_parse_depline((struct kmod_module *) mod, line);
757 	free(line);
758 
759 	return mod->path;
760 }
761 
762 
763 extern long delete_module(const char *name, unsigned int flags);
764 
765 /**
766  * kmod_module_remove_module:
767  * @mod: kmod module
768  * @flags: flags to pass to Linux kernel when removing the module. The only valid flag is
769  * KMOD_REMOVE_FORCE: force remove module regardless if it's still in
770  * use by a kernel subsystem or other process;
771  * KMOD_REMOVE_NOWAIT is always enforced, causing us to pass O_NONBLOCK to
772  * delete_module(2).
773  *
774  * Remove a module from Linux kernel.
775  *
776  * Returns: 0 on success or < 0 on failure.
777  */
kmod_module_remove_module(struct kmod_module * mod,unsigned int flags)778 KMOD_EXPORT int kmod_module_remove_module(struct kmod_module *mod,
779 							unsigned int flags)
780 {
781 	int err;
782 
783 	if (mod == NULL)
784 		return -ENOENT;
785 
786 	/* Filter out other flags and force ONONBLOCK */
787 	flags &= KMOD_REMOVE_FORCE;
788 	flags |= KMOD_REMOVE_NOWAIT;
789 
790 	err = delete_module(mod->name, flags);
791 	if (err != 0) {
792 		err = -errno;
793 		ERR(mod->ctx, "could not remove '%s': %m\n", mod->name);
794 	}
795 
796 	return err;
797 }
798 
799 extern long init_module(const void *mem, unsigned long len, const char *args);
800 
801 /**
802  * kmod_module_insert_module:
803  * @mod: kmod module
804  * @flags: flags are not passed to Linux Kernel, but instead they dictate the
805  * behavior of this function, valid flags are
806  * KMOD_INSERT_FORCE_VERMAGIC: ignore kernel version magic;
807  * KMOD_INSERT_FORCE_MODVERSION: ignore symbol version hashes.
808  * @options: module's options to pass to Linux Kernel.
809  *
810  * Insert a module in Linux kernel. It opens the file pointed by @mod,
811  * mmap'ing it and passing to kernel.
812  *
813  * Returns: 0 on success or < 0 on failure. If module is already loaded it
814  * returns -EEXIST.
815  */
kmod_module_insert_module(struct kmod_module * mod,unsigned int flags,const char * options)816 KMOD_EXPORT int kmod_module_insert_module(struct kmod_module *mod,
817 							unsigned int flags,
818 							const char *options)
819 {
820 	int err;
821 	const void *mem;
822 	off_t size;
823 	struct kmod_elf *elf;
824 	const char *path;
825 	const char *args = options ? options : "";
826 
827 	if (mod == NULL)
828 		return -ENOENT;
829 
830 	path = kmod_module_get_path(mod);
831 	if (path == NULL) {
832 		ERR(mod->ctx, "could not find module by name='%s'\n", mod->name);
833 		return -ENOENT;
834 	}
835 
836 	if (!mod->file) {
837 		mod->file = kmod_file_open(mod->ctx, path);
838 		if (mod->file == NULL) {
839 			err = -errno;
840 			return err;
841 		}
842 	}
843 
844 	if (kmod_file_get_direct(mod->file)) {
845 		unsigned int kernel_flags = 0;
846 
847 		if (flags & KMOD_INSERT_FORCE_VERMAGIC)
848 			kernel_flags |= MODULE_INIT_IGNORE_VERMAGIC;
849 		if (flags & KMOD_INSERT_FORCE_MODVERSION)
850 			kernel_flags |= MODULE_INIT_IGNORE_MODVERSIONS;
851 
852 		err = finit_module(kmod_file_get_fd(mod->file), args, kernel_flags);
853 		if (err == 0 || errno != ENOSYS)
854 			goto init_finished;
855 	}
856 
857 	if (flags & (KMOD_INSERT_FORCE_VERMAGIC | KMOD_INSERT_FORCE_MODVERSION)) {
858 		elf = kmod_file_get_elf(mod->file);
859 		if (elf == NULL) {
860 			err = -errno;
861 			return err;
862 		}
863 
864 		if (flags & KMOD_INSERT_FORCE_MODVERSION) {
865 			err = kmod_elf_strip_section(elf, "__versions");
866 			if (err < 0)
867 				INFO(mod->ctx, "Failed to strip modversion: %s\n", strerror(-err));
868 		}
869 
870 		if (flags & KMOD_INSERT_FORCE_VERMAGIC) {
871 			err = kmod_elf_strip_vermagic(elf);
872 			if (err < 0)
873 				INFO(mod->ctx, "Failed to strip vermagic: %s\n", strerror(-err));
874 		}
875 
876 		mem = kmod_elf_get_memory(elf);
877 	} else {
878 		mem = kmod_file_get_contents(mod->file);
879 	}
880 	size = kmod_file_get_size(mod->file);
881 
882 	err = init_module(mem, size, args);
883 init_finished:
884 	if (err < 0) {
885 		err = -errno;
886 		INFO(mod->ctx, "Failed to insert module '%s': %m\n", path);
887 	}
888 	return err;
889 }
890 
module_is_blacklisted(struct kmod_module * mod)891 static bool module_is_blacklisted(struct kmod_module *mod)
892 {
893 	struct kmod_ctx *ctx = mod->ctx;
894 	const struct kmod_config *config = kmod_get_config(ctx);
895 	const struct kmod_list *bl = config->blacklists;
896 	const struct kmod_list *l;
897 
898 	kmod_list_foreach(l, bl) {
899 		const char *modname = kmod_blacklist_get_modname(l);
900 
901 		if (streq(modname, mod->name))
902 			return true;
903 	}
904 
905 	return false;
906 }
907 
908 /**
909  * kmod_module_apply_filter
910  * @ctx: kmod library context
911  * @filter_type: bitmask to filter modules out, valid types are
912  * KMOD_FILTER_BLACKLIST: filter modules in blacklist out;
913  * KMOD_FILTER_BUILTIN: filter builtin modules out.
914  * @input: list of kmod_module to be filtered
915  * @output: where to save the new list
916  *
917  * Given a list @input, this function filter it out by the filter mask
918  * and save it in @output.
919  *
920  * Returns: 0 on success or < 0 otherwise. @output is saved with the updated
921  * list.
922  */
kmod_module_apply_filter(const struct kmod_ctx * ctx,enum kmod_filter filter_type,const struct kmod_list * input,struct kmod_list ** output)923 KMOD_EXPORT int kmod_module_apply_filter(const struct kmod_ctx *ctx,
924 						enum kmod_filter filter_type,
925 						const struct kmod_list *input,
926 						struct kmod_list **output)
927 {
928 	const struct kmod_list *li;
929 
930 	if (ctx == NULL || output == NULL)
931 		return -ENOENT;
932 
933 	*output = NULL;
934 	if (input == NULL)
935 		return 0;
936 
937 	kmod_list_foreach(li, input) {
938 		struct kmod_module *mod = li->data;
939 		struct kmod_list *node;
940 
941 		if ((filter_type & KMOD_FILTER_BLACKLIST) &&
942 				module_is_blacklisted(mod))
943 			continue;
944 
945 		if ((filter_type & KMOD_FILTER_BUILTIN)
946 		    && kmod_module_is_builtin(mod))
947 			continue;
948 
949 		node = kmod_list_append(*output, mod);
950 		if (node == NULL)
951 			goto fail;
952 
953 		*output = node;
954 		kmod_module_ref(mod);
955 	}
956 
957 	return 0;
958 
959 fail:
960 	kmod_module_unref_list(*output);
961 	*output = NULL;
962 	return -ENOMEM;
963 }
964 
command_do(struct kmod_module * mod,const char * type,const char * cmd)965 static int command_do(struct kmod_module *mod, const char *type,
966 							const char *cmd)
967 {
968 	const char *modname = kmod_module_get_name(mod);
969 	int err;
970 
971 	DBG(mod->ctx, "%s %s\n", type, cmd);
972 
973 	setenv("MODPROBE_MODULE", modname, 1);
974 	err = system(cmd);
975 	unsetenv("MODPROBE_MODULE");
976 
977 	if (err == -1 || WEXITSTATUS(err)) {
978 		ERR(mod->ctx, "Error running %s command for %s\n",
979 								type, modname);
980 		if (err != -1)
981 			err = -WEXITSTATUS(err);
982 	}
983 
984 	return err;
985 }
986 
987 struct probe_insert_cb {
988 	int (*run_install)(struct kmod_module *m, const char *cmd, void *data);
989 	void *data;
990 };
991 
module_do_install_commands(struct kmod_module * mod,const char * options,struct probe_insert_cb * cb)992 static int module_do_install_commands(struct kmod_module *mod,
993 					const char *options,
994 					struct probe_insert_cb *cb)
995 {
996 	const char *command = kmod_module_get_install_commands(mod);
997 	char *p;
998 	_cleanup_free_ char *cmd;
999 	int err;
1000 	size_t cmdlen, options_len, varlen;
1001 
1002 	assert(command);
1003 
1004 	if (options == NULL)
1005 		options = "";
1006 
1007 	options_len = strlen(options);
1008 	cmdlen = strlen(command);
1009 	varlen = sizeof("$CMDLINE_OPTS") - 1;
1010 
1011 	cmd = memdup(command, cmdlen + 1);
1012 	if (cmd == NULL)
1013 		return -ENOMEM;
1014 
1015 	while ((p = strstr(cmd, "$CMDLINE_OPTS")) != NULL) {
1016 		size_t prefixlen = p - cmd;
1017 		size_t suffixlen = cmdlen - prefixlen - varlen;
1018 		size_t slen = cmdlen - varlen + options_len;
1019 		char *suffix = p + varlen;
1020 		char *s = malloc(slen + 1);
1021 		if (!s)
1022 			return -ENOMEM;
1023 
1024 		memcpy(s, cmd, p - cmd);
1025 		memcpy(s + prefixlen, options, options_len);
1026 		memcpy(s + prefixlen + options_len, suffix, suffixlen);
1027 		s[slen] = '\0';
1028 
1029 		free(cmd);
1030 		cmd = s;
1031 		cmdlen = slen;
1032 	}
1033 
1034 	if (cb->run_install != NULL)
1035 		err = cb->run_install(mod, cmd, cb->data);
1036 	else
1037 		err = command_do(mod, "install", cmd);
1038 
1039 	return err;
1040 }
1041 
module_options_concat(const char * opt,const char * xopt)1042 static char *module_options_concat(const char *opt, const char *xopt)
1043 {
1044 	// TODO: we might need to check if xopt overrides options on opt
1045 	size_t optlen = opt == NULL ? 0 : strlen(opt);
1046 	size_t xoptlen = xopt == NULL ? 0 : strlen(xopt);
1047 	char *r;
1048 
1049 	if (optlen == 0 && xoptlen == 0)
1050 		return NULL;
1051 
1052 	r = malloc(optlen + xoptlen + 2);
1053 
1054 	if (opt != NULL) {
1055 		memcpy(r, opt, optlen);
1056 		r[optlen] = ' ';
1057 		optlen++;
1058 	}
1059 
1060 	if (xopt != NULL)
1061 		memcpy(r + optlen, xopt, xoptlen);
1062 
1063 	r[optlen + xoptlen] = '\0';
1064 
1065 	return r;
1066 }
1067 
1068 static int __kmod_module_get_probe_list(struct kmod_module *mod,
1069 						bool required,
1070 						bool ignorecmd,
1071 						struct kmod_list **list);
1072 
1073 /* re-entrant */
__kmod_module_fill_softdep(struct kmod_module * mod,struct kmod_list ** list)1074 static int __kmod_module_fill_softdep(struct kmod_module *mod,
1075 						struct kmod_list **list)
1076 {
1077 	struct kmod_list *pre = NULL, *post = NULL, *l;
1078 	int err;
1079 
1080 	err = kmod_module_get_softdeps(mod, &pre, &post);
1081 	if (err < 0) {
1082 		ERR(mod->ctx, "could not get softdep: %s\n",
1083 							strerror(-err));
1084 		goto fail;
1085 	}
1086 
1087 	kmod_list_foreach(l, pre) {
1088 		struct kmod_module *m = l->data;
1089 		err = __kmod_module_get_probe_list(m, false, false, list);
1090 		if (err < 0)
1091 			goto fail;
1092 	}
1093 
1094 	l = kmod_list_append(*list, kmod_module_ref(mod));
1095 	if (l == NULL) {
1096 		kmod_module_unref(mod);
1097 		err = -ENOMEM;
1098 		goto fail;
1099 	}
1100 	*list = l;
1101 	mod->ignorecmd = (pre != NULL || post != NULL);
1102 
1103 	kmod_list_foreach(l, post) {
1104 		struct kmod_module *m = l->data;
1105 		err = __kmod_module_get_probe_list(m, false, false, list);
1106 		if (err < 0)
1107 			goto fail;
1108 	}
1109 
1110 fail:
1111 	kmod_module_unref_list(pre);
1112 	kmod_module_unref_list(post);
1113 
1114 	return err;
1115 }
1116 
1117 /* re-entrant */
__kmod_module_get_probe_list(struct kmod_module * mod,bool required,bool ignorecmd,struct kmod_list ** list)1118 static int __kmod_module_get_probe_list(struct kmod_module *mod,
1119 						bool required,
1120 						bool ignorecmd,
1121 						struct kmod_list **list)
1122 {
1123 	struct kmod_list *dep, *l;
1124 	int err = 0;
1125 
1126 	if (mod->visited) {
1127 		DBG(mod->ctx, "Ignore module '%s': already visited\n",
1128 								mod->name);
1129 		return 0;
1130 	}
1131 	mod->visited = true;
1132 
1133 	dep = kmod_module_get_dependencies(mod);
1134 	if (required) {
1135 		/*
1136 		 * Called from kmod_module_probe_insert_module(); set the
1137 		 * ->required flag on mod and all its dependencies before
1138 		 * they are possibly visited through some softdeps.
1139 		 */
1140 		mod->required = true;
1141 		kmod_list_foreach(l, dep) {
1142 			struct kmod_module *m = l->data;
1143 			m->required = true;
1144 		}
1145 	}
1146 
1147 	kmod_list_foreach(l, dep) {
1148 		struct kmod_module *m = l->data;
1149 		err = __kmod_module_fill_softdep(m, list);
1150 		if (err < 0)
1151 			goto finish;
1152 	}
1153 
1154 	if (ignorecmd) {
1155 		l = kmod_list_append(*list, kmod_module_ref(mod));
1156 		if (l == NULL) {
1157 			kmod_module_unref(mod);
1158 			err = -ENOMEM;
1159 			goto finish;
1160 		}
1161 		*list = l;
1162 		mod->ignorecmd = true;
1163 	} else
1164 		err = __kmod_module_fill_softdep(mod, list);
1165 
1166 finish:
1167 	kmod_module_unref_list(dep);
1168 	return err;
1169 }
1170 
kmod_module_get_probe_list(struct kmod_module * mod,bool ignorecmd,struct kmod_list ** list)1171 static int kmod_module_get_probe_list(struct kmod_module *mod,
1172 						bool ignorecmd,
1173 						struct kmod_list **list)
1174 {
1175 	int err;
1176 
1177 	assert(mod != NULL);
1178 	assert(list != NULL && *list == NULL);
1179 
1180 	/*
1181 	 * Make sure we don't get screwed by previous calls to this function
1182 	 */
1183 	kmod_set_modules_visited(mod->ctx, false);
1184 	kmod_set_modules_required(mod->ctx, false);
1185 
1186 	err = __kmod_module_get_probe_list(mod, true, ignorecmd, list);
1187 	if (err < 0) {
1188 		kmod_module_unref_list(*list);
1189 		*list = NULL;
1190 	}
1191 
1192 	return err;
1193 }
1194 
1195 /**
1196  * kmod_module_probe_insert_module:
1197  * @mod: kmod module
1198  * @flags: flags are not passed to Linux Kernel, but instead they dictate the
1199  * behavior of this function, valid flags are
1200  * KMOD_PROBE_FORCE_VERMAGIC: ignore kernel version magic;
1201  * KMOD_PROBE_FORCE_MODVERSION: ignore symbol version hashes;
1202  * KMOD_PROBE_IGNORE_COMMAND: whether the probe should ignore install
1203  * commands and softdeps configured in the system;
1204  * KMOD_PROBE_IGNORE_LOADED: do not check whether the module is already
1205  * live in kernel or not;
1206  * KMOD_PROBE_DRY_RUN: dry run, do not insert module, just call the
1207  * associated callback function;
1208  * KMOD_PROBE_FAIL_ON_LOADED: if KMOD_PROBE_IGNORE_LOADED is not specified
1209  * and the module is already live in kernel, the function will fail if this
1210  * flag is specified;
1211  * KMOD_PROBE_APPLY_BLACKLIST_ALL: probe will apply KMOD_FILTER_BLACKLIST
1212  * filter to this module and its dependencies. If any of the dependencies (or
1213  * the module) is blacklisted, the probe will fail, unless the blacklisted
1214  * module is already live in kernel;
1215  * KMOD_PROBE_APPLY_BLACKLIST: probe will fail if the module is blacklisted;
1216  * KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY: probe will fail if the module is an
1217  * alias and is blacklisted.
1218  * @extra_options: module's options to pass to Linux Kernel. It applies only
1219  * to @mod, not to its dependencies.
1220  * @run_install: function to run when @mod is backed by an install command.
1221  * @data: data to give back to @run_install callback
1222  * @print_action: function to call with the action being taken (install or
1223  * insmod). It's useful for tools like modprobe when running with verbose
1224  * output or in dry-run mode.
1225  *
1226  * Insert a module in Linux kernel resolving dependencies, soft dependencies,
1227  * install commands and applying blacklist.
1228  *
1229  * If @run_install is NULL, this function will fork and exec by calling
1230  * system(3). Don't pass a NULL argument in @run_install if your binary is
1231  * setuid/setgid (see warning in system(3)). If you need control over the
1232  * execution of an install command, give a callback function instead.
1233  *
1234  * Returns: 0 on success, > 0 if stopped by a reason given in @flags or < 0 on
1235  * failure.
1236  */
kmod_module_probe_insert_module(struct kmod_module * mod,unsigned int flags,const char * extra_options,int (* run_install)(struct kmod_module * m,const char * cmd,void * data),const void * data,void (* print_action)(struct kmod_module * m,bool install,const char * options))1237 KMOD_EXPORT int kmod_module_probe_insert_module(struct kmod_module *mod,
1238 			unsigned int flags, const char *extra_options,
1239 			int (*run_install)(struct kmod_module *m,
1240 						const char *cmd, void *data),
1241 			const void *data,
1242 			void (*print_action)(struct kmod_module *m,
1243 						bool install,
1244 						const char *options))
1245 {
1246 	struct kmod_list *list = NULL, *l;
1247 	struct probe_insert_cb cb;
1248 	int err;
1249 
1250 	if (mod == NULL)
1251 		return -ENOENT;
1252 
1253 	if (!(flags & KMOD_PROBE_IGNORE_LOADED)
1254 					&& module_is_inkernel(mod)) {
1255 		if (flags & KMOD_PROBE_FAIL_ON_LOADED)
1256 			return -EEXIST;
1257 		else
1258 			return 0;
1259 	}
1260 
1261 	/*
1262 	 * Ugly assignement + check. We need to check if we were told to check
1263 	 * blacklist and also return the reason why we failed.
1264 	 * KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY will take effect only if the
1265 	 * module is an alias, so we also need to check it
1266 	 */
1267 	if ((mod->alias != NULL && ((err = flags & KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY)))
1268 			|| (err = flags & KMOD_PROBE_APPLY_BLACKLIST_ALL)
1269 			|| (err = flags & KMOD_PROBE_APPLY_BLACKLIST)) {
1270 		if (module_is_blacklisted(mod))
1271 			return err;
1272 	}
1273 
1274 	err = kmod_module_get_probe_list(mod,
1275 				!!(flags & KMOD_PROBE_IGNORE_COMMAND), &list);
1276 	if (err < 0)
1277 		return err;
1278 
1279 	if (flags & KMOD_PROBE_APPLY_BLACKLIST_ALL) {
1280 		struct kmod_list *filtered = NULL;
1281 
1282 		err = kmod_module_apply_filter(mod->ctx,
1283 				KMOD_FILTER_BLACKLIST, list, &filtered);
1284 		if (err < 0)
1285 			return err;
1286 
1287 		kmod_module_unref_list(list);
1288 		if (filtered == NULL)
1289 			return KMOD_PROBE_APPLY_BLACKLIST_ALL;
1290 
1291 		list = filtered;
1292 	}
1293 
1294 	cb.run_install = run_install;
1295 	cb.data = (void *) data;
1296 
1297 	kmod_list_foreach(l, list) {
1298 		struct kmod_module *m = l->data;
1299 		const char *moptions = kmod_module_get_options(m);
1300 		const char *cmd = kmod_module_get_install_commands(m);
1301 		char *options;
1302 
1303 		if (!(flags & KMOD_PROBE_IGNORE_LOADED)
1304 						&& module_is_inkernel(m)) {
1305 			DBG(mod->ctx, "Ignoring module '%s': already loaded\n",
1306 								m->name);
1307 			err = -EEXIST;
1308 			goto finish_module;
1309 		}
1310 
1311 		options = module_options_concat(moptions,
1312 					m == mod ? extra_options : NULL);
1313 
1314 		if (cmd != NULL && !m->ignorecmd) {
1315 			if (print_action != NULL)
1316 				print_action(m, true, options ?: "");
1317 
1318 			if (!(flags & KMOD_PROBE_DRY_RUN))
1319 				err = module_do_install_commands(m, options,
1320 									&cb);
1321 		} else {
1322 			if (print_action != NULL)
1323 				print_action(m, false, options ?: "");
1324 
1325 			if (!(flags & KMOD_PROBE_DRY_RUN))
1326 				err = kmod_module_insert_module(m, flags,
1327 								options);
1328 		}
1329 
1330 		free(options);
1331 
1332 finish_module:
1333 		/*
1334 		 * Treat "already loaded" error. If we were told to stop on
1335 		 * already loaded and the module being loaded is not a softdep
1336 		 * or dep, bail out. Otherwise, just ignore and continue.
1337 		 *
1338 		 * We need to check here because of race conditions. We
1339 		 * checked first if module was already loaded but it may have
1340 		 * been loaded between the check and the moment we try to
1341 		 * insert it.
1342 		 */
1343 		if (err == -EEXIST && m == mod &&
1344 				(flags & KMOD_PROBE_FAIL_ON_LOADED))
1345 			break;
1346 
1347 		/*
1348 		 * Ignore errors from softdeps
1349 		 */
1350 		if (err == -EEXIST || !m->required)
1351 			err = 0;
1352 
1353 		else if (err < 0)
1354 			break;
1355 	}
1356 
1357 	kmod_module_unref_list(list);
1358 	return err;
1359 }
1360 
1361 /**
1362  * kmod_module_get_options:
1363  * @mod: kmod module
1364  *
1365  * Get options of this kmod module. Options come from the configuration file
1366  * and are cached in @mod. The first call to this function will search for
1367  * this module in configuration and subsequent calls return the cached string.
1368  *
1369  * Returns: a string with all the options separated by spaces. This string is
1370  * owned by @mod, do not free it.
1371  */
kmod_module_get_options(const struct kmod_module * mod)1372 KMOD_EXPORT const char *kmod_module_get_options(const struct kmod_module *mod)
1373 {
1374 	if (mod == NULL)
1375 		return NULL;
1376 
1377 	if (!mod->init.options) {
1378 		/* lazy init */
1379 		struct kmod_module *m = (struct kmod_module *)mod;
1380 		const struct kmod_list *l;
1381 		const struct kmod_config *config;
1382 		char *opts = NULL;
1383 		size_t optslen = 0;
1384 
1385 		config = kmod_get_config(mod->ctx);
1386 
1387 		kmod_list_foreach(l, config->options) {
1388 			const char *modname = kmod_option_get_modname(l);
1389 			const char *str;
1390 			size_t len;
1391 			void *tmp;
1392 
1393 			DBG(mod->ctx, "modname=%s mod->name=%s mod->alias=%s\n", modname, mod->name, mod->alias);
1394 			if (!(streq(modname, mod->name) || (mod->alias != NULL &&
1395 						streq(modname, mod->alias))))
1396 				continue;
1397 
1398 			DBG(mod->ctx, "passed = modname=%s mod->name=%s mod->alias=%s\n", modname, mod->name, mod->alias);
1399 			str = kmod_option_get_options(l);
1400 			len = strlen(str);
1401 			if (len < 1)
1402 				continue;
1403 
1404 			tmp = realloc(opts, optslen + len + 2);
1405 			if (tmp == NULL) {
1406 				free(opts);
1407 				goto failed;
1408 			}
1409 
1410 			opts = tmp;
1411 
1412 			if (optslen > 0) {
1413 				opts[optslen] = ' ';
1414 				optslen++;
1415 			}
1416 
1417 			memcpy(opts + optslen, str, len);
1418 			optslen += len;
1419 			opts[optslen] = '\0';
1420 		}
1421 
1422 		m->init.options = true;
1423 		m->options = opts;
1424 	}
1425 
1426 	return mod->options;
1427 
1428 failed:
1429 	ERR(mod->ctx, "out of memory\n");
1430 	return NULL;
1431 }
1432 
1433 /**
1434  * kmod_module_get_install_commands:
1435  * @mod: kmod module
1436  *
1437  * Get install commands for this kmod module. Install commands come from the
1438  * configuration file and are cached in @mod. The first call to this function
1439  * will search for this module in configuration and subsequent calls return
1440  * the cached string. The install commands are returned as they were in the
1441  * configuration, concatenated by ';'. No other processing is made in this
1442  * string.
1443  *
1444  * Returns: a string with all install commands separated by semicolons. This
1445  * string is owned by @mod, do not free it.
1446  */
kmod_module_get_install_commands(const struct kmod_module * mod)1447 KMOD_EXPORT const char *kmod_module_get_install_commands(const struct kmod_module *mod)
1448 {
1449 	if (mod == NULL)
1450 		return NULL;
1451 
1452 	if (!mod->init.install_commands) {
1453 		/* lazy init */
1454 		struct kmod_module *m = (struct kmod_module *)mod;
1455 		const struct kmod_list *l;
1456 		const struct kmod_config *config;
1457 
1458 		config = kmod_get_config(mod->ctx);
1459 
1460 		kmod_list_foreach(l, config->install_commands) {
1461 			const char *modname = kmod_command_get_modname(l);
1462 
1463 			if (fnmatch(modname, mod->name, 0) != 0)
1464 				continue;
1465 
1466 			m->install_commands = kmod_command_get_command(l);
1467 
1468 			/*
1469 			 * find only the first command, as modprobe from
1470 			 * module-init-tools does
1471 			 */
1472 			break;
1473 		}
1474 
1475 		m->init.install_commands = true;
1476 	}
1477 
1478 	return mod->install_commands;
1479 }
1480 
kmod_module_set_install_commands(struct kmod_module * mod,const char * cmd)1481 void kmod_module_set_install_commands(struct kmod_module *mod, const char *cmd)
1482 {
1483 	mod->init.install_commands = true;
1484 	mod->install_commands = cmd;
1485 }
1486 
lookup_softdep(struct kmod_ctx * ctx,const char * const * array,unsigned int count)1487 static struct kmod_list *lookup_softdep(struct kmod_ctx *ctx, const char * const * array, unsigned int count)
1488 {
1489 	struct kmod_list *ret = NULL;
1490 	unsigned i;
1491 
1492 	for (i = 0; i < count; i++) {
1493 		const char *depname = array[i];
1494 		struct kmod_list *lst = NULL;
1495 		int err;
1496 
1497 		err = kmod_module_new_from_lookup(ctx, depname, &lst);
1498 		if (err < 0) {
1499 			ERR(ctx, "failed to lookup soft dependency '%s', continuing anyway.\n", depname);
1500 			continue;
1501 		} else if (lst != NULL)
1502 			ret = kmod_list_append_list(ret, lst);
1503 	}
1504 	return ret;
1505 }
1506 
1507 /**
1508  * kmod_module_get_softdeps:
1509  * @mod: kmod module
1510  * @pre: where to save the list of preceding soft dependencies.
1511  * @post: where to save the list of post soft dependencies.
1512  *
1513  * Get soft dependencies for this kmod module. Soft dependencies come
1514  * from configuration file and are not cached in @mod because it may include
1515  * dependency cycles that would make we leak kmod_module. Any call
1516  * to this function will search for this module in configuration, allocate a
1517  * list and return the result.
1518  *
1519  * Both @pre and @post are newly created list of kmod_module and
1520  * should be unreferenced with kmod_module_unref_list().
1521  *
1522  * Returns: 0 on success or < 0 otherwise.
1523  */
kmod_module_get_softdeps(const struct kmod_module * mod,struct kmod_list ** pre,struct kmod_list ** post)1524 KMOD_EXPORT int kmod_module_get_softdeps(const struct kmod_module *mod,
1525 						struct kmod_list **pre,
1526 						struct kmod_list **post)
1527 {
1528 	const struct kmod_list *l;
1529 	const struct kmod_config *config;
1530 
1531 	if (mod == NULL || pre == NULL || post == NULL)
1532 		return -ENOENT;
1533 
1534 	assert(*pre == NULL);
1535 	assert(*post == NULL);
1536 
1537 	config = kmod_get_config(mod->ctx);
1538 
1539 	kmod_list_foreach(l, config->softdeps) {
1540 		const char *modname = kmod_softdep_get_name(l);
1541 		const char * const *array;
1542 		unsigned count;
1543 
1544 		if (fnmatch(modname, mod->name, 0) != 0)
1545 			continue;
1546 
1547 		array = kmod_softdep_get_pre(l, &count);
1548 		*pre = lookup_softdep(mod->ctx, array, count);
1549 		array = kmod_softdep_get_post(l, &count);
1550 		*post = lookup_softdep(mod->ctx, array, count);
1551 
1552 		/*
1553 		 * find only the first command, as modprobe from
1554 		 * module-init-tools does
1555 		 */
1556 		break;
1557 	}
1558 
1559 	return 0;
1560 }
1561 
1562 /**
1563  * kmod_module_get_remove_commands:
1564  * @mod: kmod module
1565  *
1566  * Get remove commands for this kmod module. Remove commands come from the
1567  * configuration file and are cached in @mod. The first call to this function
1568  * will search for this module in configuration and subsequent calls return
1569  * the cached string. The remove commands are returned as they were in the
1570  * configuration, concatenated by ';'. No other processing is made in this
1571  * string.
1572  *
1573  * Returns: a string with all remove commands separated by semicolons. This
1574  * string is owned by @mod, do not free it.
1575  */
kmod_module_get_remove_commands(const struct kmod_module * mod)1576 KMOD_EXPORT const char *kmod_module_get_remove_commands(const struct kmod_module *mod)
1577 {
1578 	if (mod == NULL)
1579 		return NULL;
1580 
1581 	if (!mod->init.remove_commands) {
1582 		/* lazy init */
1583 		struct kmod_module *m = (struct kmod_module *)mod;
1584 		const struct kmod_list *l;
1585 		const struct kmod_config *config;
1586 
1587 		config = kmod_get_config(mod->ctx);
1588 
1589 		kmod_list_foreach(l, config->remove_commands) {
1590 			const char *modname = kmod_command_get_modname(l);
1591 
1592 			if (fnmatch(modname, mod->name, 0) != 0)
1593 				continue;
1594 
1595 			m->remove_commands = kmod_command_get_command(l);
1596 
1597 			/*
1598 			 * find only the first command, as modprobe from
1599 			 * module-init-tools does
1600 			 */
1601 			break;
1602 		}
1603 
1604 		m->init.remove_commands = true;
1605 	}
1606 
1607 	return mod->remove_commands;
1608 }
1609 
kmod_module_set_remove_commands(struct kmod_module * mod,const char * cmd)1610 void kmod_module_set_remove_commands(struct kmod_module *mod, const char *cmd)
1611 {
1612 	mod->init.remove_commands = true;
1613 	mod->remove_commands = cmd;
1614 }
1615 
1616 /**
1617  * SECTION:libkmod-loaded
1618  * @short_description: currently loaded modules
1619  *
1620  * Information about currently loaded modules, as reported by Linux kernel.
1621  * These information are not cached by libkmod and are always read from /sys
1622  * and /proc/modules.
1623  */
1624 
1625 /**
1626  * kmod_module_new_from_loaded:
1627  * @ctx: kmod library context
1628  * @list: where to save the list of loaded modules
1629  *
1630  * Create a new list of kmod modules with all modules currently loaded in
1631  * kernel. It uses /proc/modules to get the names of loaded modules and to
1632  * create kmod modules by calling kmod_module_new_from_name() in each of them.
1633  * They are put in @list in no particular order.
1634  *
1635  * The initial refcount is 1, and needs to be decremented to release the
1636  * resources of the kmod_module. The returned @list must be released by
1637  * calling kmod_module_unref_list(). Since libkmod keeps track of all
1638  * kmod_modules created, they are all released upon @ctx destruction too. Do
1639  * not unref @ctx before all the desired operations with the returned list are
1640  * completed.
1641  *
1642  * Returns: 0 on success or < 0 on error.
1643  */
kmod_module_new_from_loaded(struct kmod_ctx * ctx,struct kmod_list ** list)1644 KMOD_EXPORT int kmod_module_new_from_loaded(struct kmod_ctx *ctx,
1645 						struct kmod_list **list)
1646 {
1647 	struct kmod_list *l = NULL;
1648 	FILE *fp;
1649 	char line[4096];
1650 
1651 	if (ctx == NULL || list == NULL)
1652 		return -ENOENT;
1653 
1654 	fp = fopen("/proc/modules", "re");
1655 	if (fp == NULL) {
1656 		int err = -errno;
1657 		ERR(ctx, "could not open /proc/modules: %s\n", strerror(errno));
1658 		return err;
1659 	}
1660 
1661 	while (fgets(line, sizeof(line), fp)) {
1662 		struct kmod_module *m;
1663 		struct kmod_list *node;
1664 		int err;
1665 		size_t len = strlen(line);
1666 		char *saveptr, *name = strtok_r(line, " \t", &saveptr);
1667 
1668 		err = kmod_module_new_from_name(ctx, name, &m);
1669 		if (err < 0) {
1670 			ERR(ctx, "could not get module from name '%s': %s\n",
1671 				name, strerror(-err));
1672 			goto eat_line;
1673 		}
1674 
1675 		node = kmod_list_append(l, m);
1676 		if (node)
1677 			l = node;
1678 		else {
1679 			ERR(ctx, "out of memory\n");
1680 			kmod_module_unref(m);
1681 		}
1682 eat_line:
1683 		while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
1684 			len = strlen(line);
1685 	}
1686 
1687 	fclose(fp);
1688 	*list = l;
1689 
1690 	return 0;
1691 }
1692 
1693 /**
1694  * kmod_module_initstate_str:
1695  * @state: the state as returned by kmod_module_get_initstate()
1696  *
1697  * Translate a initstate to a string.
1698  *
1699  * Returns: the string associated to the @state. This string is statically
1700  * allocated, do not free it.
1701  */
kmod_module_initstate_str(enum kmod_module_initstate state)1702 KMOD_EXPORT const char *kmod_module_initstate_str(enum kmod_module_initstate state)
1703 {
1704 	switch (state) {
1705 	case KMOD_MODULE_BUILTIN:
1706 		return "builtin";
1707 	case KMOD_MODULE_LIVE:
1708 		return "live";
1709 	case KMOD_MODULE_COMING:
1710 		return "coming";
1711 	case KMOD_MODULE_GOING:
1712 		return "going";
1713 	default:
1714 		return NULL;
1715 	}
1716 }
1717 
1718 /**
1719  * kmod_module_get_initstate:
1720  * @mod: kmod module
1721  *
1722  * Get the initstate of this @mod, as returned by Linux Kernel, by reading
1723  * /sys filesystem.
1724  *
1725  * Returns: < 0 on error or module state if module is found in kernel, valid states are
1726  * KMOD_MODULE_BUILTIN: module is builtin;
1727  * KMOD_MODULE_LIVE: module is live in kernel;
1728  * KMOD_MODULE_COMING: module is being loaded;
1729  * KMOD_MODULE_GOING: module is being unloaded.
1730  */
kmod_module_get_initstate(const struct kmod_module * mod)1731 KMOD_EXPORT int kmod_module_get_initstate(const struct kmod_module *mod)
1732 {
1733 	char path[PATH_MAX], buf[32];
1734 	int fd, err, pathlen;
1735 
1736 	if (mod == NULL)
1737 		return -ENOENT;
1738 
1739 	/* remove const: this can only change internal state */
1740 	if (kmod_module_is_builtin((struct kmod_module *)mod))
1741 		return KMOD_MODULE_BUILTIN;
1742 
1743 	pathlen = snprintf(path, sizeof(path),
1744 				"/sys/module/%s/initstate", mod->name);
1745 	fd = open(path, O_RDONLY|O_CLOEXEC);
1746 	if (fd < 0) {
1747 		err = -errno;
1748 
1749 		DBG(mod->ctx, "could not open '%s': %s\n",
1750 			path, strerror(-err));
1751 
1752 		if (pathlen > (int)sizeof("/initstate") - 1) {
1753 			struct stat st;
1754 			path[pathlen - (sizeof("/initstate") - 1)] = '\0';
1755 			if (stat(path, &st) == 0 && S_ISDIR(st.st_mode))
1756 				return KMOD_MODULE_COMING;
1757 		}
1758 
1759 		DBG(mod->ctx, "could not open '%s': %s\n",
1760 			path, strerror(-err));
1761 		return err;
1762 	}
1763 
1764 	err = read_str_safe(fd, buf, sizeof(buf));
1765 	close(fd);
1766 	if (err < 0) {
1767 		ERR(mod->ctx, "could not read from '%s': %s\n",
1768 			path, strerror(-err));
1769 		return err;
1770 	}
1771 
1772 	if (streq(buf, "live\n"))
1773 		return KMOD_MODULE_LIVE;
1774 	else if (streq(buf, "coming\n"))
1775 		return KMOD_MODULE_COMING;
1776 	else if (streq(buf, "going\n"))
1777 		return KMOD_MODULE_GOING;
1778 
1779 	ERR(mod->ctx, "unknown %s: '%s'\n", path, buf);
1780 	return -EINVAL;
1781 }
1782 
1783 /**
1784  * kmod_module_get_size:
1785  * @mod: kmod module
1786  *
1787  * Get the size of this kmod module as returned by Linux kernel. If supported,
1788  * the size is read from the coresize attribute in /sys/module. For older
1789  * kernels, this falls back on /proc/modules and searches for the specified
1790  * module to get its size.
1791  *
1792  * Returns: the size of this kmod module.
1793  */
kmod_module_get_size(const struct kmod_module * mod)1794 KMOD_EXPORT long kmod_module_get_size(const struct kmod_module *mod)
1795 {
1796 	FILE *fp;
1797 	char line[4096];
1798 	int lineno = 0;
1799 	long size = -ENOENT;
1800 	int dfd, cfd;
1801 
1802 	if (mod == NULL)
1803 		return -ENOENT;
1804 
1805 	/* try to open the module dir in /sys. If this fails, don't
1806 	 * bother trying to find the size as we know the module isn't
1807 	 * loaded.
1808 	 */
1809 	snprintf(line, sizeof(line), "/sys/module/%s", mod->name);
1810 	dfd = open(line, O_RDONLY|O_CLOEXEC);
1811 	if (dfd < 0)
1812 		return -errno;
1813 
1814 	/* available as of linux 3.3.x */
1815 	cfd = openat(dfd, "coresize", O_RDONLY|O_CLOEXEC);
1816 	if (cfd >= 0) {
1817 		if (read_str_long(cfd, &size, 10) < 0)
1818 			ERR(mod->ctx, "failed to read coresize from %s\n", line);
1819 		close(cfd);
1820 		goto done;
1821 	}
1822 
1823 	/* fall back on parsing /proc/modules */
1824 	fp = fopen("/proc/modules", "re");
1825 	if (fp == NULL) {
1826 		int err = -errno;
1827 		ERR(mod->ctx,
1828 		    "could not open /proc/modules: %s\n", strerror(errno));
1829 		close(dfd);
1830 		return err;
1831 	}
1832 
1833 	while (fgets(line, sizeof(line), fp)) {
1834 		size_t len = strlen(line);
1835 		char *saveptr, *endptr, *tok = strtok_r(line, " \t", &saveptr);
1836 		long value;
1837 
1838 		lineno++;
1839 		if (tok == NULL || !streq(tok, mod->name))
1840 			goto eat_line;
1841 
1842 		tok = strtok_r(NULL, " \t", &saveptr);
1843 		if (tok == NULL) {
1844 			ERR(mod->ctx,
1845 			"invalid line format at /proc/modules:%d\n", lineno);
1846 			break;
1847 		}
1848 
1849 		value = strtol(tok, &endptr, 10);
1850 		if (endptr == tok || *endptr != '\0') {
1851 			ERR(mod->ctx,
1852 			"invalid line format at /proc/modules:%d\n", lineno);
1853 			break;
1854 		}
1855 
1856 		size = value;
1857 		break;
1858 eat_line:
1859 		while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
1860 			len = strlen(line);
1861 	}
1862 	fclose(fp);
1863 
1864 done:
1865 	close(dfd);
1866 	return size;
1867 }
1868 
1869 /**
1870  * kmod_module_get_refcnt:
1871  * @mod: kmod module
1872  *
1873  * Get the ref count of this @mod, as returned by Linux Kernel, by reading
1874  * /sys filesystem.
1875  *
1876  * Returns: the reference count on success or < 0 on failure.
1877  */
kmod_module_get_refcnt(const struct kmod_module * mod)1878 KMOD_EXPORT int kmod_module_get_refcnt(const struct kmod_module *mod)
1879 {
1880 	char path[PATH_MAX];
1881 	long refcnt;
1882 	int fd, err;
1883 
1884 	if (mod == NULL)
1885 		return -ENOENT;
1886 
1887 	snprintf(path, sizeof(path), "/sys/module/%s/refcnt", mod->name);
1888 	fd = open(path, O_RDONLY|O_CLOEXEC);
1889 	if (fd < 0) {
1890 		err = -errno;
1891 		DBG(mod->ctx, "could not open '%s': %s\n",
1892 			path, strerror(errno));
1893 		return err;
1894 	}
1895 
1896 	err = read_str_long(fd, &refcnt, 10);
1897 	close(fd);
1898 	if (err < 0) {
1899 		ERR(mod->ctx, "could not read integer from '%s': '%s'\n",
1900 			path, strerror(-err));
1901 		return err;
1902 	}
1903 
1904 	return (int)refcnt;
1905 }
1906 
1907 /**
1908  * kmod_module_get_holders:
1909  * @mod: kmod module
1910  *
1911  * Get a list of kmod modules that are holding this @mod, as returned by Linux
1912  * Kernel. After use, free the @list by calling kmod_module_unref_list().
1913  *
1914  * Returns: a new list of kmod modules on success or NULL on failure.
1915  */
kmod_module_get_holders(const struct kmod_module * mod)1916 KMOD_EXPORT struct kmod_list *kmod_module_get_holders(const struct kmod_module *mod)
1917 {
1918 	char dname[PATH_MAX];
1919 	struct kmod_list *list = NULL;
1920 	struct dirent *dent;
1921 	DIR *d;
1922 
1923 	if (mod == NULL || mod->ctx == NULL)
1924 		return NULL;
1925 
1926 	snprintf(dname, sizeof(dname), "/sys/module/%s/holders", mod->name);
1927 
1928 	d = opendir(dname);
1929 	if (d == NULL) {
1930 		ERR(mod->ctx, "could not open '%s': %s\n",
1931 						dname, strerror(errno));
1932 		return NULL;
1933 	}
1934 
1935 	for (dent = readdir(d); dent != NULL; dent = readdir(d)) {
1936 		struct kmod_module *holder;
1937 		struct kmod_list *l;
1938 		int err;
1939 
1940 		if (dent->d_name[0] == '.') {
1941 			if (dent->d_name[1] == '\0' ||
1942 			    (dent->d_name[1] == '.' && dent->d_name[2] == '\0'))
1943 				continue;
1944 		}
1945 
1946 		err = kmod_module_new_from_name(mod->ctx, dent->d_name,
1947 						&holder);
1948 		if (err < 0) {
1949 			ERR(mod->ctx, "could not create module for '%s': %s\n",
1950 				dent->d_name, strerror(-err));
1951 			goto fail;
1952 		}
1953 
1954 		l = kmod_list_append(list, holder);
1955 		if (l != NULL) {
1956 			list = l;
1957 		} else {
1958 			ERR(mod->ctx, "out of memory\n");
1959 			kmod_module_unref(holder);
1960 			goto fail;
1961 		}
1962 	}
1963 
1964 	closedir(d);
1965 	return list;
1966 
1967 fail:
1968 	closedir(d);
1969 	kmod_module_unref_list(list);
1970 	return NULL;
1971 }
1972 
1973 struct kmod_module_section {
1974 	unsigned long address;
1975 	char name[];
1976 };
1977 
kmod_module_section_free(struct kmod_module_section * section)1978 static void kmod_module_section_free(struct kmod_module_section *section)
1979 {
1980 	free(section);
1981 }
1982 
1983 /**
1984  * kmod_module_get_sections:
1985  * @mod: kmod module
1986  *
1987  * Get a list of kmod sections of this @mod, as returned by Linux Kernel. The
1988  * structure contained in this list is internal to libkmod and their fields
1989  * can be obtained by calling kmod_module_section_get_name() and
1990  * kmod_module_section_get_address().
1991  *
1992  * After use, free the @list by calling kmod_module_section_free_list().
1993  *
1994  * Returns: a new list of kmod module sections on success or NULL on failure.
1995  */
kmod_module_get_sections(const struct kmod_module * mod)1996 KMOD_EXPORT struct kmod_list *kmod_module_get_sections(const struct kmod_module *mod)
1997 {
1998 	char dname[PATH_MAX];
1999 	struct kmod_list *list = NULL;
2000 	struct dirent *dent;
2001 	DIR *d;
2002 	int dfd;
2003 
2004 	if (mod == NULL)
2005 		return NULL;
2006 
2007 	snprintf(dname, sizeof(dname), "/sys/module/%s/sections", mod->name);
2008 
2009 	d = opendir(dname);
2010 	if (d == NULL) {
2011 		ERR(mod->ctx, "could not open '%s': %s\n",
2012 			dname, strerror(errno));
2013 		return NULL;
2014 	}
2015 
2016 	dfd = dirfd(d);
2017 
2018 	for (dent = readdir(d); dent; dent = readdir(d)) {
2019 		struct kmod_module_section *section;
2020 		struct kmod_list *l;
2021 		unsigned long address;
2022 		size_t namesz;
2023 		int fd, err;
2024 
2025 		if (dent->d_name[0] == '.') {
2026 			if (dent->d_name[1] == '\0' ||
2027 			    (dent->d_name[1] == '.' && dent->d_name[2] == '\0'))
2028 				continue;
2029 		}
2030 
2031 		fd = openat(dfd, dent->d_name, O_RDONLY|O_CLOEXEC);
2032 		if (fd < 0) {
2033 			ERR(mod->ctx, "could not open '%s/%s': %m\n",
2034 							dname, dent->d_name);
2035 			goto fail;
2036 		}
2037 
2038 		err = read_str_ulong(fd, &address, 16);
2039 		close(fd);
2040 		if (err < 0) {
2041 			ERR(mod->ctx, "could not read long from '%s/%s': %m\n",
2042 							dname, dent->d_name);
2043 			goto fail;
2044 		}
2045 
2046 		namesz = strlen(dent->d_name) + 1;
2047 		section = malloc(sizeof(*section) + namesz);
2048 
2049 		if (section == NULL) {
2050 			ERR(mod->ctx, "out of memory\n");
2051 			goto fail;
2052 		}
2053 
2054 		section->address = address;
2055 		memcpy(section->name, dent->d_name, namesz);
2056 
2057 		l = kmod_list_append(list, section);
2058 		if (l != NULL) {
2059 			list = l;
2060 		} else {
2061 			ERR(mod->ctx, "out of memory\n");
2062 			free(section);
2063 			goto fail;
2064 		}
2065 	}
2066 
2067 	closedir(d);
2068 	return list;
2069 
2070 fail:
2071 	closedir(d);
2072 	kmod_module_unref_list(list);
2073 	return NULL;
2074 }
2075 
2076 /**
2077  * kmod_module_section_get_module_name:
2078  * @entry: a list entry representing a kmod module section
2079  *
2080  * Get the name of a kmod module section.
2081  *
2082  * After use, free the @list by calling kmod_module_section_free_list().
2083  *
2084  * Returns: the name of this kmod module section on success or NULL on
2085  * failure. The string is owned by the section, do not free it.
2086  */
kmod_module_section_get_name(const struct kmod_list * entry)2087 KMOD_EXPORT const char *kmod_module_section_get_name(const struct kmod_list *entry)
2088 {
2089 	struct kmod_module_section *section;
2090 
2091 	if (entry == NULL)
2092 		return NULL;
2093 
2094 	section = entry->data;
2095 	return section->name;
2096 }
2097 
2098 /**
2099  * kmod_module_section_get_address:
2100  * @entry: a list entry representing a kmod module section
2101  *
2102  * Get the address of a kmod module section.
2103  *
2104  * After use, free the @list by calling kmod_module_section_free_list().
2105  *
2106  * Returns: the address of this kmod module section on success or ULONG_MAX
2107  * on failure.
2108  */
kmod_module_section_get_address(const struct kmod_list * entry)2109 KMOD_EXPORT unsigned long kmod_module_section_get_address(const struct kmod_list *entry)
2110 {
2111 	struct kmod_module_section *section;
2112 
2113 	if (entry == NULL)
2114 		return (unsigned long)-1;
2115 
2116 	section = entry->data;
2117 	return section->address;
2118 }
2119 
2120 /**
2121  * kmod_module_section_free_list:
2122  * @list: kmod module section list
2123  *
2124  * Release the resources taken by @list
2125  */
kmod_module_section_free_list(struct kmod_list * list)2126 KMOD_EXPORT void kmod_module_section_free_list(struct kmod_list *list)
2127 {
2128 	while (list) {
2129 		kmod_module_section_free(list->data);
2130 		list = kmod_list_remove(list);
2131 	}
2132 }
2133 
kmod_module_get_elf(const struct kmod_module * mod)2134 static struct kmod_elf *kmod_module_get_elf(const struct kmod_module *mod)
2135 {
2136 	if (mod->file == NULL) {
2137 		const char *path = kmod_module_get_path(mod);
2138 
2139 		if (path == NULL) {
2140 			errno = ENOENT;
2141 			return NULL;
2142 		}
2143 
2144 		((struct kmod_module *)mod)->file = kmod_file_open(mod->ctx,
2145 									path);
2146 		if (mod->file == NULL)
2147 			return NULL;
2148 	}
2149 
2150 	return kmod_file_get_elf(mod->file);
2151 }
2152 
2153 struct kmod_module_info {
2154 	char *key;
2155 	char value[];
2156 };
2157 
kmod_module_info_new(const char * key,size_t keylen,const char * value,size_t valuelen)2158 static struct kmod_module_info *kmod_module_info_new(const char *key, size_t keylen, const char *value, size_t valuelen)
2159 {
2160 	struct kmod_module_info *info;
2161 
2162 	info = malloc(sizeof(struct kmod_module_info) + keylen + valuelen + 2);
2163 	if (info == NULL)
2164 		return NULL;
2165 
2166 	info->key = (char *)info + sizeof(struct kmod_module_info)
2167 		    + valuelen + 1;
2168 	memcpy(info->key, key, keylen);
2169 	info->key[keylen] = '\0';
2170 	memcpy(info->value, value, valuelen);
2171 	info->value[valuelen] = '\0';
2172 	return info;
2173 }
2174 
kmod_module_info_free(struct kmod_module_info * info)2175 static void kmod_module_info_free(struct kmod_module_info *info)
2176 {
2177 	free(info);
2178 }
2179 
kmod_module_info_append(struct kmod_list ** list,const char * key,size_t keylen,const char * value,size_t valuelen)2180 static struct kmod_list *kmod_module_info_append(struct kmod_list **list, const char *key, size_t keylen, const char *value, size_t valuelen)
2181 {
2182 	struct kmod_module_info *info;
2183 	struct kmod_list *n;
2184 
2185 	info = kmod_module_info_new(key, keylen, value, valuelen);
2186 	if (info == NULL)
2187 		return NULL;
2188 	n = kmod_list_append(*list, info);
2189 	if (n != NULL)
2190 		*list = n;
2191 	else
2192 		kmod_module_info_free(info);
2193 	return n;
2194 }
2195 
kmod_module_hex_to_str(const char * hex,size_t len)2196 static char *kmod_module_hex_to_str(const char *hex, size_t len)
2197 {
2198 	char *str;
2199 	int i;
2200 	int j;
2201 	const size_t line_limit = 20;
2202 	size_t str_len;
2203 
2204 	str_len = len * 3; /* XX: or XX\0 */
2205 	str_len += ((str_len + line_limit - 1) / line_limit - 1) * 3; /* \n\t\t */
2206 
2207 	str = malloc(str_len);
2208 	if (str == NULL)
2209 		return NULL;
2210 
2211 	for (i = 0, j = 0; i < (int)len; i++) {
2212 		j += sprintf(str + j, "%02X", (unsigned char)hex[i]);
2213 		if (i < (int)len - 1) {
2214 			str[j++] = ':';
2215 
2216 			if ((i + 1) % line_limit == 0)
2217 				j += sprintf(str + j, "\n\t\t");
2218 		}
2219 	}
2220 	return str;
2221 }
2222 
kmod_module_info_append_hex(struct kmod_list ** list,const char * key,size_t keylen,const char * value,size_t valuelen)2223 static struct kmod_list *kmod_module_info_append_hex(struct kmod_list **list,
2224 						     const char *key,
2225 						     size_t keylen,
2226 						     const char *value,
2227 						     size_t valuelen)
2228 {
2229 	char *hex;
2230 	struct kmod_list *n;
2231 
2232 	if (valuelen > 0) {
2233 		/* Display as 01:12:DE:AD:BE:EF:... */
2234 		hex = kmod_module_hex_to_str(value, valuelen);
2235 		if (hex == NULL)
2236 			goto list_error;
2237 		n = kmod_module_info_append(list, key, keylen, hex, strlen(hex));
2238 		free(hex);
2239 		if (n == NULL)
2240 			goto list_error;
2241 	} else {
2242 		n = kmod_module_info_append(list, key, keylen, NULL, 0);
2243 		if (n == NULL)
2244 			goto list_error;
2245 	}
2246 
2247 	return n;
2248 
2249 list_error:
2250 	return NULL;
2251 }
2252 
2253 /**
2254  * kmod_module_get_info:
2255  * @mod: kmod module
2256  * @list: where to return list of module information. Use
2257  *        kmod_module_info_get_key() and
2258  *        kmod_module_info_get_value(). Release this list with
2259  *        kmod_module_info_free_list()
2260  *
2261  * Get a list of entries in ELF section ".modinfo", these contain
2262  * alias, license, depends, vermagic and other keys with respective
2263  * values. If the module is signed (CONFIG_MODULE_SIG), information
2264  * about the module signature is included as well: signer,
2265  * sig_key and sig_hashalgo.
2266  *
2267  * After use, free the @list by calling kmod_module_info_free_list().
2268  *
2269  * Returns: 0 on success or < 0 otherwise.
2270  */
kmod_module_get_info(const struct kmod_module * mod,struct kmod_list ** list)2271 KMOD_EXPORT int kmod_module_get_info(const struct kmod_module *mod, struct kmod_list **list)
2272 {
2273 	struct kmod_elf *elf;
2274 	char **strings;
2275 	int i, count, ret = -ENOMEM;
2276 	struct kmod_signature_info sig_info = {};
2277 
2278 	if (mod == NULL || list == NULL)
2279 		return -ENOENT;
2280 
2281 	assert(*list == NULL);
2282 
2283 	elf = kmod_module_get_elf(mod);
2284 	if (elf == NULL)
2285 		return -errno;
2286 
2287 	count = kmod_elf_get_strings(elf, ".modinfo", &strings);
2288 	if (count < 0)
2289 		return count;
2290 
2291 	for (i = 0; i < count; i++) {
2292 		struct kmod_list *n;
2293 		const char *key, *value;
2294 		size_t keylen, valuelen;
2295 
2296 		key = strings[i];
2297 		value = strchr(key, '=');
2298 		if (value == NULL) {
2299 			keylen = strlen(key);
2300 			valuelen = 0;
2301 			value = key;
2302 		} else {
2303 			keylen = value - key;
2304 			value++;
2305 			valuelen = strlen(value);
2306 		}
2307 
2308 		n = kmod_module_info_append(list, key, keylen, value, valuelen);
2309 		if (n == NULL)
2310 			goto list_error;
2311 	}
2312 
2313 	if (kmod_module_signature_info(mod->file, &sig_info)) {
2314 		struct kmod_list *n;
2315 
2316 		n = kmod_module_info_append(list, "sig_id", strlen("sig_id"),
2317 				sig_info.id_type, strlen(sig_info.id_type));
2318 		if (n == NULL)
2319 			goto list_error;
2320 		count++;
2321 
2322 		n = kmod_module_info_append(list, "signer", strlen("signer"),
2323 				sig_info.signer, sig_info.signer_len);
2324 		if (n == NULL)
2325 			goto list_error;
2326 		count++;
2327 
2328 
2329 		n = kmod_module_info_append_hex(list, "sig_key", strlen("sig_key"),
2330 						sig_info.key_id,
2331 						sig_info.key_id_len);
2332 		if (n == NULL)
2333 			goto list_error;
2334 		count++;
2335 
2336 		n = kmod_module_info_append(list,
2337 				"sig_hashalgo", strlen("sig_hashalgo"),
2338 				sig_info.hash_algo, strlen(sig_info.hash_algo));
2339 		if (n == NULL)
2340 			goto list_error;
2341 		count++;
2342 
2343 		/*
2344 		 * Omit sig_info.algo for now, as these
2345 		 * are currently constant.
2346 		 */
2347 		n = kmod_module_info_append_hex(list, "signature",
2348 						strlen("signature"),
2349 						sig_info.sig,
2350 						sig_info.sig_len);
2351 
2352 		if (n == NULL)
2353 			goto list_error;
2354 		count++;
2355 
2356 	}
2357 	ret = count;
2358 
2359 list_error:
2360 	/* aux structures freed in normal case also */
2361 	kmod_module_signature_info_free(&sig_info);
2362 
2363 	if (ret < 0) {
2364 		kmod_module_info_free_list(*list);
2365 		*list = NULL;
2366 	}
2367 	free(strings);
2368 	return ret;
2369 }
2370 
2371 /**
2372  * kmod_module_info_get_key:
2373  * @entry: a list entry representing a kmod module info
2374  *
2375  * Get the key of a kmod module info.
2376  *
2377  * Returns: the key of this kmod module info on success or NULL on
2378  * failure. The string is owned by the info, do not free it.
2379  */
kmod_module_info_get_key(const struct kmod_list * entry)2380 KMOD_EXPORT const char *kmod_module_info_get_key(const struct kmod_list *entry)
2381 {
2382 	struct kmod_module_info *info;
2383 
2384 	if (entry == NULL)
2385 		return NULL;
2386 
2387 	info = entry->data;
2388 	return info->key;
2389 }
2390 
2391 /**
2392  * kmod_module_info_get_value:
2393  * @entry: a list entry representing a kmod module info
2394  *
2395  * Get the value of a kmod module info.
2396  *
2397  * Returns: the value of this kmod module info on success or NULL on
2398  * failure. The string is owned by the info, do not free it.
2399  */
kmod_module_info_get_value(const struct kmod_list * entry)2400 KMOD_EXPORT const char *kmod_module_info_get_value(const struct kmod_list *entry)
2401 {
2402 	struct kmod_module_info *info;
2403 
2404 	if (entry == NULL)
2405 		return NULL;
2406 
2407 	info = entry->data;
2408 	return info->value;
2409 }
2410 
2411 /**
2412  * kmod_module_info_free_list:
2413  * @list: kmod module info list
2414  *
2415  * Release the resources taken by @list
2416  */
kmod_module_info_free_list(struct kmod_list * list)2417 KMOD_EXPORT void kmod_module_info_free_list(struct kmod_list *list)
2418 {
2419 	while (list) {
2420 		kmod_module_info_free(list->data);
2421 		list = kmod_list_remove(list);
2422 	}
2423 }
2424 
2425 struct kmod_module_version {
2426 	uint64_t crc;
2427 	char symbol[];
2428 };
2429 
kmod_module_versions_new(uint64_t crc,const char * symbol)2430 static struct kmod_module_version *kmod_module_versions_new(uint64_t crc, const char *symbol)
2431 {
2432 	struct kmod_module_version *mv;
2433 	size_t symbollen = strlen(symbol) + 1;
2434 
2435 	mv = malloc(sizeof(struct kmod_module_version) + symbollen);
2436 	if (mv == NULL)
2437 		return NULL;
2438 
2439 	mv->crc = crc;
2440 	memcpy(mv->symbol, symbol, symbollen);
2441 	return mv;
2442 }
2443 
kmod_module_version_free(struct kmod_module_version * version)2444 static void kmod_module_version_free(struct kmod_module_version *version)
2445 {
2446 	free(version);
2447 }
2448 
2449 /**
2450  * kmod_module_get_versions:
2451  * @mod: kmod module
2452  * @list: where to return list of module versions. Use
2453  *        kmod_module_version_get_symbol() and
2454  *        kmod_module_version_get_crc(). Release this list with
2455  *        kmod_module_versions_free_list()
2456  *
2457  * Get a list of entries in ELF section "__versions".
2458  *
2459  * After use, free the @list by calling kmod_module_versions_free_list().
2460  *
2461  * Returns: 0 on success or < 0 otherwise.
2462  */
kmod_module_get_versions(const struct kmod_module * mod,struct kmod_list ** list)2463 KMOD_EXPORT int kmod_module_get_versions(const struct kmod_module *mod, struct kmod_list **list)
2464 {
2465 	struct kmod_elf *elf;
2466 	struct kmod_modversion *versions;
2467 	int i, count, ret = 0;
2468 
2469 	if (mod == NULL || list == NULL)
2470 		return -ENOENT;
2471 
2472 	assert(*list == NULL);
2473 
2474 	elf = kmod_module_get_elf(mod);
2475 	if (elf == NULL)
2476 		return -errno;
2477 
2478 	count = kmod_elf_get_modversions(elf, &versions);
2479 	if (count < 0)
2480 		return count;
2481 
2482 	for (i = 0; i < count; i++) {
2483 		struct kmod_module_version *mv;
2484 		struct kmod_list *n;
2485 
2486 		mv = kmod_module_versions_new(versions[i].crc, versions[i].symbol);
2487 		if (mv == NULL) {
2488 			ret = -errno;
2489 			kmod_module_versions_free_list(*list);
2490 			*list = NULL;
2491 			goto list_error;
2492 		}
2493 
2494 		n = kmod_list_append(*list, mv);
2495 		if (n != NULL)
2496 			*list = n;
2497 		else {
2498 			kmod_module_version_free(mv);
2499 			kmod_module_versions_free_list(*list);
2500 			*list = NULL;
2501 			ret = -ENOMEM;
2502 			goto list_error;
2503 		}
2504 	}
2505 	ret = count;
2506 
2507 list_error:
2508 	free(versions);
2509 	return ret;
2510 }
2511 
2512 /**
2513  * kmod_module_version_get_symbol:
2514  * @entry: a list entry representing a kmod module versions
2515  *
2516  * Get the symbol of a kmod module versions.
2517  *
2518  * Returns: the symbol of this kmod module versions on success or NULL
2519  * on failure. The string is owned by the versions, do not free it.
2520  */
kmod_module_version_get_symbol(const struct kmod_list * entry)2521 KMOD_EXPORT const char *kmod_module_version_get_symbol(const struct kmod_list *entry)
2522 {
2523 	struct kmod_module_version *version;
2524 
2525 	if (entry == NULL || entry->data == NULL)
2526 		return NULL;
2527 
2528 	version = entry->data;
2529 	return version->symbol;
2530 }
2531 
2532 /**
2533  * kmod_module_version_get_crc:
2534  * @entry: a list entry representing a kmod module version
2535  *
2536  * Get the crc of a kmod module version.
2537  *
2538  * Returns: the crc of this kmod module version if available, otherwise default to 0.
2539  */
kmod_module_version_get_crc(const struct kmod_list * entry)2540 KMOD_EXPORT uint64_t kmod_module_version_get_crc(const struct kmod_list *entry)
2541 {
2542 	struct kmod_module_version *version;
2543 
2544 	if (entry == NULL || entry->data == NULL)
2545 		return 0;
2546 
2547 	version = entry->data;
2548 	return version->crc;
2549 }
2550 
2551 /**
2552  * kmod_module_versions_free_list:
2553  * @list: kmod module versions list
2554  *
2555  * Release the resources taken by @list
2556  */
kmod_module_versions_free_list(struct kmod_list * list)2557 KMOD_EXPORT void kmod_module_versions_free_list(struct kmod_list *list)
2558 {
2559 	while (list) {
2560 		kmod_module_version_free(list->data);
2561 		list = kmod_list_remove(list);
2562 	}
2563 }
2564 
2565 struct kmod_module_symbol {
2566 	uint64_t crc;
2567 	char symbol[];
2568 };
2569 
kmod_module_symbols_new(uint64_t crc,const char * symbol)2570 static struct kmod_module_symbol *kmod_module_symbols_new(uint64_t crc, const char *symbol)
2571 {
2572 	struct kmod_module_symbol *mv;
2573 	size_t symbollen = strlen(symbol) + 1;
2574 
2575 	mv = malloc(sizeof(struct kmod_module_symbol) + symbollen);
2576 	if (mv == NULL)
2577 		return NULL;
2578 
2579 	mv->crc = crc;
2580 	memcpy(mv->symbol, symbol, symbollen);
2581 	return mv;
2582 }
2583 
kmod_module_symbol_free(struct kmod_module_symbol * symbol)2584 static void kmod_module_symbol_free(struct kmod_module_symbol *symbol)
2585 {
2586 	free(symbol);
2587 }
2588 
2589 /**
2590  * kmod_module_get_symbols:
2591  * @mod: kmod module
2592  * @list: where to return list of module symbols. Use
2593  *        kmod_module_symbol_get_symbol() and
2594  *        kmod_module_symbol_get_crc(). Release this list with
2595  *        kmod_module_symbols_free_list()
2596  *
2597  * Get a list of entries in ELF section ".symtab" or "__ksymtab_strings".
2598  *
2599  * After use, free the @list by calling kmod_module_symbols_free_list().
2600  *
2601  * Returns: 0 on success or < 0 otherwise.
2602  */
kmod_module_get_symbols(const struct kmod_module * mod,struct kmod_list ** list)2603 KMOD_EXPORT int kmod_module_get_symbols(const struct kmod_module *mod, struct kmod_list **list)
2604 {
2605 	struct kmod_elf *elf;
2606 	struct kmod_modversion *symbols;
2607 	int i, count, ret = 0;
2608 
2609 	if (mod == NULL || list == NULL)
2610 		return -ENOENT;
2611 
2612 	assert(*list == NULL);
2613 
2614 	elf = kmod_module_get_elf(mod);
2615 	if (elf == NULL)
2616 		return -errno;
2617 
2618 	count = kmod_elf_get_symbols(elf, &symbols);
2619 	if (count < 0)
2620 		return count;
2621 
2622 	for (i = 0; i < count; i++) {
2623 		struct kmod_module_symbol *mv;
2624 		struct kmod_list *n;
2625 
2626 		mv = kmod_module_symbols_new(symbols[i].crc, symbols[i].symbol);
2627 		if (mv == NULL) {
2628 			ret = -errno;
2629 			kmod_module_symbols_free_list(*list);
2630 			*list = NULL;
2631 			goto list_error;
2632 		}
2633 
2634 		n = kmod_list_append(*list, mv);
2635 		if (n != NULL)
2636 			*list = n;
2637 		else {
2638 			kmod_module_symbol_free(mv);
2639 			kmod_module_symbols_free_list(*list);
2640 			*list = NULL;
2641 			ret = -ENOMEM;
2642 			goto list_error;
2643 		}
2644 	}
2645 	ret = count;
2646 
2647 list_error:
2648 	free(symbols);
2649 	return ret;
2650 }
2651 
2652 /**
2653  * kmod_module_symbol_get_symbol:
2654  * @entry: a list entry representing a kmod module symbols
2655  *
2656  * Get the symbol of a kmod module symbols.
2657  *
2658  * Returns: the symbol of this kmod module symbols on success or NULL
2659  * on failure. The string is owned by the symbols, do not free it.
2660  */
kmod_module_symbol_get_symbol(const struct kmod_list * entry)2661 KMOD_EXPORT const char *kmod_module_symbol_get_symbol(const struct kmod_list *entry)
2662 {
2663 	struct kmod_module_symbol *symbol;
2664 
2665 	if (entry == NULL || entry->data == NULL)
2666 		return NULL;
2667 
2668 	symbol = entry->data;
2669 	return symbol->symbol;
2670 }
2671 
2672 /**
2673  * kmod_module_symbol_get_crc:
2674  * @entry: a list entry representing a kmod module symbol
2675  *
2676  * Get the crc of a kmod module symbol.
2677  *
2678  * Returns: the crc of this kmod module symbol if available, otherwise default to 0.
2679  */
kmod_module_symbol_get_crc(const struct kmod_list * entry)2680 KMOD_EXPORT uint64_t kmod_module_symbol_get_crc(const struct kmod_list *entry)
2681 {
2682 	struct kmod_module_symbol *symbol;
2683 
2684 	if (entry == NULL || entry->data == NULL)
2685 		return 0;
2686 
2687 	symbol = entry->data;
2688 	return symbol->crc;
2689 }
2690 
2691 /**
2692  * kmod_module_symbols_free_list:
2693  * @list: kmod module symbols list
2694  *
2695  * Release the resources taken by @list
2696  */
kmod_module_symbols_free_list(struct kmod_list * list)2697 KMOD_EXPORT void kmod_module_symbols_free_list(struct kmod_list *list)
2698 {
2699 	while (list) {
2700 		kmod_module_symbol_free(list->data);
2701 		list = kmod_list_remove(list);
2702 	}
2703 }
2704 
2705 struct kmod_module_dependency_symbol {
2706 	uint64_t crc;
2707 	uint8_t bind;
2708 	char symbol[];
2709 };
2710 
kmod_module_dependency_symbols_new(uint64_t crc,uint8_t bind,const char * symbol)2711 static struct kmod_module_dependency_symbol *kmod_module_dependency_symbols_new(uint64_t crc, uint8_t bind, const char *symbol)
2712 {
2713 	struct kmod_module_dependency_symbol *mv;
2714 	size_t symbollen = strlen(symbol) + 1;
2715 
2716 	mv = malloc(sizeof(struct kmod_module_dependency_symbol) + symbollen);
2717 	if (mv == NULL)
2718 		return NULL;
2719 
2720 	mv->crc = crc;
2721 	mv->bind = bind;
2722 	memcpy(mv->symbol, symbol, symbollen);
2723 	return mv;
2724 }
2725 
kmod_module_dependency_symbol_free(struct kmod_module_dependency_symbol * dependency_symbol)2726 static void kmod_module_dependency_symbol_free(struct kmod_module_dependency_symbol *dependency_symbol)
2727 {
2728 	free(dependency_symbol);
2729 }
2730 
2731 /**
2732  * kmod_module_get_dependency_symbols:
2733  * @mod: kmod module
2734  * @list: where to return list of module dependency_symbols. Use
2735  *        kmod_module_dependency_symbol_get_symbol() and
2736  *        kmod_module_dependency_symbol_get_crc(). Release this list with
2737  *        kmod_module_dependency_symbols_free_list()
2738  *
2739  * Get a list of entries in ELF section ".symtab" or "__ksymtab_strings".
2740  *
2741  * After use, free the @list by calling
2742  * kmod_module_dependency_symbols_free_list().
2743  *
2744  * Returns: 0 on success or < 0 otherwise.
2745  */
kmod_module_get_dependency_symbols(const struct kmod_module * mod,struct kmod_list ** list)2746 KMOD_EXPORT int kmod_module_get_dependency_symbols(const struct kmod_module *mod, struct kmod_list **list)
2747 {
2748 	struct kmod_elf *elf;
2749 	struct kmod_modversion *symbols;
2750 	int i, count, ret = 0;
2751 
2752 	if (mod == NULL || list == NULL)
2753 		return -ENOENT;
2754 
2755 	assert(*list == NULL);
2756 
2757 	elf = kmod_module_get_elf(mod);
2758 	if (elf == NULL)
2759 		return -errno;
2760 
2761 	count = kmod_elf_get_dependency_symbols(elf, &symbols);
2762 	if (count < 0)
2763 		return count;
2764 
2765 	for (i = 0; i < count; i++) {
2766 		struct kmod_module_dependency_symbol *mv;
2767 		struct kmod_list *n;
2768 
2769 		mv = kmod_module_dependency_symbols_new(symbols[i].crc,
2770 							symbols[i].bind,
2771 							symbols[i].symbol);
2772 		if (mv == NULL) {
2773 			ret = -errno;
2774 			kmod_module_dependency_symbols_free_list(*list);
2775 			*list = NULL;
2776 			goto list_error;
2777 		}
2778 
2779 		n = kmod_list_append(*list, mv);
2780 		if (n != NULL)
2781 			*list = n;
2782 		else {
2783 			kmod_module_dependency_symbol_free(mv);
2784 			kmod_module_dependency_symbols_free_list(*list);
2785 			*list = NULL;
2786 			ret = -ENOMEM;
2787 			goto list_error;
2788 		}
2789 	}
2790 	ret = count;
2791 
2792 list_error:
2793 	free(symbols);
2794 	return ret;
2795 }
2796 
2797 /**
2798  * kmod_module_dependency_symbol_get_symbol:
2799  * @entry: a list entry representing a kmod module dependency_symbols
2800  *
2801  * Get the dependency symbol of a kmod module
2802  *
2803  * Returns: the symbol of this kmod module dependency_symbols on success or NULL
2804  * on failure. The string is owned by the dependency_symbols, do not free it.
2805  */
kmod_module_dependency_symbol_get_symbol(const struct kmod_list * entry)2806 KMOD_EXPORT const char *kmod_module_dependency_symbol_get_symbol(const struct kmod_list *entry)
2807 {
2808 	struct kmod_module_dependency_symbol *dependency_symbol;
2809 
2810 	if (entry == NULL || entry->data == NULL)
2811 		return NULL;
2812 
2813 	dependency_symbol = entry->data;
2814 	return dependency_symbol->symbol;
2815 }
2816 
2817 /**
2818  * kmod_module_dependency_symbol_get_crc:
2819  * @entry: a list entry representing a kmod module dependency_symbol
2820  *
2821  * Get the crc of a kmod module dependency_symbol.
2822  *
2823  * Returns: the crc of this kmod module dependency_symbol if available, otherwise default to 0.
2824  */
kmod_module_dependency_symbol_get_crc(const struct kmod_list * entry)2825 KMOD_EXPORT uint64_t kmod_module_dependency_symbol_get_crc(const struct kmod_list *entry)
2826 {
2827 	struct kmod_module_dependency_symbol *dependency_symbol;
2828 
2829 	if (entry == NULL || entry->data == NULL)
2830 		return 0;
2831 
2832 	dependency_symbol = entry->data;
2833 	return dependency_symbol->crc;
2834 }
2835 
2836 /**
2837  * kmod_module_dependency_symbol_get_bind:
2838  * @entry: a list entry representing a kmod module dependency_symbol
2839  *
2840  * Get the bind type of a kmod module dependency_symbol.
2841  *
2842  * Returns: the bind of this kmod module dependency_symbol on success
2843  * or < 0 on failure.
2844  */
kmod_module_dependency_symbol_get_bind(const struct kmod_list * entry)2845 KMOD_EXPORT int kmod_module_dependency_symbol_get_bind(const struct kmod_list *entry)
2846 {
2847 	struct kmod_module_dependency_symbol *dependency_symbol;
2848 
2849 	if (entry == NULL || entry->data == NULL)
2850 		return 0;
2851 
2852 	dependency_symbol = entry->data;
2853 	return dependency_symbol->bind;
2854 }
2855 
2856 /**
2857  * kmod_module_dependency_symbols_free_list:
2858  * @list: kmod module dependency_symbols list
2859  *
2860  * Release the resources taken by @list
2861  */
kmod_module_dependency_symbols_free_list(struct kmod_list * list)2862 KMOD_EXPORT void kmod_module_dependency_symbols_free_list(struct kmod_list *list)
2863 {
2864 	while (list) {
2865 		kmod_module_dependency_symbol_free(list->data);
2866 		list = kmod_list_remove(list);
2867 	}
2868 }
2869