1 /* 2 * Copyright (c) 2007 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 <sys/types.h> 36 #include <sys/diskslice.h> 37 #include <sys/diskmbr.h> 38 #include <sys/stat.h> 39 #include <sys/time.h> 40 #include <sys/syslimits.h> 41 #include <vfs/hammer/hammer_mount.h> 42 #include <vfs/hammer/hammer_disk.h> 43 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <stdarg.h> 47 #include <stddef.h> 48 #include <unistd.h> 49 #include <string.h> 50 #include <errno.h> 51 #include <fcntl.h> 52 #include <uuid.h> 53 #include <err.h> 54 #include <assert.h> 55 #include <ctype.h> 56 #include <mntopts.h> 57 58 typedef const char **ary_ptr_t; 59 60 static void extract_volumes(ary_ptr_t *aryp, int *countp, char **av, int ac); 61 62 #define MOPT_UPDATE { "update", 0, MNT_UPDATE, 0 } 63 64 #define MOPT_HAMMEROPTS \ 65 { "history", 1, HMNT_NOHISTORY, 1 }, \ 66 { "master=", 0, HMNT_MASTERID, 1 }, \ 67 { "mirror", 1, HMNT_MASTERID, 1 } 68 69 static struct mntopt mopts[] = { MOPT_STDOPTS, MOPT_HAMMEROPTS, 70 MOPT_UPDATE, MOPT_NULL }; 71 72 static void usage(void); 73 74 int 75 main(int ac, char **av) 76 { 77 struct hammer_mount_info info; 78 struct vfsconf vfc; 79 struct hammer_volume_ondisk *od; 80 int mount_flags = 0; 81 int error; 82 int ch; 83 int init_flags = 0; 84 int ax; 85 int fd; 86 int pr; 87 int fdevs_size; 88 char *mountpt; 89 char *ptr; 90 char *fdevs; 91 92 93 bzero(&info, sizeof(info)); 94 info.asof = 0; 95 mount_flags = 0; 96 info.hflags = 0; 97 98 while ((ch = getopt(ac, av, "o:T:u")) != -1) { 99 switch(ch) { 100 case 'T': 101 info.asof = strtoull(optarg, NULL, 0); 102 break; 103 case 'o': 104 getmntopts(optarg, mopts, &mount_flags, &info.hflags); 105 106 107 /* 108 * Handle extended flags with parameters. 109 */ 110 if (info.hflags & HMNT_MASTERID) { 111 ptr = strstr(optarg, "master="); 112 if (ptr) { 113 info.master_id = strtol(ptr + 7, NULL, 0); 114 if (info.master_id == 0) { 115 fprintf(stderr, 116 "hammer_mount: Warning: a master id of 0 is the default, explicit\n" 117 "settings should probably use 1-15\n"); 118 } 119 } 120 ptr = strstr(optarg, "nomirror"); 121 if (ptr) 122 info.master_id = -1; 123 } 124 break; 125 case 'u': 126 init_flags |= MNT_UPDATE; 127 break; 128 default: 129 usage(); 130 /* not reached */ 131 } 132 } 133 ac -= optind; 134 av += optind; 135 mount_flags |= init_flags; 136 137 /* 138 * Only the mount point need be specified in update mode. 139 */ 140 if (init_flags & MNT_UPDATE) { 141 if (ac != 1) { 142 usage(); 143 /* not reached */ 144 } 145 mountpt = av[0]; 146 if (mount(vfc.vfc_name, mountpt, mount_flags, &info)) 147 err(1, "mountpoint %s", mountpt); 148 exit(0); 149 } 150 151 if (ac < 2) { 152 usage(); 153 /* not reached */ 154 } 155 156 /* 157 * Mount arguments: vol [vol...] mountpt 158 */ 159 extract_volumes(&info.volumes, &info.nvolumes, av, ac - 1); 160 mountpt = av[ac - 1]; 161 162 /* 163 * Load the hammer module if necessary (this bit stolen from 164 * mount_null). 165 */ 166 error = getvfsbyname("hammer", &vfc); 167 if (error && vfsisloadable("hammer")) { 168 if (vfsload("hammer") != 0) 169 err(1, "vfsload(hammer)"); 170 endvfsent(); 171 error = getvfsbyname("hammer", &vfc); 172 } 173 if (error) 174 errx(1, "hammer filesystem is not available"); 175 176 if (mount(vfc.vfc_name, mountpt, mount_flags, &info)) { 177 /* Build fdevs in case of error to report failed devices */ 178 fdevs_size = ac * PATH_MAX; 179 fdevs = malloc(fdevs_size); 180 bzero(fdevs, fdevs_size); 181 182 for (ax = 0; ax < info.nvolumes; ax++) { 183 fd = open(info.volumes[ax], O_RDONLY); 184 if (fd < 0 ) { 185 fprintf(stderr, "%s: open failed\n", info.volumes[ax]); 186 strlcat(fdevs, info.volumes[ax], fdevs_size); 187 if (ax < ac - 2) 188 strlcat(fdevs, " ", fdevs_size); 189 continue; 190 } 191 192 od = malloc(HAMMER_BUFSIZE); 193 if (od == NULL) { 194 close (fd); 195 perror("malloc"); 196 continue; 197 } 198 199 bzero(od, HAMMER_BUFSIZE); 200 pr = pread(fd, od, HAMMER_BUFSIZE, 0); 201 if (pr != HAMMER_BUFSIZE || 202 od->vol_signature != HAMMER_FSBUF_VOLUME) { 203 fprintf(stderr, "%s: Not a valid HAMMER filesystem\n", 204 info.volumes[ax]); 205 strlcat(fdevs, info.volumes[ax], fdevs_size); 206 if (ax < ac - 2) 207 strlcat(fdevs, " ", fdevs_size); 208 } 209 close(fd); 210 } 211 if (strlen(fdevs)) 212 err(1, "mount %s on %s", fdevs, mountpt); 213 else 214 err(1, "Unknown error"); 215 } 216 exit (0); 217 } 218 219 /* 220 * Extract a volume list 221 */ 222 static void 223 extract_volumes(ary_ptr_t *aryp, int *countp, char **av, int ac) 224 { 225 int idx = 0; 226 int arymax = 32; 227 const char **ary = malloc(sizeof(char *) * 32); 228 char *ptr; 229 char *next; 230 231 while (ac) { 232 if (idx == arymax) { 233 arymax += 32; 234 ary = realloc(ary, sizeof(char *) * arymax); 235 } 236 if (strchr(*av, ':') == NULL) { 237 ary[idx++] = *av; 238 } else { 239 next = strdup(*av); 240 while ((ptr = next) != NULL) { 241 if (idx == arymax) { 242 arymax += 32; 243 ary = realloc(ary, sizeof(char *) * 244 arymax); 245 } 246 if ((next = strchr(ptr, ':')) != NULL) 247 *next++ = 0; 248 ary[idx++] = ptr; 249 } 250 } 251 --ac; 252 ++av; 253 } 254 *aryp = ary; 255 *countp = idx; 256 } 257 258 static 259 void 260 usage(void) 261 { 262 fprintf(stderr, "usage: mount_hammer [-o options] [-T transaction-id] " 263 "special ... node\n"); 264 fprintf(stderr, " mount_hammer [-o options] [-T transaction-id] " 265 "special[:special]* node\n"); 266 fprintf(stderr, " mount_hammer -u [-o options] node\n"); 267 exit(1); 268 } 269