lvm代码分析（五）

 回到lvm2_main()：

1. if (_lvm1_fallback(cmd)) {
2.         /* Attempt to run equivalent LVM1 tool instead */
3.         if (!alias) {
4.             argv++;
5.             argc--;
6.             alias = 0;
7.         }
8.         if (!argc) {
9.             log_error("Falling back to LVM1 tools, but no "
10.                   "command specified.");
11.             return ECMD_FAILED;
12.         }
13.         _exec_lvm1_command(argv);
14.         return ECMD_FAILED;
15.     }
16. #ifdef READLINE_SUPPORT
17.     if (!alias && argc == 1) {
18.         _nonroot_warning();
19.         ret = lvm_shell(cmd, &_cmdline);
20.         goto out;
21.     }
22. #endif
24.     if (!alias) {
25.         if (argc < 2) {
26.             log_fatal("Please supply an LVM command.");
27.             _display_help();
28.             ret = EINVALID_CMD_LINE;
29.             goto out;
30.         }
32.         argc--;
33.         argv++;
34.     }
36.     _nonroot_warning();

以上部分大概是看输入的命令能否转化为lvm1的命令执行，以及是否支持readline，还有对命令解析判断是否可执行。_noroot_warning是对非root用户执行lvm命令的警告。

1.  ret = lvm_run_command(cmd, argc, argv);
2.     if ((ret == ENO_SUCH_CMD) && (!alias))
3.         ret = _run_script(cmd, argc, argv);
4.     if (ret == ENO_SUCH_CMD)
5.         log_error("No such command.  Try 'help'.");
7.     if ((ret != ECMD_PROCESSED) && !error_message_produced()) {
8.         log_debug("Internal error: Failed command did not use log_error");
9.         log_error("Command failed with status code %d.", ret);
10.     }

前面的都准备就绪了，终于到lvm_run_command了，执行用户输入的命令。先看看他的全貌：

2. int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
3. {
4.     int ret = 0;
5.     int locking_type;
7.     init_error_message_produced(0);
9.     /* each command should start out with sigint flag cleared */
10.     sigint_clear();
12.     if (!(cmd->cmd_line = _copy_command_line(cmd, argc, argv)))
13.         return ECMD_FAILED;
15.     log_debug("Parsing: %s", cmd->cmd_line);
17.     if (!(cmd->command = _find_command(argv[0])))
18.         return ENO_SUCH_CMD;
20.     if (!_process_command_line(cmd, &argc, &argv)) {
21.         log_error("Error during parsing of command line.");
22.         return EINVALID_CMD_LINE;
23.     }
25.     set_cmd_name(cmd->command->name);
27.     if (arg_count(cmd, config_ARG))
28.         if ((ret = _override_settings(cmd)))
29.             goto_out;
31.     if (arg_count(cmd, config_ARG) || !cmd->config_valid || config_files_changed(cmd)) {
32.         /* Reinitialise various settings inc. logging, filters */
33.         if (!refresh_toolcontext(cmd)) {
34.             log_error("Updated config file invalid. Aborting.");
35.             return ECMD_FAILED;
36.         }
37.     }
39.     if ((ret = _get_settings(cmd)))
40.         goto_out;
41.     _apply_settings(cmd);
43.     log_debug("Processing: %s", cmd->cmd_line);
45. #ifdef O_DIRECT_SUPPORT
46.     log_debug("O_DIRECT will be used");
47. #endif
49.     if ((ret = _process_common_commands(cmd)))
50.         goto_out;
52.     if (arg_count(cmd, nolocking_ARG))
53.         locking_type = 0;
54.     else
55.         locking_type = find_config_tree_int(cmd,
56.                            "global/locking_type", 1);
58.     if (!init_locking(locking_type, cmd)) {
59.         log_error("Locking type %d initialisation failed.",
60.               locking_type);
61.         ret = ECMD_FAILED;
62.         goto out;
63.     }
65.     ret = cmd->command->fn(cmd, argc, argv);
67.     fin_locking();
69.       out:
70.     if (test_mode()) {
71.         log_verbose("Test mode: Wiping internal cache");
72.         lvmcache_destroy(cmd, 1);
73.     }
75.     if (cmd->cft_override) {
76.         destroy_config_tree(cmd->cft_override);
77.         cmd->cft_override = NULL;
78.         /* Move this? */
79.         if (!refresh_toolcontext(cmd))
80.             stack;
81.     }
83.     /* FIXME Move this? */
84.     cmd->current_settings = cmd->default_settings;
85.     _apply_settings(cmd);
87.     /*
88.      * free off any memory the command used.
89.      */
90.     dm_pool_empty(cmd->mem);
92.     if (ret == EINVALID_CMD_LINE && !_cmdline.interactive)
93.         _short_usage(cmd->command->name);
95.     log_debug("Completed: %s", cmd->cmd_line);
97.     return ret;
98. }

比较主要的就两个函数把，就是 _find_command和ret = cmd->command->fn(cmd, argc, argv)。顾名思义，先找到要执行的代码函数所在的位置，然后进行操作。 (cmd->cmd_line = _copy_command_line(cmd, argc, argv)是把命令携带的参数进行copy，在命令执行之前，调用 _process_command_line(cmd, &argc, &argv)对命令的参数进行处理。

1. static struct command *_find_command(const char *name)
2. {
3.     int i;
4.     char *base;
6.     base = last_path_component(name);
8.     for (i = 0; i < _cmdline.num_commands; i++) {
9.         if (!strcmp(base, _cmdline.commands[i].name))
10.             break;
11.     }
13.     if (i >= _cmdline.num_commands)
14.         return 0;
16.     return _cmdline.commands + i;
17. }

在_find_command中，就是将name和静态变量_cmdline的元素进行比较，找到对应的命令入口。
然后调用ret = cmd->command->fn(cmd, argc, argv);执行cmd对应的函数。至此，lvm初始化及其对命令的解析完毕，转入到不同命令的执行中。