5e68e6059b983e34c10ef4113990ca903514dbc3
[dragonfly.git] / sbin / hammer / cmd_config.c
1 /*
2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
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 "hammer.h"
36 #include <sys/param.h>
37 #include <sys/mount.h>
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include <time.h>
43
44 static void config_get(const char *dirpath, struct hammer_ioc_config *config);
45 static void config_set(const char *dirpath, struct hammer_ioc_config *config);
46 static void config_remove_path(void);
47
48 char *ConfigPath;
49
50 /*
51  * hammer config [<fs> [configfile]]
52  *
53  * Prints out the hammer cleanup configuration for the specified HAMMER
54  * filesystem(s) or the current filesystem.
55  */
56 void
57 hammer_cmd_config(char **av, int ac)
58 {
59         struct hammer_ioc_config config;
60         char *dirpath;
61         ssize_t n;
62         int fd;
63
64         bzero(&config, sizeof(config));
65         if (ac == 0) {
66                 config_get(".", &config);
67                 if (config.head.error == 0) {
68                         printf("%s", config.config.text);
69                 } else {
70                         errx(2, "hammer config: no configuration found");
71                         /* not reached */
72                 }
73                 return;
74         }
75         dirpath = av[0];
76         if (ac == 1) {
77                 config_get(dirpath, &config);
78                 if (config.head.error == 0) {
79                         printf("%s", config.config.text);
80                 } else {
81                         errx(2, "hammer config: no configuration found");
82                         /* not reached */
83                 }
84                 return;
85         }
86         config_get(dirpath, &config);   /* ignore errors */
87         config.head.error = 0;
88
89         fd = open(av[1], O_RDONLY);
90         n = read(fd, config.config.text, sizeof(config.config.text) - 1);
91         if (n == sizeof(config.config.text) - 1) {
92                 err(2, "hammer config: config file too big, limit %zu bytes",
93                     sizeof(config.config.text) - 1);
94                 /* not reached */
95         }
96         bzero(config.config.text + n, sizeof(config.config.text) - n);
97         config_set(dirpath, &config);
98         close(fd);
99 }
100
101 /*
102  * hammer viconfig [<fs>]
103  */
104 void
105 hammer_cmd_viconfig(char **av, int ac)
106 {
107         struct hammer_ioc_config config;
108         struct timeval times[2];
109         const char *dirpath;
110         struct stat st;
111         char *runcmd, *editor, *tmp;
112         char path[32];
113         ssize_t n;
114         int fd;
115
116         if (ac > 1) {
117                 errx(1, "hammer viconfig: 0 or 1 argument (<fs>) only");
118                 /* not reached */
119         }
120         if (ac == 0)
121                 dirpath = ".";
122         else
123                 dirpath = av[0];
124         config_get(dirpath, &config);
125         if (config.head.error == ENOENT) {
126                 snprintf(config.config.text, sizeof(config.config.text),
127                         "%s",
128                         "# No configuration present, here are some defaults\n"
129                         "# you can uncomment.  Also remove these instructions\n"
130                         "#\n"
131                         "#snapshots 1d 60d\n"
132                         "#prune     1d 5m\n"
133                         "#rebalance 1d 5m\n"
134                         "#dedup     1d 5m\n"
135                         "#reblock   1d 5m\n"
136                         "#recopy    30d 10m\n");
137                 config.head.error = 0;
138         }
139         if (config.head.error) {
140                 errx(2, "hammer viconfig: read config failed error: %s",
141                         strerror(config.head.error));
142                 /* not reached */
143         }
144
145         /*
146          * Edit a temporary file and write back if it was modified.
147          * Adjust the mtime back one second so a quick edit is not
148          * improperly detected as not having been modified.
149          */
150         snprintf(path, sizeof(path), "/tmp/configXXXXXXXXXX");
151         mkstemp(path);
152         ConfigPath = path;
153         atexit(config_remove_path);
154
155         fd = open(path, O_RDWR|O_CREAT|O_TRUNC, 0600);
156         if (fd < 0)
157                 err(2, "hammer viconfig: creating temporary file %s", path);
158         write(fd, config.config.text, strlen(config.config.text));
159         if (fstat(fd, &st) < 0)
160                 err(2, "hammer viconfig");
161         times[0].tv_sec = st.st_mtime - 1;
162         times[0].tv_usec = 0;
163         times[1] = times[0];
164         close(fd);
165         utimes(path, times);
166
167         if ((tmp = getenv("EDITOR")) != NULL ||
168             (tmp = getenv("VISUAL")) != NULL)
169                 editor = strdup(tmp);
170         else
171                 editor = strdup("vi");
172
173         asprintf(&runcmd, "%s %s", editor, path);
174         system(runcmd);
175
176         if (stat(path, &st) < 0)
177                 err(2, "hammer viconfig: unable to stat file after vi");
178         if (times[0].tv_sec == st.st_mtime) {
179                 printf("hammer viconfig: no changes were made\n");
180                 remove(path);
181                 return;
182         }
183         fd = open(path, O_RDONLY);
184         if (fd < 0)
185                 err(2, "hammer viconfig: unable to read %s", path);
186         remove(path);
187         n = read(fd, config.config.text, sizeof(config.config.text) - 1);
188         if (n < 0)
189                 err(2, "hammer viconfig: unable to read %s", path);
190         if (n == sizeof(config.config.text) - 1) {
191                 err(2, "hammer config: config file too big, limit %zu bytes",
192                     sizeof(config.config.text) - 1);
193                 /* not reached */
194         }
195         bzero(config.config.text + n, sizeof(config.config.text) - n);
196         config_set(dirpath, &config);
197         free(editor);
198         free(runcmd);
199 }
200
201 static void
202 config_get(const char *dirpath, struct hammer_ioc_config *config)
203 {
204         struct hammer_ioc_version version;
205         int fd;
206
207         bzero(&version, sizeof(version));
208         if ((fd = open(dirpath, O_RDONLY)) < 0)
209                 err(2, "hammer config: unable to open directory %s", dirpath);
210         if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) < 0)
211                 errx(2, "hammer config: not a HAMMER filesystem!");
212
213         if (ioctl(fd, HAMMERIOC_GET_CONFIG, config) < 0)
214                 errx(2, "hammer config: config_get");
215         close(fd);
216 }
217
218 static void
219 config_set(const char *dirpath, struct hammer_ioc_config *config)
220 {
221         struct hammer_ioc_version version;
222         int fd;
223
224         bzero(&version, sizeof(version));
225         if ((fd = open(dirpath, O_RDONLY)) < 0)
226                 errx(2, "hammer config: unable to open directory %s", dirpath);
227         if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) < 0)
228                 errx(2, "hammer config: not a HAMMER filesystem!");
229         if (ioctl(fd, HAMMERIOC_SET_CONFIG, config) < 0)
230                 err(2, "hammer config");
231         close(fd);
232 }
233
234 static void
235 config_remove_path(void)
236 {
237         remove(ConfigPath);
238 }