提交: f77c1188341bf0d89221c65be3c42db47c1beaa2 - system-coremmmm (git)

system/corennnnn

Commit MetaInfo

• 修訂: f77c1188341bf0d89221c65be3c42db47c1beaa2 (tree)
• 時間: 2016-07-27 03:49:13
• 作者: Jianxun Zhang <jianxun.zhang@inte...>
• Commiter: Jaap Jan Meijer

Log Message

add modprobe-like capability and automatic ueventd loading

Author: Jianxun Zhang <[e-mail]>
Author: Daniel Leung <[e-mail]>
Author: Andrew Boie <[e-mail]>

- insmod_by_dep() added to libcutils; loads a module into kernel.
Modules the target module depends on will be loaded first. Loading
will be stopped when an error occurs.

- rmmod_by_dep() added to libcutils; removes a module from kernel.
It also tries to remove other modules the target module depends
on until an error occurs.

- Implement wildcard matching for ueventd rules.
The PCI and USB addresses for devices can change from devices
from devices for a particular class of peripheral, for example,
bluetooth. The ueventd rules created with these addresses are
then device-specific.

This changes the way ueventd rules with wildcard are handled.
Instead of matching just the prefix with a trailing wildcard,
now these rules can have wildcard anywhere in the rule.
The wildcard matching is implemented using fnmatch(), where
its matching is simliar to shell pathname expansion. It suits
this particular usage model well.

For example, instead of creating a rule to match:

/sys/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.3/2-1.3:1.0/bluetooth/hci0/rfkill*

, this would suffice:

/sys/devices/*/bluetooth/hci0/rfkill*

- Let ueventd auto-load kernel modules. Implements the functionality
for ueventd to auto-load kernel modules when uevents are triggered.
Since /system may not be mounted when uevents are fired,
a deferred loading mechanism is implemented. Once mapping of
module and alias is available, these modules are then loaded.
Modules can also be blacklisted so they will not be loaded
automatically. One example would be the Wifi driver, as
Android's has to control its loading and unloading.

- add 'probemod' builtin command. This command accepts the name of a
kernel module plus a set of command line arguments. The module will
be loaded, along with all its dependencies, using the libcutils
insmod_by_dep() API.

- Drivers in kernel can request modules by launching a program in
user space, the program's path by default is "/sbin/modprobe".
Because Android system has no modprobe and ueventd is the only
program handling the module aliases so far, This patch provides a
cheap approach to handle kernel's requests in ueventd executable.

- Add new builtin init command "coldboot". The main purpose is to
provide an approach in init.*.rc files to fire uevents for devices
under the path which is passed as the the argument. This should be
called after /system is mounted so any queued events that need to
load a module can be fired.

Change Summary

• add: include/cutils/probe_module.h
• modified: init/builtins.cpp
• modified: init/devices.cpp
• modified: init/devices.h
• modified: init/init_parser.cpp
• modified: init/keywords.h
• modified: libcutils/Android.mk
• add: libcutils/probe_module.c

差異

--- /dev/null
+++ b/include/cutils/probe_module.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _LIBS_CUTILS_PROBEMODULE_H
+#define _LIBS_CUTILS_PROBEMODULE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* insmod_by_dep() - load a kernel module (target) with its dependency
+ * The module's dependency must be described in the provided dependency file.
+ * other modules in the dependency chain will be loaded prior to the target.
+ *
+ * module_name: Name of the target module. e.g. name "MyModule" is for
+ *              module file MyModule.ko.
+ *
+ * args       : A string of target module's parameters. NOTE: we only
+ *              support parameters of the target module.
+ *
+ * dep_name   : Name of dependency file. If it is NULL, we will look
+ *              up /system/lib/modules/modules.dep by default.
+ *
+ * strip      : Non-zero values remove paths of modules in dependency.
+ *              before loading them. The final path of a module will be
+ *              base/MyModule.ko. This is for devices which put every
+ *              modules into a single directory.
+ *
+ *              Passing 0 to strip keeps module paths in dependency file.
+ *              e.g. "kernel/drivers/.../MyModule.ko" in dep file will
+ *              be loaded as base/kernel/drivers/.../MyModule.ko .
+ *
+ * base       : Base dir, a prefix to be added to module's path prior to
+ *              loading. The last character prior to base string's terminator
+ *              must be a '/'. If it is NULL, we will take
+ *              /system/lib/modules/modules.dep by default.
+ *
+ * return     : 0 for success; non-zero for any errors.
+ *
+ * Note:
+ * When loading modules, function will not fail for any modules which are
+ * already in kernel. The module parameters passed to function will not be
+ * effective in this case if target module is already loaded into kernel.
+ */
+extern int insmod_by_dep(
+        const char *module_name,
+        const char *args,
+        const char *dep_name,
+        int strip,
+        const char * base);
+
+/* rmmod_by_dep() - remove a module (target) from kernel with its dependency
+ * The module's dependency must be described in the provided dependency file.
+ * This function will try to remove other modules in the dependency chain too
+ *
+ * module_name: Name of the target module. e.g. name "MyModule" is for
+ *              module file MyModule.ko.
+ *
+ * dep_name   : Name of dependency file. If it is NULL, we will look
+ *              up /system/lib/modules/modules.dep by default.
+ *
+ * return     : 0 for success; non-zero for any errors.
+ */
+extern int rmmod_by_dep(const char *module_name, const char *dep_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_LIBS_CUTILS_PROBEMODULE_H*/

--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -37,10 +37,13 @@
 #include <selinux/label.h>
 
 #include <fs_mgr.h>
+#include <dirent.h>
+#include <fnmatch.h>
 #include <base/stringprintf.h>
 #include <cutils/partition_utils.h>
 #include <cutils/android_reboot.h>
 #include <logwrap/logwrap.h>
+#include <cutils/probe_module.h>
 #include <private/android_filesystem_config.h>
 
 #include "init.h"
@@ -286,6 +289,40 @@ int do_insmod(int nargs, char **args)
     return do_insmod_inner(nargs, args, size);
 }
 
