]> git.ipfire.org Git - thirdparty/mdadm.git/blob - Detail.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Minor cosmetic fixes in various files.
[thirdparty/mdadm.git] / Detail.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25 #include "mdadm.h"
26 #include "md_p.h"
27 #include "md_u.h"
28 #include <dirent.h>
29
30 int Detail(char *dev, struct context *c)
31 {
32 /*
33 * Print out details for an md array by using
34 * GET_ARRAY_INFO and GET_DISK_INFO ioctl calls
35 */
36
37 int fd = open(dev, O_RDONLY);
38 int vers;
39 mdu_array_info_t array;
40 mdu_disk_info_t *disks;
41 int next;
42 int d;
43 time_t atime;
44 char *str;
45 char *devices = NULL;
46 int spares = 0;
47 struct stat stb;
48 int is_26 = get_linux_version() >= 2006000;
49 int is_rebuilding = 0;
50 int failed = 0;
51 struct supertype *st;
52 char *subarray = NULL;
53 int max_disks = MD_SB_DISKS; /* just a default */
54 struct mdinfo *info = NULL;
55 struct mdinfo *sra;
56 char *member = NULL;
57 char *container = NULL;
58
59 int rv = c->test ? 4 : 1;
60 int avail_disks = 0;
61 char *avail = NULL;
62
63 if (fd < 0) {
64 pr_err("cannot open %s: %s\n",
65 dev, strerror(errno));
66 return rv;
67 }
68 vers = md_get_version(fd);
69 if (vers < 0) {
70 pr_err("%s does not appear to be an md device\n",
71 dev);
72 close(fd);
73 return rv;
74 }
75 if (vers < 9000) {
76 pr_err("cannot get detail for md device %s: driver version too old.\n",
77 dev);
78 close(fd);
79 return rv;
80 }
81 if (ioctl(fd, GET_ARRAY_INFO, &array)<0) {
82 if (errno == ENODEV)
83 pr_err("md device %s does not appear to be active.\n",
84 dev);
85 else
86 pr_err("cannot get array detail for %s: %s\n",
87 dev, strerror(errno));
88 close(fd);
89 return rv;
90 }
91 sra = sysfs_read(fd, 0, GET_VERSION);
92 st = super_by_fd(fd, &subarray);
93
94 if (fstat(fd, &stb) != 0 && !S_ISBLK(stb.st_mode))
95 stb.st_rdev = 0;
96 rv = 0;
97
98 if (st)
99 max_disks = st->max_devs;
100
101 if (subarray) {
102 /* This is a subarray of some container.
103 * We want the name of the container, and the member
104 */
105 int dn = st->container_dev;
106
107 member = subarray;
108 container = map_dev_preferred(dev2major(dn), dev2minor(dn), 1, c->prefer);
109 }
110
111 /* try to load a superblock */
112 if (st) for (d = 0; d < max_disks; d++) {
113 mdu_disk_info_t disk;
114 char *dv;
115 int fd2;
116 int err;
117 disk.number = d;
118 if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
119 continue;
120 if (d >= array.raid_disks &&
121 disk.major == 0 &&
122 disk.minor == 0)
123 continue;
124
125 if (array.raid_disks > 0 &&
126 (disk.state & (1 << MD_DISK_ACTIVE)) == 0)
127 continue;
128
129 dv = map_dev(disk.major, disk.minor, 1);
130 if (!dv)
131 continue;
132
133 fd2 = dev_open(dv, O_RDONLY);
134 if (fd2 < 0)
135 continue;
136
137 if (st->sb)
138 st->ss->free_super(st);
139
140 err = st->ss->load_super(st, fd2, NULL);
141 close(fd2);
142 if (err)
143 continue;
144 if (info)
145 free(info);
146 if (subarray)
147 info = st->ss->container_content(st, subarray);
148 else {
149 info = xmalloc(sizeof(*info));
150 st->ss->getinfo_super(st, info, NULL);
151 }
152 if (!info)
153 continue;
154
155 if (array.raid_disks != 0 && /* container */
156 (info->array.ctime != array.ctime ||
157 info->array.level != array.level)) {
158 st->ss->free_super(st);
159 continue;
160 }
161 /* some formats (imsm) have free-floating-spares
162 * with a uuid of uuid_zero, they don't
163 * have very good info about the rest of the
164 * container, so keep searching when
165 * encountering such a device. Otherwise, stop
166 * after the first successful call to
167 * ->load_super.
168 */
169 if (memcmp(uuid_zero,
170 info->uuid,
171 sizeof(uuid_zero)) == 0) {
172 st->ss->free_super(st);
173 continue;
174 }
175 break;
176 }
177
178 /* Ok, we have some info to print... */
179 str = map_num(pers, array.level);
180
181 if (c->export) {
182 if (array.raid_disks) {
183 if (str)
184 printf("MD_LEVEL=%s\n", str);
185 printf("MD_DEVICES=%d\n", array.raid_disks);
186 } else {
187 printf("MD_LEVEL=container\n");
188 printf("MD_DEVICES=%d\n", array.nr_disks);
189 }
190 if (container) {
191 printf("MD_CONTAINER=%s\n", container);
192 printf("MD_MEMBER=%s\n", member);
193 } else {
194 if (sra && sra->array.major_version < 0)
195 printf("MD_METADATA=%s\n", sra->text_version);
196 else
197 printf("MD_METADATA=%d.%d\n",
198 array.major_version, array.minor_version);
199 }
200
201 if (st && st->sb && info) {
202 char nbuf[64];
203 struct map_ent *mp, *map = NULL;
204
205 fname_from_uuid(st, info, nbuf, ':');
206 printf("MD_UUID=%s\n", nbuf+5);
207 mp = map_by_uuid(&map, info->uuid);
208 if (mp && mp->path &&
209 strncmp(mp->path, "/dev/md/", 8) == 0)
210 printf("MD_DEVNAME=%s\n", mp->path+8);
211
212 if (st->ss->export_detail_super)
213 st->ss->export_detail_super(st);
214 } else {
215 struct map_ent *mp, *map = NULL;
216 char nbuf[64];
217 mp = map_by_devnum(&map, fd2devnum(fd));
218 if (mp) {
219 __fname_from_uuid(mp->uuid, 0, nbuf, ':');
220 printf("MD_UUID=%s\n", nbuf+5);
221 }
222 if (mp && mp->path &&
223 strncmp(mp->path, "/dev/md/", 8) == 0)
224 printf("MD_DEVNAME=%s\n", mp->path+8);
225 }
226 goto out;
227 }
228
229 disks = xmalloc(max_disks * sizeof(mdu_disk_info_t));
230 for (d = 0; d < max_disks; d++) {
231 disks[d].state = (1<<MD_DISK_REMOVED);
232 disks[d].major = disks[d].minor = 0;
233 disks[d].number = disks[d].raid_disk = d;
234 }
235
236 next = array.raid_disks;
237 for (d = 0; d < max_disks; d++) {
238 mdu_disk_info_t disk;
239 disk.number = d;
240 if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
241 if (d < array.raid_disks)
242 pr_err("cannot get device detail for device %d: %s\n",
243 d, strerror(errno));
244 continue;
245 }
246 if (disk.major == 0 && disk.minor == 0)
247 continue;
248 if (disk.raid_disk >= 0 && disk.raid_disk < array.raid_disks)
249 disks[disk.raid_disk] = disk;
250 else if (next < max_disks)
251 disks[next++] = disk;
252 }
253
254 avail = xcalloc(array.raid_disks, 1);
255
256 for (d= 0; d < array.raid_disks; d++) {
257 mdu_disk_info_t disk = disks[d];
258
259 if ((disk.state & (1<<MD_DISK_SYNC))) {
260 avail_disks ++;
261 avail[d] = 1;
262 }
263 }
264
265 if (c->brief) {
266 mdu_bitmap_file_t bmf;
267 printf("ARRAY %s", dev);
268 if (c->brief > 1) {
269 if (array.raid_disks)
270 printf(" level=%s num-devices=%d",
271 str?str:"-unknown-",
272 array.raid_disks );
273 else
274 printf(" level=container num-devices=%d",
275 array.nr_disks);
276 }
277 if (container) {
278 printf(" container=%s", container);
279 printf(" member=%s", member);
280 } else {
281 if (sra && sra->array.major_version < 0)
282 printf(" metadata=%s", sra->text_version);
283 else
284 printf(" metadata=%d.%d",
285 array.major_version, array.minor_version);
286 }
287
288 /* Only try GET_BITMAP_FILE for 0.90.01 and later */
289 if (vers >= 9001 &&
290 ioctl(fd, GET_BITMAP_FILE, &bmf) == 0 &&
291 bmf.pathname[0]) {
292 printf(" bitmap=%s", bmf.pathname);
293 }
294 } else {
295 mdu_bitmap_file_t bmf;
296 unsigned long long larray_size;
297 struct mdstat_ent *ms = mdstat_read(0, 0);
298 struct mdstat_ent *e;
299 int devnum = array.md_minor;
300 if (major(stb.st_rdev) == (unsigned)get_mdp_major())
301 devnum = -1 - devnum;
302
303 for (e=ms; e; e=e->next)
304 if (e->devnum == devnum)
305 break;
306 if (!get_dev_size(fd, NULL, &larray_size))
307 larray_size = 0;
308
309 printf("%s:\n", dev);
310
311 if (container)
312 printf(" Container : %s, member %s\n", container, member);
313 else {
314 if (sra && sra->array.major_version < 0)
315 printf(" Version : %s\n", sra->text_version);
316 else
317 printf(" Version : %d.%d\n",
318 array.major_version, array.minor_version);
319 }
320
321 atime = array.ctime;
322 if (atime)
323 printf(" Creation Time : %.24s\n", ctime(&atime));
324 if (array.raid_disks == 0)
325 str = "container";
326 printf(" Raid Level : %s\n", str?str:"-unknown-");
327 if (larray_size)
328 printf(" Array Size : %llu%s\n", (larray_size>>10),
329 human_size(larray_size));
330 if (array.level >= 1) {
331 if (array.major_version != 0 &&
332 (larray_size >= 0xFFFFFFFFULL|| array.size == 0)) {
333 unsigned long long dsize = get_component_size(fd);
334 if (dsize > 0)
335 printf(" Used Dev Size : %llu%s\n",
336 dsize/2,
337 human_size((long long)dsize<<9));
338 else
339 printf(" Used Dev Size : unknown\n");
340 } else
341 printf(" Used Dev Size : %d%s\n", array.size,
342 human_size((long long)array.size<<10));
343 }
344 if (array.raid_disks)
345 printf(" Raid Devices : %d\n", array.raid_disks);
346 printf(" Total Devices : %d\n", array.nr_disks);
347 if (!container &&
348 ((sra == NULL && array.major_version == 0) ||
349 (sra && sra->array.major_version == 0)))
350 printf("Preferred Minor : %d\n", array.md_minor);
351 if (sra == NULL || sra->array.major_version >= 0)
352 printf(" Persistence : Superblock is %spersistent\n",
353 array.not_persistent?"not ":"");
354 printf("\n");
355 /* Only try GET_BITMAP_FILE for 0.90.01 and later */
356 if (vers >= 9001 &&
357 ioctl(fd, GET_BITMAP_FILE, &bmf) == 0 &&
358 bmf.pathname[0]) {
359 printf(" Intent Bitmap : %s\n", bmf.pathname);
360 printf("\n");
361 } else if (array.state & (1<<MD_SB_BITMAP_PRESENT))
362 printf(" Intent Bitmap : Internal\n\n");
363 atime = array.utime;
364 if (atime)
365 printf(" Update Time : %.24s\n", ctime(&atime));
366 if (array.raid_disks) {
367 static char *sync_action[] = {
368 ", recovering", ", resyncing",
369 ", reshaping", ", checking" };
370 char *st;
371 if (avail_disks == array.raid_disks)
372 st = "";
373 else if (!enough(array.level, array.raid_disks,
374 array.layout, 1, avail))
375 st = ", FAILED";
376 else
377 st = ", degraded";
378
379 printf(" State : %s%s%s%s%s%s \n",
380 (array.state&(1<<MD_SB_CLEAN))?"clean":"active", st,
381 (!e || (e->percent < 0 && e->percent != RESYNC_PENDING &&
382 e->percent != RESYNC_DELAYED)) ? "" : sync_action[e->resync],
383 larray_size ? "": ", Not Started",
384 e->percent == RESYNC_DELAYED ? " (DELAYED)": "",
385 e->percent == RESYNC_PENDING ? " (PENDING)": "");
386 }
387 if (array.raid_disks)
388 printf(" Active Devices : %d\n", array.active_disks);
389 printf("Working Devices : %d\n", array.working_disks);
390 if (array.raid_disks) {
391 printf(" Failed Devices : %d\n", array.failed_disks);
392 printf(" Spare Devices : %d\n", array.spare_disks);
393 }
394 printf("\n");
395 if (array.level == 5) {
396 str = map_num(r5layout, array.layout);
397 printf(" Layout : %s\n", str?str:"-unknown-");
398 }
399 if (array.level == 6) {
400 str = map_num(r6layout, array.layout);
401 printf(" Layout : %s\n", str?str:"-unknown-");
402 }
403 if (array.level == 10) {
404 printf(" Layout :");
405 print_r10_layout(array.layout);
406 printf("\n");
407 }
408 switch (array.level) {
409 case 0:
410 case 4:
411 case 5:
412 case 10:
413 case 6:
414 if (array.chunk_size)
415 printf(" Chunk Size : %dK\n\n",
416 array.chunk_size/1024);
417 break;
418 case -1:
419 printf(" Rounding : %dK\n\n", array.chunk_size/1024);
420 break;
421 default: break;
422 }
423
424 if (e && e->percent >= 0) {
425 static char *sync_action[] = {
426 "Rebuild", "Resync",
427 "Reshape", "Check"};
428 printf(" %7s Status : %d%% complete\n", sync_action[e->resync], e->percent);
429 is_rebuilding = 1;
430 }
431 free_mdstat(ms);
432
433 if (st->sb && info->reshape_active) {
434 #if 0
435 This is pretty boring
436 printf(" Reshape pos'n : %llu%s\n", (unsigned long long) info->reshape_progress<<9,
437 human_size((unsigned long long)info->reshape_progress<<9));
438 #endif
439 if (info->delta_disks != 0)
440 printf(" Delta Devices : %d, (%d->%d)\n",
441 info->delta_disks,
442 array.raid_disks - info->delta_disks,
443 array.raid_disks);
444 if (info->new_level != array.level) {
445 str = map_num(pers, info->new_level);
446 printf(" New Level : %s\n", str?str:"-unknown-");
447 }
448 if (info->new_level != array.level ||
449 info->new_layout != array.layout) {
450 if (info->new_level == 5) {
451 str = map_num(r5layout, info->new_layout);
452 printf(" New Layout : %s\n",
453 str?str:"-unknown-");
454 }
455 if (info->new_level == 6) {
456 str = map_num(r6layout, info->new_layout);
457 printf(" New Layout : %s\n",
458 str?str:"-unknown-");
459 }
460 if (info->new_level == 10) {
461 printf(" New Layout : near=%d, %s=%d\n",
462 info->new_layout&255,
463 (info->new_layout&0x10000)?"offset":"far",
464 (info->new_layout>>8)&255);
465 }
466 }
467 if (info->new_chunk != array.chunk_size)
468 printf(" New Chunksize : %dK\n", info->new_chunk/1024);
469 printf("\n");
470 } else if (e && e->percent >= 0)
471 printf("\n");
472 if (st && st->sb)
473 st->ss->detail_super(st, c->homehost);
474
475 if (array.raid_disks == 0 && sra && sra->array.major_version == -1
476 && sra->array.minor_version == -2 && sra->text_version[0] != '/') {
477 /* This looks like a container. Find any active arrays
478 * That claim to be a member.
479 */
480 DIR *dir = opendir("/sys/block");
481 struct dirent *de;
482
483 printf(" Member Arrays :");
484
485 while (dir && (de = readdir(dir)) != NULL) {
486 char path[200];
487 char vbuf[1024];
488 int nlen = strlen(sra->sys_name);
489 int dn;
490 if (de->d_name[0] == '.')
491 continue;
492 sprintf(path, "/sys/block/%s/md/metadata_version",
493 de->d_name);
494 if (load_sys(path, vbuf) < 0)
495 continue;
496 if (strncmp(vbuf, "external:", 9) != 0 ||
497 !is_subarray(vbuf+9) ||
498 strncmp(vbuf+10, sra->sys_name, nlen) != 0 ||
499 vbuf[10+nlen] != '/')
500 continue;
501 dn = devname2devnum(de->d_name);
502 printf(" %s", map_dev_preferred(
503 dev2major(dn),
504 dev2minor(dn), 1, c->prefer));
505 }
506 if (dir)
507 closedir(dir);
508 printf("\n\n");
509 }
510
511 if (array.raid_disks)
512 printf(" Number Major Minor RaidDevice State\n");
513 else
514 printf(" Number Major Minor RaidDevice\n");
515 }
516 free(info);
517
518 for (d= 0; d < max_disks; d++) {
519 char *dv;
520 mdu_disk_info_t disk = disks[d];
521
522 if (d >= array.raid_disks &&
523 disk.major == 0 &&
524 disk.minor == 0)
525 continue;
526 if (!c->brief) {
527 if (d == array.raid_disks) printf("\n");
528 if (disk.raid_disk < 0)
529 printf(" %5d %5d %5d - ",
530 disk.number, disk.major, disk.minor);
531 else
532 printf(" %5d %5d %5d %5d ",
533 disk.number, disk.major, disk.minor, disk.raid_disk);
534 }
535 if (!c->brief && array.raid_disks) {
536
537 if (disk.state & (1<<MD_DISK_FAULTY)) {
538 printf(" faulty");
539 if (disk.raid_disk < array.raid_disks &&
540 disk.raid_disk >= 0)
541 failed++;
542 }
543 if (disk.state & (1<<MD_DISK_ACTIVE)) printf(" active");
544 if (disk.state & (1<<MD_DISK_SYNC)) {
545 printf(" sync");
546 if (array.level == 10 && (array.layout & ~0x1FFFF) == 0) {
547 int nc = array.layout & 0xff;
548 int fc = (array.layout >> 8) & 0xff;
549 int copies = nc*fc;
550 if (array.raid_disks % copies == 0 && copies <= 26) {
551 /* We can divide the devices into 'sets' */
552 int set = disk.raid_disk % copies;
553 printf(" set-%c", set + 'A');
554 }
555 }
556 }
557 if (disk.state & (1<<MD_DISK_REMOVED)) printf(" removed");
558 if (disk.state & (1<<MD_DISK_WRITEMOSTLY)) printf(" writemostly");
559 if ((disk.state &
560 ((1<<MD_DISK_ACTIVE)|(1<<MD_DISK_SYNC)|(1<<MD_DISK_REMOVED)))
561 == 0) {
562 printf(" spare");
563 if (is_26) {
564 if (disk.raid_disk < array.raid_disks && disk.raid_disk >= 0)
565 printf(" rebuilding");
566 } else if (is_rebuilding && failed) {
567 /* Taking a bit of a risk here, we remove the
568 * device from the array, and then put it back.
569 * If this fails, we are rebuilding
570 */
571 int err = ioctl(fd, HOT_REMOVE_DISK, makedev(disk.major, disk.minor));
572 if (err == 0) ioctl(fd, HOT_ADD_DISK, makedev(disk.major, disk.minor));
573 if (err && errno == EBUSY)
574 printf(" rebuilding");
575 }
576 }
577 }
578 if (disk.state == 0) spares++;
579 if (c->test && d < array.raid_disks
580 && !(disk.state & (1<<MD_DISK_SYNC)))
581 rv |= 1;
582 dv=map_dev_preferred(disk.major, disk.minor, 0, c->prefer);
583 if (dv != NULL) {
584 if (c->brief) {
585 if (devices) {
586 devices = xrealloc(devices,
587 strlen(devices)+1+strlen(dv)+1);
588 strcat(strcat(devices,","),dv);
589 } else
590 devices = xstrdup(dv);
591 } else
592 printf(" %s", dv);
593 }
594 if (!c->brief) printf("\n");
595 }
596 if (spares && c->brief && array.raid_disks) printf(" spares=%d", spares);
597 if (c->brief && st && st->sb)
598 st->ss->brief_detail_super(st);
599 st->ss->free_super(st);
600
601 if (c->brief > 1 && devices) printf("\n devices=%s", devices);
602 if (c->brief)
603 printf("\n");
604 if (c->test &&
605 !enough(array.level, array.raid_disks, array.layout,
606 1, avail))
607 rv = 2;
608
609 free(disks);
610 out:
611 close(fd);
612 free(subarray);
613 free(avail);
614 sysfs_free(sra);
615 return rv;
616 }
617
618 int Detail_Platform(struct superswitch *ss, int scan, int verbose)
619 {
620 /* display platform capabilities for the given metadata format
621 * 'scan' in this context means iterate over all metadata types
622 */
623 int i;
624 int err = 1;
625
626 if (ss && ss->detail_platform)
627 err = ss->detail_platform(verbose, 0);
628 else if (ss) {
629 if (verbose > 0)
630 pr_err("%s metadata is platform independent\n",
631 ss->name ? : "[no name]");
632 } else if (!scan) {
633 if (verbose > 0)
634 pr_err("specify a metadata type or --scan\n");
635 }
636
637 if (!scan)
638 return err;
639
640 for (i = 0; superlist[i]; i++) {
641 struct superswitch *meta = superlist[i];
642
643 if (meta == ss)
644 continue;
645 if (verbose > 0)
646 pr_err("checking metadata %s\n",
647 meta->name ? : "[no name]");
648 if (!meta->detail_platform) {
649 if (verbose > 0)
650 pr_err("%s metadata is platform independent\n",
651 meta->name ? : "[no name]");
652 } else
653 err |= meta->detail_platform(verbose, 0);
654 }
655
656 return err;
657 }
Unnamed repository; edit this file 'description' to name the repository.