1 /*- 2 * Copyright (c) 2004-2010 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 <limits.h> 40 #include <inttypes.h> 41 #include <stdarg.h> 42 #include <string.h> 43 #include <strings.h> 44 #include <unistd.h> 45 #include <assert.h> 46 #include <libgeom.h> 47 48 #include "misc/subr.h" 49 50 51 struct std_metadata { 52 char md_magic[16]; 53 uint32_t md_version; 54 }; 55 56 static void 57 std_metadata_decode(const unsigned char *data, struct std_metadata *md) 58 { 59 60 bcopy(data, md->md_magic, sizeof(md->md_magic)); 61 md->md_version = le32dec(data + 16); 62 } 63 64 /* 65 * Greatest Common Divisor. 66 */ 67 static unsigned int 68 gcd(unsigned int a, unsigned int b) 69 { 70 unsigned int c; 71 72 while (b != 0) { 73 c = a; 74 a = b; 75 b = (c % b); 76 } 77 return (a); 78 } 79 80 /* 81 * Least Common Multiple. 82 */ 83 unsigned int 84 g_lcm(unsigned int a, unsigned int b) 85 { 86 87 return ((a * b) / gcd(a, b)); 88 } 89 90 uint32_t 91 bitcount32(uint32_t x) 92 { 93 94 x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1); 95 x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2); 96 x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4); 97 x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8); 98 x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16); 99 return (x); 100 } 101 102 /* 103 * The size of a sector is context specific (i.e. determined by the 104 * media). But when users enter a value with a SI unit, they really 105 * mean the byte-size or byte-offset and not the size or offset in 106 * sectors. We should map the byte-oriented value into a sector-oriented 107 * value when we already know the sector size in bytes. At this time 108 * we can use g_parse_lba() function. It converts user specified 109 * value into sectors with following conditions: 110 * o Sectors size taken as argument from caller. 111 * o When no SI unit is specified the value is in sectors. 112 * o With an SI unit the value is in bytes. 113 * o The 'b' suffix forces byte interpretation and the 's' 114 * suffix forces sector interpretation. 115 * 116 * Thus: 117 * o 2 and 2s mean 2 sectors, and 2b means 2 bytes. 118 * o 4k and 4kb mean 4096 bytes, and 4ks means 4096 sectors. 119 * 120 */ 121 int 122 g_parse_lba(const char *lbastr, unsigned int sectorsize, off_t *sectors) 123 { 124 off_t number, mult, unit; 125 char *s; 126 127 assert(lbastr != NULL); 128 assert(sectorsize > 0); 129 assert(sectors != NULL); 130 131 number = (off_t)strtoimax(lbastr, &s, 0); 132 if (s == lbastr || number < 0) 133 return (EINVAL); 134 135 mult = 1; 136 unit = sectorsize; 137 if (*s == '\0') 138 goto done; 139 switch (*s) { 140 case 'e': case 'E': 141 mult *= 1024; 142 /* FALLTHROUGH */ 143 case 'p': case 'P': 144 mult *= 1024; 145 /* FALLTHROUGH */ 146 case 't': case 'T': 147 mult *= 1024; 148 /* FALLTHROUGH */ 149 case 'g': case 'G': 150 mult *= 1024; 151 /* FALLTHROUGH */ 152 case 'm': case 'M': 153 mult *= 1024; 154 /* FALLTHROUGH */ 155 case 'k': case 'K': 156 mult *= 1024; 157 break; 158 default: 159 goto sfx; 160 } 161 unit = 1; /* bytes */ 162 s++; 163 if (*s == '\0') 164 goto done; 165 sfx: 166 switch (*s) { 167 case 's': case 'S': 168 unit = sectorsize; /* sector */ 169 break; 170 case 'b': case 'B': 171 unit = 1; /* bytes */ 172 break; 173 default: 174 return (EINVAL); 175 } 176 s++; 177 if (*s != '\0') 178 return (EINVAL); 179 done: 180 if ((OFF_MAX / unit) < mult || (OFF_MAX / mult / unit) < number) 181 return (ERANGE); 182 number *= mult * unit; 183 if (number % sectorsize) 184 return (EINVAL); 185 number /= sectorsize; 186 *sectors = number; 187 return (0); 188 } 189 190 off_t 191 g_get_mediasize(const char *name) 192 { 193 off_t mediasize; 194 int fd; 195 196 fd = g_open(name, 0); 197 if (fd == -1) 198 return (0); 199 mediasize = g_mediasize(fd); 200 if (mediasize == -1) 201 mediasize = 0; 202 (void)g_close(fd); 203 return (mediasize); 204 } 205 206 unsigned int 207 g_get_sectorsize(const char *name) 208 { 209 ssize_t sectorsize; 210 int fd; 211 212 fd = g_open(name, 0); 213 if (fd == -1) 214 return (0); 215 sectorsize = g_sectorsize(fd); 216 if (sectorsize == -1) 217 sectorsize = 0; 218 (void)g_close(fd); 219 return ((unsigned int)sectorsize); 220 } 221 222 int 223 g_metadata_read(const char *name, unsigned char *md, size_t size, 224 const char *magic) 225 { 226 struct std_metadata stdmd; 227 unsigned char *sector; 228 ssize_t sectorsize; 229 off_t mediasize; 230 int error, fd; 231 232 sector = NULL; 233 error = 0; 234 235 fd = g_open(name, 0); 236 if (fd == -1) 237 return (errno); 238 mediasize = g_mediasize(fd); 239 if (mediasize == -1) { 240 error = errno; 241 goto out; 242 } 243 sectorsize = g_sectorsize(fd); 244 if (sectorsize == -1) { 245 error = errno; 246 goto out; 247 } 248 assert(sectorsize >= (ssize_t)size); 249 sector = malloc(sectorsize); 250 if (sector == NULL) { 251 error = ENOMEM; 252 goto out; 253 } 254 if (pread(fd, sector, sectorsize, mediasize - sectorsize) != 255 sectorsize) { 256 error = errno; 257 goto out; 258 } 259 if (magic != NULL) { 260 std_metadata_decode(sector, &stdmd); 261 if (strcmp(stdmd.md_magic, magic) != 0) { 262 error = EINVAL; 263 goto out; 264 } 265 } 266 bcopy(sector, md, size); 267 out: 268 if (sector != NULL) 269 free(sector); 270 g_close(fd); 271 return (error); 272 } 273 274 int 275 g_metadata_store(const char *name, const unsigned char *md, size_t size) 276 { 277 unsigned char *sector; 278 ssize_t sectorsize; 279 off_t mediasize; 280 int error, fd; 281 282 sector = NULL; 283 error = 0; 284 285 fd = g_open(name, 1); 286 if (fd == -1) 287 return (errno); 288 mediasize = g_mediasize(fd); 289 if (mediasize == -1) { 290 error = errno; 291 goto out; 292 } 293 sectorsize = g_sectorsize(fd); 294 if (sectorsize == -1) { 295 error = errno; 296 goto out; 297 } 298 assert(sectorsize >= (ssize_t)size); 299 sector = malloc(sectorsize); 300 if (sector == NULL) { 301 error = ENOMEM; 302 goto out; 303 } 304 bcopy(md, sector, size); 305 if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != 306 sectorsize) { 307 error = errno; 308 goto out; 309 } 310 (void)g_flush(fd); 311 out: 312 if (sector != NULL) 313 free(sector); 314 (void)g_close(fd); 315 return (error); 316 } 317 318 int 319 g_metadata_clear(const char *name, const char *magic) 320 { 321 struct std_metadata md; 322 unsigned char *sector; 323 ssize_t sectorsize; 324 off_t mediasize; 325 int error, fd; 326 327 sector = NULL; 328 error = 0; 329 330 fd = g_open(name, 1); 331 if (fd == -1) 332 return (errno); 333 mediasize = g_mediasize(fd); 334 if (mediasize == 0) { 335 error = errno; 336 goto out; 337 } 338 sectorsize = g_sectorsize(fd); 339 if (sectorsize == 0) { 340 error = errno; 341 goto out; 342 } 343 sector = malloc(sectorsize); 344 if (sector == NULL) { 345 error = ENOMEM; 346 goto out; 347 } 348 if (magic != NULL) { 349 if (pread(fd, sector, sectorsize, mediasize - sectorsize) != 350 sectorsize) { 351 error = errno; 352 goto out; 353 } 354 std_metadata_decode(sector, &md); 355 if (strcmp(md.md_magic, magic) != 0) { 356 error = EINVAL; 357 goto out; 358 } 359 } 360 bzero(sector, sectorsize); 361 if (pwrite(fd, sector, sectorsize, mediasize - sectorsize) != 362 sectorsize) { 363 error = errno; 364 goto out; 365 } 366 (void)g_flush(fd); 367 out: 368 if (sector != NULL) 369 free(sector); 370 g_close(fd); 371 return (error); 372 } 373 374 /* 375 * Set an error message, if one does not already exist. 376 */ 377 void 378 gctl_error(struct gctl_req *req, const char *error, ...) 379 { 380 va_list ap; 381 382 if (req->error != NULL) 383 return; 384 va_start(ap, error); 385 vasprintf(&req->error, error, ap); 386 va_end(ap); 387 } 388 389 static void * 390 gctl_get_param(struct gctl_req *req, size_t len, const char *pfmt, va_list ap) 391 { 392 struct gctl_req_arg *argp; 393 char param[256]; 394 unsigned int i; 395 void *p; 396 397 vsnprintf(param, sizeof(param), pfmt, ap); 398 for (i = 0; i < req->narg; i++) { 399 argp = &req->arg[i]; 400 if (strcmp(param, argp->name)) 401 continue; 402 if (!(argp->flag & GCTL_PARAM_RD)) 403 continue; 404 p = argp->value; 405 if (len == 0) { 406 /* We are looking for a string. */ 407 if (argp->len < 1) { 408 fprintf(stderr, "No length argument (%s).\n", 409 param); 410 abort(); 411 } 412 if (((char *)p)[argp->len - 1] != '\0') { 413 fprintf(stderr, "Unterminated argument (%s).\n", 414 param); 415 abort(); 416 } 417 } else if ((int)len != argp->len) { 418 fprintf(stderr, "Wrong length %s argument.\n", param); 419 abort(); 420 } 421 return (p); 422 } 423 fprintf(stderr, "No such argument (%s).\n", param); 424 abort(); 425 } 426 427 int 428 gctl_get_int(struct gctl_req *req, const char *pfmt, ...) 429 { 430 int *p; 431 va_list ap; 432 433 va_start(ap, pfmt); 434 p = gctl_get_param(req, sizeof(int), pfmt, ap); 435 va_end(ap); 436 return (*p); 437 } 438 439 intmax_t 440 gctl_get_intmax(struct gctl_req *req, const char *pfmt, ...) 441 { 442 intmax_t *p; 443 va_list ap; 444 445 va_start(ap, pfmt); 446 p = gctl_get_param(req, sizeof(intmax_t), pfmt, ap); 447 va_end(ap); 448 return (*p); 449 } 450 451 const char * 452 gctl_get_ascii(struct gctl_req *req, const char *pfmt, ...) 453 { 454 const char *p; 455 va_list ap; 456 457 va_start(ap, pfmt); 458 p = gctl_get_param(req, 0, pfmt, ap); 459 va_end(ap); 460 return (p); 461 } 462 463 int 464 gctl_change_param(struct gctl_req *req, const char *name, int len, 465 const void *value) 466 { 467 struct gctl_req_arg *ap; 468 unsigned int i; 469 470 if (req == NULL || req->error != NULL) 471 return (EDOOFUS); 472 for (i = 0; i < req->narg; i++) { 473 ap = &req->arg[i]; 474 if (strcmp(ap->name, name) != 0) 475 continue; 476 ap->value = __DECONST(void *, value); 477 if (len >= 0) { 478 ap->flag &= ~GCTL_PARAM_ASCII; 479 ap->len = len; 480 } else if (len < 0) { 481 ap->flag |= GCTL_PARAM_ASCII; 482 ap->len = strlen(value) + 1; 483 } 484 return (0); 485 } 486 return (ENOENT); 487 } 488 489 int 490 gctl_delete_param(struct gctl_req *req, const char *name) 491 { 492 struct gctl_req_arg *ap; 493 unsigned int i; 494 495 if (req == NULL || req->error != NULL) 496 return (EDOOFUS); 497 498 i = 0; 499 while (i < req->narg) { 500 ap = &req->arg[i]; 501 if (strcmp(ap->name, name) == 0) 502 break; 503 i++; 504 } 505 if (i == req->narg) 506 return (ENOENT); 507 508 free(ap->name); 509 req->narg--; 510 while (i < req->narg) { 511 req->arg[i] = req->arg[i + 1]; 512 i++; 513 } 514 return (0); 515 } 516 517 int 518 gctl_has_param(struct gctl_req *req, const char *name) 519 { 520 struct gctl_req_arg *ap; 521 unsigned int i; 522 523 if (req == NULL || req->error != NULL) 524 return (0); 525 526 for (i = 0; i < req->narg; i++) { 527 ap = &req->arg[i]; 528 if (strcmp(ap->name, name) == 0) 529 return (1); 530 } 531 return (0); 532 } 533