+static int do_probemod_inner(int nargs, char **args, int opt_len)
+{
+    char options[opt_len + 1];
+    int i;
+    int ret;
+
+    options[0] = '\0';
+    if (nargs > 2) {
+        strcpy(options, args[2]);
+        for (i = 3; i < nargs; ++i) {
+            strcat(options, " ");
+            strcat(options, args[i]);
+        }
+    }
+
+    ret = insmod_by_dep(args[1], options, NULL, 1, NULL);
+    if (ret)
+        ERROR("Couldn't probe module '%s'\n", args[1]);
+    return ret;
+}
+
+int do_probemod(int nargs, char **args)
+{
+    int i;
+    int size = 0;
+
+    if (nargs > 2) {
+        for (i = 2; i < nargs; ++i)
+            size += strlen(args[i]) + 1;
+    }
+
+    return do_probemod_inner(nargs, args, size);
+}
+
 int do_mkdir(int nargs, char **args)
 {
     mode_t mode = 0755;
@@ -582,6 +619,16 @@ int do_swapon_all(int nargs, char **args)
     return ret;
 }
 
+int do_builtin_coldboot(int nargs, char **args)
+{
+    if (nargs != 2 || !args[1] || *args[1] == '\0')
+        return -1;
+
+    coldboot(args[1]);
+
+    return 0;
+}
+
 int do_setprop(int nargs, char **args)
 {
     const char *name = args[1];

--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -41,6 +41,7 @@
 #include <sys/wait.h>
 
 #include <cutils/list.h>
+#include <cutils/probe_module.h>
 #include <cutils/uevent.h>
 
 #include "devices.h"
@@ -49,12 +50,18 @@
 #include "log.h"
 #include "property_service.h"
 #include <zlib.h>
+#include "parser.h"
 
 #define SYSFS_PREFIX    "/sys"
 static const char *firmware_dirs[] = { "/etc/firmware",
                                        "/vendor/firmware",
                                        "/firmware/image" };
 
+#define MODULES_ALIAS   "/system/lib/modules/modules.alias"
+#define MODULES_BLKLST  "/system/etc/modules.blacklist"
+#define READ_MODULES_ALIAS	1
+#define READ_MODULES_BLKLST	2
+
 extern struct selabel_handle *sehandle;
 
 extern char boot_device[PROP_VALUE_MAX];
@@ -68,6 +75,7 @@ struct uevent {
     const char *firmware;
     const char *partition_name;
     const char *device_name;
+    const char *modalias;
     int partition_num;
     int major;
     int minor;
@@ -95,9 +103,26 @@ struct platform_node {
     struct listnode list;
 };
 
+struct module_alias_node {
+    char *name;
+    char *pattern;
+    struct listnode list;
+};
+
+struct module_blacklist_node {
+    char *name;
+    struct listnode list;
+};
+
 static list_declare(sys_perms);
 static list_declare(dev_perms);
 static list_declare(platform_names);
+static list_declare(modules_aliases_map);
+static list_declare(modules_blacklist);
+static list_declare(deferred_module_loading_list);
+
+static int read_modules_aliases();
+static int read_modules_blacklist();
 
 int add_dev_perms(const char *name, const char *attr,
                   mode_t perm, unsigned int uid, unsigned int gid,
@@ -398,6 +423,7 @@ static void parse_event(const char *msg, struct uevent *uevent)
     uevent->partition_name = NULL;
     uevent->partition_num = -1;
     uevent->device_name = NULL;
+    uevent->modalias = NULL;
 
         /* currently ignoring SEQNUM */
     while(*msg) {
@@ -428,6 +454,9 @@ static void parse_event(const char *msg, struct uevent *uevent)
         } else if(!strncmp(msg, "DEVNAME=", 8)) {
             msg += 8;
             uevent->device_name = msg;
+        } else if(!strncmp(msg, "MODALIAS=", 9)) {
+            msg += 9;
+            uevent->modalias = msg;
         }
 
         /* advance to after the next \0 */
@@ -819,8 +848,148 @@ static void handle_generic_device_event(struct uevent *uevent)
              uevent->major, uevent->minor, links);
 }
 
+static int is_module_blacklisted(const char *name)
+{
+    struct listnode *blklst_node;
+    struct module_blacklist_node *blacklist;
+    int ret = 0;
+
+    if (!name) goto out;
+
+    /* See if module is blacklisted, skip if it is */
+    list_for_each(blklst_node, &modules_blacklist) {
+        blacklist = node_to_item(blklst_node,
+                                 struct module_blacklist_node,
+                                 list);
+        if (!strcmp(name, blacklist->name)) {
+            INFO("modules %s is blacklisted\n", name);
+            ret = 1;
+            goto out;
+        }
+    }
+
+out:
+    return ret;
+}
+
+static int load_module_by_device_modalias(const char *id)
+{
+    struct listnode *alias_node;
+    struct module_alias_node *alias;
+    int ret = -1;
+
+    if (!id) goto out;
+
+    list_for_each(alias_node, &modules_aliases_map) {
+        alias = node_to_item(alias_node, struct module_alias_node, list);
+
+        if (alias && alias->name && alias->pattern) {
+            if (fnmatch(alias->pattern, id, 0) == 0) {
+                INFO("trying to load module %s due to uevents\n", alias->name);
+
+                if (!is_module_blacklisted(alias->name)) {
+                    if (insmod_by_dep(alias->name, "", NULL, 1, NULL)) {
+                        /* cannot load module. try another one since
+                         * there may be another match.
+                         */
+                        INFO("cannot load module %s due to uevents\n",
+                             alias->name);
+                    } else {
+                        /* loading was successful */
+                        INFO("loaded module %s due to uevents\n", alias->name);
+                        ret = 0;
+                        goto out;
+                    }
+                }
+            }
+        }
+    }
+
+out:
+    return ret;
+}
+
+static void handle_deferred_module_loading()
+{
+    struct listnode *node = NULL;
+    struct listnode *next = NULL;
+    struct module_alias_node *alias = NULL;
+
+    /* try to read the module alias mapping if map is empty
+     * if succeed, loading all the modules in the queue
+     */
+    if (!list_empty(&modules_aliases_map)) {
+        list_for_each_safe(node, next, &deferred_module_loading_list) {
+            alias = node_to_item(node, struct module_alias_node, list);
+
+            if (alias && alias->pattern) {
+                INFO("deferred loading of module for %s\n", alias->pattern);
+                load_module_by_device_modalias(alias->pattern);
+                free(alias->pattern);
+                list_remove(node);
+                free(alias);
+            }
+        }
+    }
+}
+
+int module_probe(const char *modalias)
+{
+    if (list_empty(&modules_aliases_map)) {
+        if (read_modules_aliases() == 0)
+            read_modules_blacklist();
+        else
+            return -1;
+    }
+
+    return load_module_by_device_modalias(modalias);
+}
+
+static void handle_module_loading(const char *modalias)
+{
+    struct module_alias_node *node;
+
+    /* once modules.alias can be read,
+     * we load all the deferred ones
+     */
+    if (list_empty(&modules_aliases_map)) {
+        if (read_modules_aliases() == 0) {
+            read_modules_blacklist();
+            handle_deferred_module_loading();
+        }
+    }
+
+    if (!modalias) return;
+
+    if (list_empty(&modules_aliases_map)) {
+        /* if module alias mapping is empty,
+         * queue it for loading later
+         */
+        node = (module_alias_node *) calloc(1, sizeof(*node));
+        if (node) {
+            node->pattern = strdup(modalias);
+            if (!node->pattern) {
+                free(node);
+            } else {
+                list_add_tail(&deferred_module_loading_list, &node->list);
+                INFO("add to queue for deferred module loading: %s",
+                        node->pattern);
+            }
+        } else {
+            ERROR("failed to allocate memory to store device id for deferred module loading.\n");
+        }
+    } else {
+        load_module_by_device_modalias(modalias);
+    }
+
+}
+
 static void handle_device_event(struct uevent *uevent)
 {
+    if (!strcmp(uevent->action,"add")) {
+        handle_module_loading(uevent->modalias);
+    }
+
     if (!strcmp(uevent->action,"add") || !strcmp(uevent->action, "change") || !strcmp(uevent->action, "online"))
         fixup_sys_perms(uevent->path);
 
@@ -998,6 +1167,148 @@ static void handle_firmware_event(struct uevent *uevent)
     }
 }
 
