ig4 - Stop I2C controller after checking that it's kind of functional.
[dragonfly.git] / sbin / hammer2 / cmd_info.c
CommitLineData
b92bfd39
MD
1/*
2 * Copyright (c) 2015 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34#include "hammer2.h"
35
36static void h2disk_check(const char *devpath,
37 void (*callback1)(const char *, hammer2_blockref_t *, int));
38static void h2pfs_check(int fd, hammer2_blockref_t *bref,
39 void (*callback2)(const char *, hammer2_blockref_t *, int));
40
41static void info_callback1(const char *, hammer2_blockref_t *, int);
42static void info_callback2(const char *, hammer2_blockref_t *, int);
43
44int
45cmd_info(int ac, const char **av)
46{
47 struct dirent *den;
48 char *devpath;
49 DIR *dir;
50 int i;
51
52 for (i = 0; i < ac; ++i)
53 h2disk_check(av[i], info_callback1);
54 if (ac == 0 && (dir = opendir("/dev/serno")) != NULL) {
55 while ((den = readdir(dir)) != NULL) {
56 const char *ptr;
57 int slice;
58 char part;
59
60 ptr = strrchr(den->d_name, '.');
61 if (ptr && sscanf(ptr, ".s%d%c", &slice, &part) == 2) {
62 asprintf(&devpath, "/dev/serno/%s",
63 den->d_name);
64 h2disk_check(devpath, info_callback1);
65 free(devpath);
66 }
67 }
68 closedir(dir);
69 }
70 return 0;
71}
72
73static
74void
75info_callback1(const char *path, hammer2_blockref_t *bref, int fd)
76{
77 printf("%s:\n", path);
78 h2pfs_check(fd, bref, info_callback2);
79}
80
81static
82void
83info_callback2(const char *pfsname,
84 hammer2_blockref_t *bref __unused, int fd __unused)
85{
86 printf(" %s\n", pfsname);
87}
88
89static void mount_callback1(const char *, hammer2_blockref_t *, int);
90static void mount_callback2(const char *, hammer2_blockref_t *, int);
91static void cmd_mountall_alarm(int signo);
92
66056193 93static volatile sig_atomic_t DidAlarm;
b92bfd39
MD
94
95int
96cmd_mountall(int ac, const char **av)
97{
98 struct dirent *den;
99 char *devpath;
100 DIR *dir;
101 int i;
102 pid_t pid;
103
104 for (i = 0; i < ac; ++i)
105 h2disk_check(av[i], mount_callback1);
106 if (ac == 0 && (dir = opendir("/dev/serno")) != NULL) {
107 while ((den = readdir(dir)) != NULL) {
108 const char *ptr;
109 int slice;
110 char part;
111
112 ptr = strrchr(den->d_name, '.');
113 if (ptr && sscanf(ptr, ".s%d%c", &slice, &part) == 2) {
114 asprintf(&devpath, "/dev/serno/%s",
115 den->d_name);
116 h2disk_check(devpath, mount_callback1);
117 free(devpath);
118 }
119 }
120 closedir(dir);
121 }
122 signal(SIGALRM, cmd_mountall_alarm);
123 for (;;) {
124 alarm(15);
125 pid = wait3(NULL, 0, NULL);
126 if (pid < 0 && errno == ECHILD)
127 break;
128 if (pid < 0 && DidAlarm) {
129 printf("Timeout waiting for mounts to complete\n");
130 break;
131 }
132 }
133 alarm(0);
134
135 return 0;
136}
137
138static
139void
140cmd_mountall_alarm(int signo __unused)
141{
142 DidAlarm = 1;
143}
144
145static const char *mount_path;
146static const char *mount_comp;
147
148static
149void
150mount_callback1(const char *devpath, hammer2_blockref_t *bref, int fd)
151{
152 mount_path = devpath;
153 mount_comp = strrchr(devpath, '/');
154 if (mount_comp) {
155 ++mount_comp;
156 h2pfs_check(fd, bref, mount_callback2);
157 }
158}
159
160static
161void
162mount_callback2(const char *pfsname,
163 hammer2_blockref_t *bref __unused, int fd)
164{
165 char *tmp_path;
166 char *label;
167 int tfd;
168
169 if (strcmp(pfsname, "LOCAL") == 0) {
170 if ((tfd = open("/dev/null", O_RDONLY)) >= 0) {
171 dup2(tfd, fd);
172 close(tfd);
173 } else {
174 perror("open(/dev/null)");
175 exit(1);
176 }
177 asprintf(&tmp_path, "/var/hammer2/LOCAL.%s", mount_comp);
178 asprintf(&label, "%s@LOCAL", mount_path);
179 mkdir("/var/hammer2", 0700);
180 mkdir(tmp_path, 0700);
181 printf("mount %s\n", tmp_path);
182 if (fork() == 0) {
183 execl("/sbin/mount_hammer2",
184 "mount",
185 label,
186 tmp_path,
187 NULL);
188 }
189 free(label);
190 free(tmp_path);
191 }
192}
193
194/*
195 * Support
196 */
197static
198void
199h2disk_check(const char *devpath,
200 void (*callback1)(const char *, hammer2_blockref_t *, int))
201{
202 hammer2_blockref_t broot;
203 hammer2_blockref_t best;
204 hammer2_media_data_t media;
205 struct partinfo partinfo;
206 int fd;
207 int i;
208 int best_i;
209
210 fd = open(devpath, O_RDONLY);
211 if (fd < 0) {
212 fprintf(stderr, "Unable to open \"%s\"\n", devpath);
213 return;
214 }
215 if (ioctl(fd, DIOCGPART, &partinfo) == -1) {
216 fprintf(stderr, "DIOCGPART failed on \"%s\"\n", devpath);
217 goto done;
218 }
219 if (partinfo.fstype != FS_HAMMER2)
220 goto done;
221
222 /*
223 * Find the best volume header.
224 */
225 best_i = -1;
226 bzero(&best, sizeof(best));
227 for (i = 0; i < 4; ++i) {
228 bzero(&broot, sizeof(broot));
229 broot.type = HAMMER2_BREF_TYPE_VOLUME;
230 broot.data_off = (i * HAMMER2_ZONE_BYTES64) |
231 HAMMER2_PBUFRADIX;
232 lseek(fd, broot.data_off & ~HAMMER2_OFF_MASK_RADIX, 0);
233 if (read(fd, &media, HAMMER2_PBUFSIZE) ==
234 (ssize_t)HAMMER2_PBUFSIZE &&
235 media.voldata.magic == HAMMER2_VOLUME_ID_HBO) {
236 broot.mirror_tid = media.voldata.mirror_tid;
237 if (best_i < 0 || best.mirror_tid < broot.mirror_tid) {
238 best_i = i;
239 best = broot;
240 }
241 }
242 }
243 if (best_i >= 0)
244 callback1(devpath, &best, fd);
245done:
246 close(fd);
247}
248
249static
250void
251h2pfs_check(int fd, hammer2_blockref_t *bref,
252 void (*callback2)(const char *, hammer2_blockref_t *, int))
253{
254 hammer2_media_data_t media;
255 hammer2_blockref_t *bscan;
256 int bcount;
257 int i;
258 size_t bytes;
259 uint32_t cv;
7d565a4f 260 uint64_t cv64;
b92bfd39
MD
261
262 bytes = (size_t)1 << (bref->data_off & HAMMER2_OFF_MASK_RADIX);
263
264 {
265 hammer2_off_t io_off;
266 hammer2_off_t io_base;
267 size_t io_bytes;
268 size_t boff;
269
270 io_off = bref->data_off & ~HAMMER2_OFF_MASK_RADIX;
271 io_base = io_off & ~(hammer2_off_t)(HAMMER2_MINIOSIZE - 1);
272 io_bytes = bytes;
273 boff = io_off - io_base;
274
275 io_bytes = HAMMER2_MINIOSIZE;
276 while (io_bytes + boff < bytes)
277 io_bytes <<= 1;
278
279 if (io_bytes > sizeof(media)) {
280 printf("(bad block size %zd)\n", bytes);
281 return;
282 }
283 if (bref->type != HAMMER2_BREF_TYPE_DATA) {
284 lseek(fd, io_base, 0);
285 if (read(fd, &media, io_bytes) != (ssize_t)io_bytes) {
286 printf("(media read failed)\n");
287 return;
288 }
289 if (boff)
290 bcopy((char *)&media + boff, &media, bytes);
291 }
292 }
293
294 bscan = NULL;
295 bcount = 0;
296
297 /*
298 * Check data integrity in verbose mode, otherwise we are just doing
299 * a quick meta-data scan. Meta-data integrity is always checked.
300 * (Also see the check above that ensures the media data is loaded,
301 * otherwise there's no data to check!).
302 */
303 if (bref->type != HAMMER2_BREF_TYPE_DATA || VerboseOpt >= 1) {
304 switch(HAMMER2_DEC_CHECK(bref->methods)) {
305 case HAMMER2_CHECK_NONE:
306 break;
307 case HAMMER2_CHECK_DISABLED:
308 break;
309 case HAMMER2_CHECK_ISCSI32:
310 cv = hammer2_icrc32(&media, bytes);
311 if (bref->check.iscsi32.value != cv) {
312 printf("\t(icrc failed %02x:%08x/%08x)\n",
313 bref->methods,
314 bref->check.iscsi32.value,
315 cv);
316 }
317 break;
7d565a4f
MD
318 case HAMMER2_CHECK_XXHASH64:
319 cv64 = XXH64(&media, bytes, XXH_HAMMER2_SEED);
320 if (bref->check.xxhash64.value != cv64) {
321 printf("\t(xxhash failed %02x:%016jx/%016jx)\n",
322 bref->methods,
323 bref->check.xxhash64.value,
324 cv64);
325 }
b92bfd39
MD
326 break;
327 case HAMMER2_CHECK_SHA192:
328 break;
329 case HAMMER2_CHECK_FREEMAP:
330 cv = hammer2_icrc32(&media, bytes);
331 if (bref->check.freemap.icrc32 != cv) {
332 printf("\t(fcrc %02x:%08x/%08x)\n",
333 bref->methods,
334 bref->check.freemap.icrc32,
335 cv);
336 }
337 break;
338 }
339 }
340
341 switch(bref->type) {
342 case HAMMER2_BREF_TYPE_EMPTY:
343 break;
344 case HAMMER2_BREF_TYPE_INODE:
345 if (media.ipdata.meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT) {
346 if ((media.ipdata.meta.op_flags &
347 HAMMER2_OPFLAG_DIRECTDATA) == 0) {
348 bscan = &media.ipdata.u.blockset.blockref[0];
349 bcount = HAMMER2_SET_COUNT;
350 }
351 } else
352 if (media.ipdata.meta.op_flags & HAMMER2_OPFLAG_PFSROOT) {
353 callback2(media.ipdata.filename, bref, fd);
354 bscan = NULL;
355 bcount = 0;
356 } else {
357 bscan = NULL;
358 bcount = 0;
359 }
360 break;
361 case HAMMER2_BREF_TYPE_INDIRECT:
362 bscan = &media.npdata[0];
363 bcount = bytes / sizeof(hammer2_blockref_t);
364 break;
365 case HAMMER2_BREF_TYPE_DATA:
366 break;
367 case HAMMER2_BREF_TYPE_VOLUME:
368 bscan = &media.voldata.sroot_blockset.blockref[0];
369 bcount = HAMMER2_SET_COUNT;
370 break;
371 default:
372 break;
373 }
374 for (i = 0; i < bcount; ++i) {
375 if (bscan[i].type != HAMMER2_BREF_TYPE_EMPTY)
376 h2pfs_check(fd, &bscan[i], callback2);
377 }
378}