2 * libkmod - interface to kernel module operations
4 * Copyright (C) 2011 ProFUSION embedded systems
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include <sys/types.h>
39 #include "libkmod-private.h"
44 * Opaque object representing a module.
51 struct kmod_list
*dep
;
53 const char *install_commands
; /* owned by kmod_config */
54 const char *remove_commands
; /* owned by kmod_config */
55 char *alias
; /* only set if this module was created from an alias */
61 bool install_commands
: 1;
62 bool remove_commands
: 1;
66 inline char *modname_normalize(const char *modname
, char buf
[NAME_MAX
],
71 for (s
= 0; s
< NAME_MAX
- 1; s
++) {
72 const char c
= modname
[s
];
75 else if (c
== '\0' || c
== '.')
89 static char *path_to_modname(const char *path
, char buf
[NAME_MAX
], size_t *len
)
93 modname
= basename(path
);
94 if (modname
== NULL
|| modname
[0] == '\0')
97 return modname_normalize(modname
, buf
, len
);
100 static inline const char *path_join(const char *path
, size_t prefixlen
,
108 pathlen
= strlen(path
);
109 if (prefixlen
+ pathlen
+ 1 >= PATH_MAX
)
112 memcpy(buf
+ prefixlen
, path
, pathlen
+ 1);
116 int kmod_module_parse_depline(struct kmod_module
*mod
, char *line
)
118 struct kmod_ctx
*ctx
= mod
->ctx
;
119 struct kmod_list
*list
= NULL
;
128 assert(mod
->dep
== NULL
);
129 mod
->init
.dep
= true;
131 p
= strchr(line
, ':');
136 dirname
= kmod_get_dirname(mod
->ctx
);
137 dirnamelen
= strlen(dirname
);
138 if (dirnamelen
+ 2 >= PATH_MAX
)
141 memcpy(buf
, dirname
, dirnamelen
);
142 buf
[dirnamelen
] = '/';
144 buf
[dirnamelen
] = '\0';
146 if (mod
->path
== NULL
) {
147 const char *str
= path_join(line
, dirnamelen
, buf
);
150 mod
->path
= strdup(str
);
151 if (mod
->path
== NULL
)
156 for (p
= strtok_r(p
, " \t", &saveptr
); p
!= NULL
;
157 p
= strtok_r(NULL
, " \t", &saveptr
)) {
158 struct kmod_module
*depmod
;
161 path
= path_join(p
, dirnamelen
, buf
);
163 ERR(ctx
, "could not join path '%s' and '%s'.\n",
168 err
= kmod_module_new_from_path(ctx
, path
, &depmod
);
170 ERR(ctx
, "ctx=%p path=%s error=%s\n",
171 ctx
, path
, strerror(-err
));
175 DBG(ctx
, "add dep: %s\n", path
);
177 list
= kmod_list_append(list
, depmod
);
181 DBG(ctx
, "%d dependencies for %s\n", n
, mod
->name
);
188 kmod_module_unref_list(list
);
189 mod
->init
.dep
= false;
194 * kmod_module_new_from_name:
195 * @ctx: kmod library context
196 * @name: name of the module
197 * @mod: where to save the created struct kmod_module
199 * Create a new struct kmod_module using the module name. @name can not be an
200 * alias, file name or anything else; it must be a module name. There's no
201 * check if the module does exists in the system.
203 * This function is also used internally by many others that return a new
204 * struct kmod_module or a new list of modules.
206 * The initial refcount is 1, and needs to be decremented to release the
207 * resources of the kmod_module. Since libkmod keeps track of all
208 * kmod_modules created, they are all released upon @ctx destruction too. Do
209 * not unref @ctx before all the desired operations with the returned
210 * kmod_module are done.
212 * Returns: 0 on success or < 0 otherwise. It fails if name is not a valid
213 * module name or if memory allocation failed.
215 KMOD_EXPORT
int kmod_module_new_from_name(struct kmod_ctx
*ctx
,
217 struct kmod_module
**mod
)
219 struct kmod_module
*m
;
221 char name_norm
[NAME_MAX
];
224 if (ctx
== NULL
|| name
== NULL
|| mod
== NULL
)
227 alias_normalize(name
, name_norm
, &namelen
);
229 m
= kmod_pool_get_module(ctx
, name_norm
);
231 *mod
= kmod_module_ref(m
);
235 namesep
= strchr(name_norm
, '/');
236 m
= malloc(sizeof(*m
) + (namesep
== NULL
? 1 : 2) * namelen
+ 2);
242 memset(m
, 0, sizeof(*m
));
244 m
->ctx
= kmod_ref(ctx
);
245 m
->name
= (char *)m
+ sizeof(*m
);
246 memcpy(m
->name
, name_norm
, namelen
+ 1);
249 size_t len
= namesep
- name_norm
;
252 m
->alias
= m
->name
+ len
+ 1;
253 m
->hashkey
= m
->name
+ namelen
+ 1;
254 memcpy(m
->hashkey
, name_norm
, namelen
+ 1);
256 m
->hashkey
= m
->name
;
260 kmod_pool_add_module(ctx
, m
, m
->hashkey
);
266 int kmod_module_new_from_alias(struct kmod_ctx
*ctx
, const char *alias
,
267 const char *name
, struct kmod_module
**mod
)
271 size_t namelen
= strlen(name
);
272 size_t aliaslen
= strlen(alias
);
274 if (namelen
+ aliaslen
+ 2 > NAME_MAX
)
275 return -ENAMETOOLONG
;
277 memcpy(key
, name
, namelen
);
278 memcpy(key
+ namelen
+ 1, alias
, aliaslen
+ 1);
281 err
= kmod_module_new_from_name(ctx
, key
, mod
);
289 * kmod_module_new_from_path:
290 * @ctx: kmod library context
291 * @path: path where to find the given module
292 * @mod: where to save the created struct kmod_module
294 * Create a new struct kmod_module using the module path. @path must be an
295 * existent file with in the filesystem and must be accessible to libkmod.
297 * The initial refcount is 1, and needs to be decremented to release the
298 * resources of the kmod_module. Since libkmod keeps track of all
299 * kmod_modules created, they are all released upon @ctx destruction too. Do
300 * not unref @ctx before all the desired operations with the returned
301 * kmod_module are done.
303 * If @path is relative, it's treated as relative to the current working
304 * directory. Otherwise, give an absolute path.
306 * Returns: 0 on success or < 0 otherwise. It fails if file does not exist, if
307 * it's not a valid file for a kmod_module or if memory allocation failed.
309 KMOD_EXPORT
int kmod_module_new_from_path(struct kmod_ctx
*ctx
,
311 struct kmod_module
**mod
)
313 struct kmod_module
*m
;
320 if (ctx
== NULL
|| path
== NULL
|| mod
== NULL
)
323 abspath
= path_make_absolute_cwd(path
);
327 err
= stat(abspath
, &st
);
333 if (path_to_modname(path
, name
, &namelen
) == NULL
) {
338 m
= kmod_pool_get_module(ctx
, name
);
342 else if (streq(m
->path
, abspath
))
345 ERR(ctx
, "kmod_module '%s' already exists with different path\n",
351 *mod
= kmod_module_ref(m
);
355 m
= malloc(sizeof(*m
) + namelen
+ 1);
359 memset(m
, 0, sizeof(*m
));
361 m
->ctx
= kmod_ref(ctx
);
362 m
->name
= (char *)m
+ sizeof(*m
);
363 memcpy(m
->name
, name
, namelen
);
365 m
->hashkey
= m
->name
;
368 kmod_pool_add_module(ctx
, m
, m
->hashkey
);
379 * Drop a reference of the kmod module. If the refcount reaches zero, its
380 * resources are released.
382 * Returns: NULL if @mod is NULL or if the module was released. Otherwise it
383 * returns the passed @mod with its refcount decremented.
385 KMOD_EXPORT
struct kmod_module
*kmod_module_unref(struct kmod_module
*mod
)
390 if (--mod
->refcount
> 0)
393 DBG(mod
->ctx
, "kmod_module %p released\n", mod
);
395 kmod_pool_del_module(mod
->ctx
, mod
, mod
->hashkey
);
396 kmod_module_unref_list(mod
->dep
);
397 kmod_unref(mod
->ctx
);
408 * Take a reference of the kmod module, incrementing its refcount.
410 * Returns: the passed @module with its refcount incremented.
412 KMOD_EXPORT
struct kmod_module
*kmod_module_ref(struct kmod_module
*mod
)
422 #define CHECK_ERR_AND_FINISH(_err, _label_err, _list, label_finish) \
426 if (*(_list) != NULL) \
431 * kmod_module_new_from_lookup:
432 * @ctx: kmod library context
433 * @given_alias: alias to look for
434 * @list: an empty list where to save the list of modules matching
437 * Create a new list of kmod modules using an alias or module name and lookup
438 * libkmod's configuration files and indexes in order to find the module.
439 * Once it's found in one of the places, it stops searching and create the
440 * list of modules that is saved in @list.
442 * The search order is: 1. aliases in configuration file; 2. module names in
443 * modules.dep index; 3. symbol aliases in modules.symbols index; 4. aliases
444 * in modules.alias index.
446 * The initial refcount is 1, and needs to be decremented to release the
447 * resources of the kmod_module. The returned @list must be released by
448 * calling kmod_module_unref_list(). Since libkmod keeps track of all
449 * kmod_modules created, they are all released upon @ctx destruction too. Do
450 * not unref @ctx before all the desired operations with the returned list are
453 * Returns: 0 on success or < 0 otherwise. It fails if any of the lookup
454 * methods failed, which is basically due to memory allocation fail. If module
455 * is not found, it still returns 0, but @list is an empty list.
457 KMOD_EXPORT
int kmod_module_new_from_lookup(struct kmod_ctx
*ctx
,
458 const char *given_alias
,
459 struct kmod_list
**list
)
462 char alias
[NAME_MAX
];
464 if (ctx
== NULL
|| given_alias
== NULL
)
467 if (list
== NULL
|| *list
!= NULL
) {
468 ERR(ctx
, "An empty list is needed to create lookup\n");
472 if (alias_normalize(given_alias
, alias
, NULL
) < 0)
475 /* Aliases from config file override all the others */
476 err
= kmod_lookup_alias_from_config(ctx
, alias
, list
);
477 CHECK_ERR_AND_FINISH(err
, fail
, list
, finish
);
479 err
= kmod_lookup_alias_from_moddep_file(ctx
, alias
, list
);
480 CHECK_ERR_AND_FINISH(err
, fail
, list
, finish
);
482 err
= kmod_lookup_alias_from_symbols_file(ctx
, alias
, list
);
483 CHECK_ERR_AND_FINISH(err
, fail
, list
, finish
);
485 err
= kmod_lookup_alias_from_commands(ctx
, alias
, list
);
486 CHECK_ERR_AND_FINISH(err
, fail
, list
, finish
);
488 err
= kmod_lookup_alias_from_aliases_file(ctx
, alias
, list
);
489 CHECK_ERR_AND_FINISH(err
, fail
, list
, finish
);
495 kmod_module_unref_list(*list
);
499 #undef CHECK_ERR_AND_FINISH
502 * kmod_module_unref_list:
503 * @list: list of kmod modules
505 * Drop a reference of each kmod module in @list and releases the resources
506 * taken by the list itself.
508 * Returns: NULL if @mod is NULL or if the module was released. Otherwise it
509 * returns the passed @mod with its refcount decremented.
511 KMOD_EXPORT
int kmod_module_unref_list(struct kmod_list
*list
)
513 for (; list
!= NULL
; list
= kmod_list_remove(list
))
514 kmod_module_unref(list
->data
);
520 * kmod_module_get_dependencies:
523 * Search the modules.dep index to find the dependencies of the given @mod.
524 * The result is cached in @mod, so subsequent calls to this function will
525 * return the already searched list of modules.
527 * Returns: NULL on failure or if there are any dependencies. Otherwise it
528 * returns a list of kmod modules that can be released by calling
529 * kmod_module_unref_list().
531 KMOD_EXPORT
struct kmod_list
*kmod_module_get_dependencies(const struct kmod_module
*mod
)
533 struct kmod_list
*l
, *l_new
, *list_new
= NULL
;
538 if (!mod
->init
.dep
) {
540 char *line
= kmod_search_moddep(mod
->ctx
, mod
->name
);
545 kmod_module_parse_depline((struct kmod_module
*)mod
, line
);
552 kmod_list_foreach(l
, mod
->dep
) {
553 l_new
= kmod_list_append(list_new
, kmod_module_ref(l
->data
));
555 kmod_module_unref(l
->data
);
565 ERR(mod
->ctx
, "out of memory\n");
566 kmod_module_unref_list(list_new
);
571 * kmod_module_get_module:
572 * @entry: an entry in a list of kmod modules.
574 * Get the kmod module of this @entry in the list, increasing its refcount.
575 * After it's used, unref it. Since the refcount is incremented upon return,
576 * you still have to call kmod_module_unref_list() to release the list of kmod
579 * Returns: NULL on failure or the kmod_module contained in this list entry
580 * with its refcount incremented.
582 KMOD_EXPORT
struct kmod_module
*kmod_module_get_module(const struct kmod_list
*entry
)
587 return kmod_module_ref(entry
->data
);
591 * kmod_module_get_name:
594 * Get the name of this kmod module. Name is always available, independently
595 * if it was created by kmod_module_new_from_name() or another function and
596 * it's always normalized (dashes are replaced with underscores).
598 * Returns: the name of this kmod module.
600 KMOD_EXPORT
const char *kmod_module_get_name(const struct kmod_module
*mod
)
609 * kmod_module_get_path:
612 * Get the path of this kmod module. If this kmod module was not created by
613 * path, it can search the modules.dep index in order to find out the module
614 * under context's dirname (see kmod_get_dirname()).
616 * Returns: the path of this kmod module or NULL if such information is not
619 KMOD_EXPORT
const char *kmod_module_get_path(const struct kmod_module
*mod
)
626 DBG(mod
->ctx
, "name='%s' path='%s'\n", mod
->name
, mod
->path
);
628 if (mod
->path
!= NULL
)
634 line
= kmod_search_moddep(mod
->ctx
, mod
->name
);
638 kmod_module_parse_depline((struct kmod_module
*) mod
, line
);
645 extern long delete_module(const char *name
, unsigned int flags
);
648 * kmod_module_remove_module:
650 * @flags: flags to pass to Linux kernel when removing the module
652 * Remove a module from Linux kernel.
654 * Returns: 0 on success or < 0 on failure.
656 KMOD_EXPORT
int kmod_module_remove_module(struct kmod_module
*mod
,
664 /* Filter out other flags */
665 flags
&= (KMOD_REMOVE_FORCE
| KMOD_REMOVE_NOWAIT
);
667 err
= delete_module(mod
->name
, flags
);
669 ERR(mod
->ctx
, "Could not remove '%s': %s\n", mod
->name
,
677 extern long init_module(void *mem
, unsigned long len
, const char *args
);
680 * kmod_module_insert_module:
682 * @flags: flags are not passed to Linux Kernel, but instead it dictates the
683 * behavior of this function. They are not implemented yet.
684 * @options: module's options to pass to Linux Kernel.
686 * Insert a module in Linux kernel. It opens the file pointed by @mod,
687 * mmap'ing it and passing to kernel.
689 * Returns: 0 on success or < 0 on failure.
691 KMOD_EXPORT
int kmod_module_insert_module(struct kmod_module
*mod
,
698 struct kmod_file
*file
;
699 const char *args
= options
? options
: "";
704 if (mod
->path
== NULL
) {
705 ERR(mod
->ctx
, "Not supported to load a module by name yet\n");
710 INFO(mod
->ctx
, "Flags are not implemented yet\n");
712 file
= kmod_file_open(mod
->path
);
718 size
= kmod_file_get_size(file
);
719 mem
= kmod_file_get_contents(file
);
721 err
= init_module(mem
, size
, args
);
723 ERR(mod
->ctx
, "Failed to insert module '%s'\n", mod
->path
);
725 kmod_file_unref(file
);
731 * kmod_module_get_options:
734 * Get options of this kmod module. Options come from the configuration file
735 * and are cached in @mod. The first call to this function will search for
736 * this module in configuration and subsequent calls return the cached string.
738 * Returns: a string with all the options separated by spaces. This string is
739 * owned by @mod, do not free it.
741 KMOD_EXPORT
const char *kmod_module_get_options(const struct kmod_module
*mod
)
746 if (!mod
->init
.options
) {
748 struct kmod_module
*m
= (struct kmod_module
*)mod
;
749 const struct kmod_list
*l
, *ctx_options
;
753 ctx_options
= kmod_get_options(mod
->ctx
);
755 kmod_list_foreach(l
, ctx_options
) {
756 const char *modname
= kmod_option_get_modname(l
);
761 DBG(mod
->ctx
, "modname=%s mod->name=%s mod->alias=%s\n", modname
, mod
->name
, mod
->alias
);
762 if (!(streq(modname
, mod
->name
) || (mod
->alias
!= NULL
&&
763 streq(modname
, mod
->alias
))))
766 DBG(mod
->ctx
, "passed = modname=%s mod->name=%s mod->alias=%s\n", modname
, mod
->name
, mod
->alias
);
767 str
= kmod_option_get_options(l
);
772 tmp
= realloc(opts
, optslen
+ len
+ 2);
785 memcpy(opts
+ optslen
, str
, len
);
787 opts
[optslen
] = '\0';
790 m
->init
.options
= true;
797 ERR(mod
->ctx
, "out of memory\n");
802 * kmod_module_get_install_commands:
805 * Get install commands for this kmod module. Install commands come from the
806 * configuration file and are cached in @mod. The first call to this function
807 * will search for this module in configuration and subsequent calls return
808 * the cached string. The install commands are returned as they were in the
809 * configuration, concatenated by ';'. No other processing is made in this
812 * Returns: a string with all install commands separated by semicolons. This
813 * string is owned by @mod, do not free it.
815 KMOD_EXPORT
const char *kmod_module_get_install_commands(const struct kmod_module
*mod
)
820 if (!mod
->init
.install_commands
) {
822 struct kmod_module
*m
= (struct kmod_module
*)mod
;
823 const struct kmod_list
*l
, *ctx_install_commands
;
825 ctx_install_commands
= kmod_get_install_commands(mod
->ctx
);
827 kmod_list_foreach(l
, ctx_install_commands
) {
828 const char *modname
= kmod_command_get_modname(l
);
830 if (strcmp(modname
, mod
->name
) != 0)
833 m
->install_commands
= kmod_command_get_command(l
);
836 * find only the first command, as modprobe from
837 * module-init-tools does
842 m
->init
.install_commands
= true;
845 return mod
->install_commands
;
848 void kmod_module_set_install_commands(struct kmod_module
*mod
, const char *cmd
)
850 mod
->init
.install_commands
= true;
851 mod
->install_commands
= cmd
;
855 * kmod_module_get_remove_commands:
858 * Get remove commands for this kmod module. Remove commands come from the
859 * configuration file and are cached in @mod. The first call to this function
860 * will search for this module in configuration and subsequent calls return
861 * the cached string. The remove commands are returned as they were in the
862 * configuration, concatenated by ';'. No other processing is made in this
865 * Returns: a string with all remove commands separated by semicolons. This
866 * string is owned by @mod, do not free it.
868 KMOD_EXPORT
const char *kmod_module_get_remove_commands(const struct kmod_module
*mod
)
873 if (!mod
->init
.remove_commands
) {
875 struct kmod_module
*m
= (struct kmod_module
*)mod
;
876 const struct kmod_list
*l
, *ctx_remove_commands
;
878 ctx_remove_commands
= kmod_get_remove_commands(mod
->ctx
);
880 kmod_list_foreach(l
, ctx_remove_commands
) {
881 const char *modname
= kmod_command_get_modname(l
);
883 if (strcmp(modname
, mod
->name
) != 0)
886 m
->remove_commands
= kmod_command_get_command(l
);
889 * find only the first command, as modprobe from
890 * module-init-tools does
895 m
->init
.remove_commands
= true;
898 return mod
->remove_commands
;
901 void kmod_module_set_remove_commands(struct kmod_module
*mod
, const char *cmd
)
903 mod
->init
.remove_commands
= true;
904 mod
->remove_commands
= cmd
;
908 * SECTION:libkmod-loaded
909 * @short_description: currently loaded modules
911 * Information about currently loaded modules, as reported by Linux kernel.
912 * These information are not cached by libkmod and are always read from /sys
917 * kmod_module_new_from_loaded:
918 * @ctx: kmod library context
919 * @list: where to save the list of loaded modules
921 * Create a new list of kmod modules with all modules currently loaded in
922 * kernel. It uses /proc/modules to get the names of loaded modules and to
923 * create kmod modules by calling kmod_module_new_from_name() in each of them.
924 * They are put are put in @list in no particular order.
926 * The initial refcount is 1, and needs to be decremented to release the
927 * resources of the kmod_module. The returned @list must be released by
928 * calling kmod_module_unref_list(). Since libkmod keeps track of all
929 * kmod_modules created, they are all released upon @ctx destruction too. Do
930 * not unref @ctx before all the desired operations with the returned list are
933 * Returns: 0 on success or < 0 on error.
935 KMOD_EXPORT
int kmod_module_new_from_loaded(struct kmod_ctx
*ctx
,
936 struct kmod_list
**list
)
938 struct kmod_list
*l
= NULL
;
942 if (ctx
== NULL
|| list
== NULL
)
945 fp
= fopen("/proc/modules", "re");
948 ERR(ctx
, "could not open /proc/modules: %s\n", strerror(errno
));
952 while (fgets(line
, sizeof(line
), fp
)) {
953 struct kmod_module
*m
;
954 struct kmod_list
*node
;
956 char *saveptr
, *name
= strtok_r(line
, " \t", &saveptr
);
958 err
= kmod_module_new_from_name(ctx
, name
, &m
);
960 ERR(ctx
, "could not get module from name '%s': %s\n",
961 name
, strerror(-err
));
965 node
= kmod_list_append(l
, m
);
969 ERR(ctx
, "out of memory\n");
970 kmod_module_unref(m
);
981 * kmod_module_initstate_str:
982 * @state: the state as returned by kmod_module_get_initstate()
984 * Translate a initstate to a string.
986 * Returns: the string associated to the @state. This string is statically
987 * allocated, do not free it.
989 KMOD_EXPORT
const char *kmod_module_initstate_str(enum kmod_module_initstate state
)
992 case KMOD_MODULE_BUILTIN
:
994 case KMOD_MODULE_LIVE
:
996 case KMOD_MODULE_COMING
:
998 case KMOD_MODULE_GOING
:
1006 * kmod_module_get_initstate:
1009 * Get the initstate of this @mod, as returned by Linux Kernel, by reading
1012 * Returns: < 0 on error or enum kmod_initstate if module is found in kernel.
1014 KMOD_EXPORT
int kmod_module_get_initstate(const struct kmod_module
*mod
)
1016 char path
[PATH_MAX
], buf
[32];
1017 int fd
, err
, pathlen
;
1022 pathlen
= snprintf(path
, sizeof(path
),
1023 "/sys/module/%s/initstate", mod
->name
);
1024 fd
= open(path
, O_RDONLY
|O_CLOEXEC
);
1028 if (pathlen
> (int)sizeof("/initstate") - 1) {
1030 path
[pathlen
- (sizeof("/initstate") - 1)] = '\0';
1031 if (stat(path
, &st
) == 0 && S_ISDIR(st
.st_mode
))
1032 return KMOD_MODULE_BUILTIN
;
1035 DBG(mod
->ctx
, "could not open '%s': %s\n",
1036 path
, strerror(-err
));
1040 err
= read_str_safe(fd
, buf
, sizeof(buf
));
1043 ERR(mod
->ctx
, "could not read from '%s': %s\n",
1044 path
, strerror(-err
));
1048 if (streq(buf
, "live\n"))
1049 return KMOD_MODULE_LIVE
;
1050 else if (streq(buf
, "coming\n"))
1051 return KMOD_MODULE_COMING
;
1052 else if (streq(buf
, "going\n"))
1053 return KMOD_MODULE_GOING
;
1055 ERR(mod
->ctx
, "unknown %s: '%s'\n", path
, buf
);
1060 * kmod_module_get_size:
1063 * Get the size of this kmod module as returned by Linux kernel. It reads the
1064 * file /proc/modules to search for this module and get its size.
1066 * Returns: the size of this kmod module.
1068 KMOD_EXPORT
long kmod_module_get_size(const struct kmod_module
*mod
)
1070 // FIXME TODO: this should be available from /sys/module/foo
1074 long size
= -ENOENT
;
1079 fp
= fopen("/proc/modules", "re");
1083 "could not open /proc/modules: %s\n", strerror(errno
));
1087 while (fgets(line
, sizeof(line
), fp
)) {
1088 char *saveptr
, *endptr
, *tok
= strtok_r(line
, " \t", &saveptr
);
1092 if (tok
== NULL
|| !streq(tok
, mod
->name
))
1095 tok
= strtok_r(NULL
, " \t", &saveptr
);
1098 "invalid line format at /proc/modules:%d\n", lineno
);
1102 value
= strtol(tok
, &endptr
, 10);
1103 if (endptr
== tok
|| *endptr
!= '\0') {
1105 "invalid line format at /proc/modules:%d\n", lineno
);
1117 * kmod_module_get_refcnt:
1120 * Get the ref count of this @mod, as returned by Linux Kernel, by reading
1123 * Returns: 0 on success or < 0 on failure.
1125 KMOD_EXPORT
int kmod_module_get_refcnt(const struct kmod_module
*mod
)
1127 char path
[PATH_MAX
];
1134 snprintf(path
, sizeof(path
), "/sys/module/%s/refcnt", mod
->name
);
1135 fd
= open(path
, O_RDONLY
|O_CLOEXEC
);
1138 ERR(mod
->ctx
, "could not open '%s': %s\n",
1139 path
, strerror(errno
));
1143 err
= read_str_long(fd
, &refcnt
, 10);
1146 ERR(mod
->ctx
, "could not read integer from '%s': '%s'\n",
1147 path
, strerror(-err
));
1155 * kmod_module_get_holders:
1158 * Get a list of kmod modules that are holding this @mod, as returned by Linux
1159 * Kernel. After use, free the @list by calling kmod_module_unref_list().
1161 * Returns: a new list of kmod modules on success or NULL on failure.
1163 KMOD_EXPORT
struct kmod_list
*kmod_module_get_holders(const struct kmod_module
*mod
)
1165 char dname
[PATH_MAX
];
1166 struct kmod_list
*list
= NULL
;
1172 snprintf(dname
, sizeof(dname
), "/sys/module/%s/holders", mod
->name
);
1176 ERR(mod
->ctx
, "could not open '%s': %s\n",
1177 dname
, strerror(errno
));
1182 struct dirent de
, *entp
;
1183 struct kmod_module
*holder
;
1184 struct kmod_list
*l
;
1187 err
= readdir_r(d
, &de
, &entp
);
1189 ERR(mod
->ctx
, "could not iterate for module '%s': %s\n",
1190 mod
->name
, strerror(-err
));
1197 if (de
.d_name
[0] == '.') {
1198 if (de
.d_name
[1] == '\0' ||
1199 (de
.d_name
[1] == '.' && de
.d_name
[2] == '\0'))
1203 err
= kmod_module_new_from_name(mod
->ctx
, de
.d_name
, &holder
);
1205 ERR(mod
->ctx
, "could not create module for '%s': %s\n",
1206 de
.d_name
, strerror(-err
));
1210 l
= kmod_list_append(list
, holder
);
1214 ERR(mod
->ctx
, "out of memory\n");
1215 kmod_module_unref(holder
);
1225 kmod_module_unref_list(list
);
1229 struct kmod_module_section
{
1230 unsigned long address
;
1234 static void kmod_module_section_free(struct kmod_module_section
*section
)
1240 * kmod_module_get_sections:
1243 * Get a list of kmod sections of this @mod, as returned by Linux Kernel. The
1244 * structure contained in this list is internal to libkmod and their fields
1245 * can be obtained by calling kmod_module_section_get_name() and
1246 * kmod_module_section_get_address().
1248 * After use, free the @list by calling kmod_module_section_free_list().
1250 * Returns: a new list of kmod module sections on success or NULL on failure.
1252 KMOD_EXPORT
struct kmod_list
*kmod_module_get_sections(const struct kmod_module
*mod
)
1254 char dname
[PATH_MAX
];
1255 struct kmod_list
*list
= NULL
;
1262 snprintf(dname
, sizeof(dname
), "/sys/module/%s/sections", mod
->name
);
1266 ERR(mod
->ctx
, "could not open '%s': %s\n",
1267 dname
, strerror(errno
));
1274 struct dirent de
, *entp
;
1275 struct kmod_module_section
*section
;
1276 struct kmod_list
*l
;
1277 unsigned long address
;
1281 err
= readdir_r(d
, &de
, &entp
);
1283 ERR(mod
->ctx
, "could not iterate for module '%s': %s\n",
1284 mod
->name
, strerror(-err
));
1288 if (de
.d_name
[0] == '.') {
1289 if (de
.d_name
[1] == '\0' ||
1290 (de
.d_name
[1] == '.' && de
.d_name
[2] == '\0'))
1294 fd
= openat(dfd
, de
.d_name
, O_RDONLY
|O_CLOEXEC
);
1296 ERR(mod
->ctx
, "could not open '%s/%s': %m\n",
1301 err
= read_str_ulong(fd
, &address
, 16);
1304 ERR(mod
->ctx
, "could not read long from '%s/%s': %m\n",
1309 namesz
= strlen(de
.d_name
) + 1;
1310 section
= malloc(sizeof(*section
) + namesz
);
1312 if (section
== NULL
) {
1313 ERR(mod
->ctx
, "out of memory\n");
1317 section
->address
= address
;
1318 memcpy(section
->name
, de
.d_name
, namesz
);
1320 l
= kmod_list_append(list
, section
);
1324 ERR(mod
->ctx
, "out of memory\n");
1335 kmod_module_unref_list(list
);
1340 * kmod_module_section_get_module_name:
1341 * @entry: a list entry representing a kmod module section
1343 * Get the name of a kmod module section.
1345 * After use, free the @list by calling kmod_module_section_free_list().
1347 * Returns: the name of this kmod module section on success or NULL on
1348 * failure. The string is owned by the section, do not free it.
1350 KMOD_EXPORT
const char *kmod_module_section_get_name(const struct kmod_list
*entry
)
1352 struct kmod_module_section
*section
;
1357 section
= entry
->data
;
1358 return section
->name
;
1362 * kmod_module_section_get_address:
1363 * @entry: a list entry representing a kmod module section
1365 * Get the address of a kmod module section.
1367 * After use, free the @list by calling kmod_module_section_free_list().
1369 * Returns: the address of this kmod module section on success or ULONG_MAX
1372 KMOD_EXPORT
unsigned long kmod_module_section_get_address(const struct kmod_list
*entry
)
1374 struct kmod_module_section
*section
;
1377 return (unsigned long)-1;
1379 section
= entry
->data
;
1380 return section
->address
;
1384 * kmod_module_section_free_list:
1385 * @list: kmod module section list
1387 * Release the resources taken by @list
1389 KMOD_EXPORT
void kmod_module_section_free_list(struct kmod_list
*list
)
1392 kmod_module_section_free(list
->data
);
1393 list
= kmod_list_remove(list
);