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