{un,}vis.3: Bring back some small fixes we had earlier.
[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.meta.ncopies);
78                 printf("%9s ", sizetostr(ino.data_count));
79                 printf("%9s ", counttostr(ino.inode_count));
80                 /*printf("%p ", ino.kdata); debugging */
81                 printf("comp=%s ", compmodestr(ino.ip_data.meta.comp_algo));
82                 printf("check=%s ", checkmodestr(ino.ip_data.meta.check_algo));
83                 if (ino.ip_data.meta.data_quota ||
84                     ino.ip_data.meta.inode_quota) {
85                         printf(" quota ");
86                         printf("%12s",
87                                 sizetostr(ino.ip_data.meta.data_quota));
88                         printf("/%-12s",
89                                 counttostr(ino.ip_data.meta.inode_quota));
90                 }
91                 printf("\n");
92         }
93         return ec;
94 }
95
96 static
97 const char *
98 compmodestr(uint8_t comp_algo)
99 {
100         static char buf[64];
101         static const char *comps[] = HAMMER2_COMP_STRINGS;
102         int comp = HAMMER2_DEC_ALGO(comp_algo);
103         int level = HAMMER2_DEC_LEVEL(comp_algo);
104
105         if (level) {
106                 if (comp >= 0 && comp < HAMMER2_COMP_STRINGS_COUNT)
107                         snprintf(buf, sizeof(buf), "%s:%d",
108                                  comps[comp], level);
109                 else
110                         snprintf(buf, sizeof(buf), "unknown(%d):%d",
111                                  comp, level);
112         } else {
113                 if (comp >= 0 && comp < HAMMER2_COMP_STRINGS_COUNT)
114                         snprintf(buf, sizeof(buf), "%s:default",
115                                  comps[comp]);
116                 else
117                         snprintf(buf, sizeof(buf), "unknown(%d):default",
118                                  comp);
119         }
120         return (buf);
121 }
122
123 static
124 const char *
125 checkmodestr(uint8_t check_algo)
126 {
127         static char buf[64];
128         static const char *checks[] = HAMMER2_CHECK_STRINGS;
129         int check = HAMMER2_DEC_ALGO(check_algo);
130         int level = HAMMER2_DEC_LEVEL(check_algo);
131
132         /*
133          * NOTE: Check algorithms normally do not encode any level.
134          */
135         if (level) {
136                 if (check >= 0 && check < HAMMER2_CHECK_STRINGS_COUNT)
137                         snprintf(buf, sizeof(buf), "%s:%d",
138                                  checks[check], level);
139                 else
140                         snprintf(buf, sizeof(buf), "unknown(%d):%d",
141                                  check, level);
142         } else {
143                 if (check >= 0 && check < HAMMER2_CHECK_STRINGS_COUNT)
144                         snprintf(buf, sizeof(buf), "%s", checks[check]);
145                 else
146                         snprintf(buf, sizeof(buf), "unknown(%d)", check);
147         }
148         return (buf);
149 }