1 /*- 2 * Copyright (c) 2004 Pawel Jakub Dawidek <pjd@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/disk.h> 32 #include <sys/endian.h> 33 #include <sys/uio.h> 34 #include <errno.h> 35 #include <fcntl.h> 36 #include <paths.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <stdarg.h> 40 #include <string.h> 41 #include <strings.h> 42 #include <unistd.h> 43 #include <assert.h> 44 #include <libgeom.h> 45 46 #include "misc/subr.h" 47 48 49 struct std_metadata { 50 char md_magic[16]; 51 uint32_t md_version; 52 }; 53 54 static void 55 std_metadata_decode(const u_char *data, struct std_metadata *md) 56 { 57 58 bcopy(data, md->md_magic, sizeof(md->md_magic)); 59 md->md_version = le32dec(data + 16); 60 } 61 62 static void 63 pathgen(const char *name, char *path, size_t size) 64 { 65 66 if (strncmp(name, _PATH_DEV, strlen(_PATH_DEV)) != 0) 67 snprintf(path, size, "%s%s", _PATH_DEV, name); 68 else 69 strlcpy(path, name, size); 70 } 71 72 /* 73 * Greatest Common Divisor. 74 */ 75 static unsigned 76 gcd(unsigned a, unsigned b) 77 { 78 u_int c; 79 80 while (b != 0) { 81 c = a; 82 a = b; 83 b = (c % b); 84 } 85 return (a); 86 } 87 88 /* 89 * Least Common Multiple. 90 */ 91 unsigned 92 g_lcm(unsigned a, unsigned b) 93 { 94 95 return ((a * b) / gcd(a, b)); 96 } 97 98 uint32_t 99 bitcount32(uint32_t x) 100 { 101 102 x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1); 103 x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2); 104 x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4); 105 x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8); 106 x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16); 107 return (x); 108 } 109 110 off_t 111 g_get_mediasize(const char *name) 112 { 113 char path[MAXPATHLEN]; 114 off_t mediasize; 115 int fd; 116 117 pathgen(name, path, sizeof(path)); 118 fd = open(path, O_RDONLY); 119 if (fd == -1) 120 return (0); 121 if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) < 0) { 122 close(fd); 123 return (0); 124 } 125 close(fd); 126 return (mediasize); 127 } 128 129 unsigned 130 g_get_sectorsize(const char *name) 131 { 132 char path[MAXPATHLEN]; 133 unsigned sectorsize; 134 int fd; 135 136 pathgen(name, path, sizeof(path)); 137 fd = open(path, O_RDONLY); 138 if (fd == -1) 139 return (0); 140 if (ioctl(fd, DIOCGSECTORSIZE, §orsize) < 0) { 141 close(fd); 142 return (0); 143 } 144 close(fd); 145 return (sectorsize); 146 } 147 148 int 149 g_metadata_read(const char *name, u_char *md, size_t size, const char *magic) 150 { 151 struct std_metadata stdmd; 152 char path[MAXPATHLEN]; 153 unsigned sectorsize; 154 off_t mediasize; 155 u_char *sector; 156 int error, fd; 157 158 pathgen(name, path, sizeof(path)); 159 sector = NULL; 160 error = 0; 161 162 fd = open(path, O_RDONLY); 163 if (fd == -1) 164 return (errno); 165 mediasize = g_get_mediasize(name); 166 if (mediasize == 0) { 167 error = errno; 168 goto out; 169 } 170 sectorsize = g_get_sectorsize(name); 171 if (sectorsize == 0) { 172 error = errno; 173 goto out; 174 } 175 assert(sectorsize >= size); 176 sector = malloc(sectorsize); 177 if (sector == NULL) { 178 error = ENOMEM; 179 goto out; 180 } 181 if (pread(fd, sector, sectorsize, mediasize - sectorsize) != 182 (ssize_t)sectorsize) { 183 error = errno; 184 goto out; 185 } 186 if (magic != NULL) { 187 std_metadata_decode(sector, &stdmd); 188 if (strcmp(stdmd.md_magic, magic) != 0) { 189 error = EINVAL; 190 goto out; 191 } 192 } 193 bcopy(sector, md, size); 194 out: 195 if (sector != NULL) 196 free(sector); 197 close(fd); 198 return (error); 199 } 200 201 int 202 g_metadata_store(const char *name, u_char *md, size_t size) 203 { 204 char path[MAXPATHLEN]; 205 unsigned sectorsize; 206 off_t mediasize; 207 u_char *sector; 208 int error, fd; 209 210 pathgen(name, path, sizeof(path)); 211 sector = NULL; 212 error = 0; 213 214 fd = open(path, O_WRONLY); 215 if (fd == -1) 216 return (errno); 217 mediasize = g_get_mediasize(name); 218 if (mediasize == 0) { 219 error = errno; 220 goto out; 221 } 222 sectorsize = g_get_sectorsize(name); 223 if (sectorsize == 0) { 224 error = errno; 225 goto out; 226 } 227 assert(sectorsize >= size); 228 sector = malloc(sectorsize); 229 if (sector == NULL) { 230 error = ENOMEM; 231 goto out; 232 } 233 bcopy(md, sector, size); 234 if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != 235 (ssize_t)sectorsize) { 236 error = errno; 237 goto out; 238 } 239 (void)ioctl(fd, DIOCGFLUSH, NULL); 240 out: 241 if (sector != NULL) 242 free(sector); 243 close(fd); 244 return (error); 245 } 246 247 int 248 g_metadata_clear(const char *name, const char *magic) 249 { 250 struct std_metadata md; 251 char path[MAXPATHLEN]; 252 unsigned sectorsize; 253 off_t mediasize; 254 u_char *sector; 255 int error, fd; 256 257 pathgen(name, path, sizeof(path)); 258 sector = NULL; 259 error = 0; 260 261 fd = open(path, O_RDWR); 262 if (fd == -1) 263 return (errno); 264 mediasize = g_get_mediasize(name); 265 if (mediasize == 0) { 266 error = errno; 267 goto out; 268 } 269 sectorsize = g_get_sectorsize(name); 270 if (sectorsize == 0) { 271 error = errno; 272 goto out; 273 } 274 sector = malloc(sectorsize); 275 if (sector == NULL) { 276 error = ENOMEM; 277 goto out; 278 } 279 if (magic != NULL) { 280 if (pread(fd, sector, sectorsize, mediasize - sectorsize) != 281 (ssize_t)sectorsize) { 282 error = errno; 283 goto out; 284 } 285 std_metadata_decode(sector, &md); 286 if (strcmp(md.md_magic, magic) != 0) { 287 error = EINVAL; 288 goto out; 289 } 290 } 291 bzero(sector, sectorsize); 292 if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != 293 (ssize_t)sectorsize) { 294 error = errno; 295 goto out; 296 } 297 (void)ioctl(fd, DIOCGFLUSH, NULL); 298 out: 299 if (sector != NULL) 300 free(sector); 301 close(fd); 302 return (error); 303 } 304 305 /* 306 * Set an error message, if one does not already exist. 307 */ 308 void 309 gctl_error(struct gctl_req *req, const char *error, ...) 310 { 311 va_list ap; 312 313 if (req->error != NULL) 314 return; 315 va_start(ap, error); 316 vasprintf(&req->error, error, ap); 317 va_end(ap); 318 } 319 320 static void * 321 gctl_get_param(struct gctl_req *req, size_t len, const char *pfmt, va_list ap) 322 { 323 struct gctl_req_arg *argp; 324 char param[256]; 325 void *p; 326 unsigned i; 327 328 vsnprintf(param, sizeof(param), pfmt, ap); 329 for (i = 0; i < req->narg; i++) { 330 argp = &req->arg[i]; 331 if (strcmp(param, argp->name)) 332 continue; 333 if (!(argp->flag & GCTL_PARAM_RD)) 334 continue; 335 p = argp->value; 336 if (len == 0) { 337 /* We are looking for a string. */ 338 if (argp->len < 1) { 339 fprintf(stderr, "No length argument (%s).\n", 340 param); 341 abort(); 342 } 343 if (((char *)p)[argp->len - 1] != '\0') { 344 fprintf(stderr, "Unterminated argument (%s).\n", 345 param); 346 abort(); 347 } 348 } else if ((int)len != argp->len) { 349 fprintf(stderr, "Wrong length %s argument.\n", param); 350 abort(); 351 } 352 return (p); 353 } 354 fprintf(stderr, "No such argument (%s).\n", param); 355 abort(); 356 } 357 358 int 359 gctl_get_int(struct gctl_req *req, const char *pfmt, ...) 360 { 361 int *p; 362 va_list ap; 363 364 va_start(ap, pfmt); 365 p = gctl_get_param(req, sizeof(int), pfmt, ap); 366 va_end(ap); 367 return (*p); 368 } 369 370 intmax_t 371 gctl_get_intmax(struct gctl_req *req, const char *pfmt, ...) 372 { 373 intmax_t *p; 374 va_list ap; 375 376 va_start(ap, pfmt); 377 p = gctl_get_param(req, sizeof(intmax_t), pfmt, ap); 378 va_end(ap); 379 return (*p); 380 } 381 382 const char * 383 gctl_get_ascii(struct gctl_req *req, const char *pfmt, ...) 384 { 385 const char *p; 386 va_list ap; 387 388 va_start(ap, pfmt); 389 p = gctl_get_param(req, 0, pfmt, ap); 390 va_end(ap); 391 return (p); 392 } 393 394 int 395 gctl_change_param(struct gctl_req *req, const char *name, int len, 396 const void *value) 397 { 398 struct gctl_req_arg *ap; 399 unsigned i; 400 401 if (req == NULL || req->error != NULL) 402 return (EDOOFUS); 403 for (i = 0; i < req->narg; i++) { 404 ap = &req->arg[i]; 405 if (strcmp(ap->name, name) != 0) 406 continue; 407 ap->value = __DECONST(void *, value); 408 if (len >= 0) { 409 ap->flag &= ~GCTL_PARAM_ASCII; 410 ap->len = len; 411 } else if (len < 0) { 412 ap->flag |= GCTL_PARAM_ASCII; 413 ap->len = strlen(value) + 1; 414 } 415 return (0); 416 } 417 return (ENOENT); 418 } 419 420 int 421 gctl_delete_param(struct gctl_req *req, const char *name) 422 { 423 struct gctl_req_arg *ap; 424 unsigned int i; 425 426 if (req == NULL || req->error != NULL) 427 return (EDOOFUS); 428 429 i = 0; 430 while (i < req->narg) { 431 ap = &req->arg[i]; 432 if (strcmp(ap->name, name) == 0) 433 break; 434 i++; 435 } 436 if (i == req->narg) 437 return (ENOENT); 438 439 free(ap->name); 440 req->narg--; 441 while (i < req->narg) { 442 req->arg[i] = req->arg[i + 1]; 443 i++; 444 } 445 return (0); 446 } 447 448 int 449 gctl_has_param(struct gctl_req *req, const char *name) 450 { 451 struct gctl_req_arg *ap; 452 unsigned int i; 453 454 if (req == NULL || req->error != NULL) 455 return (0); 456 457 for (i = 0; i < req->narg; i++) { 458 ap = &req->arg[i]; 459 if (strcmp(ap->name, name) == 0) 460 return (1); 461 } 462 return (0); 463 } 464