1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2015-2020 Intel Corporation. All rights reserved.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <util/json.h>
#include <json-c/json.h>
#include <daxctl/libdaxctl.h>
#include <util/parse-options.h>
#include <ccan/array_size/array_size.h>
#include "filter.h"
#include "json.h"
static struct {
bool devs;
bool regions;
bool mappings;
bool idle;
bool human;
} list;
static unsigned long listopts_to_flags(void)
{
unsigned long flags = 0;
if (list.devs)
flags |= UTIL_JSON_DAX_DEVS;
if (list.mappings)
flags |= UTIL_JSON_DAX_MAPPINGS;
if (list.idle)
flags |= UTIL_JSON_IDLE;
if (list.human)
flags |= UTIL_JSON_HUMAN;
return flags;
}
static struct {
const char *dev;
const char *region;
} param;
static int did_fail;
#define fail(fmt, ...) \
do { \
did_fail = 1; \
fprintf(stderr, "daxctl-%s:%s:%d: " fmt, \
VERSION, __func__, __LINE__, ##__VA_ARGS__); \
} while (0)
static int num_list_flags(void)
{
return list.regions + list.devs;
}
int cmd_list(int argc, const char **argv, struct daxctl_ctx *ctx)
{
const struct option options[] = {
OPT_STRING('r', "region", ¶m.region, "region-id",
"filter by region"),
OPT_STRING('d', "dev", ¶m.dev, "dev-id",
"filter by dax device instance name"),
OPT_BOOLEAN('D', "devices", &list.devs, "include dax device info"),
OPT_BOOLEAN('R', "regions", &list.regions, "include dax region info"),
OPT_BOOLEAN('M', "mappings", &list.mappings, "include dax mappings info"),
OPT_BOOLEAN('i', "idle", &list.idle, "include idle devices"),
OPT_BOOLEAN('u', "human", &list.human,
"use human friendly number formats "),
OPT_END(),
};
const char * const u[] = {
"daxctl list [<options>]",
NULL
};
struct json_object *jregions = NULL;
struct json_object *jdevs = NULL;
struct daxctl_region *region;
unsigned long list_flags;
int i;
argc = parse_options(argc, argv, options, u, 0);
for (i = 0; i < argc; i++)
error("unknown parameter \"%s\"\n", argv[i]);
if (argc)
usage_with_options(u, options);
if (num_list_flags() == 0) {
list.regions = !!param.region;
list.devs = !!param.dev;
}
if (num_list_flags() == 0)
list.devs = true;
list_flags = listopts_to_flags();
daxctl_region_foreach(ctx, region) {
struct json_object *jregion = NULL;
if (!util_daxctl_region_filter(region, param.region))
continue;
if (list.regions) {
if (!jregions) {
jregions = json_object_new_array();
if (!jregions) {
fail("\n");
continue;
}
}
jregion = util_daxctl_region_to_json(region,
param.dev, list_flags);
if (!jregion) {
fail("\n");
continue;
}
json_object_array_add(jregions, jregion);
} else if (list.devs)
jdevs = util_daxctl_devs_to_list(region, jdevs,
param.dev, list_flags);
}
if (jregions)
util_display_json_array(stdout, jregions, list_flags);
else if (jdevs)
util_display_json_array(stdout, jdevs, list_flags);
if (did_fail)
return -ENOMEM;
return 0;
}
|
