engine.c revision 80f2d036a9dff894df27961c4aed300f1a5ebbc4
1/* 2 * Copyright (C) 2008 The Android Open Source Project 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 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include "fastboot.h" 30#include "make_ext4fs.h" 31#include "ext4_utils.h" 32 33#include <stdio.h> 34#include <stdlib.h> 35#include <stdarg.h> 36#include <stdbool.h> 37#include <string.h> 38#include <sys/stat.h> 39#include <sys/time.h> 40#include <sys/types.h> 41#include <unistd.h> 42 43#ifdef USE_MINGW 44#include <fcntl.h> 45#else 46#include <sys/mman.h> 47#endif 48 49extern struct fs_info info; 50 51#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 52 53double now() 54{ 55 struct timeval tv; 56 gettimeofday(&tv, NULL); 57 return (double)tv.tv_sec + (double)tv.tv_usec / 1000000; 58} 59 60char *mkmsg(const char *fmt, ...) 61{ 62 char buf[256]; 63 char *s; 64 va_list ap; 65 66 va_start(ap, fmt); 67 vsprintf(buf, fmt, ap); 68 va_end(ap); 69 70 s = strdup(buf); 71 if (s == 0) die("out of memory"); 72 return s; 73} 74 75#define OP_DOWNLOAD 1 76#define OP_COMMAND 2 77#define OP_QUERY 3 78#define OP_NOTICE 4 79#define OP_FORMAT 5 80 81typedef struct Action Action; 82 83#define CMD_SIZE 64 84 85struct Action 86{ 87 unsigned op; 88 Action *next; 89 90 char cmd[CMD_SIZE]; 91 const char *prod; 92 void *data; 93 unsigned size; 94 95 const char *msg; 96 int (*func)(Action *a, int status, char *resp); 97 98 double start; 99}; 100 101static Action *action_list = 0; 102static Action *action_last = 0; 103 104 105struct image_data { 106 long long partition_size; 107 long long image_size; // real size of image file 108 void *buffer; 109}; 110 111void generate_ext4_image(struct image_data *image); 112void cleanup_image(struct image_data *image); 113 114int fb_getvar(struct usb_handle *usb, char *response, const char *fmt, ...) 115{ 116 char cmd[CMD_SIZE] = "getvar:"; 117 int getvar_len = strlen(cmd); 118 va_list args; 119 120 response[FB_RESPONSE_SZ] = '\0'; 121 va_start(args, fmt); 122 vsnprintf(cmd + getvar_len, sizeof(cmd) - getvar_len, fmt, args); 123 va_end(args); 124 cmd[CMD_SIZE - 1] = '\0'; 125 return fb_command_response(usb, cmd, response); 126} 127 128struct generator { 129 char *fs_type; 130 131 /* generate image and return it as image->buffer. 132 * size of the buffer returned as image->image_size. 133 * 134 * image->partition_size specifies what is the size of the 135 * file partition we generate image for. 136 */ 137 void (*generate)(struct image_data *image); 138 139 /* it cleans the buffer allocated during image creation. 140 * this function probably does free() or munmap(). 141 */ 142 void (*cleanup)(struct image_data *image); 143} generators[] = { 144 { "ext4", generate_ext4_image, cleanup_image } 145}; 146 147static int cb_default(Action *a, int status, char *resp) 148{ 149 if (status) { 150 fprintf(stderr,"FAILED (%s)\n", resp); 151 } else { 152 double split = now(); 153 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); 154 a->start = split; 155 } 156 return status; 157} 158 159static Action *queue_action(unsigned op, const char *fmt, ...) 160{ 161 Action *a; 162 va_list ap; 163 size_t cmdsize; 164 165 a = calloc(1, sizeof(Action)); 166 if (a == 0) die("out of memory"); 167 168 va_start(ap, fmt); 169 cmdsize = vsnprintf(a->cmd, sizeof(a->cmd), fmt, ap); 170 va_end(ap); 171 172 if (cmdsize >= sizeof(a->cmd)) { 173 free(a); 174 die("Command length (%d) exceeds maximum size (%d)", cmdsize, sizeof(a->cmd)); 175 } 176 177 if (action_last) { 178 action_last->next = a; 179 } else { 180 action_list = a; 181 } 182 action_last = a; 183 a->op = op; 184 a->func = cb_default; 185 186 a->start = -1; 187 188 return a; 189} 190 191void fb_queue_erase(const char *ptn) 192{ 193 Action *a; 194 a = queue_action(OP_COMMAND, "erase:%s", ptn); 195 a->msg = mkmsg("erasing '%s'", ptn); 196} 197 198/* Loads file content into buffer. Returns NULL on error. */ 199static void *load_buffer(int fd, off_t size) 200{ 201 void *buffer; 202 203#ifdef USE_MINGW 204 ssize_t count = 0; 205 206 // mmap is more efficient but mingw does not support it. 207 // In this case we read whole image into memory buffer. 208 buffer = malloc(size); 209 if (!buffer) { 210 perror("malloc"); 211 return NULL; 212 } 213 214 lseek(fd, 0, SEEK_SET); 215 while(count < size) { 216 ssize_t actually_read = read(fd, (char*)buffer+count, size-count); 217 218 if (actually_read == 0) { 219 break; 220 } 221 if (actually_read < 0) { 222 if (errno == EINTR) { 223 continue; 224 } 225 perror("read"); 226 free(buffer); 227 return NULL; 228 } 229 230 count += actually_read; 231 } 232#else 233 buffer = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); 234 if (buffer == MAP_FAILED) { 235 perror("mmap"); 236 return NULL; 237 } 238#endif 239 240 return buffer; 241} 242 243void cleanup_image(struct image_data *image) 244{ 245#ifdef USE_MINGW 246 free(image->buffer); 247#else 248 munmap(image->buffer, image->image_size); 249#endif 250} 251 252void generate_ext4_image(struct image_data *image) 253{ 254 int fd; 255 struct stat st; 256 257#ifdef USE_MINGW 258 /* Ideally we should use tmpfile() here, the same as with unix version. 259 * But unfortunately it is not portable as it is not clear whether this 260 * function opens file in TEXT or BINARY mode. 261 * 262 * There are also some reports it is buggy: 263 * http://pdplab.it.uom.gr/teaching/gcc_manuals/gnulib.html#tmpfile 264 * http://www.mega-nerd.com/erikd/Blog/Windiots/tmpfile.html 265 */ 266 char *filename = tempnam(getenv("TEMP"), "fastboot-format.img"); 267 fd = open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0644); 268 unlink(filename); 269#else 270 fd = fileno(tmpfile()); 271#endif 272 /* reset ext4fs info so we can be called multiple times */ 273 reset_ext4fs_info(); 274 info.len = image->partition_size; 275 make_ext4fs_internal(fd, NULL, NULL, NULL, 0, 1, 0, 0, 0, NULL); 276 277 fstat(fd, &st); 278 image->image_size = st.st_size; 279 image->buffer = load_buffer(fd, st.st_size); 280 281 close(fd); 282} 283 284int fb_format(Action *a, usb_handle *usb, int skip_if_not_supported) 285{ 286 const char *partition = a->cmd; 287 char response[FB_RESPONSE_SZ+1]; 288 int status = 0; 289 struct image_data image; 290 struct generator *generator = NULL; 291 int fd; 292 unsigned i; 293 char cmd[CMD_SIZE]; 294 295 status = fb_getvar(usb, response, "partition-type:%s", partition); 296 if (status) { 297 if (skip_if_not_supported) { 298 fprintf(stderr, 299 "Erase successful, but not automatically formatting.\n"); 300 fprintf(stderr, 301 "Can't determine partition type.\n"); 302 return 0; 303 } 304 fprintf(stderr,"FAILED (%s)\n", fb_get_error()); 305 return status; 306 } 307 308 for (i = 0; i < ARRAY_SIZE(generators); i++) { 309 if (!strncmp(generators[i].fs_type, response, FB_RESPONSE_SZ)) { 310 generator = &generators[i]; 311 break; 312 } 313 } 314 if (!generator) { 315 if (skip_if_not_supported) { 316 fprintf(stderr, 317 "Erase successful, but not automatically formatting.\n"); 318 fprintf(stderr, 319 "File system type %s not supported.\n", response); 320 return 0; 321 } 322 fprintf(stderr,"Formatting is not supported for filesystem with type '%s'.\n", 323 response); 324 return -1; 325 } 326 327 status = fb_getvar(usb, response, "partition-size:%s", partition); 328 if (status) { 329 if (skip_if_not_supported) { 330 fprintf(stderr, 331 "Erase successful, but not automatically formatting.\n"); 332 fprintf(stderr, "Unable to get partition size\n."); 333 return 0; 334 } 335 fprintf(stderr,"FAILED (%s)\n", fb_get_error()); 336 return status; 337 } 338 image.partition_size = strtoll(response, (char **)NULL, 16); 339 340 generator->generate(&image); 341 if (!image.buffer) { 342 fprintf(stderr,"Cannot generate image.\n"); 343 return -1; 344 } 345 346 // Following piece of code is similar to fb_queue_flash() but executes 347 // actions directly without queuing 348 fprintf(stderr, "sending '%s' (%lli KB)...\n", partition, image.image_size/1024); 349 status = fb_download_data(usb, image.buffer, image.image_size); 350 if (status) goto cleanup; 351 352 fprintf(stderr, "writing '%s'...\n", partition); 353 snprintf(cmd, sizeof(cmd), "flash:%s", partition); 354 status = fb_command(usb, cmd); 355 if (status) goto cleanup; 356 357cleanup: 358 generator->cleanup(&image); 359 360 return status; 361} 362 363void fb_queue_format(const char *partition, int skip_if_not_supported) 364{ 365 Action *a; 366 367 a = queue_action(OP_FORMAT, partition); 368 a->data = (void*)skip_if_not_supported; 369 a->msg = mkmsg("formatting '%s' partition", partition); 370} 371 372void fb_queue_flash(const char *ptn, void *data, unsigned sz) 373{ 374 Action *a; 375 376 a = queue_action(OP_DOWNLOAD, ""); 377 a->data = data; 378 a->size = sz; 379 a->msg = mkmsg("sending '%s' (%d KB)", ptn, sz / 1024); 380 381 a = queue_action(OP_COMMAND, "flash:%s", ptn); 382 a->msg = mkmsg("writing '%s'", ptn); 383} 384 385static int match(char *str, const char **value, unsigned count) 386{ 387 const char *val; 388 unsigned n; 389 int len; 390 391 for (n = 0; n < count; n++) { 392 const char *val = value[n]; 393 int len = strlen(val); 394 int match; 395 396 if ((len > 1) && (val[len-1] == '*')) { 397 len--; 398 match = !strncmp(val, str, len); 399 } else { 400 match = !strcmp(val, str); 401 } 402 403 if (match) return 1; 404 } 405 406 return 0; 407} 408 409 410 411static int cb_check(Action *a, int status, char *resp, int invert) 412{ 413 const char **value = a->data; 414 unsigned count = a->size; 415 unsigned n; 416 int yes; 417 418 if (status) { 419 fprintf(stderr,"FAILED (%s)\n", resp); 420 return status; 421 } 422 423 if (a->prod) { 424 if (strcmp(a->prod, cur_product) != 0) { 425 double split = now(); 426 fprintf(stderr,"IGNORE, product is %s required only for %s [%7.3fs]\n", 427 cur_product, a->prod, (split - a->start)); 428 a->start = split; 429 return 0; 430 } 431 } 432 433 yes = match(resp, value, count); 434 if (invert) yes = !yes; 435 436 if (yes) { 437 double split = now(); 438 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); 439 a->start = split; 440 return 0; 441 } 442 443 fprintf(stderr,"FAILED\n\n"); 444 fprintf(stderr,"Device %s is '%s'.\n", a->cmd + 7, resp); 445 fprintf(stderr,"Update %s '%s'", 446 invert ? "rejects" : "requires", value[0]); 447 for (n = 1; n < count; n++) { 448 fprintf(stderr," or '%s'", value[n]); 449 } 450 fprintf(stderr,".\n\n"); 451 return -1; 452} 453 454static int cb_require(Action *a, int status, char *resp) 455{ 456 return cb_check(a, status, resp, 0); 457} 458 459static int cb_reject(Action *a, int status, char *resp) 460{ 461 return cb_check(a, status, resp, 1); 462} 463 464void fb_queue_require(const char *prod, const char *var, 465 int invert, unsigned nvalues, const char **value) 466{ 467 Action *a; 468 a = queue_action(OP_QUERY, "getvar:%s", var); 469 a->prod = prod; 470 a->data = value; 471 a->size = nvalues; 472 a->msg = mkmsg("checking %s", var); 473 a->func = invert ? cb_reject : cb_require; 474 if (a->data == 0) die("out of memory"); 475} 476 477static int cb_display(Action *a, int status, char *resp) 478{ 479 if (status) { 480 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp); 481 return status; 482 } 483 fprintf(stderr, "%s: %s\n", (char*) a->data, resp); 484 return 0; 485} 486 487void fb_queue_display(const char *var, const char *prettyname) 488{ 489 Action *a; 490 a = queue_action(OP_QUERY, "getvar:%s", var); 491 a->data = strdup(prettyname); 492 if (a->data == 0) die("out of memory"); 493 a->func = cb_display; 494} 495 496static int cb_save(Action *a, int status, char *resp) 497{ 498 if (status) { 499 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp); 500 return status; 501 } 502 strncpy(a->data, resp, a->size); 503 return 0; 504} 505 506void fb_queue_query_save(const char *var, char *dest, unsigned dest_size) 507{ 508 Action *a; 509 a = queue_action(OP_QUERY, "getvar:%s", var); 510 a->data = (void *)dest; 511 a->size = dest_size; 512 a->func = cb_save; 513} 514 515static int cb_do_nothing(Action *a, int status, char *resp) 516{ 517 fprintf(stderr,"\n"); 518 return 0; 519} 520 521void fb_queue_reboot(void) 522{ 523 Action *a = queue_action(OP_COMMAND, "reboot"); 524 a->func = cb_do_nothing; 525 a->msg = "rebooting"; 526} 527 528void fb_queue_command(const char *cmd, const char *msg) 529{ 530 Action *a = queue_action(OP_COMMAND, cmd); 531 a->msg = msg; 532} 533 534void fb_queue_download(const char *name, void *data, unsigned size) 535{ 536 Action *a = queue_action(OP_DOWNLOAD, ""); 537 a->data = data; 538 a->size = size; 539 a->msg = mkmsg("downloading '%s'", name); 540} 541 542void fb_queue_notice(const char *notice) 543{ 544 Action *a = queue_action(OP_NOTICE, ""); 545 a->data = (void*) notice; 546} 547 548int fb_execute_queue(usb_handle *usb) 549{ 550 Action *a; 551 char resp[FB_RESPONSE_SZ+1]; 552 int status = 0; 553 554 a = action_list; 555 resp[FB_RESPONSE_SZ] = 0; 556 557 double start = -1; 558 for (a = action_list; a; a = a->next) { 559 a->start = now(); 560 if (start < 0) start = a->start; 561 if (a->msg) { 562 // fprintf(stderr,"%30s... ",a->msg); 563 fprintf(stderr,"%s...\n",a->msg); 564 } 565 if (a->op == OP_DOWNLOAD) { 566 status = fb_download_data(usb, a->data, a->size); 567 status = a->func(a, status, status ? fb_get_error() : ""); 568 if (status) break; 569 } else if (a->op == OP_COMMAND) { 570 status = fb_command(usb, a->cmd); 571 status = a->func(a, status, status ? fb_get_error() : ""); 572 if (status) break; 573 } else if (a->op == OP_QUERY) { 574 status = fb_command_response(usb, a->cmd, resp); 575 status = a->func(a, status, status ? fb_get_error() : resp); 576 if (status) break; 577 } else if (a->op == OP_NOTICE) { 578 fprintf(stderr,"%s\n",(char*)a->data); 579 } else if (a->op == OP_FORMAT) { 580 status = fb_format(a, usb, (int)a->data); 581 status = a->func(a, status, status ? fb_get_error() : ""); 582 if (status) break; 583 } else { 584 die("bogus action"); 585 } 586 } 587 588 fprintf(stderr,"finished. total time: %.3fs\n", (now() - start)); 589 return status; 590} 591