hammer2 - Add directives for setting the check mode
[dragonfly.git] / sbin / hammer2 / cmd_stat.c
1 /*
2  * Copyright (c) 2011-2012 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
35 #include "hammer2.h"
36
37 static const char *compmodestr(uint8_t comp_algo);
38 static const char *checkmodestr(uint8_t comp_algo);
39
40 /*
41  * Should be run as root.  Creates /etc/hammer2/rsa.{pub,prv} using
42  * an openssl command.
43  */
44 int
45 cmd_stat(int ac, const char **av)
46 {
47         hammer2_ioc_inode_t ino;
48         const char *cdir = ".";
49         int ec = 0;
50         int w;
51         int i;
52         int fd;
53
54         if (ac == 0) {
55                 ac = 1;
56                 av = &cdir;
57         }
58         for (i = w = 0; i < ac; ++i) {
59                 if (w < (int)strlen(av[i]))
60                         w = (int)strlen(av[i]);
61         }
62         if (w < 16)
63                 w = 16;
64         printf("%-*.*s ncp  data-use inode-use comp kaddr\n", w, w, "PATH");
65         for (i = 0; i < ac; ++i) {
66                 if ((fd = open(av[i], O_RDONLY)) < 0) {
67                         fprintf(stderr, "%s: %s\n", av[i], strerror(errno));
68                         ec = 1;
69                         continue;
70                 }
71                 if (ioctl(fd, HAMMER2IOC_INODE_GET, &ino) < 0) {
72                         fprintf(stderr, "%s: %s\n", av[i], strerror(errno));
73                         ec = 1;
74                         continue;
75                 }
76                 printf("%-*.*s ", w, w, av[i]);
77                 printf("%3d ", ino.ip_data.ncopies);
78                 printf("%9s ", sizetostr(ino.ip_data.data_count));
79                 printf("%9s ", counttostr(ino.ip_data.inode_count));
80                 printf("%p ", ino.kdata);
81                 printf("comp=%s ", compmodestr(ino.ip_data.comp_algo));
82                 printf("check=%s ", checkmodestr(ino.ip_data.check_algo));
83                 if (ino.ip_data.data_quota || ino.ip_data.inode_quota) {
84                         printf(" quota ");
85                         printf("%12s", sizetostr(ino.ip_data.data_quota));
86                         printf("/%-12s", counttostr(ino.ip_data.inode_quota));
87                 }
88                 printf("\n");
89         }
90         return ec;
91 }
92
93 static
94 const char *
95 compmodestr(uint8_t comp_algo)
96 {
97         static char buf[64];
98         static const char *comps[] = HAMMER2_COMP_STRINGS;
99         int comp = HAMMER2_DEC_ALGO(comp_algo);
100         int level = HAMMER2_DEC_LEVEL(comp_algo);
101
102         if (level) {
103                 if (comp >= 0 && comp < HAMMER2_COMP_STRINGS_COUNT)
104                         snprintf(buf, sizeof(buf), "%s:%d",
105                                  comps[comp], level);
106                 else
107                         snprintf(buf, sizeof(buf), "unknown(%d):%d",
108                                  comp, level);
109         } else {
110                 if (comp >= 0 && comp < HAMMER2_COMP_STRINGS_COUNT)
111                         snprintf(buf, sizeof(buf), "%s:default",
112                                  comps[comp]);
113                 else
114                         snprintf(buf, sizeof(buf), "unknown(%d):default",
115                                  comp);
116         }
117         return (buf);
118 }
119
120 static
121 const char *
122 checkmodestr(uint8_t check_algo)
123 {
124         static char buf[64];
125         static const char *checks[] = HAMMER2_CHECK_STRINGS;
126         int check = HAMMER2_DEC_ALGO(check_algo);
127         int level = HAMMER2_DEC_LEVEL(check_algo);
128
129         /*
130          * NOTE: Check algorithms normally do not encode any level.
131          */
132         if (level) {
133                 if (check >= 0 && check < HAMMER2_CHECK_STRINGS_COUNT)
134                         snprintf(buf, sizeof(buf), "%s:%d",
135                                  checks[check], level);
136                 else
137                         snprintf(buf, sizeof(buf), "unknown(%d):%d",
138                                  check, level);
139         } else {
140                 if (check >= 0 && check < HAMMER2_CHECK_STRINGS_COUNT)
141                         snprintf(buf, sizeof(buf), "%s", checks[check]);
142                 else
143                         snprintf(buf, sizeof(buf), "unknown(%d)", check);
144         }
145         return (buf);
146 }