~registry/kmod/master

« back to all changes in this revision

Viewing changes to libkmod/libkmod-module.c

  • Committer: Lucas De Marchi
  • Date: 2011-12-12 12:30:01 UTC
  • mfrom: (161.1.30)
  • Revision ID: git-v1:2fee2f13ce5f6b17dd672389de422217c56105e2
Merge branch 'use-mmap'

Conflicts:
        libkmod/libkmod.c

Show diffs side-by-side

added added

removed removed

Lines of Context:
46
46
        struct kmod_ctx *ctx;
47
47
        char *path;
48
48
        struct kmod_list *dep;
 
49
        char *options;
 
50
        char *install_commands;
 
51
        char *remove_commands;
 
52
        int n_dep;
49
53
        int refcount;
50
54
        struct {
51
55
                bool dep : 1;
 
56
                bool options : 1;
 
57
                bool install_commands : 1;
 
58
                bool remove_commands : 1;
52
59
        } init;
53
60
        char name[];
54
61
};
55
62
 
56
 
static inline char *modname_normalize(const char *modname, char buf[NAME_MAX],
 
63
inline char *modname_normalize(const char *modname, char buf[NAME_MAX],
57
64
                                                                size_t *len)
58
65
{
59
66
        size_t s;
111
118
        int err, n = 0;
112
119
        size_t dirnamelen;
113
120
 
114
 
        assert(!mod->init.dep && mod->dep == NULL);
 
121
        if (mod->init.dep)
 
122
                return mod->n_dep;
 
123
        assert(mod->dep == NULL);
115
124
        mod->init.dep = true;
116
125
 
117
126
        p = strchr(line, ':');
166
175
        DBG(ctx, "%d dependencies for %s\n", n, mod->name);
167
176
 
168
177
        mod->dep = list;
 
178
        mod->n_dep = n;
169
179
        return n;
170
180
 
171
181
fail:
281
291
 
282
292
        kmod_module_unref_list(mod->dep);
283
293
        kmod_unref(mod->ctx);
 
294
        free(mod->options);
 
295
        free(mod->install_commands);
 
296
        free(mod->remove_commands);
284
297
        free(mod->path);
285
298
        free(mod);
286
299
        return NULL;
305
318
        } while (0)
306
319
 
307
320
KMOD_EXPORT int kmod_module_new_from_lookup(struct kmod_ctx *ctx,
308
 
                                                const char *alias,
 
321
                                                const char *given_alias,
309
322
                                                struct kmod_list **list)
310
323
{
311
324
        int err;
 
325
        char alias[NAME_MAX];
312
326
 
313
327
        if (ctx == NULL || alias == NULL)
314
328
                return -ENOENT;
318
332
                return -ENOSYS;
319
333
        }
320
334
 
 
335
        modname_normalize(given_alias, alias, NULL);
 
336
 
321
337
        /* Aliases from config file override all the others */
322
338
        err = kmod_lookup_alias_from_config(ctx, alias, list);
323
339
        CHECK_ERR_AND_FINISH(err, fail, list, finish);
457
473
{
458
474
        char *line;
459
475
 
460
 
        DBG(mod->ctx, "name='%s' path='%s'", mod->name, mod->path);
 
476
        DBG(mod->ctx, "name='%s' path='%s'\n", mod->name, mod->path);
461
477
 
462
478
        if (mod->path != NULL)
463
479
                return mod->path;
502
518
extern long init_module(void *mem, unsigned long len, const char *args);
503
519
 
504
520
KMOD_EXPORT int kmod_module_insert_module(struct kmod_module *mod,
505
 
                                                        unsigned int flags)
 
521
                                                        unsigned int flags,
 
522
                                                        const char *options)
506
523
{
507
524
        int err;
508
525
        void *mmaped_file;
509
526
        struct stat st;
510
527
        int fd;
511
 
        const char *args = "";
 
528
        const char *args = options ? options : "";
512
529
 
513
530
        if (mod == NULL)
514
531
                return -ENOENT;
578
595
                                return KMOD_MODULE_BUILTIN;
579
596
                }
580
597
 
581
 
                ERR(mod->ctx, "could not open '%s': %s\n",
 
598
                DBG(mod->ctx, "could not open '%s': %s\n",
582
599
                        path, strerror(-err));
583
600
                return err;
584
601
        }
815
832
                list = kmod_list_remove(list);
816
833
        }
817
834
}
 
835
 
 
836
KMOD_EXPORT const char *kmod_module_get_options(const struct kmod_module *mod)
 