+static void parse_line_module_alias(struct parse_state *state, int nargs, char **args)
+{
+    struct module_alias_node *node;
+
+    if (!args ||
+        (nargs != 3) ||
+        !args[0] || !args[1] || !args[2]) {
+        /* empty line or not enough arguments */
+        return;
+    }
+
+    node = (module_alias_node *) calloc(1, sizeof(*node));
+    if (!node) return;
+
+    node->name = strdup(args[2]);
+    if (!node->name) {
+        free(node);
+        return;
+    }
+
+    node->pattern = strdup(args[1]);
+    if (!node->pattern) {
+        free(node->name);
+        free(node);
+        return;
+    }
+
+    list_add_tail(&modules_aliases_map, &node->list);
+}
+
+static void parse_line_module_blacklist(struct parse_state *state, int nargs, char **args)
+{
+    struct module_blacklist_node *node;
+
+    if (!args ||
+        (nargs != 2) ||
+        !args[0] || !args[1]) {
+        /* empty line or not enough arguments */
+        return;
+    }
+
+    /* this line does not being with "blacklist" */
+    if (strncmp(args[0], "blacklist", 9)) return;
+
+    node = (module_blacklist_node *) calloc(1, sizeof(*node));
+    if (!node) return;
+
+    node->name = strdup(args[1]);
+    if (!node->name) {
+        free(node);
+        return;
+    }
+
+    list_add_tail(&modules_blacklist, &node->list);
+}
+
+static int __read_modules_desc_file(int mode)
+{
+    struct parse_state state;
+    char *args[3];
+    int nargs;
+    char *fn;
+    int fd = -1;
+    int ret = -1;
+    int args_to_read = 0;
+    std::string data;
+
+    if (mode == READ_MODULES_ALIAS) {
+        /* read modules.alias */
+        if (asprintf(&fn, "%s", MODULES_ALIAS) <= 0) {
+            goto out;
+        }
+    } else if (mode == READ_MODULES_BLKLST) {
+        /* read modules.blacklist */
+        if (asprintf(&fn, "%s", MODULES_BLKLST) <= 0) {
+            goto out;
+        }
+    } else {
+        /* unknown mode */
+        goto out;
+    }
+
+    fd = open(fn, O_RDONLY);
+    if (fd == -1) {
+        goto out;
+    }
+
+    /* read the whole file */
+    if (!read_file(fn, &data)) {
+        goto out;
+    }
+
+    /* invoke tokenizer */
+    nargs = 0;
+    state.filename = fn;
+    state.line = 1;
+    state.ptr = const_cast<char *>(data.c_str());
+    state.nexttoken = 0;
+    if (mode == READ_MODULES_ALIAS) {
+        state.parse_line = parse_line_module_alias;
+        args_to_read = 3;
+    } else if (mode == READ_MODULES_BLKLST) {
+        state.parse_line = parse_line_module_blacklist;
+        args_to_read = 2;
+    }
+    for (;;) {
+        int token = next_token(&state);
+        switch (token) {
+        case T_EOF:
+            state.parse_line(&state, 0, 0);
+            ret = 0;
+            goto out;
+        case T_NEWLINE:
+            if (nargs) {
+                state.parse_line(&state, nargs, args);
+                nargs = 0;
+            }
+            break;
+        case T_TEXT:
+            if (nargs < args_to_read) {
+                args[nargs++] = state.text;
+            }
+            break;
+        }
+    }
+    ret = 0;
+
+out:
+    if (fd != -1) {
+        close(fd);
+    }
+    return ret;
+}
+
+static int read_modules_aliases() {
+    return __read_modules_desc_file(READ_MODULES_ALIAS);
+}
+
+static int read_modules_blacklist() {
+    return __read_modules_desc_file(READ_MODULES_BLKLST);
+}
+
 #define UEVENT_MSG_LEN  2048
 void handle_device_fd()
 {
@@ -1070,7 +1381,7 @@ static void do_coldboot(DIR *d)
     }
 }
 
