← Back to branch summary

~psusi/ubuntu/precise/dmraid/fix-gpt

« back to all changes in this revision

Viewing changes to 1.0.0.rc16/lib/display/display.c

  • Committer: Bazaar Package Importer
  • Author(s): Artur Rona
  • Date: 2010-02-04 21:34:22 UTC
  • mfrom: (1.1.4 upstream) (2.4.3 sid)
  • Revision ID: james.westby@ubuntu.com-20100204213422-tdag8lcxpr7ahmg4
Tags: 1.0.0.rc16-3ubuntu1
https://launchpad.net/bugs/503136
* Merge from debian testing. (LP: #503136)  Remaining changes:
  - debian/dmraid-activate: Remove the special-casing of the root
    device which breaks in many situations and leaves the raw devices
    exposed. This was introduced in Debian to accommodate some broken
    configurations which wanted to access "partitions" on the raid
    raw devices. In Ubuntu, broken configurations has not been supported.
  - debian/dmraid.postinst: Comment out "udevadm trigger" call in postinst
    for now as it has severeconsequences when mountall is installed
    (clears /tmp).  If dmraid is installed, then presumably the important
    system devices are up and one canbe bothered with a reboot to take 
    the change into account. Let update-initramfs flag the system
    as needing a reboot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1.0.0.rc16/lib/display/display.c
 
1
/*
 
2
 * Copyright (C) 2004,2005  Heinz Mauelshagen, Red Hat GmbH.
 
3
 *                          All rights reserved.
 
4
 *
 
5
 * See file LICENSE at the top of this source tree for license information.
 
6
 */
 
7
 
 
8
#include "internal.h"
 
9
#include "activate/devmapper.h"
 
10
 
 
11
#define ARRAY_LIMIT(array, idx) \
 
12
        ((idx) < ARRAY_SIZE(array) ? (idx) : ARRAY_SIZE(array) - 1)
 
13
 
 
14
struct log_handler {
 
15
        const char *field;
 
16
        const unsigned char minlen;
 
17
        void (*log_func) (struct lib_context *, void *arg);
 
18
        void *arg;
 
19
};
 
20
 
 
21
static void
 
22
log_string(struct lib_context *lc, void *arg)
 
23
{
 
24
        log_print_nnl(lc, "%s", (char *) arg);
 
25
}
 
26
 
 
27
static void
 
28
log_uint64(struct lib_context *lc, void *arg)
 
29
{
 
30
        log_print_nnl(lc, "%" PRIu64, *((uint64_t *) arg));
 
31
}
 
32
 
 
33
static void
 
34
log_uint(struct lib_context *lc, void *arg)
 
35
{
 
36
        log_print_nnl(lc, "%u", *((unsigned int *) arg));
 
37
}
 
38
 
 
39
/* Log a structure member by field name. */
 
40
static int
 
41
log_field(struct lib_context *lc, const struct log_handler *lh,
 
42
          size_t lh_size, char *field)
 
43
{
 
44
        const struct log_handler *h;
 
45
 
 
46
        for (h = lh; h < lh + lh_size; h++) {
 
47
                size_t len = strlen(field);
 
48
 
 
49
                if (!strncmp(field, h->field,
 
50
                             len > h->minlen ? len : h->minlen)) {
 
51
                        h->log_func(lc, h->arg);
 
52
                        return 1;
 
53
                }
 
54
        }
 
55
 
 
56
        log_print_nnl(lc, "*ERR*");
 
57
 
 
58
        return 1;
 
59
}
 
60
 
 
61
/* Log a list of structure members by field name. */
 
62
static void
 
63
log_fields(struct lib_context *lc, const struct log_handler *lh, size_t lh_size)
 
64
{
 
65
        int logged = 0, last_logged = 0;
 
66
        const char delim = *OPT_STR_SEPARATOR(lc);
 
67
        char *p, *sep, *sep_sav;
 
68
 
 
69
        if (!(sep_sav = dbg_strdup((char *) OPT_STR_COLUMN(lc)))) {
 
70
                log_alloc_err(lc, __func__);
 
71
                return;
 
72
        }
 
73
 
 
74
        sep = sep_sav;
 
75
        do {
 
76
                sep = remove_delimiter((p = sep), delim);
 
77
                if (last_logged)
 
78
                        log_print_nnl(lc, "%c", delim);
 
79
 
 
80
                last_logged = log_field(lc, lh, lh_size, p);
 
81
                logged += last_logged;
 
82
                add_delimiter(&sep, delim);
 
83
        } while (sep);
 
84
 
 
85
        dbg_free(sep_sav);
 
86
        if (logged)
 
87
                log_print(lc, "");
 
88
}
 
89
 
 
90
/* Display information about a block device */
 
91
static void
 
92
log_disk(struct lib_context *lc, struct list_head *pos)
 
93
{
 
94
        struct dev_info *di = list_entry(pos, typeof(*di), list);
 
95
 
 
96
        if (OPT_STR_COLUMN(lc)) {
 
97
                const struct log_handler log_handlers[] = {
 
98
                        {"devpath", 1, log_string, di->path},
 
99
                        {"path", 1, log_string, di->path},
 
100
                        {"sectors", 3, log_uint64, &di->sectors},
 
101
                        {"serialnumber", 3, log_string,
 
102
                         di->serial ? (void *) di->serial : (void *) "N/A"},
 
103
                        {"size", 2, log_uint64, &di->sectors},
 
104
                };
 
105
 
 
106
                log_fields(lc, log_handlers, ARRAY_SIZE(log_handlers));
 
107
        }
 
108
        else {
 
109
                const char *fmt[] = {
 
110
                        "%s: %12" PRIu64 " total, \"%s\"",
 
111
                        "%s",
 
112
                        "%s:%" PRIu64 ":\"%s\"",
 
113
                };
 
114
 
 
115
                log_print(lc, fmt[ARRAY_LIMIT(fmt, OPT_COLUMN(lc))],
 
116
                          di->path, di->sectors,
 
117
                          di->serial ? di->serial : "N/A");
 
118
        }
 
119
}
 
120
 
 
121
/* Turn NULL (= "unknown") into a displayable string. */
 
122
static const char *
 
123
check_null(const char *str)
 
124
{
 
125
        return str ? str : "unknown";
 
126
}
 
127
 
 
128
/* Log native RAID device information. */
 
129
static void
 
130
log_rd_native(struct lib_context *lc, struct list_head *pos)
 
131
{
 
132
        struct raid_dev *rd = list_entry(pos, typeof(*rd), list);
 
133
 
 
134
        if (rd->fmt->log) {
 
135
                rd->fmt->log(lc, rd);
 
136
                log_print(lc, "");
 
137
        }
 
138
        else
 
139
                log_print(lc, "\"%s\" doesn't support native logging of RAID "
 
140
                          "device information", rd->fmt->name);
 
141
}
 
142
 
 
143
/* Display information about a RAID device */
 
144
static void
 
145
log_rd(struct lib_context *lc, struct list_head *pos)
 
146
{
 
147
        struct raid_dev *rd = list_entry(pos, typeof(*rd), list);
 
148
 
 
149
        if (OPT_STR_COLUMN(lc)) {
 
150
                const struct log_handler log_handlers[] = {
 
151
                        {"dataoffset", 2, log_uint64, &rd->offset},
 
152
                        {"devpath", 2, log_string, rd->di->path},
 
153
                        {"format", 1, log_string, (void *) rd->fmt->name},
 
154
                        {"offset", 1, log_uint64, &rd->offset},
 
155
                        {"path", 1, log_string, rd->di->path},
 
156
                        {"raidname", 1, log_string, rd->name},
 
157
                        {"type", 1, log_string,
 
158
                         (void *) check_null(get_type(lc, rd->type))},
 
159
                        {"sectors", 2, log_uint64, &rd->sectors},
 
160
                        {"size", 2, log_uint64, &rd->sectors},
 
161
                        {"status", 2, log_string,
 
162
                         (void *) check_null(get_status(lc, rd->status))},
 
163
                };
 
164
 
 
165
                log_fields(lc, log_handlers, ARRAY_SIZE(log_handlers));
 
166
        }
 
167
        else {
 
168
                const char *fmt[] = {
 
169
                        "%s: %s, \"%s\", %s, %s, %" PRIu64 " sectors, "
 
170
                                "data@ %" PRIu64,
 
171
                        "%s",
 
172
                        "%s:%s:%s:%s:%s:%" PRIu64 ":%" PRIu64,
 
173
                };
 
174
 
 
175
                log_print(lc, fmt[ARRAY_LIMIT(fmt, OPT_COLUMN(lc))],
 
176
                          rd->di->path, rd->fmt->name, rd->name,
 
177
                          check_null(get_type(lc, rd->type)),
 
178
                          check_null(get_status(lc, rd->status)),
 
179
                          rd->sectors, rd->offset);
 
180
        }
 
181
}
 
182
 
 
183
/* Dispatch log functions. */
 
184
static void
 
185
log_devices(struct lib_context *lc, enum dev_type type)
 
186
{
 
187
        struct list_head *pos;
 
188
        struct {
 
189
                enum dev_type type;
 
190
                struct list_head *list;
 
191
                void (*log) (struct lib_context *, struct list_head *);
 
192
        } types[] = {
 
193
                { DEVICE, LC_DI(lc), log_disk },
 
194
                { NATIVE, LC_RD(lc), log_rd_native },
 
195
                { RAID, LC_RD(lc), log_rd },
 
196
        }, *t = types;
 
197
 
 
198
        do {
 
199
                if (t->type == type) {
 
200
                        list_for_each(pos, t->list)
 
201
                                t->log(lc, pos);
 
202
 
 
203
                        return;
 
204
                }
 
205
        } while (++t < ARRAY_END(types));
 
206
 
 
207
        LOG_ERR(lc,, "%s: unknown device type", __func__);
 
208
}
 
209
 
 
210
/* Display information about a dmraid format handler */
 
211
static void
 
212
log_format(struct lib_context *lc, struct dmraid_format *fmt)
 
213
{
 
214
        log_print_nnl(lc, "%-7s : %s", fmt->name, fmt->descr);
 
215
        if (fmt->caps)
 
216
                log_print_nnl(lc, " (%s)", fmt->caps);
 
217
 
 
218
        log_print(lc, "");
 
219
}
 
220
 
 
221
/* Pretty print a mapping table. */
 
222
void
 
223
display_table(struct lib_context *lc, char *rs_name, char *table)
 
224
{
 
225
        char *nl = table, *p;
 
226
 
 
227
        do {
 
228
                nl = remove_delimiter((p = nl), '\n');
 
229
                log_print(lc, "%s: %s", rs_name, p);
 
230
                add_delimiter(&nl, '\n');
 
231
        } while (nl);
 
232
}
 
233
 
 
234
/* Display information about devices depending on device type. */
 
235
void
 
236
display_devices(struct lib_context *lc, enum dev_type type)
 
237
{
 
238
        int devs;
 
239
 
 
240
        if ((devs = count_devices(lc, type))) {
 
241
                log_info(lc, "%s device%s discovered:\n",
 
242
                         (type & (RAID | NATIVE)) ? "RAID" : "Block",
 
243
                         devs == 1 ? "" : "s");
 
244
 
 
245
                log_devices(lc, type);
 
246
        }
 
247
}
 
248
 
 
249
/* Retrieve format name from (hierarchical) raid set. */
 
250
static void *
 
251
get_format_name(struct raid_set *rs)
 
252
{
 
253
        struct dmraid_format *fmt = get_format(rs);
 
254
 
 
255
        return (void *) check_null(fmt ? fmt->name : NULL);
 
256
}
 
257
 
 
258
static void
 
259
log_rs(struct lib_context *lc, struct raid_set *rs)
 
260
{
 
261
        unsigned int devs = 0, spares = 0, subsets = 0;
 
262
        uint64_t sectors = 0;
 
263
 
 
264
        if (T_GROUP(rs) && !OPT_GROUP(lc))
 
265
                return;
 
266
 
 
267
        sectors = total_sectors(lc, rs);
 
268
        subsets = count_sets(lc, &rs->sets);
 
269
        devs = count_devs(lc, rs, ct_dev);
 
270
        spares = count_devs(lc, rs, ct_spare);
 
271
 
 
272
        if (OPT_STR_COLUMN(lc)) {
 
273
                const struct log_handler log_handlers[] = {
 
274
                        {"devices", 1, log_uint, &devs},
 
275
                        {"format", 1, log_string, get_format_name(rs)},
 
276
                        {"raidname", 1, log_string, rs->name},
 
277
                        {"sectors", 2, log_uint64, &sectors},
 
278
                        {"size", 2, log_uint64, &sectors},
 
279
                        {"spares", 2, log_uint, &spares},
 
280
                        {"status", 3, log_string,
 
281
                         (void *) check_null(get_status(lc, rs->status))},
 
282
                        {"stride", 3, log_uint, &rs->stride},
 
283
                        {"subsets", 2, log_uint, &subsets},
 
284
                        {"type", 1, log_string,
 
285
                         (void *) check_null(get_set_type(lc, rs))},
 
286
                };
 
287
 
 
288
                log_fields(lc, log_handlers, ARRAY_SIZE(log_handlers));
 
289
        }
 
290
        else {
 
291
                const char *fmt[] = {
 
292
                        "name   : %s\n"
 
293
                                "size   : %" PRIu64 "\n"
 
294
                                "stride : %u\n"
 
295
                                "type   : %s\n"
 
296
                                "status : %s\n"
 
297
                                "subsets: %u\n" "devs   : %u\n" "spares : %u",
 
298
                        "%s",
 
299
                        "%s:%" PRIu64 ":%u:%s:%s:%u:%u:%u",
 
300
                };
 
301
                unsigned int o = ARRAY_LIMIT(fmt, lc_opt(lc, LC_COLUMN));
 
302
 
 
303
                log_print(lc, fmt[o],
 
304
                          rs->name, sectors, rs->stride,
 
305
                          check_null(get_set_type(lc, rs)),
 
306
                          check_null(get_status(lc, rs->status)),
 
307
                          subsets, devs, spares);
 
308
 
 
309
        }
 
310
 
 
311
        if (OPT_COLUMN(lc) > 2) {
 
312
                struct raid_dev *rd;
 
313
 
 
314
                list_for_each_entry(rd, &rs->devs, devs)
 
315
                        log_rd(lc, &rd->list);
 
316
        }
 
317
}
 
318
 
 
319
static int
 
320
group_active(struct lib_context *lc, struct raid_set *rs)
 
321
{
 
322
        struct raid_set *r;
 
323
 
 
324
        list_for_each_entry(r, &rs->sets, list) {
 
325
                if (dm_status(lc, r))
 
326
                        return 1;
 
327
        }
 
328
 
 
329
        return 0;
 
330
}
 
331
 
 
332
/* FIXME: Spock, do something better (neater). */
 
333
void
 
334
display_set(struct lib_context *lc, void *v, enum active_type active, int top)
 
335
{
 
336
        struct raid_set *rs = v;
 
337
        struct raid_set *r;
 
338
        int dmstatus = T_GROUP(rs) ? group_active(lc, rs) : dm_status(lc, rs);
 
339
 
 
340
        if (((active & D_ACTIVE) && !dmstatus) ||
 
341
            ((active & D_INACTIVE) && dmstatus))
 
342
                return;
 
343
 
 
344
        if (!OPT_COLUMN(lc)) {
 
345
                if (T_GROUP(rs) && !OPT_GROUP(lc))
 
346
                        log_print(lc, "*** Group superset %s", rs->name);
 
347
                else {
 
348
                        log_print(lc, "%s %s%s%set",
 
349
                                  top ? "-->" : "***",
 
350
                                  S_INCONSISTENT(rs->status) ?
 
351
                                  "*Inconsistent* " : "",
 
352
                                  dm_status(lc, rs) ? "Active " : "",
 
353
                                  SETS(rs) ? "Supers" : (top ? "Subs" : "S"));
 
354
                }
 
355
        }
 
356
 
 
357
        log_rs(lc, rs);
 
358
 
 
359
        /* Optionally display subsets. */
 
360
        if (T_GROUP(rs) ||      /* Always display for GROUP sets. */
 
361
            OPT_SETS(lc) > 1 || OPT_COLUMN(lc) > 2) {
 
362
                list_for_each_entry(r, &rs->sets, list)
 
363
                        display_set(lc, r, active, ++top);
 
364
        }
 
365
}
 
366
 
 
367
/*
 
368
 * Display information about supported RAID metadata formats
 
369
 * (ie. registered format handlers)
 
370
 */
 
371
static void
 
372
_list_formats(struct lib_context *lc, enum fmt_type type)
 
373
{
 
374
        struct format_list *fmt_list;
 
375
 
 
376
        list_for_each_entry(fmt_list, LC_FMT(lc), list) {
 
377
                if (type == fmt_list->fmt->format)
 
378
                        log_format(lc, fmt_list->fmt);
 
379
        }
 
380
}
 
381
 
 
382
int
 
383
list_formats(struct lib_context *lc, int arg)
 
384
{
 
385
        log_info(lc, "supported metadata formats:");
 
386
        _list_formats(lc, FMT_RAID);
 
387
        _list_formats(lc, FMT_PARTITION);
 
388
 
 
389
        return 1;
 
390
}