engine.c revision 230d160a718333651f7ca1557404f96682795b37
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#ifndef USE_MINGW 44#include <sys/mman.h> 45#endif 46 47 48extern struct fs_info info; 49 50#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 51 52double now() 53{ 54 struct timeval tv; 55 gettimeofday(&tv, NULL); 56 return (double)tv.tv_sec + (double)tv.tv_usec / 1000000; 57} 58 59char *mkmsg(const char *fmt, ...) 60{ 61 char buf[256]; 62 char *s; 63 va_list ap; 64 65 va_start(ap, fmt); 66 vsprintf(buf, fmt, ap); 67 va_end(ap); 68 69 s = strdup(buf); 70 if (s == 0) die("out of memory"); 71 return s; 72} 73 74#define OP_DOWNLOAD 1 75#define OP_COMMAND 2 76#define OP_QUERY 3 77#define OP_NOTICE 4 78#define OP_FORMAT 5 79 80typedef struct Action Action; 81 82#define CMD_SIZE 64 83 84struct Action 85{ 86 unsigned op; 87 Action *next; 88 89 char cmd[CMD_SIZE]; 90 const char *prod; 91 void *data; 92 unsigned size; 93 94 const char *msg; 95 int (*func)(Action *a, int status, char *resp); 96 97 double start; 98}; 99 100static Action *action_list = 0; 101static Action *action_last = 0; 102 103 104struct image_data { 105 long long partition_size; 106 long long image_size; // real size of image file 107 void *buffer; 108}; 109 110void generate_ext4_image(struct image_data *image); 111void cleanup_image(struct image_data *image); 112 113struct generator { 114 char *fs_type; 115 116 /* generate image and return it as image->buffer. 117 * size of the buffer returned as image->image_size. 118 * 119 * image->partition_size specifies what is the size of the 120 * file partition we generate image for. 121 */ 122 void (*generate)(struct image_data *image); 123 124 /* it cleans the buffer allocated during image creation. 125 * this function probably does free() or munmap(). 126 */ 127 void (*cleanup)(struct image_data *image); 128} generators[] = { 129 { "ext4", generate_ext4_image, cleanup_image } 130}; 131 132static int cb_default(Action *a, int status, char *resp) 133{ 134 if (status) { 135 fprintf(stderr,"FAILED (%s)\n", resp); 136 } else { 137 double split = now(); 138 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); 139 a->start = split; 140 } 141 return status; 142} 143 144static Action *queue_action(unsigned op, const char *fmt, ...) 145{ 146 Action *a; 147 va_list ap; 148 size_t cmdsize; 149 150 a = calloc(1, sizeof(Action)); 151 if (a == 0) die("out of memory"); 152 153 va_start(ap, fmt); 154 cmdsize = vsnprintf(a->cmd, sizeof(a->cmd), fmt, ap); 155 va_end(ap); 156 157 if (cmdsize >= sizeof(a->cmd)) { 158 free(a); 159 die("Command length (%d) exceeds maximum size (%d)", cmdsize, sizeof(a->cmd)); 160 } 161 162 if (action_last) { 163 action_last->next = a; 164 } else { 165 action_list = a; 166 } 167 action_last = a; 168 a->op = op; 169 a->func = cb_default; 170 171 a->start = -1; 172 173 return a; 174} 175 176void fb_queue_erase(const char *ptn) 177{ 178 Action *a; 179 a = queue_action(OP_COMMAND, "erase:%s", ptn); 180 a->msg = mkmsg("erasing '%s'", ptn); 181} 182 183/* Loads file content into buffer. Returns NULL on error. */ 184static void *load_buffer(int fd, off_t size) 185{ 186 void *buffer; 187 188#ifdef USE_MINGW 189 ssize_t count = 0; 190 191 // mmap is more efficient but mingw does not support it. 192 // In this case we read whole image into memory buffer. 193 buffer = malloc(size); 194 if (!buffer) { 195 perror("malloc"); 196 return NULL; 197 } 198 199 while(count < size) { 200 ssize_t actually_read = pread(fd, (char*)buffer+count, size-count, count); 201 202 if (actually_read == 0) { 203 break; 204 } 205 if (actually_read < 0) { 206 if (errno == EINTR) { 207 continue; 208 } 209 perror("read"); 210 free(buffer); 211 return NULL; 212 } 213 214 count += actually_read; 215 } 216#else 217 buffer = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); 218 if (buffer == MAP_FAILED) { 219 perror("mmap"); 220 return NULL; 221 } 222#endif 223 224 return buffer; 225} 226 227void cleanup_image(struct image_data *image) 228{ 229#ifdef USE_MINGW 230 free(image->buffer); 231#else 232 munmap(image->buffer, image->image_size); 233#endif 234} 235 236void generate_ext4_image(struct image_data *image) 237{ 238 int fd; 239 struct stat st; 240 241 fd = fileno(tmpfile()); 242 info.len = image->partition_size; 243 make_ext4fs_internal(fd, NULL, NULL, 0, 0, 1, 0, 0, 0); 244 245 fstat(fd, &st); 246 image->image_size = st.st_size; 247 image->buffer = load_buffer(fd, st.st_size); 248 249 close(fd); 250} 251 252int fb_format(Action *a, usb_handle *usb) 253{ 254 const char *partition = a->cmd; 255 char query[256]; 256 char response[FB_RESPONSE_SZ+1]; 257 int status = 0; 258 struct image_data image; 259 struct generator *generator = NULL; 260 int fd; 261 unsigned i; 262 char cmd[CMD_SIZE]; 263 264 response[FB_RESPONSE_SZ] = '\0'; 265 snprintf(query, sizeof(query), "getvar:partition-type:%s", partition); 266 status = fb_command_response(usb, query, response); 267 if (status) { 268 fprintf(stderr,"FAILED (%s)\n", fb_get_error()); 269 return status; 270 } 271 272 for (i = 0; i < ARRAY_SIZE(generators); i++) { 273 if (!strncmp(generators[i].fs_type, response, FB_RESPONSE_SZ)) { 274 generator = &generators[i]; 275 break; 276 } 277 } 278 if (!generator) { 279 fprintf(stderr,"Formatting is not supported for filesystem with type '%s'.\n", 280 response); 281 return -1; 282 } 283 284 response[FB_RESPONSE_SZ] = '\0'; 285 snprintf(query, sizeof(query), "getvar:partition-size:%s", partition); 286 status = fb_command_response(usb, query, response); 287 if (status) { 288 fprintf(stderr,"FAILED (%s)\n", fb_get_error()); 289 return status; 290 } 291 image.partition_size = strtoll(response, (char **)NULL, 16); 292 293 generator->generate(&image); 294 if (!image.buffer) { 295 fprintf(stderr,"Cannot generate image.\n"); 296 return -1; 297 } 298 299 // Following piece of code is similar to fb_queue_flash() but executes 300 // actions directly without queuing 301 fprintf(stderr, "sending '%s' (%lli KB)...\n", partition, image.image_size/1024); 302 status = fb_download_data(usb, image.buffer, image.image_size); 303 if (status) goto cleanup; 304 305 fprintf(stderr, "writing '%s'...\n", partition); 306 snprintf(cmd, CMD_SIZE, "flash:%s", partition); 307 status = fb_command(usb, cmd); 308 if (status) goto cleanup; 309 310cleanup: 311 generator->cleanup(&image); 312 313 return status; 314} 315 316void fb_queue_format(const char *partition) 317{ 318 Action *a; 319 320 a = queue_action(OP_FORMAT, partition); 321 a->msg = mkmsg("formatting '%s' partition", partition); 322} 323 324void fb_queue_flash(const char *ptn, void *data, unsigned sz) 325{ 326 Action *a; 327 328 a = queue_action(OP_DOWNLOAD, ""); 329 a->data = data; 330 a->size = sz; 331 a->msg = mkmsg("sending '%s' (%d KB)", ptn, sz / 1024); 332 333 a = queue_action(OP_COMMAND, "flash:%s", ptn); 334 a->msg = mkmsg("writing '%s'", ptn); 335} 336 337static int match(char *str, const char **value, unsigned count) 338{ 339 const char *val; 340 unsigned n; 341 int len; 342 343 for (n = 0; n < count; n++) { 344 const char *val = value[n]; 345 int len = strlen(val); 346 int match; 347 348 if ((len > 1) && (val[len-1] == '*')) { 349 len--; 350 match = !strncmp(val, str, len); 351 } else { 352 match = !strcmp(val, str); 353 } 354 355 if (match) return 1; 356 } 357 358 return 0; 359} 360 361 362 363static int cb_check(Action *a, int status, char *resp, int invert) 364{ 365 const char **value = a->data; 366 unsigned count = a->size; 367 unsigned n; 368 int yes; 369 370 if (status) { 371 fprintf(stderr,"FAILED (%s)\n", resp); 372 return status; 373 } 374 375 if (a->prod) { 376 if (strcmp(a->prod, cur_product) != 0) { 377 double split = now(); 378 fprintf(stderr,"IGNORE, product is %s required only for %s [%7.3fs]\n", 379 cur_product, a->prod, (split - a->start)); 380 a->start = split; 381 return 0; 382 } 383 } 384 385 yes = match(resp, value, count); 386 if (invert) yes = !yes; 387 388 if (yes) { 389 double split = now(); 390 fprintf(stderr,"OKAY [%7.3fs]\n", (split - a->start)); 391 a->start = split; 392 return 0; 393 } 394 395 fprintf(stderr,"FAILED\n\n"); 396 fprintf(stderr,"Device %s is '%s'.\n", a->cmd + 7, resp); 397 fprintf(stderr,"Update %s '%s'", 398 invert ? "rejects" : "requires", value[0]); 399 for (n = 1; n < count; n++) { 400 fprintf(stderr," or '%s'", value[n]); 401 } 402 fprintf(stderr,".\n\n"); 403 return -1; 404} 405 406static int cb_require(Action *a, int status, char *resp) 407{ 408 return cb_check(a, status, resp, 0); 409} 410 411static int cb_reject(Action *a, int status, char *resp) 412{ 413 return cb_check(a, status, resp, 1); 414} 415 416void fb_queue_require(const char *prod, const char *var, 417 int invert, unsigned nvalues, const char **value) 418{ 419 Action *a; 420 a = queue_action(OP_QUERY, "getvar:%s", var); 421 a->prod = prod; 422 a->data = value; 423 a->size = nvalues; 424 a->msg = mkmsg("checking %s", var); 425 a->func = invert ? cb_reject : cb_require; 426 if (a->data == 0) die("out of memory"); 427} 428 429static int cb_display(Action *a, int status, char *resp) 430{ 431 if (status) { 432 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp); 433 return status; 434 } 435 fprintf(stderr, "%s: %s\n", (char*) a->data, resp); 436 return 0; 437} 438 439void fb_queue_display(const char *var, const char *prettyname) 440{ 441 Action *a; 442 a = queue_action(OP_QUERY, "getvar:%s", var); 443 a->data = strdup(prettyname); 444 if (a->data == 0) die("out of memory"); 445 a->func = cb_display; 446} 447 448static int cb_save(Action *a, int status, char *resp) 449{ 450 if (status) { 451 fprintf(stderr, "%s FAILED (%s)\n", a->cmd, resp); 452 return status; 453 } 454 strncpy(a->data, resp, a->size); 455 return 0; 456} 457 458void fb_queue_query_save(const char *var, char *dest, unsigned dest_size) 459{ 460 Action *a; 461 a = queue_action(OP_QUERY, "getvar:%s", var); 462 a->data = (void *)dest; 463 a->size = dest_size; 464 a->func = cb_save; 465} 466 467static int cb_do_nothing(Action *a, int status, char *resp) 468{ 469 fprintf(stderr,"\n"); 470 return 0; 471} 472 473void fb_queue_reboot(void) 474{ 475 Action *a = queue_action(OP_COMMAND, "reboot"); 476 a->func = cb_do_nothing; 477 a->msg = "rebooting"; 478} 479 480void fb_queue_command(const char *cmd, const char *msg) 481{ 482 Action *a = queue_action(OP_COMMAND, cmd); 483 a->msg = msg; 484} 485 486void fb_queue_download(const char *name, void *data, unsigned size) 487{ 488 Action *a = queue_action(OP_DOWNLOAD, ""); 489 a->data = data; 490 a->size = size; 491 a->msg = mkmsg("downloading '%s'", name); 492} 493 494void fb_queue_notice(const char *notice) 495{ 496 Action *a = queue_action(OP_NOTICE, ""); 497 a->data = (void*) notice; 498} 499 500int fb_execute_queue(usb_handle *usb) 501{ 502 Action *a; 503 char resp[FB_RESPONSE_SZ+1]; 504 int status = 0; 505 506 a = action_list; 507 resp[FB_RESPONSE_SZ] = 0; 508 509 double start = -1; 510 for (a = action_list; a; a = a->next) { 511 a->start = now(); 512 if (start < 0) start = a->start; 513 if (a->msg) { 514 // fprintf(stderr,"%30s... ",a->msg); 515 fprintf(stderr,"%s...\n",a->msg); 516 } 517 if (a->op == OP_DOWNLOAD) { 518 status = fb_download_data(usb, a->data, a->size); 519 status = a->func(a, status, status ? fb_get_error() : ""); 520 if (status) break; 521 } else if (a->op == OP_COMMAND) { 522 status = fb_command(usb, a->cmd); 523 status = a->func(a, status, status ? fb_get_error() : ""); 524 if (status) break; 525 } else if (a->op == OP_QUERY) { 526 status = fb_command_response(usb, a->cmd, resp); 527 status = a->func(a, status, status ? fb_get_error() : resp); 528 if (status) break; 529 } else if (a->op == OP_NOTICE) { 530 fprintf(stderr,"%s\n",(char*)a->data); 531 } else if (a->op == OP_FORMAT) { 532 status = fb_format(a, usb); 533 status = a->func(a, status, status ? fb_get_error() : ""); 534 if (status) break; 535 } else { 536 die("bogus action"); 537 } 538 } 539 540 fprintf(stderr,"finished. total time: %.3fs\n", (now() - start)); 541 return status; 542} 543