-static void coldboot(const char *path)
+void coldboot(const char *path)
 {
     DIR *d = opendir(path);
     if(d) {

--- a/init/devices.h
+++ b/init/devices.h
@@ -21,10 +21,12 @@
 
 extern void handle_device_fd();
 extern void device_init(void);
+extern int module_probe(const char *alias);
 extern int add_dev_perms(const char *name, const char *attr,
                          mode_t perm, unsigned int uid,
                          unsigned int gid, unsigned short prefix,
                          unsigned short wildcard);
 int get_device_fd();
 
+void coldboot(const char *path);
 #endif	/* _INIT_DEVICES_H */

--- a/init/init_parser.cpp
+++ b/init/init_parser.cpp
@@ -129,6 +129,7 @@ static int lookup_keyword(const char *s)
         if (!strcmp(s, "onsole")) return K_console;
         if (!strcmp(s, "hown")) return K_chown;
         if (!strcmp(s, "hmod")) return K_chmod;
+        if (!strcmp(s, "oldboot")) return K_coldboot;
         if (!strcmp(s, "ritical")) return K_critical;
         break;
     case 'd':
@@ -173,6 +174,7 @@ static int lookup_keyword(const char *s)
         break;
     case 'p':
         if (!strcmp(s, "owerctl")) return K_powerctl;
+        if (!strcmp(s, "robemod")) return K_probemod;
         break;
     case 'r':
         if (!strcmp(s, "estart")) return K_restart;

--- a/init/keywords.h
+++ b/init/keywords.h
@@ -1,5 +1,6 @@
 #ifndef KEYWORD
 int do_bootchart_init(int nargs, char **args);
+int do_builtin_coldboot(int nargs, char **args);
 int do_class_start(int nargs, char **args);
 int do_class_stop(int nargs, char **args);
 int do_class_reset(int nargs, char **args);
@@ -15,6 +16,7 @@ int do_mkdir(int nargs, char **args);
 int do_mount_all(int nargs, char **args);
 int do_mount(int nargs, char **args);
 int do_powerctl(int nargs, char **args);
+int do_probemod(int nargs, char **args);
 int do_restart(int nargs, char **args);
 int do_restorecon(int nargs, char **args);
 int do_restorecon_recursive(int nargs, char **args);
@@ -51,6 +53,7 @@ enum {
     KEYWORD(class_reset, COMMAND, 1, do_class_reset)
     KEYWORD(class_start, COMMAND, 1, do_class_start)
     KEYWORD(class_stop,  COMMAND, 1, do_class_stop)
+    KEYWORD(coldboot,    COMMAND, 1, do_builtin_coldboot)
     KEYWORD(console,     OPTION,  0, 0)
     KEYWORD(copy,        COMMAND, 2, do_copy)
     KEYWORD(critical,    OPTION,  0, 0)
@@ -77,6 +80,7 @@ enum {
     KEYWORD(onrestart,   OPTION,  0, 0)
     KEYWORD(on,          SECTION, 0, 0)
     KEYWORD(powerctl,    COMMAND, 1, do_powerctl)
+    KEYWORD(probemod,    COMMAND, 1, do_probemod)
     KEYWORD(restart,     COMMAND, 1, do_restart)
     KEYWORD(restorecon,  COMMAND, 1, do_restorecon)
     KEYWORD(restorecon_recursive,  COMMAND, 1, do_restorecon_recursive)

--- a/libcutils/Android.mk
+++ b/libcutils/Android.mk
@@ -31,6 +31,7 @@ commonSources := \
 	threads.c \
 	sched_policy.c \
 	iosched_policy.c \
+	probe_module.c \
 	str_parms.c \
 	fs_config.c
 

--- /dev/null
+++ b/libcutils/probe_module.c
@@ -0,0 +1,456 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <cutils/misc.h>
+
+#define LOG_TAG "ProbeModule"
+#include <cutils/log.h>
+
+
+#define LDM_DEFAULT_DEP_FILE "/system/lib/modules/modules.dep"
+#define LDM_DEFAULT_MOD_PATH "/system/lib/modules/"
+#define LDM_INIT_DEP_NUM 10
+
+extern int init_module(void *, unsigned long, const char *);
+extern int delete_module(const char *, unsigned int);
+
+static void dump_dep(char **dep)
+{
+    int d;
+
+    for (d = 0; dep[d]; d++)
+        ALOGD("DUMP DEP: %s\n", dep[d]);
+}
+
+static char * strip_path(const char * const str)
+{
+    char *ptr;
+    int i;
+
+    /* initialize pos to terminator */
+    for (i = strlen(str); i > 0; i--)
+        if (str[i - 1] == '/')
+            break;
+
+    return (char *)&str[i];
+}
+
+static void hyphen_to_underscore(char *str)
+{
+    while (str && *str != '\0') {
+        if (*str == '-')
+            *str = '_';
+        str++;
+    }
+}
+
+/* Compare module names, but don't differentiate '_' and '-'.
+ * return: 0 when s1 is matched to s2 or size is zero.
+ *         non-zero in any other cases.
+ */
+static int match_name(const char *s1, const char *s2, const size_t size)
+{
+    size_t i;
+
+    if (!size)
+        return 0;
+
+    for (i = 0; i < size; i++, s1++, s2++) {
+
+        if ((*s1 == '_' || *s1 == '-') && (*s2 == '_' || *s2 == '-'))
+            continue;
+
+        if (*s1 != *s2)
+            return -1;
+
+        if (*s1 == '\0')
+            return 0;
+    }
+
+    return 0;
+}
+
+/* check if a line in dep file is target module's dependency.
+ * return 1 when it is, otherwise 0 in any other cases.
+ */
+static int is_target_module(char *line, const char *target)
+{
+    char *token;
+    char *name;
+    size_t name_len;
+    const char *suffix = ".ko";
+    const char *delimiter = ":";
+    int ret = 0;
+
+    /* search token */
+    token = strstr(line, delimiter);
+
+    if (!token) {
+        ALOGE("invalid line: no token\n");
+        return 0;
+    }
+
+    /* only take stuff before the token */
+    *token = '\0';
+
+    /* use "module.ko" in comparision */
+    name_len = strlen(suffix) + strlen(target) + 1;
+
+    name = malloc(sizeof(char) * name_len);
+
+    if (!name) {
+        ALOGE("cannot alloc ram for comparision\n");
+        return 0;
+    }
+
+    snprintf(name, name_len, "%s%s", target, suffix);
+
+    ret = !match_name(strip_path(line), name, name_len);
+
+    /* restore [single] token, keep line unchanged until we parse it later */
+    *token = *delimiter;
+
+    free(name);
+
+    return ret;
+
+}
+
+/* turn a single string into an array of dependency.
+ *
+ * return: dependency array's address if it succeeded. Caller
+ *         is responsible to free the array's memory.
+ *         NULL when any error happens.
+ */
+static char** setup_dep(char *line)
+{
+    char *tmp;
+    char *brk;
+    int dep_num = LDM_INIT_DEP_NUM;
+    char **new;
+    int i;
+    char **dep = NULL;
+
+    dep = malloc(sizeof(char *) * dep_num);
+
+    if (!dep) {
+        ALOGE("cannot alloc dep array\n");
+        return dep;
+    }
+
+    for (i = 0, tmp = strtok_r(line, ": ", &brk);
+            tmp;
+            tmp = strtok_r(NULL, ": ", &brk), i++) {
+
+        /* check if we need enlarge dep array */
+        if (!(i < dep_num - 1)) {
+
+            dep_num += LDM_INIT_DEP_NUM;
+
+            new = realloc(dep, dep_num);
+
+            if (!new) {
+                ALOGE("failed to enlarge dep buffer\n");
+                free(dep);
+                return NULL;
+            }
+            else
+                dep = new;
+        }
+
+        dep[i] = tmp;
+
+    }
+    /* terminate array with a null pointer */
+    dep[i] = NULL;
+
+    return dep;
+}
+
+static int insmod(const char *path_name, const char *args)
+{
+    void *data;
+    unsigned int len;
+    int ret;
+
+    data = load_file(path_name, &len);
+
+    if (!data) {
+        ALOGE("%s: Failed to load module file [%s]\n", __FUNCTION__, path_name);
+        return -1;
+    }
+
+    ret = init_module(data, len, args);
+
+    if (ret != 0 && errno != EEXIST) {
+        ALOGE("%s: Failed to insmod [%s] with args [%s] error: %s ret: %d\n",
+                __FUNCTION__, path_name, args, strerror(errno), ret);
+        ret = -1;
+    }
+    else
+        ret = 0;    /* if module is already in kernel, return success. */
+
+    free(data);
+
+    return ret;
+}
+
+/* install all modules in the dependency chain
+ * deps    : A array of module file names, must be terminated by a NULL pointer
+ * args    : The module parameters for target module.
+ * strip   : Non-zero to strip out path info in the file name;
+ *           0 to keep path info when loading modules.
+ * base    : a prefix to module path, it will NOT be affected by strip flag.
+ * return  : 0 for success or nothing to do; non-zero when any error occurs.
+ */
+static int insmod_s(char *dep[], const char *args, int strip, const char *base)
+{
+    char *name;
+    char *path_name;
+    int cnt;
+    size_t len;
+    int ret = 0;
+    const char * base_dir = LDM_DEFAULT_MOD_PATH;
+
+    if (base && strlen(base))
+        base_dir = base;
+
+    /* load modules in reversed order */
+    for (cnt = 0; dep[cnt]; cnt++)
+        ;
+
+    while (cnt--) {
+
+        name = strip ? strip_path(dep[cnt]) : dep[cnt];
+
+        len = strlen(base_dir) + strlen(name) + 1;
+
+        path_name = malloc(sizeof(char) * len);
+
+        if (!path_name) {
+            ALOGE("alloc module [%s] path failed\n", path_name);
+            return -1;
+        }
+
+        snprintf(path_name, len, "%s%s", base_dir, name);
+
+        if (cnt)
+            ret = insmod(path_name, "");
+        else
+            ret = insmod(path_name, args);
+
+        free(path_name);
+
+        if (ret)
+            break;
+    }
+
+    return ret;
+}
+
+static int rmmod(const char *mod_name, unsigned int flags)
+{
+    return delete_module(mod_name, flags);
+}
+
+/* remove all modules in a dependency chain
+ * NOTE: We assume module name in kernel is same as the file name without .ko
+ */
+static int rmmod_s(char *dep[], unsigned int flags)
+{
+    int i;
+    int ret = 0;
+    char * mod_name;
+
+    for (i = 0; dep[i]; i++) {
+        size_t len;
+        mod_name = strip_path(dep[i]);
+        len = strlen(mod_name);
+
+        if (len > strlen(".ko")
+                && mod_name[len - 1] == 'o'
+                        && mod_name[len - 2] == 'k'
+                                && mod_name[len - 3] == '.') {
+
+            mod_name[len - 3] = '\0';
+
+            hyphen_to_underscore(mod_name);
+
+            ret = rmmod(mod_name, flags);
+
+            if (ret) {
+                ALOGE("%s: Failed to remove module [%s] error (%s)\n",
+                        __FUNCTION__, mod_name, strerror(errno));
+                break;
+
+            }
+        }
+    }
+
+    return ret;
+}
+
+/* look_up_dep() find and setup target module's dependency in modules.dep
+ *
+ * dep_file:    a pointer to module's dep file loaded in memory, its content
+ *              will be CHANGED during parsing.
+ *
+ * return:      a pointer to an array which holds the dependency strings and
+ *              terminated by a NULL pointer. Caller is responsible to free the
+ *              array's memory.
+ *
+ *              non-zero in any other cases. Content of dep array is invalid.
+ */
+static char ** look_up_dep(const char *module_name, void *dep_file)
+{
+
+    char *line;
+    char *saved_pos;
+    char *start;
+    int ret = -1;
+    char **dep = NULL;
+
+    if (!dep_file || !module_name || *module_name == '\0')
+        return NULL;
+
+    start = (char *)dep_file;
+
+    /* We expect modules.dep file has a new line char before EOF. */
+    while ((line = strtok_r(start, "\n", &saved_pos)) != NULL) {
+
+        start = NULL;
+
+        if (is_target_module(line, module_name)) {
+
+            dep = setup_dep(line);
+            /* job done */
+            break;
+        }
+    }
+
+    return dep;
+}
+
+/* load_dep_file() load a dep file (usually it is modules.dep)
+ * into memory. Caller is responsible to free the memory.
+ *
+ * file_name:   dep file's name, if it is NULL or an empty string,
+ *              This function will try to load a dep file in the
+ *              default path defined in LDM_DEFAULT_DEP_FILE
+ *
+ * return:      a pointer to the allocated mem which holds all
+ *              content of the depfile. a zero pointer will be
+ *              returned for any errors.
+ * */
+static void *load_dep_file(const char *file_name)
+{
+    const char *dep_file_name = LDM_DEFAULT_DEP_FILE;
+    unsigned int len;
+
+    if (file_name && *file_name != '\0')
+        dep_file_name = file_name;
+
+    return load_file(dep_file_name, &len);
+}
+
+/* insmod_by_dep() interface to outside,
+ * refer to its description in probe_module.h
+ */
+int insmod_by_dep(const char *module_name,
+        const char *args,
+        const char *dep_name,
+        int strip,
+        const char *base)
+{
+    void *dep_file;
+    char **dep = NULL;
+    int ret = -1;
+
+    if (!module_name || *module_name == '\0') {
+        ALOGE("need valid module name\n");
+        return ret;
+    }
+
+    dep_file = load_dep_file(dep_name);
+
+    if (!dep_file) {
+        ALOGE("cannot load dep file : %s\n", dep_name);
+        return ret;
+    }
+
+    dep = look_up_dep(module_name, dep_file);
+
+    if (!dep) {
+        ALOGE("%s: cannot load module: [%s]\n", __FUNCTION__, module_name);
+        goto free_file;
+    }
+
+    ret = insmod_s(dep, args, strip, base);
+
+    free(dep);
+
+free_file:
+    free(dep_file);
+
+    return ret;
+
+}
+
+/* rmmod_by_dep() interface to outside,
+ * refer to its description in probe_module.h
+ */
+int rmmod_by_dep(const char *module_name,
+        const char *dep_name)
+{
+    void *dep_file;
+    char **dep = NULL;
+    int ret = -1;
+
+    if (!module_name || *module_name == '\0') {
+        ALOGE("need valid module name\n");
+        return ret;
+    }
+
+    dep_file = load_dep_file(dep_name);
+
+    if (!dep_file) {
+        ALOGE("cannot load dep file : %s\n", dep_name);
+        return ret;
+    }
+
+    dep = look_up_dep(module_name, dep_file);
+
+    if (!dep) {
+        ALOGE("%s: cannot remove module: [%s]\n", __FUNCTION__, module_name);
+        goto free_file;
+    }
+
+    ret = rmmod_s(dep, O_NONBLOCK);
+
+    free(dep);
+
+free_file:
+    free(dep_file);
+
+    return ret;
+}
+
+/* end of file */