shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-03-11 20:58:50 +03:00
Code Releases Activity

vdo: get status parser compiling

Browse Source
This commit is contained in:
Joe Thornber 2018-05-02 11:15:35 +01:00
parent 11d9b0cae7
commit 6abc3f10ae
2 changed files with 55 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
device-mapper/vdo/status.c
View File

@ -3,11 +3,13 @@
// For DM_ARRAY_SIZE! // For DM_ARRAY_SIZE!
#include "libdevmapper.h" #include "libdevmapper.h"
#include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
//---------------------------------------------------------------- //----------------------------------------------------------------
static const char *_tok_cpy(const char *b, const char *e, const char *str) static char *_tok_cpy(const char *b, const char *e)
{ {
char *new = malloc((e - b) + 1); char *new = malloc((e - b) + 1);
char *ptr = new; char *ptr = new;
@ -32,8 +34,7 @@ static bool _tok_eq(const char *b, const char *e, const char *str)
return !*str; return !*str;
} }
static bool _parse_operating_mode(const char *b, const char *e, static bool _parse_operating_mode(const char *b, const char *e, void *context)
enum vdo_operating_mode *r)
{ {
static struct { static struct {
const char *str; const char *str;
@ -44,6 +45,7 @@ static bool _parse_operating_mode(const char *b, const char *e,
{"normal", VDO_MODE_NORMAL} {"normal", VDO_MODE_NORMAL}
}; };
enum vdo_operating_mode *r = context;
unsigned i; unsigned i;
for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { for (i = 0; i < DM_ARRAY_SIZE(_table); i++) {
if (_tok_eq(b, e, _table[i].str)) { if (_tok_eq(b, e, _table[i].str)) {
@ -55,8 +57,7 @@ static bool _parse_operating_mode(const char *b, const char *e,
return false; return false;
} }
static bool _parse_compression_state(const char *b, const char *e, static bool _parse_compression_state(const char *b, const char *e, void *context)
enum vdo_compression_state *r)
{ {
static struct { static struct {
const char *str; const char *str;
@ -66,6 +67,7 @@ static bool _parse_compression_state(const char *b, const char *e,
{"offline", VDO_COMPRESSION_OFFLINE} {"offline", VDO_COMPRESSION_OFFLINE}
}; };
enum vdo_compression_state *r = context;
unsigned i; unsigned i;
for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { for (i = 0; i < DM_ARRAY_SIZE(_table); i++) {
if (_tok_eq(b, e, _table[i].str)) { if (_tok_eq(b, e, _table[i].str)) {
@ -77,8 +79,10 @@ static bool _parse_compression_state(const char *b, const char *e,
return false; return false;
} }
static bool _parse_recovering(const char *b, const char *e, bool *r) static bool _parse_recovering(const char *b, const char *e, void *context)
{ {
bool *r = context;
if (_tok_eq(b, e, "recovering")) if (_tok_eq(b, e, "recovering"))
*r = true; *r = true;
@ -91,8 +95,7 @@ static bool _parse_recovering(const char *b, const char *e, bool *r)
return true; return true;
} }
static bool _parse_index_state(const char *b, const char *e, static bool _parse_index_state(const char *b, const char *e, void *context)
enum vdo_index_state *r)
{ {
static struct { static struct {
const char *str; const char *str;
@ -107,6 +110,7 @@ static bool _parse_index_state(const char *b, const char *e,
{"unknown", VDO_INDEX_UNKNOWN} {"unknown", VDO_INDEX_UNKNOWN}
}; };
enum vdo_index_state *r = context;
unsigned i; unsigned i;
for (i = 0; i < DM_ARRAY_SIZE(_table); i++) { for (i = 0; i < DM_ARRAY_SIZE(_table); i++) {
if (_tok_eq(b, e, _table[i].str)) { if (_tok_eq(b, e, _table[i].str)) {
@ -118,6 +122,23 @@ static bool _parse_index_state(const char *b, const char *e,
return false; return false;
} }
static bool _parse_uint64(const char *b, const char *e, void *context)
{
uint64_t *r = context, n;
n = 0;
while (b != e) {
if (!isdigit(*b))
return false;
n = (n << 1) + (*b - '0');
b++;
}
*r = n;
return true;
}
static const char *_eat_space(const char *b, const char *e) static const char *_eat_space(const char *b, const char *e)
{ {
while (b != e && isspace(*b)) while (b != e && isspace(*b))
@ -134,8 +155,20 @@ static const char *_next_tok(const char *b, const char *e)
return b == e ? NULL : b; return b == e ? NULL : b;
} }
static void _set_error(struct parse_result *result, const char *fmt, ...)
__attribute__ ((format(printf, 2, 3)));
static void _set_error(struct parse_result *result, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(result->error, sizeof(result->error), fmt, ap);
va_end(ap);
}
static bool _parse_field(const char **b, const char *e, static bool _parse_field(const char **b, const char *e,
bool (*p_fn)(const char *, const char *, void *) bool (*p_fn)(const char *, const char *, void *),
void *field, const char *field_name, void *field, const char *field_name,
struct parse_result *result) struct parse_result *result)
{ {
@ -143,53 +176,53 @@ static bool _parse_field(const char **b, const char *e,
te = _next_tok(*b, e); te = _next_tok(*b, e);
if (!te) { if (!te) {
snprintf(result->error, sizeof(result->error), _set_error(result, "couldn't get token for '%s'", field_name);
"couldn't get token for '%s'", field_name);
return false; return false;
} }
if (!p_fn(*b, te, field) { if (!p_fn(*b, te, field)) {
snprintf(result->error, sizeof(result->error), _set_error(result, "couldn't parse '%s'", field_name);
"couldn't parse '%s'", field_name);
return false; return false;
} }
*b = _eat_space(te); *b = _eat_space(te, e);
return true; return true;
} }
bool parse_vdo_status(const char *input, struct parse_result *result) bool parse_vdo_status(const char *input, struct parse_result *result)
{ {
const char *b = _eat_space(input); const char *b = b = input;
const char *e = input + strlen(input); const char *e = input + strlen(input);
const char *te; const char *te;
struct vdo_status *s = malloc(sizeof(*s)); struct vdo_status *s = malloc(sizeof(*s));
if (!s) { if (!s) {
result->error = "out of memory"; _set_error(result, "out of memory");
return false; return false;
} }
b = _eat_space(b, e);
te = _next_tok(b, e); te = _next_tok(b, e);
if (!te) { if (!te) {
result->error = "couldn't get token for device"; _set_error(result, "couldn't get token for device");
free(s); free(s);
return false; return false;
} }
s->device = _tok_cpy(b, te); s->device = _tok_cpy(b, te);
if (!s->device) { if (!s->device) {
result->error = "out of memory"; _set_error(result, "out of memory");
free(s); free(s);
return false; return false;
} }
b = _eat_space(te); b = _eat_space(te, e);
#define XX(p, f, fn) if (!_parse_field(&b, e, p, f, fn, result)) goto bad; #define XX(p, f, fn) if (!_parse_field(&b, e, p, f, fn, result)) goto bad;
XX(_parse_operating_mode, &s->operating_mode, "operating mode");
XX(_parse_recovering, &s->recovering, "recovering"); XX(_parse_recovering, &s->recovering, "recovering");
XX(_parse_index, &s->index_state, "index state"); XX(_parse_index_state, &s->index_state, "index state");
XX(_parse_compression_state, &s->compression_state, "compression state"); XX(_parse_compression_state, &s->compression_state, "compression state");
XX(_parse_uint64, &s->used_blocks, "used blocks"); XX(_parse_uint64, &s->used_blocks, "used blocks");
XX(_parse_uint64, &s->total_blocks, "total blocks"); XX(_parse_uint64, &s->total_blocks, "total blocks");

2
device-mapper/vdo/target.h
View File

@ -42,7 +42,7 @@ enum vdo_index_state {
}; };
struct vdo_status { struct vdo_status {
const char *device; char *device;
enum vdo_operating_mode operating_mode; enum vdo_operating_mode operating_mode;
bool recovering; bool recovering;
enum vdo_index_state index_state; enum vdo_index_state index_state;