mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-22 17:35:59 +03:00
c1ab9fb37f
generate the header in the include dir so it can be easily used from both lib and tools dirs.
4039 lines
98 KiB
C
4039 lines
98 KiB
C
/*
|
|
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
|
|
* Copyright (C) 2004-2017 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This file is part of LVM2.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU Lesser General Public License v.2.1.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include <asm/types.h>
|
|
#include <sys/types.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <sys/wait.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdarg.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#include <syslog.h>
|
|
#include <sched.h>
|
|
#include <dirent.h>
|
|
#include <ctype.h>
|
|
#include <getopt.h>
|
|
|
|
const char *_lvt_enum_to_name(int lvt_enum);
|
|
const size_t _LONG_LINE = 42; /* length of line that neededs .nh .. .hy */
|
|
/*
|
|
* This file can be compiled by itself as a man page generator.
|
|
*/
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
|
|
#define stack
|
|
|
|
struct cmd_context {
|
|
void *libmem;
|
|
};
|
|
|
|
#define log_error(fmt, args...) \
|
|
do { \
|
|
printf(fmt "\n", ##args); \
|
|
} while (0)
|
|
|
|
#define dm_snprintf snprintf
|
|
|
|
static int dm_strncpy(char *dest, const char *src, size_t n)
|
|
{
|
|
if (memccpy(dest, src, 0, n))
|
|
return 1;
|
|
|
|
if (n > 0)
|
|
dest[n - 1] = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
static char *dm_pool_strdup(void *p, const char *str)
|
|
{
|
|
return strdup(str);
|
|
}
|
|
|
|
static void *dm_pool_alloc(void *p, size_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
/* needed to include args.h */
|
|
#define ARG_COUNTABLE 0x00000001
|
|
#define ARG_GROUPABLE 0x00000002
|
|
#define ARG_NONINTERACTIVE 0x00000004
|
|
struct cmd_context;
|
|
struct arg_values;
|
|
|
|
/* needed to include vals.h */
|
|
static inline int yes_no_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int activation_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int cachemetadataformat_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int cachemode_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int discards_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int mirrorlog_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int size_kb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int ssize_kb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int size_mb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int ssize_mb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int psize_mb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int nsize_mb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int int_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int uint32_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int int_arg_with_sign(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int int_arg_with_plus(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int extents_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int sextents_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int pextents_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int nextents_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int major_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int minor_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int string_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int tag_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int permission_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int metadatatype_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int units_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int segtype_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int alloc_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int locktype_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int readahead_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int regionsize_mb_arg(struct cmd_context *cmd, struct arg_values *av) { return 0; }
|
|
static inline int vgmetadatacopies_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int pvmetadatacopies_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int metadatacopies_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int polloperation_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int writemostly_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int syncaction_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int reportformat_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int configreport_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int configtype_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int repairtype_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
static inline int dumptype_arg(struct cmd_context *cmd __attribute__((unused)), struct arg_values *av) { return 0; }
|
|
|
|
/* needed to include commands.h when building man page generator */
|
|
#define CACHE_VGMETADATA 0x00000001
|
|
#define PERMITTED_READ_ONLY 0x00000002
|
|
#define ALL_VGS_IS_DEFAULT 0x00000004
|
|
#define ENABLE_ALL_DEVS 0x00000008
|
|
#define ALLOW_UUID_AS_NAME 0x00000010
|
|
#define LOCKD_VG_SH 0x00000020
|
|
#define NO_METADATA_PROCESSING 0x00000040
|
|
#define MUST_USE_ALL_ARGS 0x00000100
|
|
#define ENABLE_DUPLICATE_DEVS 0x00000400
|
|
#define DISALLOW_TAG_ARGS 0x00000800
|
|
#define GET_VGNAME_FROM_OPTIONS 0x00001000
|
|
#define CAN_USE_ONE_SCAN 0x00002000
|
|
#define ALLOW_HINTS 0x00004000
|
|
#define ALLOW_EXPORTED 0x00008000
|
|
#define CHECK_DEVS_USED 0x00010000
|
|
#define DEVICE_ID_NOT_FOUND 0x00020000
|
|
|
|
/* create foo_CMD enums for command def ID's in command-lines.in */
|
|
|
|
enum {
|
|
#define cmd(a, b) a ,
|
|
#include "../include/cmds.h"
|
|
#undef cmd
|
|
};
|
|
|
|
/* create foo_VAL enums for option and position values */
|
|
|
|
enum {
|
|
#define val(a, b, c, d) a ,
|
|
#include "vals.h"
|
|
#undef val
|
|
};
|
|
|
|
/* create foo_ARG enums for --option's */
|
|
|
|
enum {
|
|
#define arg(a, b, c, d, e, f, g) a ,
|
|
#include "args.h"
|
|
#undef arg
|
|
};
|
|
|
|
/* create foo_LVP enums for LV properties */
|
|
|
|
enum {
|
|
#define lvp(a, b, c) a,
|
|
#include "lv_props.h"
|
|
#undef lvp
|
|
};
|
|
|
|
/* create foo_LVT enums for LV types */
|
|
|
|
enum {
|
|
#define lvt(a, b, c) a,
|
|
#include "lv_types.h"
|
|
#undef lvt
|
|
};
|
|
|
|
#else /* MAN_PAGE_GENERATOR */
|
|
|
|
#include "tools.h"
|
|
|
|
#endif /* MAN_PAGE_GENERATOR */
|
|
|
|
#include "command.h" /* defines struct command */
|
|
#include "command-count.h" /* defines COMMAND_COUNT */
|
|
|
|
/* see cmd_names[] below, one for each unique "ID" in command-lines.in */
|
|
|
|
struct cmd_name {
|
|
const char *enum_name; /* "foo_CMD" */
|
|
int cmd_enum; /* foo_CMD */
|
|
const char *name; /* "foo" from string after ID: */
|
|
};
|
|
|
|
/* create table of value names, e.g. String, and corresponding enum from vals.h */
|
|
|
|
struct val_name val_names[VAL_COUNT + 1] = {
|
|
#define val(a, b, c, d) { # a, a, b, c, d },
|
|
#include "vals.h"
|
|
#undef val
|
|
};
|
|
|
|
/* create table of option names, e.g. --foo, and corresponding enum from args.h */
|
|
|
|
struct opt_name opt_names[ARG_COUNT + 1] = {
|
|
#define arg(a, b, c, d, e, f, g) { # a, a, b, "", "--" c, d, e, f, g },
|
|
#include "args.h"
|
|
#undef arg
|
|
};
|
|
|
|
/* create table of lv property names, e.g. lv_is_foo, and corresponding enum from lv_props.h */
|
|
|
|
struct lv_prop lv_props[LVP_COUNT + 1] = {
|
|
#define lvp(a, b, c) { # a, a, b, c },
|
|
#include "lv_props.h"
|
|
#undef lvp
|
|
};
|
|
|
|
/* create table of lv type names, e.g. linear and corresponding enum from lv_types.h */
|
|
|
|
struct lv_type lv_types[LVT_COUNT + 1] = {
|
|
#define lvt(a, b, c) { # a, a, b, c },
|
|
#include "lv_types.h"
|
|
#undef lvt
|
|
};
|
|
|
|
/* create table of command IDs */
|
|
|
|
struct cmd_name cmd_names[CMD_COUNT + 1] = {
|
|
#define cmd(a, b) { # a, a, # b },
|
|
#include "../include/cmds.h"
|
|
#undef cmd
|
|
};
|
|
|
|
/*
|
|
* command_names[] and commands[] are defined in lvmcmdline.c when building lvm,
|
|
* but need to be defined here when building the stand-alone man page generator.
|
|
*/
|
|
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
|
|
struct command_name command_names[] = {
|
|
#define xx(a, b, c...) { # a, b, c },
|
|
#include "commands.h"
|
|
#undef xx
|
|
{ .name = NULL }
|
|
};
|
|
struct command commands[COMMAND_COUNT];
|
|
|
|
#else /* MAN_PAGE_GENERATOR */
|
|
|
|
struct command_name command_names[] = {
|
|
#define xx(a, b, c...) { # a, b, c, a},
|
|
#include "commands.h"
|
|
#undef xx
|
|
{ .name = NULL }
|
|
};
|
|
extern struct command commands[COMMAND_COUNT]; /* defined in lvmcmdline.c */
|
|
|
|
#endif /* MAN_PAGE_GENERATOR */
|
|
|
|
/* array of pointers into opt_names[] that is sorted alphabetically (by long opt name) */
|
|
|
|
struct opt_name *opt_names_alpha[ARG_COUNT + 1];
|
|
|
|
/* lvm_all is for recording options that are common for all lvm commands */
|
|
|
|
struct command lvm_all;
|
|
|
|
/* saves OO_FOO lines (groups of optional options) to include in multiple defs */
|
|
|
|
static int _oo_line_count;
|
|
#define MAX_OO_LINES 256
|
|
|
|
struct oo_line {
|
|
char *name;
|
|
char *line;
|
|
};
|
|
static struct oo_line _oo_lines[MAX_OO_LINES];
|
|
|
|
#define REQUIRED 1 /* required option */
|
|
#define OPTIONAL 0 /* optional option */
|
|
#define IGNORE (-1) /* ignore option */
|
|
|
|
#define MAX_LINE 1024
|
|
#define MAX_LINE_ARGC 256
|
|
#define DESC_LINE 1024
|
|
|
|
/*
|
|
* Contains _command_input[] which is command-lines.in with comments
|
|
* removed and wrapped as a string. The _command_input[] string is
|
|
* used to populate commands[].
|
|
*/
|
|
#include "command-lines-input.h"
|
|
|
|
static void __add_optional_opt_line(struct cmd_context *cmdtool, struct command *cmd, int argc, char *argv[]);
|
|
|
|
static unsigned _was_hyphen = 0;
|
|
static void printf_hyphen(char c)
|
|
{
|
|
/* When .hy 1 was printed, we do not want to emit empty space */
|
|
printf("%c%c\n", _was_hyphen ? '\n' : ' ', c);
|
|
_was_hyphen = 0;
|
|
}
|
|
|
|
/*
|
|
* modifies buf, replacing the sep characters with \0
|
|
* argv pointers point to positions in buf
|
|
*/
|
|
|
|
static char *_split_line(char *buf, int *argc, char **argv, char sep)
|
|
{
|
|
char *p = buf, *rp = NULL;
|
|
int i;
|
|
|
|
argv[0] = p;
|
|
|
|
for (i = 1; i < MAX_LINE_ARGC; i++) {
|
|
p = strchr(buf, sep);
|
|
if (!p)
|
|
break;
|
|
*p = '\0';
|
|
|
|
argv[i] = p + 1;
|
|
buf = p + 1;
|
|
}
|
|
*argc = i;
|
|
|
|
/* we ended by hitting \0, return the point following that */
|
|
if (!rp)
|
|
rp = strchr(buf, '\0') + 1;
|
|
|
|
return rp;
|
|
}
|
|
|
|
/* convert value string, e.g. Number, to foo_VAL enum */
|
|
|
|
static int _val_str_to_num(char *str)
|
|
{
|
|
char name[MAX_LINE_ARGC];
|
|
char *new;
|
|
int i;
|
|
|
|
/* compare the name before any suffix like _new or _<lvtype> */
|
|
|
|
if (!dm_strncpy(name, str, sizeof(name)))
|
|
return 0; /* Buffer is too short */
|
|
|
|
if ((new = strchr(name, '_')))
|
|
*new = '\0';
|
|
|
|
for (i = 0; i < VAL_COUNT; i++) {
|
|
if (!val_names[i].name)
|
|
break;
|
|
if (!strncmp(name, val_names[i].name, strlen(val_names[i].name)))
|
|
return val_names[i].val_enum;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* convert "--option" to foo_ARG enum */
|
|
|
|
#define MAX_LONG_OPT_NAME_LEN 32
|
|
|
|
static int _opt_str_to_num(struct command *cmd, char *str)
|
|
{
|
|
char long_name[MAX_LONG_OPT_NAME_LEN];
|
|
char *p;
|
|
int i;
|
|
int first = 0, last = ARG_COUNT - 1, middle;
|
|
|
|
(void) dm_strncpy(long_name, str, sizeof(long_name));
|
|
|
|
if ((p = strstr(long_name, "_long")))
|
|
/*
|
|
* --foo_long means there are two args entries
|
|
* for --foo, one with a short option and one
|
|
* without, and we want the one without the
|
|
* short option (== 0).
|
|
*/
|
|
*p = '\0';
|
|
|
|
/* Binary search in sorted array of long options (with duplicates) */
|
|
while (first <= last) {
|
|
middle = first + (last - first) / 2;
|
|
if ((i = strcmp(opt_names_alpha[middle]->long_opt, long_name)) < 0)
|
|
first = middle + 1;
|
|
else if (i > 0)
|
|
last = middle - 1;
|
|
else {
|
|
/* Matching long option string found.
|
|
* As sorted array contains duplicates, we need to also
|
|
* check left & right side for possible match
|
|
*/
|
|
for (i = middle;;) {
|
|
if ((!p && !strstr(opt_names_alpha[i]->name, "_long_ARG")) ||
|
|
(p && !opt_names_alpha[i]->short_opt))
|
|
return opt_names_alpha[i]->opt_enum; /* Found */
|
|
/* Check if there is something on the 'left-side' */
|
|
if ((i <= first) || strcmp(opt_names_alpha[--i]->long_opt, long_name))
|
|
break;
|
|
}
|
|
|
|
/* Nothing on the left, so look on the 'right-side' */
|
|
for (i = middle + 1; i <= last; ++i) {
|
|
if (strcmp(opt_names_alpha[i]->long_opt, long_name))
|
|
break;
|
|
if ((!p && !strstr(opt_names_alpha[i]->name, "_long_ARG")) ||
|
|
(p && !opt_names_alpha[i]->short_opt))
|
|
return opt_names_alpha[i]->opt_enum; /* Found */
|
|
}
|
|
|
|
break; /* Nothing... */
|
|
}
|
|
}
|
|
|
|
log_error("Parsing command defs: unknown opt str: \"%s\"%s%s.",
|
|
str, p ? " ": "", p ? long_name : "");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
|
|
return ARG_UNUSED;
|
|
}
|
|
|
|
/* "foo" string to foo_CMD int */
|
|
|
|
int command_id_to_enum(const char *str)
|
|
{
|
|
int i;
|
|
int first = 1, last = CMD_COUNT - 1, middle;
|
|
|
|
while (first <= last) {
|
|
middle = first + (last - first) / 2;
|
|
if ((i = strcmp(cmd_names[middle].name, str)) < 0)
|
|
first = middle + 1;
|
|
else if (i > 0)
|
|
last = middle - 1;
|
|
else
|
|
return cmd_names[middle].cmd_enum;
|
|
}
|
|
|
|
log_error("Cannot find command %s.", str);
|
|
return CMD_NONE;
|
|
}
|
|
|
|
/* "lv_is_prop" to is_prop_LVP */
|
|
|
|
static int _lvp_name_to_enum(struct command *cmd, char *str)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < LVP_COUNT; i++) {
|
|
if (!strcmp(str, lv_props[i].name))
|
|
return lv_props[i].lvp_enum;
|
|
}
|
|
|
|
log_error("Parsing command defs: unknown lv property %s.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return LVP_NONE;
|
|
}
|
|
|
|
/* "type" to type_LVT */
|
|
|
|
static int _lvt_name_to_enum(struct command *cmd, char *str)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < LVT_COUNT; i++) {
|
|
if (!strcmp(str, lv_types[i].name))
|
|
return lv_types[i].lvt_enum;
|
|
}
|
|
|
|
log_error("Parsing command defs: unknown lv type %s.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return LVT_NONE;
|
|
}
|
|
|
|
/* LV_<type> to <type>_LVT */
|
|
|
|
static int _lv_to_enum(struct command *cmd, char *name)
|
|
{
|
|
return _lvt_name_to_enum(cmd, name + 3);
|
|
}
|
|
|
|
/*
|
|
* LV_<type1>_<type2> to lvt_bits
|
|
*
|
|
* type1 to lvt_enum
|
|
* lvt_bits |= lvt_enum_to_bit(lvt_enum)
|
|
* type2 to lvt_enum
|
|
* lvt_bits |= lvt_enum_to_bit(lvt_enum)
|
|
*/
|
|
|
|
#define LVTYPE_LEN 64
|
|
|
|
static uint64_t _lv_to_bits(struct command *cmd, char *name)
|
|
{
|
|
char buf[LVTYPE_LEN];
|
|
char *argv[MAX_LINE_ARGC];
|
|
uint64_t lvt_bits = 0;
|
|
int lvt_enum;
|
|
int argc;
|
|
int i;
|
|
|
|
(void) dm_strncpy(buf, name, LVTYPE_LEN);
|
|
|
|
_split_line(buf, &argc, argv, '_');
|
|
|
|
/* 0 is "LV" */
|
|
for (i = 1; i < argc; i++) {
|
|
if (!strcmp(argv[i], "new"))
|
|
continue;
|
|
lvt_enum = _lvt_name_to_enum(cmd, argv[i]);
|
|
lvt_bits |= lvt_enum_to_bit(lvt_enum);
|
|
}
|
|
|
|
return lvt_bits;
|
|
}
|
|
|
|
struct command_name *find_command_name(const char *name)
|
|
{
|
|
static int _command_names_count = -1;
|
|
int first = 0, last, middle;
|
|
int i;
|
|
|
|
if (_command_names_count == -1) {
|
|
/* Validate cmd_names & command_names arrays are properly sorted */
|
|
for (i = 1; i < CMD_COUNT - 2; i++)
|
|
if (strcmp(cmd_names[i].name, cmd_names[i + 1].name) > 0) {
|
|
log_error("File cmds.h has unsorted name entry %s.",
|
|
cmd_names[i].name);
|
|
return 0;
|
|
}
|
|
for (i = 1; command_names[i].name; i++) /* assume > 1 */
|
|
if (strcmp(command_names[i - 1].name, command_names[i].name) > 0) {
|
|
log_error("File commands.h has unsorted name entry %s.",
|
|
command_names[i].name);
|
|
return 0;
|
|
}
|
|
_command_names_count = i - 1;
|
|
}
|
|
last = _command_names_count;
|
|
|
|
while (first <= last) {
|
|
middle = first + (last - first) / 2;
|
|
if ((i = strcmp(command_names[middle].name, name)) < 0)
|
|
first = middle + 1;
|
|
else if (i > 0)
|
|
last = middle - 1;
|
|
else
|
|
return &command_names[middle];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct command_name *_find_command_name(const char *name)
|
|
{
|
|
if (!islower(name[0]))
|
|
return NULL; /* Commands starts with lower-case */
|
|
|
|
return find_command_name(name);
|
|
}
|
|
|
|
static const char *_is_command_name(char *str)
|
|
{
|
|
const struct command_name *c;
|
|
|
|
if ((c = _find_command_name(str)))
|
|
return c->name;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int _is_opt_name(char *str)
|
|
{
|
|
if ((str[0] == '-') && (str[1] == '-'))
|
|
return 1;
|
|
|
|
if ((str[0] == '-') && (str[1] != '-'))
|
|
log_error("Parsing command defs: options must be specified in long form: %s.", str);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* "Select" as a pos name means that the position
|
|
* can be empty if the --select option is used.
|
|
*/
|
|
|
|
static int _is_pos_name(char *str)
|
|
{
|
|
switch (str[0]) {
|
|
case 'V': return (str[1] == 'G'); /* VG */
|
|
case 'L': return (str[1] == 'V'); /* LV */
|
|
case 'P': return (str[1] == 'V'); /* PV */
|
|
case 'T': return (strncmp(str, "Tag", 3) == 0);
|
|
case 'S': return ((strncmp(str, "String", 6) == 0) ||
|
|
(strncmp(str, "Select", 6) == 0));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int _is_oo_definition(char *str)
|
|
{
|
|
if (!strncmp(str, "OO_", 3) && strchr(str, ':'))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_oo_line(char *str)
|
|
{
|
|
if (!strncmp(str, "OO:", 3))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_io_line(char *str)
|
|
{
|
|
if (!strncmp(str, "IO:", 3))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_op_line(char *str)
|
|
{
|
|
if (!strncmp(str, "OP:", 3))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_desc_line(char *str)
|
|
{
|
|
if (!strncmp(str, "DESC:", 5))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_autotype_line(char *str)
|
|
{
|
|
if (!strncmp(str, "AUTOTYPE:", 6))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_flags_line(char *str)
|
|
{
|
|
if (!strncmp(str, "FLAGS:", 6))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_rule_line(char *str)
|
|
{
|
|
if (!strncmp(str, "RULE:", 5))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _is_id_line(char *str)
|
|
{
|
|
if (!strncmp(str, "ID:", 3))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Save a positional arg in a struct arg_def.
|
|
* Parse str for anything that can appear in a position,
|
|
* like VG, VG|LV, VG|LV_linear|LV_striped, etc.
|
|
*/
|
|
|
|
static void _set_pos_def(struct command *cmd, char *str, struct arg_def *def)
|
|
{
|
|
char *argv[MAX_LINE_ARGC];
|
|
int argc;
|
|
char *name;
|
|
int val_enum;
|
|
int i;
|
|
|
|
_split_line(str, &argc, argv, '|');
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
name = argv[i];
|
|
|
|
val_enum = _val_str_to_num(name);
|
|
|
|
if (!val_enum) {
|
|
log_error("Parsing command defs: unknown pos arg: %s.", name);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
def->val_bits |= val_enum_to_bit(val_enum);
|
|
|
|
if ((val_enum == lv_VAL) && strchr(name, '_'))
|
|
def->lvt_bits = _lv_to_bits(cmd, name);
|
|
|
|
if (strstr(name, "_new")) {
|
|
if (val_enum == lv_VAL)
|
|
def->flags |= ARG_DEF_FLAG_NEW_LV;
|
|
else if (val_enum == vg_VAL)
|
|
def->flags |= ARG_DEF_FLAG_NEW_VG;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Save an option arg in a struct arg_def.
|
|
* Parse str for anything that can follow --option.
|
|
*/
|
|
static void _set_opt_def(struct cmd_context *cmdtool, struct command *cmd, char *str, struct arg_def *def)
|
|
{
|
|
char *argv[MAX_LINE_ARGC];
|
|
int argc;
|
|
char *name;
|
|
int val_enum;
|
|
int i;
|
|
|
|
_split_line(str, &argc, argv, '|');
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
name = argv[i];
|
|
|
|
val_enum = _val_str_to_num(name);
|
|
|
|
if (!val_enum) {
|
|
/* a literal number or string */
|
|
|
|
if (isdigit(name[0]))
|
|
val_enum = constnum_VAL;
|
|
|
|
else if (isalpha(name[0]))
|
|
val_enum = conststr_VAL;
|
|
|
|
else {
|
|
log_error("Parsing command defs: unknown opt arg: %s.", name);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
def->val_bits |= val_enum_to_bit(val_enum);
|
|
|
|
if (val_enum == constnum_VAL)
|
|
def->num = (uint64_t)atoi(name);
|
|
|
|
if (val_enum == conststr_VAL) {
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
free((void*)def->str);
|
|
#endif
|
|
def->str = dm_pool_strdup(cmdtool->libmem, name);
|
|
|
|
if (!def->str) {
|
|
/* FIXME */
|
|
stack;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (val_enum == lv_VAL) {
|
|
if (strchr(name, '_'))
|
|
def->lvt_bits = _lv_to_bits(cmd, name);
|
|
}
|
|
|
|
if (strstr(name, "_new")) {
|
|
if (val_enum == lv_VAL)
|
|
def->flags |= ARG_DEF_FLAG_NEW_LV;
|
|
else if (val_enum == vg_VAL)
|
|
def->flags |= ARG_DEF_FLAG_NEW_VG;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Save a set of common options so they can be included in
|
|
* multiple command defs.
|
|
*
|
|
* OO_FOO: --opt1 ...
|
|
*
|
|
* oo->name = "OO_FOO";
|
|
* oo->line = "--opt1 ...";
|
|
*/
|
|
|
|
static void _add_oo_definition_line(const char *name, const char *line)
|
|
{
|
|
struct oo_line *oo;
|
|
char *colon;
|
|
char *start;
|
|
|
|
oo = &_oo_lines[_oo_line_count++];
|
|
|
|
if (!(oo->name = strdup(name))) {
|
|
log_error("Failer to duplicate name %s.", name);
|
|
return; /* FIXME: return code */
|
|
}
|
|
|
|
if ((colon = strchr(oo->name, ':')))
|
|
*colon = '\0';
|
|
else {
|
|
log_error("Parsing command defs: invalid OO definition.");
|
|
return;
|
|
}
|
|
|
|
start = strchr(line, ':') + 2;
|
|
if (!(oo->line = strdup(start))) {
|
|
log_error("Failer to duplicate line %s.", start);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Support OO_FOO: continuing on multiple lines. */
|
|
|
|
static void _append_oo_definition_line(const char *new_line)
|
|
{
|
|
struct oo_line *oo;
|
|
char *old_line;
|
|
char *line;
|
|
int len;
|
|
|
|
oo = &_oo_lines[_oo_line_count - 1];
|
|
|
|
old_line = oo->line;
|
|
|
|
/* +2 = 1 space between old and new + 1 terminating \0 */
|
|
len = strlen(old_line) + strlen(new_line) + 2;
|
|
line = malloc(len);
|
|
if (!line) {
|
|
log_error("Parsing command defs: no memory.");
|
|
return;
|
|
}
|
|
|
|
(void) dm_snprintf(line, len, "%s %s", old_line, new_line);
|
|
free(oo->line);
|
|
oo->line = line;
|
|
}
|
|
|
|
/* Find a saved OO_FOO definition. */
|
|
|
|
#define OO_NAME_LEN 64
|
|
|
|
static char *_get_oo_line(const char *str)
|
|
{
|
|
char *name;
|
|
char *end;
|
|
char str2[OO_NAME_LEN];
|
|
int i;
|
|
|
|
(void) dm_strncpy(str2, str, sizeof(str2));
|
|
if ((end = strchr(str2, ':')))
|
|
*end = '\0';
|
|
if ((end = strchr(str2, ',')))
|
|
*end = '\0';
|
|
|
|
for (i = 0; i < _oo_line_count; i++) {
|
|
name = _oo_lines[i].name;
|
|
if (!strcmp(name, str2))
|
|
return _oo_lines[i].line;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Add optional_opt_args entries when OO_FOO appears on OO: line,
|
|
* i.e. include common options from an OO_FOO definition.
|
|
*/
|
|
|
|
static void _include_optional_opt_args(struct cmd_context *cmdtool, struct command *cmd, const char *str)
|
|
{
|
|
char *oo_line;
|
|
char *line;
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
int line_argc;
|
|
|
|
if (!(oo_line = _get_oo_line(str))) {
|
|
log_error("Parsing command defs: no OO line found for %s.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
if (!(line = strdup(oo_line))) {
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
_split_line(line, &line_argc, line_argv, ' ');
|
|
__add_optional_opt_line(cmdtool, cmd, line_argc, line_argv);
|
|
free(line);
|
|
}
|
|
|
|
/*
|
|
* When an --option is seen, add a new opt_args entry for it.
|
|
* This function sets the opt_args.opt value for it.
|
|
*/
|
|
|
|
static void _add_opt_arg(struct command *cmd, char *str,
|
|
int *takes_arg, int *already, int required)
|
|
{
|
|
char *comma;
|
|
int opt;
|
|
int i;
|
|
|
|
/* opt_arg.opt set here */
|
|
/* opt_arg.def will be set in _update_prev_opt_arg() if needed */
|
|
|
|
if ((comma = strchr(str, ',')))
|
|
*comma = '\0';
|
|
|
|
/*
|
|
* Work around nasty hack where --uuid is used for both uuid_ARG
|
|
* and uuidstr_ARG. The input uses --uuidstr, where an actual
|
|
* command uses --uuid string.
|
|
*/
|
|
if (!strcmp(str, "--uuidstr")) {
|
|
opt = uuidstr_ARG;
|
|
goto skip;
|
|
}
|
|
|
|
opt = _opt_str_to_num(cmd, str);
|
|
|
|
/* If the binary-search finds uuidstr_ARG switch to uuid_ARG */
|
|
if (opt == uuidstr_ARG)
|
|
opt = uuid_ARG;
|
|
|
|
/* Skip adding an optional opt if it is already included. */
|
|
if (already && !required) {
|
|
for (i = 0; i < cmd->oo_count; i++) {
|
|
if (cmd->optional_opt_args[i].opt == opt) {
|
|
*already = 1;
|
|
*takes_arg = opt_names[opt].val_enum ? 1 : 0;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
skip:
|
|
if (required > 0)
|
|
cmd->required_opt_args[cmd->ro_count++].opt = opt;
|
|
else if (!required)
|
|
cmd->optional_opt_args[cmd->oo_count++].opt = opt;
|
|
else if (required < 0)
|
|
cmd->ignore_opt_args[cmd->io_count++].opt = opt;
|
|
|
|
*takes_arg = opt_names[opt].val_enum ? 1 : 0;
|
|
}
|
|
|
|
/*
|
|
* After --option has been seen, this function sets opt_args.def value
|
|
* for the value that appears after --option.
|
|
*/
|
|
|
|
static void _update_prev_opt_arg(struct cmd_context *cmdtool, struct command *cmd, char *str, int required)
|
|
{
|
|
struct arg_def def = { 0 };
|
|
char *comma;
|
|
|
|
if (str[0] == '-') {
|
|
log_error("Parsing command defs: option %s must be followed by an arg.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
/* opt_arg.def set here */
|
|
/* opt_arg.opt was previously set in _add_opt_arg() when --foo was read */
|
|
|
|
if ((comma = strchr(str, ',')))
|
|
*comma = '\0';
|
|
|
|
_set_opt_def(cmdtool, cmd, str, &def);
|
|
|
|
if (required > 0)
|
|
cmd->required_opt_args[cmd->ro_count-1].def = def;
|
|
else if (!required)
|
|
cmd->optional_opt_args[cmd->oo_count-1].def = def;
|
|
else if (required < 0)
|
|
cmd->ignore_opt_args[cmd->io_count-1].def = def;
|
|
}
|
|
|
|
/*
|
|
* When an position arg is seen, add a new pos_args entry for it.
|
|
* This function sets the pos_args.pos and pos_args.def.
|
|
*/
|
|
|
|
static void _add_pos_arg(struct command *cmd, char *str, int required)
|
|
{
|
|
struct arg_def def = { 0 };
|
|
|
|
/* pos_arg.pos and pos_arg.def are set here */
|
|
|
|
_set_pos_def(cmd, str, &def);
|
|
|
|
if (required) {
|
|
cmd->required_pos_args[cmd->rp_count].pos = cmd->pos_count++;
|
|
cmd->required_pos_args[cmd->rp_count].def = def;
|
|
cmd->rp_count++;
|
|
} else {
|
|
cmd->optional_pos_args[cmd->op_count].pos = cmd->pos_count++;;
|
|
cmd->optional_pos_args[cmd->op_count].def = def;
|
|
cmd->op_count++;
|
|
}
|
|
}
|
|
|
|
/* Process something that follows a pos arg, which is not a new pos arg. */
|
|
|
|
static void _update_prev_pos_arg(struct command *cmd, char *str, int required)
|
|
{
|
|
struct arg_def *def;
|
|
|
|
/* a previous pos_arg.def is modified here */
|
|
|
|
if (required)
|
|
def = &cmd->required_pos_args[cmd->rp_count-1].def;
|
|
else
|
|
def = &cmd->optional_pos_args[cmd->op_count-1].def;
|
|
|
|
if (!strcmp(str, "..."))
|
|
def->flags |= ARG_DEF_FLAG_MAY_REPEAT;
|
|
else {
|
|
log_error("Parsing command defs: unknown pos arg: %s.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Process what follows OO:, which are the optional opt args for the cmd def. */
|
|
|
|
static void __add_optional_opt_line(struct cmd_context *cmdtool, struct command *cmd, int argc, char *argv[])
|
|
{
|
|
int takes_arg = 0;
|
|
int already;
|
|
int i;
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
if (!i && !strncmp(argv[i], "OO:", 3))
|
|
continue;
|
|
|
|
already = 0;
|
|
|
|
if (_is_opt_name(argv[i]))
|
|
_add_opt_arg(cmd, argv[i], &takes_arg, &already, OPTIONAL);
|
|
else if (!strncmp(argv[i], "OO_", 3))
|
|
_include_optional_opt_args(cmdtool, cmd, argv[i]);
|
|
else if (takes_arg)
|
|
_update_prev_opt_arg(cmdtool, cmd, argv[i], OPTIONAL);
|
|
else {
|
|
log_error("Parsing command defs: can't parse argc %d argv %s%s%s.",
|
|
i, argv[i], (i > 0) ? " prev " : "", (i > 0) ? argv[i - 1] : "");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
if (already && takes_arg)
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/* Process what follows IO:, which are the ignore options for the cmd def. */
|
|
|
|
static void _add_ignore_opt_line(struct cmd_context *cmdtool, struct command *cmd, int argc, char *argv[])
|
|
{
|
|
int takes_arg = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
if (!i && !strncmp(argv[i], "IO:", 3))
|
|
continue;
|
|
if (_is_opt_name(argv[i]))
|
|
_add_opt_arg(cmd, argv[i], &takes_arg, NULL, IGNORE);
|
|
else if (takes_arg)
|
|
_update_prev_opt_arg(cmdtool, cmd, argv[i], IGNORE);
|
|
else {
|
|
log_error("Parsing command defs: can't parse argc %d argv %s%s%s.",
|
|
i, argv[i], (i > 0) ? " prev " : "", (i > 0) ? argv[i - 1] : "");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Process what follows OP:, which are optional pos args for the cmd def. */
|
|
|
|
static void _add_optional_pos_line(struct command *cmd, int argc, char *argv[])
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
if (!i && !strncmp(argv[i], "OP:", 3))
|
|
continue;
|
|
if (_is_pos_name(argv[i]))
|
|
_add_pos_arg(cmd, argv[i], OPTIONAL);
|
|
else
|
|
_update_prev_pos_arg(cmd, argv[i], OPTIONAL);
|
|
}
|
|
}
|
|
|
|
static void _add_required_opt_line(struct cmd_context *cmdtool, struct command *cmd, int argc, char *argv[])
|
|
{
|
|
int takes_arg = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
if (_is_opt_name(argv[i]))
|
|
_add_opt_arg(cmd, argv[i], &takes_arg, NULL, REQUIRED);
|
|
else if (takes_arg)
|
|
_update_prev_opt_arg(cmdtool, cmd, argv[i], REQUIRED);
|
|
else {
|
|
log_error("Parsing command defs: can't parse argc %d argv %s%s%s.",
|
|
i, argv[i], (i > 0) ? " prev " : "", (i > 0) ? argv[i - 1] : "");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add to required_opt_args from an OO_FOO definition.
|
|
* (This is the special case of vgchange/lvchange where one
|
|
* optional option is required, and others are then optional.)
|
|
* The set of options from OO_FOO are saved in required_opt_args,
|
|
* and flag CMD_FLAG_ANY_REQUIRED_OPT is set on the cmd indicating
|
|
* this special case.
|
|
*/
|
|
static void _include_required_opt_args(struct cmd_context *cmdtool, struct command *cmd, char *str)
|
|
{
|
|
char *oo_line;
|
|
char *line;
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
int line_argc;
|
|
|
|
if (!(oo_line = _get_oo_line(str))) {
|
|
log_error("Parsing command defs: no OO line found for %s.", str);
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
if (!(line = strdup(oo_line))) {
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
_split_line(line, &line_argc, line_argv, ' ');
|
|
_add_required_opt_line(cmdtool, cmd, line_argc, line_argv);
|
|
free(line);
|
|
}
|
|
|
|
/* Process what follows command_name, which are required opt/pos args. */
|
|
|
|
static void _add_required_line(struct cmd_context *cmdtool, struct command *cmd, int argc, char *argv[])
|
|
{
|
|
int i;
|
|
int takes_arg;
|
|
int prev_was_opt = 0, prev_was_pos = 0;
|
|
int orig_ro_count = 0;
|
|
|
|
/* argv[0] is command name */
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
if (_is_opt_name(argv[i])) {
|
|
/* add new required_opt_arg */
|
|
_add_opt_arg(cmd, argv[i], &takes_arg, NULL, REQUIRED);
|
|
prev_was_opt = 1;
|
|
prev_was_pos = 0;
|
|
|
|
} else if (prev_was_opt && takes_arg) {
|
|
/* set value for previous required_opt_arg */
|
|
_update_prev_opt_arg(cmdtool, cmd, argv[i], REQUIRED);
|
|
prev_was_opt = 0;
|
|
prev_was_pos = 0;
|
|
|
|
} else if (_is_pos_name(argv[i])) {
|
|
/* add new required_pos_arg */
|
|
_add_pos_arg(cmd, argv[i], REQUIRED);
|
|
prev_was_opt = 0;
|
|
prev_was_pos = 1;
|
|
|
|
} else if (!strncmp(argv[i], "OO_", 3)) {
|
|
/*
|
|
* the first ro_count entries in required_opt_arg required,
|
|
* after which one or more of the next any_ro_count entries
|
|
* in required_opt_arg are required. required_opt_arg
|
|
* has a total of ro_count+any_ro_count entries.
|
|
*/
|
|
cmd->cmd_flags |= CMD_FLAG_ANY_REQUIRED_OPT;
|
|
orig_ro_count = cmd->ro_count;
|
|
|
|
_include_required_opt_args(cmdtool, cmd, argv[i]);
|
|
|
|
cmd->any_ro_count = cmd->ro_count - orig_ro_count;
|
|
cmd->ro_count = orig_ro_count;
|
|
|
|
} else if (prev_was_pos) {
|
|
/* set property for previous required_pos_arg */
|
|
_update_prev_pos_arg(cmd, argv[i], REQUIRED);
|
|
} else {
|
|
log_error("Parsing command defs: can't parse argc %d argv %s%s%s.",
|
|
i, argv[i], (i > 0) ? " prev " : "", (i > 0) ? argv[i - 1] : "");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _add_flags(struct command *cmd, char *line)
|
|
{
|
|
if (strstr(line, "SECONDARY_SYNTAX"))
|
|
cmd->cmd_flags |= CMD_FLAG_SECONDARY_SYNTAX;
|
|
if (strstr(line, "PREVIOUS_SYNTAX"))
|
|
cmd->cmd_flags |= CMD_FLAG_PREVIOUS_SYNTAX;
|
|
}
|
|
|
|
static void _add_autotype(struct cmd_context *cmdtool, struct command *cmd, char *line)
|
|
{
|
|
int line_argc;
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
|
|
_split_line(line, &line_argc, line_argv, ' ');
|
|
|
|
if (cmd->autotype)
|
|
cmd->autotype2 = dm_pool_strdup(cmdtool->libmem, line_argv[1]);
|
|
else
|
|
cmd->autotype = dm_pool_strdup(cmdtool->libmem, line_argv[1]);
|
|
}
|
|
|
|
#define MAX_RULE_OPTS 64
|
|
|
|
static void _add_rule(struct cmd_context *cmdtool, struct command *cmd, char *line)
|
|
{
|
|
struct cmd_rule *rule;
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
char *arg;
|
|
int line_argc;
|
|
int i, lvt_enum, lvp_enum;
|
|
int check = 0;
|
|
|
|
if (cmd->rule_count == CMD_MAX_RULES) {
|
|
log_error("Parsing command defs: too many rules for cmd.");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
|
|
rule = &cmd->rules[cmd->rule_count++];
|
|
|
|
_split_line(line, &line_argc, line_argv, ' ');
|
|
|
|
for (i = 0; i < line_argc; i++) {
|
|
arg = line_argv[i];
|
|
|
|
if (!strcmp(arg, "not")) {
|
|
rule->rule = RULE_INVALID;
|
|
check = 1;
|
|
}
|
|
|
|
else if (!strcmp(arg, "and")) {
|
|
rule->rule = RULE_REQUIRE;
|
|
check = 1;
|
|
}
|
|
|
|
else if (!strncmp(arg, "all", 3)) {
|
|
/* opt/lvt_bits/lvp_bits all remain 0 to mean all */
|
|
continue;
|
|
}
|
|
|
|
else if (!strncmp(arg, "--", 2)) {
|
|
if (!rule->opts) {
|
|
if (!(rule->opts = dm_pool_alloc(cmdtool->libmem, MAX_RULE_OPTS * sizeof(int)))) {
|
|
log_error("Parsing command defs: no mem.");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
memset(rule->opts, 0, MAX_RULE_OPTS * sizeof(int));
|
|
}
|
|
|
|
if (!rule->check_opts) {
|
|
if (!(rule->check_opts = dm_pool_alloc(cmdtool->libmem, MAX_RULE_OPTS * sizeof(int)))) {
|
|
log_error("Parsing command defs: no mem.");
|
|
cmd->cmd_flags |= CMD_FLAG_PARSE_ERROR;
|
|
return;
|
|
}
|
|
memset(rule->check_opts, 0, MAX_RULE_OPTS * sizeof(int));
|
|
}
|
|
|
|
if (check)
|
|
rule->check_opts[rule->check_opts_count++] = _opt_str_to_num(cmd, arg);
|
|
else
|
|
rule->opts[rule->opts_count++] = _opt_str_to_num(cmd, arg);
|
|
}
|
|
|
|
else if (!strncmp(arg, "LV_", 3)) {
|
|
lvt_enum = _lv_to_enum(cmd, arg);
|
|
|
|
if (check)
|
|
rule->check_lvt_bits |= lvt_enum_to_bit(lvt_enum);
|
|
else
|
|
rule->lvt_bits |= lvt_enum_to_bit(lvt_enum);
|
|
}
|
|
|
|
else if (!strncmp(arg, "lv_is_", 6)) {
|
|
lvp_enum = _lvp_name_to_enum(cmd, arg);
|
|
|
|
if (check)
|
|
rule->check_lvp_bits |= lvp_enum_to_bit(lvp_enum);
|
|
else
|
|
rule->lvp_bits |= lvp_enum_to_bit(lvp_enum);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The given option is common to all lvm commands (set in lvm_all). */
|
|
|
|
static int _is_lvm_all_opt(int opt)
|
|
{
|
|
int oo;
|
|
|
|
for (oo = 0; oo < lvm_all.oo_count; oo++) {
|
|
if (lvm_all.optional_opt_args[oo].opt == opt)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Find common options for all variants of each command name. */
|
|
|
|
void factor_common_options(void)
|
|
{
|
|
int cn, opt_enum, ci, oo, ro, found;
|
|
struct command *cmd;
|
|
|
|
for (cn = 0; command_names[cn].name; cn++) {
|
|
/* already factored */
|
|
if (command_names[cn].variants)
|
|
continue;
|
|
|
|
for (ci = 0; ci < COMMAND_COUNT; ci++) {
|
|
cmd = &commands[ci];
|
|
|
|
if (strcmp(cmd->name, command_names[cn].name))
|
|
continue;
|
|
|
|
command_names[cn].variants++;
|
|
}
|
|
|
|
for (opt_enum = 0; opt_enum < ARG_COUNT; opt_enum++) {
|
|
|
|
for (ci = 0; ci < COMMAND_COUNT; ci++) {
|
|
cmd = &commands[ci];
|
|
|
|
if (strcmp(cmd->name, command_names[cn].name))
|
|
continue;
|
|
|
|
if (cmd->ro_count || cmd->any_ro_count)
|
|
command_names[cn].variant_has_ro = 1;
|
|
if (cmd->rp_count)
|
|
command_names[cn].variant_has_rp = 1;
|
|
if (cmd->oo_count)
|
|
command_names[cn].variant_has_oo = 1;
|
|
if (cmd->op_count)
|
|
command_names[cn].variant_has_op = 1;
|
|
|
|
for (ro = 0; ro < cmd->ro_count + cmd->any_ro_count; ro++) {
|
|
command_names[cn].all_options[cmd->required_opt_args[ro].opt] = 1;
|
|
|
|
if ((cmd->required_opt_args[ro].opt == size_ARG) && !strncmp(cmd->name, "lv", 2))
|
|
command_names[cn].all_options[extents_ARG] = 1;
|
|
}
|
|
for (oo = 0; oo < cmd->oo_count; oo++)
|
|
command_names[cn].all_options[cmd->optional_opt_args[oo].opt] = 1;
|
|
|
|
found = 0;
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt == opt_enum) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
goto next_opt;
|
|
}
|
|
|
|
/* all commands starting with this name use this option */
|
|
command_names[cn].common_options[opt_enum] = 1;
|
|
next_opt:
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* FIXME: use a flag in command_name struct? */
|
|
|
|
int command_has_alternate_extents(const char *name)
|
|
{
|
|
if (name[0] != 'l')
|
|
return 0;
|
|
if (!strcmp(name, "lvcreate") ||
|
|
!strcmp(name, "lvresize") ||
|
|
!strcmp(name, "lvextend") ||
|
|
!strcmp(name, "lvreduce"))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int _long_name_compare(const void *on1, const void *on2)
|
|
{
|
|
const struct opt_name * const *optname1 = on1;
|
|
const struct opt_name * const *optname2 = on2;
|
|
|
|
return strcmp((*optname1)->long_opt + 2, (*optname2)->long_opt + 2);
|
|
}
|
|
|
|
/* Create list of option names for printing alphabetically. */
|
|
|
|
static void _create_opt_names_alpha(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARG_COUNT; i++)
|
|
opt_names_alpha[i] = &opt_names[i];
|
|
|
|
qsort(opt_names_alpha, ARG_COUNT, sizeof(long), _long_name_compare);
|
|
}
|
|
|
|
static int _copy_line(char *line, int max_line, int *position)
|
|
{
|
|
int p = *position;
|
|
int i = 0;
|
|
|
|
memset(line, 0, max_line);
|
|
|
|
while (1) {
|
|
line[i] = _command_input[p];
|
|
i++;
|
|
p++;
|
|
|
|
if (_command_input[p] == '\n') {
|
|
p++;
|
|
break;
|
|
}
|
|
|
|
if (i == (max_line - 1))
|
|
break;
|
|
}
|
|
*position = p;
|
|
return 1;
|
|
}
|
|
|
|
int define_commands(struct cmd_context *cmdtool, const char *run_name)
|
|
{
|
|
struct command *cmd = NULL;
|
|
char line[MAX_LINE];
|
|
char line_orig[MAX_LINE];
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
const char *name;
|
|
char *n;
|
|
int line_argc;
|
|
int cmd_count = 0;
|
|
int prev_was_oo_def = 0;
|
|
int prev_was_oo = 0;
|
|
int prev_was_op = 0;
|
|
int copy_pos = 0;
|
|
int skip = 0;
|
|
int i;
|
|
|
|
if (run_name && !strcmp(run_name, "help"))
|
|
run_name = NULL;
|
|
|
|
_create_opt_names_alpha();
|
|
|
|
/* Process each line of command-lines-input.h (from command-lines.in) */
|
|
|
|
while (_copy_line(line, MAX_LINE, ©_pos)) {
|
|
if (line[0] == '\n')
|
|
break;
|
|
|
|
if (!strcmp(line, "---") || !strcmp(line, "--"))
|
|
continue;
|
|
|
|
if ((n = strchr(line, '\n')))
|
|
*n = '\0';
|
|
|
|
memcpy(line_orig, line, sizeof(line));
|
|
_split_line(line, &line_argc, line_argv, ' ');
|
|
|
|
if (!line_argc)
|
|
continue;
|
|
|
|
/* New cmd def begins: command_name <required opt/pos args> */
|
|
if ((name = _is_command_name(line_argv[0]))) {
|
|
if (cmd_count >= COMMAND_COUNT) {
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* FIXME: when running one specific command name,
|
|
* we can optimize by not parsing command defs
|
|
* that don't start with that command name.
|
|
*/
|
|
|
|
cmd = &commands[cmd_count];
|
|
cmd->command_index = cmd_count;
|
|
cmd_count++;
|
|
cmd->name = dm_pool_strdup(cmdtool->libmem, name);
|
|
|
|
if (!cmd->name) {
|
|
/* FIXME */
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (run_name && strcmp(run_name, name)) {
|
|
skip = 1;
|
|
prev_was_oo_def = 0;
|
|
prev_was_oo = 0;
|
|
prev_was_op = 0;
|
|
continue;
|
|
}
|
|
skip = 0;
|
|
|
|
cmd->pos_count = 1;
|
|
_add_required_line(cmdtool, cmd, line_argc, line_argv);
|
|
|
|
/* Every cmd gets the OO_ALL options */
|
|
_include_optional_opt_args(cmdtool, cmd, "OO_ALL:");
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* All other kinds of lines are processed in the
|
|
* context of the existing command[].
|
|
*/
|
|
|
|
if (_is_desc_line(line_argv[0]) && !skip && cmd) {
|
|
if (cmd->desc) {
|
|
size_t newlen = strlen(cmd->desc) + strlen(line_orig) + 2;
|
|
char *newdesc = dm_pool_alloc(cmdtool->libmem, newlen);
|
|
|
|
if (!newdesc) {
|
|
/* FIXME */
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
snprintf(newdesc, newlen, "%s %s", cmd->desc, line_orig);
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
free((void*)cmd->desc);
|
|
#endif
|
|
cmd->desc = newdesc;
|
|
} else if (!(cmd->desc = dm_pool_strdup(cmdtool->libmem, line_orig))) {
|
|
/* FIXME */
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (_is_autotype_line(line_argv[0]) && !skip && cmd) {
|
|
_add_autotype(cmdtool, cmd, line_orig);
|
|
continue;
|
|
}
|
|
|
|
if (_is_flags_line(line_argv[0]) && !skip && cmd) {
|
|
_add_flags(cmd, line_orig);
|
|
continue;
|
|
}
|
|
|
|
if (_is_rule_line(line_argv[0]) && !skip && cmd) {
|
|
_add_rule(cmdtool, cmd, line_orig);
|
|
continue;
|
|
}
|
|
|
|
if (_is_id_line(line_argv[0]) && cmd) {
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
free((void*)cmd->command_id);
|
|
#endif
|
|
cmd->command_id = dm_pool_strdup(cmdtool->libmem, line_argv[1]);
|
|
|
|
if (!cmd->command_id) {
|
|
/* FIXME */
|
|
stack;
|
|
return 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* OO_FOO: ... */
|
|
if (_is_oo_definition(line_argv[0])) {
|
|
_add_oo_definition_line(line_argv[0], line_orig);
|
|
prev_was_oo_def = 1;
|
|
prev_was_oo = 0;
|
|
prev_was_op = 0;
|
|
continue;
|
|
}
|
|
|
|
/* OO: ... */
|
|
if (_is_oo_line(line_argv[0]) && !skip && cmd) {
|
|
__add_optional_opt_line(cmdtool, cmd, line_argc, line_argv);
|
|
prev_was_oo_def = 0;
|
|
prev_was_oo = 1;
|
|
prev_was_op = 0;
|
|
continue;
|
|
}
|
|
|
|
/* OP: ... */
|
|
if (_is_op_line(line_argv[0]) && !skip && cmd) {
|
|
_add_optional_pos_line(cmd, line_argc, line_argv);
|
|
prev_was_oo_def = 0;
|
|
prev_was_oo = 0;
|
|
prev_was_op = 1;
|
|
continue;
|
|
}
|
|
|
|
/* IO: ... */
|
|
if (_is_io_line(line_argv[0]) && !skip && cmd) {
|
|
_add_ignore_opt_line(cmdtool, cmd, line_argc, line_argv);
|
|
prev_was_oo = 0;
|
|
prev_was_op = 0;
|
|
continue;
|
|
}
|
|
|
|
/* handle OO_FOO:, OO:, OP: continuing on multiple lines */
|
|
|
|
if (prev_was_oo_def) {
|
|
_append_oo_definition_line(line_orig);
|
|
continue;
|
|
}
|
|
|
|
if (prev_was_oo && cmd) {
|
|
__add_optional_opt_line(cmdtool, cmd, line_argc, line_argv);
|
|
continue;
|
|
}
|
|
|
|
if (prev_was_op && cmd) {
|
|
_add_optional_pos_line(cmd, line_argc, line_argv);
|
|
continue;
|
|
}
|
|
|
|
if (!skip)
|
|
log_error("Parsing command defs: can't process input line %s.", line_orig);
|
|
}
|
|
|
|
for (i = 0; i < COMMAND_COUNT; i++) {
|
|
if (commands[i].cmd_flags & CMD_FLAG_PARSE_ERROR)
|
|
return 0;
|
|
}
|
|
|
|
_include_optional_opt_args(cmdtool, &lvm_all, "OO_ALL");
|
|
|
|
for (i = 0; i < _oo_line_count; i++) {
|
|
struct oo_line *oo = &_oo_lines[i];
|
|
free(oo->name);
|
|
free(oo->line);
|
|
}
|
|
memset(&_oo_lines, 0, sizeof(_oo_lines));
|
|
_oo_line_count = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* The opt_names[] table describes each option. It is indexed by the
|
|
* option typedef, e.g. size_ARG. The size_ARG entry specifies the
|
|
* option name, e.g. --size, and the kind of value it accepts,
|
|
* e.g. sizemb_VAL.
|
|
*
|
|
* The val_names[] table describes each option value type. It is indexed by
|
|
* the value typedef, e.g. sizemb_VAL. The sizemb_VAL entry specifies the
|
|
* function used to parse the value, e.g. size_mb_arg(), the string used to
|
|
* refer to the value in the command-lines.in specifications, e.g. SizeMB,
|
|
* and how the value should be displayed in a man page, e.g. Size[m|UNIT].
|
|
*
|
|
* A problem is that these tables are independent of a particular command
|
|
* (they are created at build time), but different commands accept different
|
|
* types of values for the same option, e.g. one command will accept
|
|
* signed size values (ssizemb_VAL), while another does not accept a signed
|
|
* number, (sizemb_VAL). This function deals with this problem by tweaking
|
|
* the opt_names[] table at run time according to the specific command being run.
|
|
* i.e. it changes size_ARG to accept sizemb_VAL or ssizemb_VAL depending
|
|
* on the command.
|
|
*
|
|
* By default, size_ARG in opt_names[] is set up to accept a standard
|
|
* sizemb_VAL. The same is done for other opt_names[] entries that
|
|
* take different option values.
|
|
*
|
|
* This function overrides default opt_names[] entries at run time according
|
|
* to the command name, adjusting the value types accepted by various options.
|
|
* So, for lvresize, opt_names[sizemb_VAL] is overridden to accept
|
|
* the relative (+ or -) value type ssizemb_VAL, instead of the default
|
|
* sizemb_VAL. This way, when lvresize processes the --size value, it
|
|
* will use the ssize_mb_arg() function which accepts relative size values.
|
|
* When lvcreate processes the --size value, it uses size_mb_arg() which
|
|
* rejects signed values.
|
|
*
|
|
* The command defs in commands[] do not need to be overridden because
|
|
* the command-lines.in defs have the context of a command, and are
|
|
* described using the proper value type, e.g. this cmd def already
|
|
* uses the relative size value: "lvresize --size SSizeMB LV",
|
|
* so the commands[] entry for the cmd def already references the
|
|
* correct ssizemb_VAL.
|
|
*/
|
|
void configure_command_option_values(const char *name)
|
|
{
|
|
if (!strcmp(name, "lvresize")) {
|
|
/* relative +|- allowed for LV, + allowed for metadata */
|
|
opt_names[size_ARG].val_enum = ssizemb_VAL;
|
|
opt_names[extents_ARG].val_enum = sextents_VAL;
|
|
opt_names[poolmetadatasize_ARG].val_enum = psizemb_VAL;
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(name, "lvextend")) {
|
|
/* relative + allowed */
|
|
opt_names[size_ARG].val_enum = psizemb_VAL;
|
|
opt_names[extents_ARG].val_enum = pextents_VAL;
|
|
opt_names[poolmetadatasize_ARG].val_enum = psizemb_VAL;
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(name, "lvreduce")) {
|
|
/* relative - allowed */
|
|
opt_names[size_ARG].val_enum = nsizemb_VAL;
|
|
opt_names[extents_ARG].val_enum = nextents_VAL;
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(name, "lvconvert")) {
|
|
opt_names[mirrors_ARG].val_enum = snumber_VAL;
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(name, "lvcreate")) {
|
|
/*
|
|
* lvcreate is a bit of a mess because it has previously
|
|
* accepted + but used it as an absolute value, so we
|
|
* have to recognize it. (We don't want to show the +
|
|
* option in man/help, though, since it's confusing,
|
|
* so there's a special case when printing man/help
|
|
* output to show sizemb_VAL/extents_VAL rather than
|
|
* psizemb_VAL/pextents_VAL.)
|
|
*/
|
|
opt_names[size_ARG].val_enum = psizemb_VAL;
|
|
opt_names[extents_ARG].val_enum = pextents_VAL;
|
|
opt_names[poolmetadatasize_ARG].val_enum = psizemb_VAL;
|
|
opt_names[mirrors_ARG].val_enum = pnumber_VAL;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* type_LVT to "type" */
|
|
|
|
const char *_lvt_enum_to_name(int lvt_enum)
|
|
{
|
|
return lv_types[lvt_enum].name;
|
|
}
|
|
|
|
static void _print_usage_description(struct command *cmd)
|
|
{
|
|
const char *desc = cmd->desc;
|
|
char buf[MAX_LINE] = {0};
|
|
unsigned di = 0;
|
|
int bi = 0;
|
|
|
|
for (di = 0; di < strlen(desc); di++) {
|
|
if (!strncmp(&desc[di], "DESC:", 5)) {
|
|
if (bi) {
|
|
buf[bi] = '\0';
|
|
printf(" %s\n", buf);
|
|
memset(buf, 0, sizeof(buf));
|
|
bi = 0;
|
|
}
|
|
/* skip DESC: */
|
|
di += 5;
|
|
continue;
|
|
}
|
|
|
|
if (!bi && desc[di] == ' ')
|
|
continue;
|
|
|
|
if (desc[di] != '\\')
|
|
buf[bi++] = desc[di];
|
|
|
|
if (bi == (MAX_LINE - 1))
|
|
break;
|
|
}
|
|
|
|
if (bi) {
|
|
buf[bi] = '\0';
|
|
printf(" %s\n", buf);
|
|
}
|
|
}
|
|
|
|
static void _print_val_usage(struct command *cmd, int opt_enum, int val_enum)
|
|
{
|
|
int is_relative_opt = (opt_enum == size_ARG) ||
|
|
(opt_enum == extents_ARG) ||
|
|
(opt_enum == poolmetadatasize_ARG) ||
|
|
(opt_enum == mirrors_ARG);
|
|
|
|
/*
|
|
* Suppress the [+] prefix for lvcreate which we have to
|
|
* accept for backwards compat, but don't want to advertise.
|
|
*/
|
|
if (!strcmp(cmd->name, "lvcreate") && is_relative_opt) {
|
|
if (val_enum == psizemb_VAL)
|
|
val_enum = sizemb_VAL;
|
|
else if (val_enum == pextents_VAL)
|
|
val_enum = extents_VAL;
|
|
else if ((val_enum == pnumber_VAL) && (opt_enum == mirrors_ARG))
|
|
val_enum = number_VAL;
|
|
}
|
|
|
|
if (!val_names[val_enum].usage)
|
|
printf("%s", val_names[val_enum].name);
|
|
else
|
|
printf("%s", val_names[val_enum].usage);
|
|
}
|
|
|
|
static void _print_usage_def(struct command *cmd, int opt_enum, struct arg_def *def)
|
|
{
|
|
int val_enum;
|
|
int sep = 0;
|
|
|
|
for (val_enum = 0; val_enum < VAL_COUNT; val_enum++) {
|
|
if (def->val_bits & val_enum_to_bit(val_enum)) {
|
|
|
|
if (val_enum == conststr_VAL)
|
|
printf("%s", def->str);
|
|
|
|
else if (val_enum == constnum_VAL)
|
|
printf("%llu", (unsigned long long)def->num);
|
|
|
|
else {
|
|
if (sep) printf("|");
|
|
_print_val_usage(cmd, opt_enum, val_enum);
|
|
sep = 1;
|
|
}
|
|
|
|
/* Too many types have made this too long. man page has this info. */
|
|
/*
|
|
if (val_enum == lv_VAL && def->lvt_bits) {
|
|
int lvt_enum;
|
|
for (lvt_enum = 1; lvt_enum < LVT_COUNT; lvt_enum++) {
|
|
if (lvt_bit_is_set(def->lvt_bits, lvt_enum))
|
|
printf("_%s", _lvt_enum_to_name(lvt_enum));
|
|
}
|
|
}
|
|
*/
|
|
|
|
if ((val_enum == vg_VAL) && (def->flags & ARG_DEF_FLAG_NEW_VG))
|
|
printf("_new");
|
|
if ((val_enum == lv_VAL) && (def->flags & ARG_DEF_FLAG_NEW_LV))
|
|
printf("_new");
|
|
}
|
|
}
|
|
|
|
if (def->flags & ARG_DEF_FLAG_MAY_REPEAT)
|
|
printf(" ...");
|
|
}
|
|
|
|
void print_usage(struct command *cmd, int longhelp, int desc_first)
|
|
{
|
|
struct command_name *cname = _find_command_name(cmd->name);
|
|
int any_req = (cmd->cmd_flags & CMD_FLAG_ANY_REQUIRED_OPT) ? 1 : 0;
|
|
int include_extents = 0;
|
|
int ro, rp, oo, op, opt_enum, first;
|
|
|
|
/*
|
|
* Looks at all variants of each command name and figures out
|
|
* which options are common to all variants (for compact output)
|
|
*/
|
|
factor_common_options();
|
|
|
|
if (desc_first && cmd->desc)
|
|
_print_usage_description(cmd);
|
|
|
|
printf(" %s", cmd->name);
|
|
|
|
if (any_req) {
|
|
for (ro = 0; ro < cmd->ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
else
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->required_opt_args[ro].def);
|
|
}
|
|
}
|
|
|
|
/* one required option in a set */
|
|
first = 1;
|
|
|
|
/* options with short and long */
|
|
for (ro = cmd->ro_count; ro < cmd->ro_count + cmd->any_ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (first)
|
|
printf("\n\t(");
|
|
else
|
|
printf(",\n\t ");
|
|
first = 0;
|
|
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->required_opt_args[ro].def);
|
|
}
|
|
}
|
|
|
|
/* options with only long */
|
|
for (ro = cmd->ro_count; ro < cmd->ro_count + cmd->any_ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if ((opt_enum == size_ARG) && command_has_alternate_extents(cmd->name))
|
|
include_extents = 1;
|
|
|
|
if (first)
|
|
printf("\n\t(");
|
|
else
|
|
printf(",\n\t ");
|
|
first = 0;
|
|
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->required_opt_args[ro].def);
|
|
}
|
|
}
|
|
|
|
printf_hyphen(')');
|
|
}
|
|
|
|
if (!any_req && cmd->ro_count) {
|
|
for (ro = 0; ro < cmd->ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if ((opt_enum == size_ARG) && command_has_alternate_extents(cmd->name))
|
|
include_extents = 1;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
else
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->required_opt_args[ro].def);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cmd->rp_count) {
|
|
if (any_req)
|
|
printf("\t");
|
|
for (rp = 0; rp < cmd->rp_count; rp++) {
|
|
if (cmd->required_pos_args[rp].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, 0, &cmd->required_pos_args[rp].def);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!longhelp)
|
|
goto done;
|
|
|
|
if (!cmd->oo_count)
|
|
goto op_count;
|
|
|
|
if (cmd->oo_count) {
|
|
if (cmd->autotype) {
|
|
printf("\n\t");
|
|
if (!cmd->autotype2)
|
|
printf("[ --type %s ] (implied)", cmd->autotype);
|
|
else
|
|
printf("[ --type %s|%s ] (implied)", cmd->autotype, cmd->autotype2);
|
|
}
|
|
|
|
if (include_extents) {
|
|
printf("\n\t[ -l|--extents ");
|
|
_print_val_usage(cmd, extents_ARG, opt_names[extents_ARG].val_enum);
|
|
printf(" ]");
|
|
}
|
|
|
|
/* print optional options with short opts */
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
opt_enum = cmd->optional_opt_args[oo].opt;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
/*
|
|
* Skip common lvm options in lvm_all which
|
|
* are printed at the end under "Common options for lvm"
|
|
* see print_common_options_lvm()
|
|
*/
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
/*
|
|
* When there is more than one variant,
|
|
* skip common command options from
|
|
* cname->common_options (options common
|
|
* to all variants), which are printed at
|
|
* the end under "Common options for command"
|
|
* see print_common_options_cmd()
|
|
*/
|
|
|
|
if (cname && (cname->variants > 1) && cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->optional_opt_args[oo].def);
|
|
}
|
|
|
|
printf(" ]");
|
|
}
|
|
|
|
/* print optional options without short opts */
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
opt_enum = cmd->optional_opt_args[oo].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
/*
|
|
* Skip common lvm options in lvm_all which
|
|
* are printed at the end under "Common options for lvm"
|
|
* see print_common_options_lvm()
|
|
*/
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
/*
|
|
* When there is more than one variant,
|
|
* skip common command options from
|
|
* cname->common_options (options common
|
|
* to all variants), which are printed at
|
|
* the end under "Common options for command"
|
|
* see print_common_options_cmd()
|
|
*/
|
|
|
|
if (cname && (cname->variants > 1) && cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->optional_opt_args[oo].def);
|
|
}
|
|
|
|
printf(" ]");
|
|
}
|
|
|
|
printf("\n\t[ COMMON_OPTIONS ]");
|
|
}
|
|
|
|
op_count:
|
|
if (!cmd->op_count)
|
|
goto done;
|
|
|
|
printf("\n\t[");
|
|
|
|
if (cmd->op_count) {
|
|
for (op = 0; op < cmd->op_count; op++) {
|
|
if (cmd->optional_pos_args[op].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, 0, &cmd->optional_pos_args[op].def);
|
|
}
|
|
}
|
|
}
|
|
|
|
printf(" ]");
|
|
done:
|
|
printf("\n");
|
|
|
|
if (!desc_first && cmd->desc)
|
|
_print_usage_description(cmd);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
void print_usage_common_lvm(struct command_name *cname, struct command *cmd)
|
|
{
|
|
int oo, opt_enum;
|
|
|
|
printf(" Common options for lvm:");
|
|
|
|
/* print options with short opts */
|
|
|
|
for (oo = 0; oo < lvm_all.oo_count; oo++) {
|
|
opt_enum = lvm_all.optional_opt_args[oo].opt;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
if (lvm_all.optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &lvm_all.optional_opt_args[oo].def);
|
|
}
|
|
printf(" ]");
|
|
}
|
|
|
|
/* print options without short opts */
|
|
|
|
for (oo = 0; oo < lvm_all.oo_count; oo++) {
|
|
opt_enum = lvm_all.optional_opt_args[oo].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
if (lvm_all.optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &lvm_all.optional_opt_args[oo].def);
|
|
}
|
|
printf(" ]");
|
|
}
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
void print_usage_common_cmd(struct command_name *cname, struct command *cmd)
|
|
{
|
|
int oo, opt_enum;
|
|
int found_common_command = 0;
|
|
|
|
/*
|
|
* when there's more than one variant, options that
|
|
* are common to all commands with a common name.
|
|
*/
|
|
|
|
if (cname->variants < 2)
|
|
return;
|
|
|
|
for (opt_enum = 0; opt_enum < ARG_COUNT; opt_enum++) {
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
found_common_command = 1;
|
|
break;
|
|
}
|
|
|
|
if (!found_common_command)
|
|
return;
|
|
|
|
printf(" Common options for command:");
|
|
|
|
/* print options with short opts */
|
|
|
|
for (opt_enum = 0; opt_enum < ARG_COUNT; opt_enum++) {
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
printf(" -%c|%s", opt_names[opt_enum].short_opt, opt_names[opt_enum].long_opt);
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->optional_opt_args[oo].def);
|
|
}
|
|
break;
|
|
}
|
|
printf(" ]");
|
|
}
|
|
|
|
/* print options without short opts */
|
|
|
|
for (opt_enum = 0; opt_enum < ARG_COUNT; opt_enum++) {
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
printf("\n\t[");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_usage_def(cmd, opt_enum, &cmd->optional_opt_args[oo].def);
|
|
}
|
|
break;
|
|
}
|
|
printf(" ]");
|
|
}
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
void print_usage_notes(struct command_name *cname)
|
|
{
|
|
if (cname && command_has_alternate_extents(cname->name)) {
|
|
printf(" Special options for command:\n");
|
|
printf(" [ --extents Number[PERCENT] ]\n"
|
|
" The --extents option can be used in place of --size.\n"
|
|
" The number allows an optional percent suffix.\n");
|
|
printf("\n");
|
|
}
|
|
|
|
if (cname && !strcmp(cname->name, "lvcreate")) {
|
|
printf(" [ --name String ]\n"
|
|
" The --name option is not required but is typically used.\n"
|
|
" When a name is not specified, a new LV name is generated\n"
|
|
" with the \"lvol\" prefix and a unique numeric suffix.\n");
|
|
printf("\n");
|
|
}
|
|
|
|
printf(" Common variables for lvm:\n"
|
|
" Variables in option or position args are capitalized,\n"
|
|
" e.g. PV, VG, LV, Size, Number, String, Tag.\n");
|
|
printf("\n");
|
|
|
|
printf(" PV\n"
|
|
" Physical Volume name, a device path under /dev.\n"
|
|
" For commands managing physical extents, a PV positional arg\n"
|
|
" generally accepts a suffix indicating a range (or multiple ranges)\n"
|
|
" of PEs. When the first PE is omitted, it defaults to the start of\n"
|
|
" the device, and when the last PE is omitted it defaults to the end.\n"
|
|
" PV[:PE-PE]... is start and end range (inclusive),\n"
|
|
" PV[:PE+PE]... is start and length range (counting from 0).\n");
|
|
printf("\n");
|
|
|
|
printf(" LV\n"
|
|
" Logical Volume name. See lvm(8) for valid names. An LV positional\n"
|
|
" arg generally includes the VG name and LV name, e.g. VG/LV.\n"
|
|
" LV followed by _<type> indicates that an LV of the given type is\n"
|
|
" required. (raid represents raid<N> type).\n"
|
|
" The _new suffix indicates that the LV name is new.\n");
|
|
printf("\n");
|
|
|
|
printf(" Tag\n"
|
|
" Tag name. See lvm(8) for information about tag names and using\n"
|
|
" tags in place of a VG, LV or PV.\n");
|
|
printf("\n");
|
|
|
|
printf(" Select\n"
|
|
" Select indicates that a required positional arg can be omitted\n"
|
|
" if the --select option is used. No arg appears in this position.\n");
|
|
printf("\n");
|
|
|
|
printf(" Size[UNIT]\n"
|
|
" Size is an input number that accepts an optional unit.\n"
|
|
" Input units are always treated as base two values, regardless of\n"
|
|
" capitalization, e.g. 'k' and 'K' both refer to 1024.\n"
|
|
" The default input unit is specified by letter, followed by |UNIT.\n"
|
|
" UNIT represents other possible input units: BbBsSkKmMgGtTpPeE.\n"
|
|
" (This should not be confused with the output control --units, where\n"
|
|
" capital letters mean multiple of 1000.)\n");
|
|
printf("\n");
|
|
}
|
|
|
|
#ifdef MAN_PAGE_GENERATOR
|
|
|
|
/*
|
|
* FIXME: this just replicates the val usage strings
|
|
* that officially lives in vals.h. Should there
|
|
* be some programatic way to add man markup to
|
|
* the strings in vals.h without replicating it?
|
|
* Otherwise, this function has to be updated in
|
|
* sync with any string changes in vals.h
|
|
*/
|
|
static void _print_val_man(struct command_name *cname, int opt_enum, int val_enum)
|
|
{
|
|
const char *str;
|
|
char *line;
|
|
char *line_argv[MAX_LINE_ARGC];
|
|
int line_argc;
|
|
int i;
|
|
|
|
_was_hyphen = 0;
|
|
int is_relative_opt = (opt_enum == size_ARG) ||
|
|
(opt_enum == extents_ARG) ||
|
|
(opt_enum == poolmetadatasize_ARG) ||
|
|
(opt_enum == mirrors_ARG);
|
|
|
|
/*
|
|
* Suppress the [+] prefix for lvcreate which we have to
|
|
* accept for backwards compat, but don't want to advertise.
|
|
*/
|
|
if (!strcmp(cname->name, "lvcreate") && is_relative_opt) {
|
|
if (val_enum == psizemb_VAL)
|
|
val_enum = sizemb_VAL;
|
|
else if (val_enum == pextents_VAL)
|
|
val_enum = extents_VAL;
|
|
else if ((val_enum == pnumber_VAL) && (opt_enum == mirrors_ARG))
|
|
val_enum = number_VAL;
|
|
}
|
|
|
|
if (val_enum == sizemb_VAL) {
|
|
printf("\\fISize\\fP[m|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == ssizemb_VAL) {
|
|
printf("[\\fB+\\fP|\\fB-\\fP]\\fISize\\fP[m|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == psizemb_VAL) {
|
|
printf("[\\fB+\\fP]\\fISize\\fP[m|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == nsizemb_VAL) {
|
|
printf("[\\fB-\\fP]\\fISize\\fP[m|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == extents_VAL) {
|
|
printf("\\fINumber\\fP[PERCENT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == sextents_VAL) {
|
|
printf("[\\fB+\\fP|\\fB-\\fP]\\fINumber\\fP[PERCENT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == pextents_VAL) {
|
|
printf("[\\fB+\\fP]\\fINumber\\fP[PERCENT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == nextents_VAL) {
|
|
printf("[\\fB-\\fP]\\fINumber\\fP[PERCENT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == sizekb_VAL) {
|
|
printf("\\fISize\\fP[k|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == ssizekb_VAL) {
|
|
printf("[\\fB+\\fP|\\fB-\\fP]\\fISize\\fP[k|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == regionsizemb_VAL) {
|
|
printf("\\fISize\\fP[m|UNIT]");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == snumber_VAL) {
|
|
printf("[\\fB+\\fP|\\fB-\\fP]\\fINumber\\fP");
|
|
return;
|
|
}
|
|
|
|
if (val_enum == pnumber_VAL) {
|
|
printf("[\\fB+\\fP]\\fINumber\\fP");
|
|
return;
|
|
}
|
|
|
|
str = val_names[val_enum].usage;
|
|
if (!str)
|
|
str = val_names[val_enum].name;
|
|
|
|
if (!strcmp(str, "PV[:t|n|y]")) {
|
|
printf("\\fIPV\\fP[\\fB:t\\fP|\\fBn\\fP|\\fBy\\fP]");
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(str, "Number") ||
|
|
!strcmp(str, "String") ||
|
|
!strncmp(str, "VG", 2) ||
|
|
!strncmp(str, "LV", 2) ||
|
|
!strncmp(str, "PV", 2) ||
|
|
!strcmp(str, "Tag")) {
|
|
printf("\\fI%s\\fP", str);
|
|
return;
|
|
}
|
|
|
|
if (strchr(str, '|')) {
|
|
if (!(line = strdup(str)))
|
|
return;
|
|
if ((_was_hyphen = (strlen(line) > _LONG_LINE)))
|
|
/* TODO: prevent line to end with already printed space */
|
|
printf("\\c\n.nh\n\\%%");
|
|
_split_line(line, &line_argc, line_argv, '|');
|
|
for (i = 0; i < line_argc; i++) {
|
|
if (i)
|
|
printf("|%s", _was_hyphen ? "\\:" : "");
|
|
|
|
if (strncmp(line_argv[i], "[Number]", 8) == 0) {
|
|
printf("[\\fINumber\\fP]");
|
|
line_argv[i] += 8;
|
|
}
|
|
|
|
if (strstr(line_argv[i], "Number"))
|
|
printf("\\fI%s\\fP", line_argv[i]);
|
|
else
|
|
printf("\\fB%s\\fP", line_argv[i]);
|
|
}
|
|
if (_was_hyphen)
|
|
printf("\n.hy");
|
|
free(line);
|
|
return;
|
|
}
|
|
|
|
printf("\\fB%s\\fP", str);
|
|
}
|
|
|
|
static void _print_def_man(struct command_name *cname, int opt_enum, struct arg_def *def, int usage, uint64_t *lv_type_bits)
|
|
{
|
|
int val_enum;
|
|
int sep = 0;
|
|
|
|
if (lv_type_bits)
|
|
*lv_type_bits = 0;
|
|
|
|
for (val_enum = 0; val_enum < VAL_COUNT; val_enum++) {
|
|
if (def->val_bits & val_enum_to_bit(val_enum)) {
|
|
|
|
if (val_enum == conststr_VAL)
|
|
printf("\\fB%s\\fP", def->str);
|
|
|
|
else if (val_enum == constnum_VAL)
|
|
printf("\\fB%llu\\fP", (unsigned long long)def->num);
|
|
|
|
else {
|
|
if (sep) printf("|");
|
|
|
|
if (!usage || !val_names[val_enum].usage) {
|
|
if (_was_hyphen) {
|
|
printf("\n");
|
|
_was_hyphen = 0;
|
|
}
|
|
|
|
/* special case to print LV1 instead of LV */
|
|
if ((val_enum == lv_VAL) && def->lvt_bits && lv_type_bits) {
|
|
printf("\\fILV1\\fP");
|
|
*lv_type_bits = def->lvt_bits;
|
|
} else {
|
|
printf("\\fI%s\\fP", val_names[val_enum].name);
|
|
}
|
|
} else {
|
|
_print_val_man(cname, opt_enum, val_enum);
|
|
}
|
|
|
|
sep = 1;
|
|
}
|
|
|
|
if (((val_enum == vg_VAL) && (def->flags & ARG_DEF_FLAG_NEW_VG)) ||
|
|
((val_enum == lv_VAL) && (def->flags & ARG_DEF_FLAG_NEW_LV)))
|
|
printf("\\fI_new\\fP");
|
|
}
|
|
}
|
|
|
|
if (def->flags & ARG_DEF_FLAG_MAY_REPEAT)
|
|
printf(" ...");
|
|
}
|
|
|
|
#define LONG_OPT_NAME_LEN 64
|
|
static const char *_man_long_opt_name(const char *cmdname, int opt_enum)
|
|
{
|
|
static char long_opt_name[LONG_OPT_NAME_LEN];
|
|
const char *long_opt;
|
|
int i;
|
|
|
|
memset(&long_opt_name, 0, sizeof(long_opt_name));
|
|
|
|
switch (opt_enum) {
|
|
case syncaction_ARG:
|
|
long_opt = "--[raid]syncaction";
|
|
break;
|
|
case writemostly_ARG:
|
|
long_opt = "--[raid]writemostly";
|
|
break;
|
|
case minrecoveryrate_ARG:
|
|
long_opt = "--[raid]minrecoveryrate";
|
|
break;
|
|
case maxrecoveryrate_ARG:
|
|
long_opt = "--[raid]maxrecoveryrate";
|
|
break;
|
|
case writebehind_ARG:
|
|
long_opt = "--[raid]writebehind";
|
|
break;
|
|
case vgmetadatacopies_ARG:
|
|
if (!strncmp(cmdname, "vg", 2))
|
|
long_opt = "--[vg]metadatacopies";
|
|
else
|
|
long_opt = "--vgmetadatacopies";
|
|
break;
|
|
case pvmetadatacopies_ARG:
|
|
if (!strncmp(cmdname, "pv", 2))
|
|
long_opt = "--[pv]metadatacopies";
|
|
else
|
|
long_opt = "--pvmetadatacopies";
|
|
break;
|
|
default:
|
|
long_opt = opt_names[opt_enum].long_opt;
|
|
break;
|
|
}
|
|
|
|
if (strchr(long_opt, '[')) {
|
|
for (i = 0; *long_opt && i < sizeof(long_opt_name) - 1; ++long_opt, ++i) {
|
|
if (i < (sizeof(long_opt_name) - 8))
|
|
switch(*long_opt) {
|
|
case '[':
|
|
strcpy(long_opt_name + i, "\\fP[\\fB");
|
|
i += 6;
|
|
continue;
|
|
case ']':
|
|
strcpy(long_opt_name + i, "\\fP]\\fB");
|
|
i += 6;
|
|
continue;
|
|
}
|
|
long_opt_name[i] = *long_opt;
|
|
}
|
|
long_opt_name[i] = 0;
|
|
return long_opt_name;
|
|
}
|
|
|
|
return long_opt;
|
|
}
|
|
|
|
static void _print_man_usage(char *lvmname, struct command *cmd)
|
|
{
|
|
struct command_name *cname;
|
|
int any_req = (cmd->cmd_flags & CMD_FLAG_ANY_REQUIRED_OPT) ? 1 : 0;
|
|
int sep, ro, rp, oo, op, opt_enum;
|
|
int need_ro_indent_end = 0;
|
|
int include_extents = 0;
|
|
int lvt_enum;
|
|
uint64_t lv_type_bits = 0;
|
|
|
|
_was_hyphen = 0;
|
|
if (!(cname = _find_command_name(cmd->name)))
|
|
return;
|
|
|
|
printf("\\fB%s\\fP", lvmname);
|
|
|
|
if (!any_req)
|
|
goto ro_normal;
|
|
|
|
/*
|
|
* required options that follow command name, all required
|
|
*/
|
|
if (cmd->ro_count) {
|
|
sep = 0;
|
|
|
|
for (ro = 0; ro < cmd->ro_count; ro++) {
|
|
|
|
/* avoid long line wrapping */
|
|
if ((cmd->ro_count > 2) && (sep == 2)) {
|
|
printf("\n.RS 5\n");
|
|
need_ro_indent_end = 1;
|
|
}
|
|
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if ((opt_enum == size_ARG) && command_has_alternate_extents(cmd->name))
|
|
include_extents = 1;
|
|
|
|
if (opt_names[opt_enum].short_opt) {
|
|
printf(" \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
} else
|
|
printf(" \\fB%s\\fP", opt_names[cmd->required_opt_args[ro].opt].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->required_opt_args[ro].def, 1, NULL);
|
|
}
|
|
|
|
sep++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* one required option in a set, print as:
|
|
* ( -a|--a,
|
|
* -b|--b,
|
|
* --c,
|
|
* --d )
|
|
*
|
|
* First loop through ro prints those with short opts,
|
|
* and the second loop prints those without short opts.
|
|
*/
|
|
|
|
if (cmd->any_ro_count) {
|
|
printf("\n");
|
|
printf(".RS 4\n");
|
|
printf("(");
|
|
|
|
sep = 0;
|
|
|
|
/* print required options with a short opt */
|
|
for (ro = cmd->ro_count; ro < cmd->ro_count + cmd->any_ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (sep) {
|
|
printf("\n.br\n");
|
|
printf(" ");
|
|
}
|
|
|
|
if (opt_names[opt_enum].short_opt) {
|
|
printf(" \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
} else {
|
|
printf(" ");
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cmd->name, opt_enum));
|
|
}
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->required_opt_args[ro].def, 1, NULL);
|
|
}
|
|
|
|
sep++;
|
|
}
|
|
|
|
/* print required options without a short opt */
|
|
for (ro = cmd->ro_count; ro < cmd->ro_count + cmd->any_ro_count; ro++) {
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (sep) {
|
|
printf("\n.br\n");
|
|
printf(" ");
|
|
} else
|
|
printf(".ad l\n");
|
|
|
|
printf(" ");
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->required_opt_args[ro].def, 1, NULL);
|
|
}
|
|
|
|
sep++;
|
|
}
|
|
|
|
printf_hyphen(')');
|
|
printf(".RE\n");
|
|
}
|
|
|
|
/* print required position args on a new line after the any_req set */
|
|
if (cmd->rp_count) {
|
|
printf(".RS 4\n");
|
|
for (rp = 0; rp < cmd->rp_count; rp++) {
|
|
if (cmd->required_pos_args[rp].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, 0, &cmd->required_pos_args[rp].def, 1, NULL);
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
printf(".RE\n");
|
|
} else {
|
|
/* printf("\n"); */
|
|
}
|
|
|
|
printf(".br\n");
|
|
goto oo_count;
|
|
|
|
ro_normal:
|
|
|
|
/*
|
|
* all are required options, print as:
|
|
* -a|--aaa <val> -b|--bbb <val>
|
|
*/
|
|
|
|
if (cmd->ro_count) {
|
|
sep = 0;
|
|
|
|
for (ro = 0; ro < cmd->ro_count; ro++) {
|
|
|
|
/* avoid long line wrapping */
|
|
if ((cmd->ro_count > 2) && (sep == 2)) {
|
|
printf("\n.RS 5\n");
|
|
need_ro_indent_end = 1;
|
|
}
|
|
|
|
opt_enum = cmd->required_opt_args[ro].opt;
|
|
|
|
if ((opt_enum == size_ARG) && command_has_alternate_extents(cmd->name))
|
|
include_extents = 1;
|
|
|
|
if (opt_names[opt_enum].short_opt) {
|
|
printf(" \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
} else
|
|
printf(" \\fB%s\\fP", opt_names[cmd->required_opt_args[ro].opt].long_opt);
|
|
|
|
if (cmd->required_opt_args[ro].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->required_opt_args[ro].def, 1, NULL);
|
|
}
|
|
|
|
sep++;
|
|
}
|
|
}
|
|
|
|
/* print required position args on the same line as the required options */
|
|
if (cmd->rp_count) {
|
|
for (rp = 0; rp < cmd->rp_count; rp++) {
|
|
if (cmd->required_pos_args[rp].def.val_bits) {
|
|
printf(" ");
|
|
/* Only print lv_type_bits for one LV arg (no cases exist with more) */
|
|
_print_def_man(cname, 0, &cmd->required_pos_args[rp].def, 1, lv_type_bits ? NULL : &lv_type_bits);
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
} else {
|
|
printf("\n");
|
|
}
|
|
|
|
if (need_ro_indent_end)
|
|
printf(".RE\n");
|
|
|
|
printf(".br\n");
|
|
|
|
oo_count:
|
|
if (!cmd->oo_count)
|
|
goto op_count;
|
|
|
|
sep = 0;
|
|
|
|
if (cmd->oo_count) {
|
|
printf(".RS 4\n");
|
|
printf(".ad l\n");
|
|
|
|
if (cmd->autotype) {
|
|
if (!cmd->autotype2)
|
|
printf("[ \\fB--type %s\\fP ] (implied)\n", cmd->autotype);
|
|
else
|
|
printf("[ \\fB--type %s\\fP|\\fB%s\\fP ] (implied)\n", cmd->autotype, cmd->autotype2);
|
|
printf(".br\n");
|
|
sep = 1;
|
|
}
|
|
|
|
if (include_extents) {
|
|
/*
|
|
* NB we don't just pass extents_VAL here because the
|
|
* actual val type for extents_ARG has been adjusted
|
|
* in opt_names[] according to the command name.
|
|
*/
|
|
printf("[ \\fB-l\\fP|\\fB--extents\\fP ");
|
|
_print_val_man(cname, extents_ARG, opt_names[extents_ARG].val_enum);
|
|
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
}
|
|
|
|
/* print optional options with short opts */
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
opt_enum = cmd->optional_opt_args[oo].opt;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if ((cname->variants > 1) && cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
printf("[ \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
}
|
|
|
|
/* print optional options without short opts */
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
opt_enum = cmd->optional_opt_args[oo].opt;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if ((cname->variants > 1) && cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
/* space alignment without short opt */
|
|
printf("[ ");
|
|
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
}
|
|
|
|
if (sep) {
|
|
printf(".br\n");
|
|
/* space alignment without short opt */
|
|
/* printf(" "); */
|
|
}
|
|
printf("[ COMMON_OPTIONS ]\n");
|
|
printf(".ad b\n");
|
|
printf(".RE\n");
|
|
}
|
|
|
|
op_count:
|
|
if (!cmd->op_count)
|
|
goto out;
|
|
|
|
printf(".RS 4\n");
|
|
printf("[");
|
|
|
|
if (cmd->op_count) {
|
|
for (op = 0; op < cmd->op_count; op++) {
|
|
if (cmd->optional_pos_args[op].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, 0, &cmd->optional_pos_args[op].def, 1, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
printf_hyphen(']');
|
|
printf(".RE\n");
|
|
|
|
out:
|
|
printf(".P\n");
|
|
if (!lv_type_bits)
|
|
return;
|
|
|
|
printf(".RS 4\n");
|
|
|
|
if (lv_type_bits) {
|
|
printf("LV1 types:");
|
|
for (lvt_enum = 1; lvt_enum < LVT_COUNT; lvt_enum++) {
|
|
if (lvt_bit_is_set(lv_type_bits, lvt_enum))
|
|
printf(" %s", _lvt_enum_to_name(lvt_enum));
|
|
}
|
|
printf("\n");
|
|
}
|
|
printf(".RE\n");
|
|
printf(".P\n");
|
|
}
|
|
|
|
/*
|
|
* common options listed in the usage section.
|
|
*
|
|
* For commands with only one variant, this is only
|
|
* the options which are common to all lvm commands
|
|
* (in lvm_all, see _is_lvm_all_opt).
|
|
*
|
|
* For commands with more than one variant, this
|
|
* is the set of options common to all variants
|
|
* (in cname->common_options), (which obviously
|
|
* includes the options common to all lvm commands.)
|
|
*
|
|
* List ordering:
|
|
* options with short+long names, alphabetically,
|
|
* then options with only long names, alphabetically
|
|
*/
|
|
|
|
static void _print_man_usage_common_lvm(struct command *cmd)
|
|
{
|
|
struct command_name *cname;
|
|
int i, sep, oo, opt_enum;
|
|
|
|
if (!(cname = _find_command_name(cmd->name)))
|
|
return;
|
|
|
|
printf("Common options for lvm:\n");
|
|
printf(".\n");
|
|
|
|
sep = 0;
|
|
|
|
printf(".RS 4\n");
|
|
printf(".ad l\n");
|
|
|
|
/* print those with short opts */
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (!_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
printf("[ \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
/* print those without short opts */
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
if (!_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
/* space alignment without short opt */
|
|
printf("[ ");
|
|
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
printf(".ad b\n");
|
|
printf(".RE\n");
|
|
}
|
|
|
|
static void _print_man_usage_common_cmd(struct command *cmd)
|
|
{
|
|
struct command_name *cname;
|
|
int i, sep, oo, opt_enum;
|
|
int found_common_command = 0;
|
|
|
|
if (!(cname = _find_command_name(cmd->name)))
|
|
return;
|
|
|
|
if (cname->variants < 2)
|
|
return;
|
|
|
|
for (opt_enum = 0; opt_enum < ARG_COUNT; opt_enum++) {
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
found_common_command = 1;
|
|
break;
|
|
}
|
|
|
|
if (!found_common_command)
|
|
return;
|
|
|
|
printf("Common options for command:\n");
|
|
printf(".\n");
|
|
|
|
sep = 0;
|
|
|
|
printf(".RS 4\n");
|
|
printf(".ad l\n");
|
|
|
|
/* print those with short opts */
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (!opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
/* common cmd options only used with variants */
|
|
if (cname->variants < 2)
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
printf("[ \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* print those without short opts */
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (!cname->common_options[opt_enum])
|
|
continue;
|
|
|
|
if (opt_names[opt_enum].short_opt)
|
|
continue;
|
|
|
|
/* common cmd options only used with variants */
|
|
if (cname->variants < 2)
|
|
continue;
|
|
|
|
if (_is_lvm_all_opt(opt_enum))
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
for (oo = 0; oo < cmd->oo_count; oo++) {
|
|
if (cmd->optional_opt_args[oo].opt != opt_enum)
|
|
continue;
|
|
|
|
/* space alignment without short opt */
|
|
printf("[ ");
|
|
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cmd->name, opt_enum));
|
|
|
|
if (cmd->optional_opt_args[oo].def.val_bits) {
|
|
printf(" ");
|
|
_print_def_man(cname, opt_enum, &cmd->optional_opt_args[oo].def, 1, NULL);
|
|
}
|
|
printf_hyphen(']');
|
|
sep = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
printf(".ad b\n");
|
|
printf(".RE\n");
|
|
printf(".P\n");
|
|
}
|
|
|
|
/*
|
|
* Format of description, when different command names have
|
|
* different descriptions:
|
|
*
|
|
* "#cmdname1"
|
|
* "text foo goes here"
|
|
* "a second line of text."
|
|
* "#cmdname2"
|
|
* "text bar goes here"
|
|
* "another line of text."
|
|
*
|
|
* When called for cmdname2, this function should just print:
|
|
*
|
|
* "text bar goes here"
|
|
* "another line of text."
|
|
*/
|
|
|
|
static void _print_man_option_desc(struct command_name *cname, int opt_enum)
|
|
{
|
|
const char *desc = opt_names[opt_enum].desc;
|
|
char buf[DESC_LINE];
|
|
int started_cname = 0;
|
|
int line_count = 0;
|
|
int bi = 0;
|
|
unsigned di;
|
|
|
|
if (desc[0] != '#') {
|
|
printf("%s", desc);
|
|
return;
|
|
}
|
|
|
|
for (di = 0; di < strlen(desc); di++) {
|
|
buf[bi++] = desc[di];
|
|
|
|
if (bi == DESC_LINE) {
|
|
log_error("Parsing command defs: print_man_option_desc line too long.");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (buf[bi-1] != '\n')
|
|
continue;
|
|
|
|
if (buf[0] != '#') {
|
|
if (started_cname) {
|
|
printf("%s", buf);
|
|
line_count++;
|
|
}
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
bi = 0;
|
|
continue;
|
|
}
|
|
|
|
/* Line starting with #cmdname */
|
|
|
|
/*
|
|
* Must be starting a new command name.
|
|
* If no lines have been printed, multiple command names
|
|
* are using the same text. If lines have been printed,
|
|
* then the start of a new command name means the end
|
|
* of text for the current command name.
|
|
*/
|
|
if (line_count && started_cname)
|
|
return;
|
|
|
|
if (!strncmp(buf + 1, cname->name, strlen(cname->name))) {
|
|
/* The start of our command name. */
|
|
started_cname = 1;
|
|
memset(buf, 0, sizeof(buf));
|
|
bi = 0;
|
|
} else {
|
|
/* The start of another command name. */
|
|
memset(buf, 0, sizeof(buf));
|
|
bi = 0;
|
|
}
|
|
}
|
|
|
|
if (bi && started_cname)
|
|
printf("%s", buf);
|
|
}
|
|
|
|
/*
|
|
* Print a list of all options names for a given command name.
|
|
*/
|
|
|
|
static void _print_man_all_options_list(struct command_name *cname)
|
|
{
|
|
int opt_enum, val_enum;
|
|
int sep = 0;
|
|
int i;
|
|
int adl = 0;
|
|
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (!cname->all_options[opt_enum])
|
|
continue;
|
|
|
|
if (sep)
|
|
printf(".br\n");
|
|
|
|
if (!adl) {
|
|
printf(".ad l\n");
|
|
adl = 1;
|
|
}
|
|
|
|
if (opt_names[opt_enum].short_opt) {
|
|
printf(" \\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cname->name, opt_enum));
|
|
} else {
|
|
/* spaces for alignment without short opt */
|
|
printf(" \\fB%s\\fP", _man_long_opt_name(cname->name, opt_enum));
|
|
}
|
|
|
|
val_enum = opt_names[opt_enum].val_enum;
|
|
|
|
if (!val_names[val_enum].fn) {
|
|
/* takes no arg */
|
|
} else if (!val_names[val_enum].usage) {
|
|
printf(" ");
|
|
printf("\\fI");
|
|
printf("%s", val_names[val_enum].name);
|
|
printf("\\fP");
|
|
} else {
|
|
printf(" ");
|
|
_print_val_man(cname, opt_enum, val_enum);
|
|
}
|
|
|
|
printf("\n");
|
|
sep = 1;
|
|
}
|
|
|
|
if (adl)
|
|
printf(".ad b\n");
|
|
|
|
}
|
|
|
|
/*
|
|
* All options used for a given command name, along with descriptions.
|
|
*/
|
|
|
|
static void _print_man_all_options_desc(struct command_name *cname)
|
|
{
|
|
int opt_enum, val_enum;
|
|
int i;
|
|
int adl;
|
|
|
|
for (i = 0; i < ARG_COUNT; i++) {
|
|
opt_enum = opt_names_alpha[i]->opt_enum;
|
|
|
|
if (!cname->all_options[opt_enum])
|
|
continue;
|
|
|
|
val_enum = opt_names[opt_enum].val_enum;
|
|
|
|
if (val_names[val_enum].usage &&
|
|
(strlen(val_names[val_enum].usage) > _LONG_LINE)) {
|
|
printf(".\n.HP\n");
|
|
printf(".ad l\n");
|
|
adl = 1;
|
|
} else {
|
|
/* printf(".\n.TP\n");
|
|
* ATM HTML rendering can't handle HP and TP mixing properly
|
|
* so still keeping .HP usage for this case
|
|
* untill some better workaround is found
|
|
* .TP does not need .br */
|
|
printf(".\n.HP\n");
|
|
adl = 0;
|
|
}
|
|
|
|
if (opt_names[opt_enum].short_opt) {
|
|
printf("\\fB-%c\\fP|\\fB%s\\fP",
|
|
opt_names[opt_enum].short_opt,
|
|
_man_long_opt_name(cname->name, opt_enum));
|
|
} else {
|
|
printf("\\fB%s\\fP", _man_long_opt_name(cname->name, opt_enum));
|
|
}
|
|
|
|
|
|
if (!val_names[val_enum].fn) {
|
|
/* takes no arg */
|
|
} else if (!val_names[val_enum].usage) {
|
|
printf(" ");
|
|
printf("\\fI");
|
|
printf("%s", val_names[val_enum].name);
|
|
printf("\\fP");
|
|
} else {
|
|
printf(" ");
|
|
_print_val_man(cname, opt_enum, val_enum);
|
|
}
|
|
|
|
if (opt_names[opt_enum].flags & ARG_COUNTABLE)
|
|
printf(" ...");
|
|
|
|
printf("\n");
|
|
if (adl) {
|
|
printf(".ad b\n");
|
|
}
|
|
printf(".br\n");
|
|
|
|
if (opt_names[opt_enum].desc) {
|
|
_print_man_option_desc(cname, opt_enum);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _print_man_all_positions_desc(struct command_name *cname)
|
|
{
|
|
struct command *cmd;
|
|
int ci, rp, op;
|
|
int has_vg_val = 0;
|
|
int has_lv_val = 0;
|
|
int has_pv_val = 0;
|
|
int has_tag_val = 0;
|
|
int has_select_val = 0;
|
|
int has_lv_type = 0;
|
|
|
|
for (ci = 0; ci < COMMAND_COUNT; ci++) {
|
|
cmd = &commands[ci];
|
|
|
|
if (strcmp(cmd->name, cname->name))
|
|
continue;
|
|
|
|
for (rp = 0; rp < cmd->rp_count; rp++) {
|
|
if (cmd->required_pos_args[rp].def.val_bits & val_enum_to_bit(vg_VAL))
|
|
has_vg_val = 1;
|
|
|
|
if (cmd->required_pos_args[rp].def.val_bits & val_enum_to_bit(lv_VAL)) {
|
|
has_lv_val = 1;
|
|
if (cmd->required_pos_args[rp].def.lvt_bits)
|
|
has_lv_type = 1;
|
|
}
|
|
|
|
if (cmd->required_pos_args[rp].def.val_bits & val_enum_to_bit(pv_VAL))
|
|
has_pv_val = 1;
|
|
|
|
if (cmd->required_pos_args[rp].def.val_bits & val_enum_to_bit(tag_VAL))
|
|
has_tag_val = 1;
|
|
|
|
if (cmd->required_pos_args[rp].def.val_bits & val_enum_to_bit(select_VAL))
|
|
has_select_val = 1;
|
|
}
|
|
|
|
for (op = 0; op < cmd->op_count; op++) {
|
|
if (cmd->optional_pos_args[op].def.val_bits & val_enum_to_bit(vg_VAL))
|
|
has_vg_val = 1;
|
|
|
|
if (cmd->optional_pos_args[op].def.val_bits & val_enum_to_bit(lv_VAL)) {
|
|
has_lv_val = 1;
|
|
if (cmd->optional_pos_args[op].def.lvt_bits)
|
|
has_lv_type = 1;
|
|
}
|
|
|
|
if (cmd->optional_pos_args[op].def.val_bits & val_enum_to_bit(pv_VAL))
|
|
has_pv_val = 1;
|
|
|
|
if (cmd->optional_pos_args[op].def.val_bits & val_enum_to_bit(tag_VAL))
|
|
has_tag_val = 1;
|
|
|
|
if (cmd->optional_pos_args[op].def.val_bits & val_enum_to_bit(select_VAL))
|
|
has_select_val = 1;
|
|
}
|
|
}
|
|
|
|
if (has_vg_val) {
|
|
printf(".TP\n");
|
|
|
|
printf(".I %s\n", val_names[vg_VAL].name);
|
|
printf("Volume Group name. See \\fBlvm\\fP(8) for valid names.\n");
|
|
|
|
if (!strcmp(cname->name, "lvcreate"))
|
|
printf("For lvcreate, the required VG positional arg may be\n"
|
|
"omitted when the VG name is included in another option,\n"
|
|
"e.g. --name VG/LV.\n");
|
|
}
|
|
|
|
if (has_lv_val) {
|
|
printf(".TP\n");
|
|
|
|
printf(".I %s\n", val_names[lv_VAL].name);
|
|
printf("Logical Volume name. See \\fBlvm\\fP(8) for valid names.\n"
|
|
"An LV positional arg generally includes the VG name and LV name, e.g. VG/LV.\n");
|
|
|
|
if (has_lv_type)
|
|
printf("LV1 indicates the LV must have a specific type, where the\n"
|
|
"accepted LV types are listed. (raid represents raid<N> type).\n");
|
|
|
|
}
|
|
|
|
if (has_pv_val) {
|
|
printf(".TP\n");
|
|
|
|
printf(".I %s\n", val_names[pv_VAL].name);
|
|
printf("Physical Volume name, a device path under /dev.\n"
|
|
"For commands managing physical extents, a PV positional arg\n"
|
|
"generally accepts a suffix indicating a range (or multiple ranges)\n"
|
|
"of physical extents (PEs). When the first PE is omitted, it defaults\n"
|
|
"to the start of the device, and when the last PE is omitted it defaults to end.\n"
|
|
"Start and end range (inclusive): \\fIPV\\fP[\\fB:\\fP\\fIPE\\fP\\fB-\\fP\\fIPE\\fP]...\n"
|
|
"Start and length range (counting from 0): \\fIPV\\fP[\\fB:\\fP\\fIPE\\fP\\fB+\\fP\\fIPE\\fP]...\n");
|
|
}
|
|
|
|
if (has_tag_val) {
|
|
printf(".TP\n");
|
|
|
|
printf(".I %s\n", val_names[tag_VAL].name);
|
|
printf("Tag name. See \\fBlvm\\fP(8) for information about tag names and using tags\n"
|
|
"in place of a VG, LV or PV.\n");
|
|
}
|
|
|
|
if (has_select_val) {
|
|
printf(".TP\n");
|
|
|
|
printf(".I %s\n", val_names[select_VAL].name);
|
|
printf("Select indicates that a required positional parameter can\n"
|
|
"be omitted if the \\fB--select\\fP option is used.\n"
|
|
"No arg appears in this position.\n");
|
|
}
|
|
|
|
/* Every command uses a string arg somewhere. */
|
|
|
|
printf(".TP\n");
|
|
printf(".I %s\n", val_names[string_VAL].name);
|
|
printf("See the option description for information about the string content.\n");
|
|
|
|
/*
|
|
* We could possibly check if the command accepts any option that
|
|
* uses Size, and only print this in those cases, but this seems
|
|
* so common that we should probably always print it.
|
|
*/
|
|
|
|
printf(".TP\n");
|
|
printf(".IR Size [UNIT]\n");
|
|
printf("Size is an input number that accepts an optional unit.\n"
|
|
"Input units are always treated as base two values, regardless of\n"
|
|
"capitalization, e.g. 'k' and 'K' both refer to 1024.\n"
|
|
"The default input unit is specified by letter, followed by |UNIT.\n"
|
|
"UNIT represents other possible input units:\n"
|
|
".BR b | B\nis bytes,\n.BR s | S\nis sectors of 512 bytes,\n.BR k | K\nis KiB,\n"
|
|
".BR m | M\nis MiB,\n.BR g | G\nis GiB,\n.BR t | T\nis TiB,\n"
|
|
".BR p | P\nis PiB,\n.BR e | E\nis EiB.\n"
|
|
"(This should not be confused with the output control --units, where\n"
|
|
"capital letters mean multiple of 1000.)\n");
|
|
|
|
printf(".\n.SH ENVIRONMENT VARIABLES\n.\n");
|
|
printf("See \\fBlvm\\fP(8) for information about environment variables used by lvm.\n"
|
|
"For example, LVM_VG_NAME can generally be substituted for a required VG parameter.\n");
|
|
}
|
|
|
|
static void _print_desc_man(const char *desc)
|
|
{
|
|
char buf[DESC_LINE] = {0};
|
|
unsigned di;
|
|
int bi = 0;
|
|
|
|
for (di = 0; di < strlen(desc); di++) {
|
|
if (desc[di] == '\0')
|
|
break;
|
|
if (desc[di] == '\n')
|
|
continue;
|
|
|
|
if (!strncmp(&desc[di], "DESC:", 5)) {
|
|
if (bi) {
|
|
printf("%s\n", buf);
|
|
printf(".br\n");
|
|
memset(buf, 0, sizeof(buf));
|
|
bi = 0;
|
|
}
|
|
di += 5;
|
|
continue;
|
|
}
|
|
|
|
if (!bi && desc[di] == ' ')
|
|
continue;
|
|
|
|
buf[bi++] = desc[di];
|
|
|
|
if (bi == (DESC_LINE - 1))
|
|
break;
|
|
}
|
|
|
|
if (bi) {
|
|
printf("%s\n", buf);
|
|
printf(".br\n");
|
|
}
|
|
}
|
|
|
|
static const char *_upper_command_name(char *str)
|
|
{
|
|
static char str_upper[32];
|
|
int i = 0;
|
|
|
|
while (*str) {
|
|
str_upper[i++] = toupper(*str);
|
|
str++;
|
|
}
|
|
str_upper[i] = '\0';
|
|
return str_upper;
|
|
}
|
|
|
|
#define MAX_MAN_DESC (1024 * 1024)
|
|
|
|
static int _include_description_file(char *name, char *des_file)
|
|
{
|
|
char *buf;
|
|
int fd, r = 0;
|
|
ssize_t sz;
|
|
struct stat statbuf = { 0 };
|
|
|
|
if ((fd = open(des_file, O_RDONLY)) < 0) {
|
|
log_error("Failed to open description file %s.", des_file);
|
|
return 0;
|
|
}
|
|
|
|
if (fstat(fd, &statbuf) < 0) {
|
|
log_error("Failed to stat description file %s.", des_file);
|
|
goto out_close;
|
|
}
|
|
|
|
if (statbuf.st_size > MAX_MAN_DESC) {
|
|
log_error("Description file %s is too large.", des_file);
|
|
goto out_close;
|
|
}
|
|
|
|
if (!(buf = malloc(statbuf.st_size + 1))) {
|
|
log_error("Failed to allocate buffer for description file %s.", des_file);
|
|
goto out_close;
|
|
}
|
|
|
|
if ((sz = read(fd, buf, statbuf.st_size)) < 0) {
|
|
log_error("Failed to read description file %s.", des_file);
|
|
goto out_free;
|
|
}
|
|
|
|
buf[sz] = '\0';
|
|
printf(".\n.SH DESCRIPTION\n.\n%s", buf);
|
|
r = 1;
|
|
|
|
out_free:
|
|
free(buf);
|
|
out_close:
|
|
(void) close(fd);
|
|
|
|
return r;
|
|
}
|
|
|
|
static int _print_man(char *name, char *des_file, int secondary)
|
|
{
|
|
struct command_name *cname;
|
|
struct command *cmd, *prev_cmd = NULL;
|
|
char *lvmname = name;
|
|
int i;
|
|
|
|
if (!strncmp(name, "lvm-", 4)) {
|
|
name[3] = ' ';
|
|
name += 4;
|
|
}
|
|
|
|
cname = _find_command_name(name);
|
|
|
|
printf(".TH %s 8 \"LVM TOOLS #VERSION#\" \"Red Hat, Inc.\"\n",
|
|
_upper_command_name(lvmname));
|
|
|
|
for (i = 0; i < COMMAND_COUNT; i++) {
|
|
|
|
cmd = &commands[i];
|
|
|
|
if (prev_cmd && strcmp(prev_cmd->name, cmd->name)) {
|
|
_print_man_usage_common_cmd(prev_cmd);
|
|
_print_man_usage_common_lvm(prev_cmd);
|
|
|
|
printf(".\n.SH OPTIONS\n.\n");
|
|
_print_man_all_options_desc(cname);
|
|
printf(".\n.SH VARIABLES\n.\n");
|
|
_print_man_all_positions_desc(cname);
|
|
|
|
prev_cmd = NULL;
|
|
}
|
|
|
|
if (cmd->cmd_flags & CMD_FLAG_PREVIOUS_SYNTAX)
|
|
continue;
|
|
|
|
if ((cmd->cmd_flags & CMD_FLAG_SECONDARY_SYNTAX) && !secondary)
|
|
continue;
|
|
|
|
if (strcmp(name, cmd->name))
|
|
continue;
|
|
|
|
if (!prev_cmd || strcmp(prev_cmd->name, cmd->name)) {
|
|
printf(".\n.SH NAME\n.\n");
|
|
if (cname && cname->desc)
|
|
printf("%s \\(em %s\n", lvmname, cname->desc);
|
|
else
|
|
printf("%s\n", lvmname);
|
|
|
|
printf(".\n.SH SYNOPSIS\n.\n");
|
|
prev_cmd = cmd;
|
|
|
|
if (!(cname = _find_command_name(cmd->name)))
|
|
return 0;
|
|
|
|
if (cname->variant_has_ro && cname->variant_has_rp)
|
|
printf("\\fB%s\\fP \\fIoption_args\\fP \\fIposition_args\\fP\n", lvmname);
|
|
else if (cname->variant_has_ro && !cname->variant_has_rp)
|
|
printf("\\fB%s\\fP \\fIoption_args\\fP\n", lvmname);
|
|
else if (!cname->variant_has_ro && cname->variant_has_rp)
|
|
printf("\\fB%s\\fP \\fIposition_args\\fP\n", lvmname);
|
|
else if (!cname->variant_has_ro && !cname->variant_has_rp)
|
|
printf("\\fB%s\\fP\n", lvmname);
|
|
|
|
printf(".br\n");
|
|
|
|
if (cname->variant_has_oo) {
|
|
printf(" [ \\fIoption_args\\fP ]\n");
|
|
printf(".br\n");
|
|
}
|
|
|
|
if (cname->variant_has_op) {
|
|
printf(" [ \\fIposition_args\\fP ]\n");
|
|
printf(".br\n");
|
|
}
|
|
|
|
/* listing them all when there's only 1 or 2 is just repetative */
|
|
if (cname->variants > 2) {
|
|
printf(".P\n");
|
|
_print_man_all_options_list(cname);
|
|
}
|
|
|
|
if (des_file && !_include_description_file(lvmname, des_file))
|
|
return 0;
|
|
|
|
printf(".\n.SH USAGE\n.\n");
|
|
}
|
|
|
|
if (cmd->desc) {
|
|
_print_desc_man(cmd->desc);
|
|
printf(".P\n");
|
|
}
|
|
|
|
_print_man_usage(lvmname, cmd);
|
|
|
|
if (i == (COMMAND_COUNT - 1)) {
|
|
_print_man_usage_common_cmd(cmd);
|
|
_print_man_usage_common_lvm(cmd);
|
|
|
|
printf(".\n.SH OPTIONS\n.\n");
|
|
_print_man_all_options_desc(cname);
|
|
printf(".\n.SH VARIABLES\n.\n");
|
|
_print_man_all_positions_desc(cname);
|
|
} else {
|
|
if (cname->variants > 2) {
|
|
printf("\\(em\n");
|
|
printf(".P\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void _print_man_secondary(char *name)
|
|
{
|
|
struct command *cmd;
|
|
char *lvmname = name;
|
|
int header = 0;
|
|
int i;
|
|
|
|
if (!strncmp(name, "lvm-", 4))
|
|
name += 4;
|
|
|
|
for (i = 0; i < COMMAND_COUNT; i++) {
|
|
|
|
cmd = &commands[i];
|
|
|
|
if (cmd->cmd_flags & CMD_FLAG_PREVIOUS_SYNTAX)
|
|
continue;
|
|
|
|
if (!(cmd->cmd_flags & CMD_FLAG_SECONDARY_SYNTAX))
|
|
continue;
|
|
|
|
if (strcmp(name, cmd->name))
|
|
continue;
|
|
|
|
if (!header) {
|
|
printf(".\n.SH ADVANCED USAGE\n.\n");
|
|
printf("Alternate command forms, advanced command usage, and listing of all valid syntax for completeness.\n");
|
|
printf(".P\n");
|
|
header = 1;
|
|
}
|
|
|
|
if (cmd->desc) {
|
|
_print_desc_man(cmd->desc);
|
|
printf(".P\n");
|
|
}
|
|
|
|
_print_man_usage(lvmname, cmd);
|
|
|
|
printf("\\(em\n");
|
|
printf(".P\n");
|
|
}
|
|
}
|
|
|
|
static void _print_opt_list(const char *prefix, int *opt_list, int opt_count)
|
|
{
|
|
int i;
|
|
int opt_enum;
|
|
|
|
printf("%s ", prefix);
|
|
for (i = 0; i < opt_count; i++) {
|
|
opt_enum = opt_list[i];
|
|
printf(" %s", opt_names[opt_enum].long_opt);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
/* return 1 if the lists do not match, 0 if they match */
|
|
static int _compare_opt_lists(int *list1, int count1, int *list2, int count2, const char *type1_str, const char *type2_str)
|
|
{
|
|
int i, j;
|
|
|
|
if (count1 != count2)
|
|
return 1;
|
|
|
|
for (i = 0; i < count1; i++) {
|
|
for (j = 0; j < count2; j++) {
|
|
|
|
/* lists do not match if one has --type foo and the other --type bar */
|
|
if ((list1[i] == type_ARG) && (list2[j] == type_ARG) &&
|
|
type1_str && type2_str && strcmp(type1_str, type2_str)) {
|
|
return 1;
|
|
}
|
|
|
|
if (list1[i] == list2[j])
|
|
goto next;
|
|
}
|
|
return 1;
|
|
next:
|
|
;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int _compare_cmds(struct command *cmd1, struct command *cmd2, int *all_req_opts)
|
|
{
|
|
const char *cmd1_type_str = NULL;
|
|
const char *cmd2_type_str = NULL;
|
|
int opt_list_1[ARG_COUNT] = { 0 };
|
|
int opt_list_2[ARG_COUNT] = { 0 };
|
|
int opt_count_1 = 0;
|
|
int opt_count_2 = 0;
|
|
int i, j;
|
|
int r = 1;
|
|
|
|
/* different number of required pos items means different cmds */
|
|
if (cmd1->rp_count != cmd2->rp_count)
|
|
return 1;
|
|
|
|
/* different types of required pos items means different cmds */
|
|
for (i = 0; i < cmd1->rp_count; i++) {
|
|
if (cmd1->required_pos_args[i].def.val_bits != cmd2->required_pos_args[i].def.val_bits)
|
|
return 1;
|
|
}
|
|
|
|
/* create opt list from cmd1 */
|
|
for (i = 0; i < cmd1->ro_count; i++) {
|
|
if (!all_req_opts[cmd1->required_opt_args[i].opt])
|
|
continue;
|
|
|
|
opt_list_1[opt_count_1++] = cmd1->required_opt_args[i].opt;
|
|
|
|
if (cmd1->required_opt_args[i].opt == type_ARG)
|
|
cmd1_type_str = cmd1->required_opt_args[i].def.str;
|
|
}
|
|
|
|
/* create opt list from cmd2 */
|
|
for (i = 0; i < cmd2->ro_count; i++) {
|
|
if (!all_req_opts[cmd2->required_opt_args[i].opt])
|
|
continue;
|
|
|
|
opt_list_2[opt_count_2++] = cmd2->required_opt_args[i].opt;
|
|
|
|
if (cmd2->required_opt_args[i].opt == type_ARG)
|
|
cmd2_type_str = cmd2->required_opt_args[i].def.str;
|
|
}
|
|
|
|
/* "--type foo" and "--type bar" are different */
|
|
if (cmd1_type_str && cmd2_type_str && strcmp(cmd1_type_str, cmd2_type_str))
|
|
return 1;
|
|
|
|
/* compare opt_list_1 and opt_list_2 */
|
|
if (!_compare_opt_lists(opt_list_1, opt_count_1, opt_list_2, opt_count_2, NULL, NULL)) {
|
|
log_error("Repeated commands %s %s", cmd1->command_id, cmd2->command_id);
|
|
log_error("cmd1: %s", cmd1->desc);
|
|
log_error("cmd2: %s", cmd2->desc);
|
|
_print_opt_list("cmd1 options: ", opt_list_1, opt_count_1);
|
|
_print_opt_list("cmd2 options: ", opt_list_2, opt_count_2);
|
|
printf("\n");
|
|
r = 0;
|
|
}
|
|
|
|
/* check if cmd1 matches cmd2 + one of its oo */
|
|
for (i = 0; i < cmd2->oo_count; i++) {
|
|
/* for each cmd2 optional_opt_arg, add it to opt_list_2
|
|
and compare opt_list_1 and opt_list_2 again */
|
|
|
|
/* cmd1 "--type foo" and cmd2 OO "--type bar" are different */
|
|
if (cmd2->optional_opt_args[i].opt == type_ARG) {
|
|
if (cmd2->optional_opt_args[i].def.str && cmd1_type_str &&
|
|
strcmp(cmd2->optional_opt_args[i].def.str, cmd1_type_str))
|
|
return 1;
|
|
}
|
|
|
|
opt_list_2[opt_count_2] = cmd2->optional_opt_args[i].opt;
|
|
|
|
if (!_compare_opt_lists(opt_list_1, opt_count_1, opt_list_2, opt_count_2+1, NULL, NULL)) {
|
|
log_error("Repeated commands %s %s", cmd1->command_id, cmd2->command_id);
|
|
log_error("cmd1: %s", cmd1->desc);
|
|
log_error("cmd2: %s", cmd2->desc);
|
|
log_error("Included cmd2 OO: %s", opt_names[cmd2->optional_opt_args[i].opt].long_opt);
|
|
_print_opt_list("cmd1 options: ", opt_list_1, opt_count_1);
|
|
_print_opt_list("cmd2 options: ", opt_list_2, opt_count_2+1);
|
|
printf("\n");
|
|
r = 0;
|
|
}
|
|
}
|
|
|
|
/* check if cmd1 + an oo matches cmd2 + an oo */
|
|
|
|
if (!cmd1_type_str) {
|
|
for (i = 0; i < cmd1->oo_count; i++) {
|
|
if (cmd1->optional_opt_args[i].opt == type_ARG)
|
|
cmd1_type_str = cmd1->optional_opt_args[i].def.str;
|
|
}
|
|
}
|
|
if (!cmd2_type_str) {
|
|
for (j = 0; j < cmd2->oo_count; j++) {
|
|
if (cmd2->optional_opt_args[j].opt == type_ARG)
|
|
cmd2_type_str = cmd2->optional_opt_args[j].def.str;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < cmd1->oo_count; i++) {
|
|
|
|
for (j = 0; j < cmd2->oo_count; j++) {
|
|
if (cmd1->optional_opt_args[i].opt == cmd2->optional_opt_args[j].opt)
|
|
continue;
|
|
|
|
opt_list_1[opt_count_1] = cmd1->optional_opt_args[i].opt;
|
|
opt_list_2[opt_count_2] = cmd2->optional_opt_args[j].opt;
|
|
|
|
if (!_compare_opt_lists(opt_list_1, opt_count_1+1, opt_list_2, opt_count_2+1, cmd1_type_str, cmd2_type_str)) {
|
|
log_error("Repeated commands %s %s", cmd1->command_id, cmd2->command_id);
|
|
log_error("cmd1: %s", cmd1->desc);
|
|
log_error("cmd2: %s", cmd2->desc);
|
|
log_error("Included cmd1 OO: %s and cmd2 OO: %s",
|
|
opt_names[cmd1->optional_opt_args[i].opt].long_opt,
|
|
opt_names[cmd2->optional_opt_args[j].opt].long_opt);
|
|
_print_opt_list("cmd1 options: ", opt_list_1, opt_count_1+1);
|
|
_print_opt_list("cmd2 options: ", opt_list_2, opt_count_2+1);
|
|
printf("\n");
|
|
r = 0;
|
|
}
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static int _check_overlap(void)
|
|
{
|
|
int all_req_opts[ARG_COUNT] = { 0 };
|
|
struct command *cmd1, *cmd2;
|
|
int i, j;
|
|
int r = 1;
|
|
|
|
for (i = 0; i < COMMAND_COUNT; i++) {
|
|
cmd1 = &commands[i];
|
|
for (j = 0; j < cmd1->ro_count; j++)
|
|
all_req_opts[cmd1->required_opt_args[j].opt] = 1;
|
|
}
|
|
|
|
for (i = 0; i < COMMAND_COUNT; i++) {
|
|
|
|
cmd1 = &commands[i];
|
|
|
|
if (cmd1->any_ro_count)
|
|
continue;
|
|
|
|
for (j = 0; j < COMMAND_COUNT; j++) {
|
|
if (i == j)
|
|
continue;
|
|
|
|
cmd2 = &commands[j];
|
|
|
|
if (cmd2->any_ro_count)
|
|
continue;
|
|
|
|
if (strcmp(cmd1->name, cmd2->name))
|
|
continue;
|
|
|
|
if (!_compare_cmds(cmd1, cmd2, all_req_opts))
|
|
r = 0;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
#define STDOUT_BUF_SIZE (MAX_MAN_DESC + 4 * 1024)
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
struct cmd_context cmdtool = { 0 };
|
|
char *cmdname = NULL;
|
|
char *desfile = NULL;
|
|
char *stdout_buf;
|
|
int primary = 0;
|
|
int secondary = 0;
|
|
int check = 0;
|
|
int r = 0;
|
|
size_t sz = STDOUT_BUF_SIZE;
|
|
|
|
static struct option long_options[] = {
|
|
{"primary", no_argument, 0, 'p' },
|
|
{"secondary", no_argument, 0, 's' },
|
|
{"check", no_argument, 0, 'c' },
|
|
{0, 0, 0, 0 }
|
|
};
|
|
|
|
memset(&commands, 0, sizeof(commands));
|
|
|
|
if (!(stdout_buf = malloc(sz)))
|
|
log_error("Failed to allocate stdout buffer; carrying on with default buffering.");
|
|
else
|
|
setbuffer(stdout, stdout_buf, sz);
|
|
|
|
while (1) {
|
|
int c;
|
|
int option_index = 0;
|
|
|
|
c = getopt_long(argc, argv, "psc", long_options, &option_index);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c) {
|
|
case '0':
|
|
break;
|
|
case 'p':
|
|
primary = 1;
|
|
break;
|
|
case 's':
|
|
secondary = 1;
|
|
break;
|
|
case 'c':
|
|
check = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!primary && !secondary && !check) {
|
|
log_error("Usage: %s --primary|--secondary|--check <command> [/path/to/description-file].", argv[0]);
|
|
goto out_free;
|
|
}
|
|
|
|
if (optind < argc) {
|
|
if (!(cmdname = strdup(argv[optind++]))) {
|
|
log_error("Out of memory.");
|
|
goto out_free;
|
|
}
|
|
} else if (!check) {
|
|
log_error("Missing command name.");
|
|
goto out_free;
|
|
}
|
|
|
|
if (optind < argc)
|
|
desfile = argv[optind++];
|
|
|
|
define_commands(&cmdtool, NULL);
|
|
|
|
if (!check)
|
|
configure_command_option_values(cmdname);
|
|
|
|
factor_common_options();
|
|
|
|
if (primary && cmdname)
|
|
r = _print_man(cmdname, desfile, secondary);
|
|
else if (secondary && cmdname) {
|
|
r = 1;
|
|
_print_man_secondary(cmdname);
|
|
} else if (check) {
|
|
r = _check_overlap();
|
|
}
|
|
|
|
out_free:
|
|
if (stdout_buf) {
|
|
fflush(stdout);
|
|
setlinebuf(stdout);
|
|
free(stdout_buf);
|
|
}
|
|
|
|
exit(r ? EXIT_SUCCESS: EXIT_FAILURE);
|
|
}
|
|
|
|
#endif
|