837
{
 
838
        if (mod == NULL)
 
839
                return NULL;
 
840
 
 
841
        if (!mod->init.options) {
 
842
                /* lazy init */
 
843
                struct kmod_module *m = (struct kmod_module *)mod;
 
844
                const struct kmod_list *l, *ctx_options;
 
845
                char *opts = NULL;
 
846
                size_t optslen = 0;
 
847
                ctx_options = kmod_get_options(mod->ctx);
 
848
                kmod_list_foreach(l, ctx_options) {
 
849
                        const char *modname = kmod_option_get_modname(l);
 
850
                        const char *str;
 
851
                        size_t len;
 
852
                        void *tmp;
 
853
 
 
854
                        if (strcmp(modname, mod->name) != 0)
 
855
                                continue;
 
856
 
 
857
                        str = kmod_option_get_options(l);
 
858
                        len = strlen(str);
 
859
                        if (len < 1)
 
860
                                continue;
 
861
 
 
862
                        tmp = realloc(opts, optslen + len + 2);
 
863
                        if (tmp == NULL) {
 
864
                                free(opts);
 
865
                                goto failed;
 
866
                        }
 
867
                        opts = tmp;
 
868
                        if (optslen > 0) {
 
869
                                opts[optslen] = ' ';
 
870
                                optslen++;
 
871
                        }
 
872
                        memcpy(opts + optslen, str, len);
 
873
                        optslen += len;
 
874
                        opts[optslen] = '\0';
 
875
                }
 
876
                m->init.options = true;
 
877
                m->options = opts;
 
878
        }
 
879
 
 
880
        return mod->options;
 
881
 
 
882
failed:
 
883
        ERR(mod->ctx, "out of memory\n");
 
884
        return NULL;
 
885
}
 
886
 
 
887
KMOD_EXPORT const char *kmod_module_get_install_commands(const struct kmod_module *mod)
 
888
{
 
889
        if (mod == NULL)
 
890
                return NULL;
 
891
 
 
892
        if (!mod->init.install_commands) {
 
893
                /* lazy init */
 
894
                struct kmod_module *m = (struct kmod_module *)mod;
 
895
                const struct kmod_list *l, *ctx_install_commands;
 
896
                char *cmds = NULL;
 
897
                size_t cmdslen = 0;
 
898
                ctx_install_commands = kmod_get_install_commands(mod->ctx);
 
899
                kmod_list_foreach(l, ctx_install_commands) {
 
900
                        const char *modname = kmod_command_get_modname(l);
 
901
                        const char *str;
 
902
                        size_t len;
 
903
                        void *tmp;
 
904
 
 
905
                        if (strcmp(modname, mod->name) != 0)
 
906
                                continue;
 
907
 
 
908
                        str = kmod_command_get_command(l);
 
909
                        len = strlen(str);
 
910
                        if (len < 1)
 
911
                                continue;
 
912
 
 
913
                        tmp = realloc(cmds, cmdslen + len + 2);
 
914
                        if (tmp == NULL) {
 
915
                                free(cmds);
 
916
                                goto failed;
 
917
                        }
 
918
                        cmds = tmp;
 
919
                        if (cmdslen > 0) {
 
920
                                cmds[cmdslen] = ';';
 
921
                                cmdslen++;
 
922
                        }
 
923
                        memcpy(cmds + cmdslen, str, len);
 
924
                        cmdslen += len;
 
925
                        cmds[cmdslen] = '\0';
 
926
                }
 
927
                m->init.install_commands = true;
 
928
                m->install_commands = cmds;
 
929
        }
 
930
 
 
931
        return mod->install_commands;
 
932
 
 
933
failed:
 
934
        ERR(mod->ctx, "out of memory\n");
 
935
        return NULL;
 
936
}
 
937
 
 
938
KMOD_EXPORT const char *kmod_module_get_remove_commands(const struct kmod_module *mod)
 
939
{
 
940
        if (mod == NULL)
 
941
                return NULL;
 
942
 
 
943
        if (!mod->init.remove_commands) {
 
944
                /* lazy init */
 
945
                struct kmod_module *m = (struct kmod_module *)mod;
 
946
                const struct kmod_list *l, *ctx_remove_commands;
 
947
                char *cmds = NULL;
 
948
                size_t cmdslen = 0;
 
949
                ctx_remove_commands = kmod_get_remove_commands(mod->ctx);
 
950
                kmod_list_foreach(l, ctx_remove_commands) {
 
951
                        const char *modname = kmod_command_get_modname(l);
 
952
                        const char *str;
 
953
                        size_t len;
 
954
                        void *tmp;
 
955
 
 
956
                        if (strcmp(modname, mod->name) != 0)
 
957
                                continue;
 
958
 
 
959
                        str = kmod_command_get_command(l);
 
960
                        len = strlen(str);
 
961
                        if (len < 1)
 
962
                                continue;
 
963
 
 
964
                        tmp = realloc(cmds, cmdslen + len + 2);
 
965
                        if (tmp == NULL) {
 
966
                                free(cmds);
 
967
                                goto failed;
 
968
                        }
 
969
                        cmds = tmp;
 
970
                        if (cmdslen > 0) {
 
971
                                cmds[cmdslen] = ';';
 
972
                                cmdslen++;
 
973
                        }
 
974
                        memcpy(cmds + cmdslen, str, len);
 
975
                        cmdslen += len;
 
976
                        cmds[cmdslen] = '\0';
 
977
                }
 
978
                m->init.remove_commands = true;
 
979
                m->remove_commands = cmds;
 
980
        }
 
981
 
 
982
        return mod->remove_commands;
 
983
 
 
984
failed:
 
985
        ERR(mod->ctx, "out of memory\n");
 
986
        return NULL;
 
987
}