aosp源码分析 5.0 BlockImageUpdateFn

block_image_update("/dev/block/bootdevice/by-name/system", package_extract_file("system.transfer.list"), "system.new.dat", "system.patch.dat");

// args:

//    - block device (or file) to modify in-place

//    - transfer list (blob)

//    - new data stream (filename within package.zip)

//    - patch stream (filename within package.zip, must be uncompressed)

 

Value* BlockImageUpdateFn(const char* name, State* state, int argc, Expr* argv[]) {

    Value* blockdev_filename;

    Value* transfer_list_value;

    char* transfer_list = NULL;

    Value* new_data_fn;

    Value* patch_data_fn;

    bool success = false;

 

// 因为block_image_update中有类似package_extract_file("system.transfer.list")这种还需要执行

// 才能得到返回值的函数

// 在ReadValueArgs中利用va_list等C语言的可变参数宏，将block_image_update的四个输入参数

"/dev/block/bootdevice/by-name/system", package_extract_file("system.transfer.list"), "system.new.dat", "system.patch.dat"，分别赋值给blockdev_filename，transfer_list_value，new_data_fn，patch_data_fn

    if (ReadValueArgs(state, argv, 4, &blockdev_filename, &transfer_list_value,

                      &new_data_fn, &patch_data_fn) < 0) {

        return NULL;

    }

 

    if (blockdev_filename->type != VAL_STRING) {

        ErrorAbort(state, "blockdev_filename argument to %s must be string", name);

        goto done;

    }

//在package_extract_file("system.transfer.list"),中将type设为了VAL_BLOB

//BLOB (binary large object)，二进制大对象，是一个可以存储二进制文件的容器

BLOB是一个大文件，典型的BLOB是一张图片或一个声音文件，由于它们的尺寸，必须使用特殊的方式来处理（例如：上传、下载或者存放到一个数据库）

    if (transfer_list_value->type != VAL_BLOB) {

        ErrorAbort(state, "transfer_list argument to %s must be blob", name);

        goto done;

    }

    if (new_data_fn->type != VAL_STRING) {

        ErrorAbort(state, "new_data_fn argument to %s must be string", name);

        goto done;

    }

    if (patch_data_fn->type != VAL_STRING) {

        ErrorAbort(state, "patch_data_fn argument to %s must be string", name);

        goto done;

    }

 

（这里的ui是updater info的含义，而不是user interface）

    UpdaterInfo* ui = (UpdaterInfo*)(state->cookie);

    FILE* cmd_pipe = ui->cmd_pipe;

 

    ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip;

 

//patch_data_fn->data指向的是“system.patch.dat”这段字符串，而不是ystem.patch.dat这个文件的内容，

//因此patch_entry就代表内存中的zip安装包中的system.patch.dat这一项

    const ZipEntry* patch_entry = mzFindZipEntry(za, patch_data_fn->data);

    if (patch_entry == NULL) {

        ErrorAbort(state, "%s(): no file \"%s\" in package", name, patch_data_fn->data);

        goto done;

    }

 //计算出patch_entry的起始地址，因为注释中说patch stream must be uncompressed

    uint8_t* patch_start = ((UpdaterInfo*)(state->cookie))->package_zip_addr +

        mzGetZipEntryOffset(patch_entry);

 

//new_data_fn->data指向的数据是“system.new.dat”，而不是ystem.new.dat这个文件的内容，

    const ZipEntry* new_entry = mzFindZipEntry(za, new_data_fn->data);

    if (new_entry == NULL) {

        ErrorAbort(state, "%s(): no file \"%s\" in package", name, new_data_fn->data);

        goto done;

    }

 

    // The transfer list is a text file containing commands to

    // transfer data from one place to another on the target

    // partition.  We parse it and execute the commands in order:

    //

    //    zero [rangeset]

    //      - fill the indicated blocks with zeros

    //

    //    new [rangeset]

    //      - fill the blocks with data read from the new_data file

    //

    //    bsdiff patchstart patchlen [src rangeset] [tgt rangeset]

    //    imgdiff patchstart patchlen [src rangeset] [tgt rangeset]

    //      - read the source blocks, apply a patch, write result to

    //        target blocks.  bsdiff or imgdiff specifies the type of

    //        patch.

    //

    //    move [src rangeset] [tgt rangeset]

    //      - copy data from source blocks to target blocks (no patch

    //        needed; rangesets are the same size)

    //

    //    erase [rangeset]

    //      - mark the given blocks as empty

    //

    // The creator of the transfer list will guarantee that no block

    // is read (ie, used as the source for a patch or move) after it

    // has been written.

    //

    // Within one command the source and target ranges may overlap so

    // in general we need to read the entire source into memory before

    // writing anything to the target blocks.

    //

    // All the patch data is concatenated into one patch_data file in

    // the update package.  It must be stored uncompressed because we

    // memory-map it in directly from the archive.  (Since patches are

    // already compressed, we lose very little by not compressing

    // their concatenation.)

 

    pthread_t new_data_thread;

// we expand the new data from the archive in a

// background thread, and block that threads 'receive uncompressed

// data' function until the main thread has reached a point where we

// want some new data to be written. We signal the background thread

// with the destination for the data and block the main thread,

// waiting for the background thread to complete writing that section.

// Then it signals the main thread to wake up and goes back to

// blocking waiting for a transfer.

//

// NewThreadInfo is the struct used to pass information back and forth

// between the two threads. When the main thread wants some data

// written, it sets rss to the destination location and signals the

// condition. When the background thread is done writing, it clears

// rss and signals the condition again.

typedef struct {

ZipArchive* za;

const ZipEntry* entry;

RangeSinkState* rss;

pthread_mutex_t mu;

pthread_cond_t cv;

} NewThreadInfo;

    NewThreadInfo nti;

    nti.za = za;

    nti.entry = new_entry;

    nti.rss = NULL; //先将rss标记置空

    pthread_mutex_init(&nti.mu, NULL); //互斥锁的初始化

    pthread_cond_init(&nti.cv, NULL); //创建一个条件变量，cv就是condition value的意思

 extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));

　　其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指 针。结构 pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，默认值是 PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用

    pthread_attr_t attr; //线程具有属性,用pthread_attr_t表示,在对该结构进行处理之前必须进行初始化，我们用pthread_attr_init函数对其初始化，用pthread_attr_destroy对其去除初始化

    pthread_attr_init(&attr);

//pthread_attr_setdetachstate修改线程的分离状态属性，可以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。

    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

//pthread_create的四个参数：1指向线程标识符的指针 2 设置线程属性 3 线程运行函数的起始地址 4 运行函数的参数。

    pthread_create(&new_data_thread, &attr, unzip_new_data, &nti);

 

    int i, j;

 

    char* linesave;

    char* wordsave;

 

    int fd = open(blockdev_filename->data, O_RDWR);

    if (fd < 0) {

        ErrorAbort(state, "failed to open %s: %s", blockdev_filename->data, strerror(errno));

        goto done;

    }

 

    char* line;

    char* word;

 

    // The data in transfer_list_value is not necessarily

    // null-terminated, so we need to copy it to a new buffer and add

    // the null that strtok_r will need.

// char* transfer_list = NULL;

    transfer_list = malloc(transfer_list_value->size+1);

    if (transfer_list == NULL) {

        fprintf(stderr, "failed to allocate %zd bytes for transfer list\n",

                transfer_list_value->size+1);

        exit(1);

    }

//将system.transfer.list文件的所有内容读取到了transfer_list中

    memcpy(transfer_list, transfer_list_value->data, transfer_list_value->size);

    transfer_list[transfer_list_value->size] = '\0';

  //按行分割读取system.transfer.list中的命令

    line = strtok_r(transfer_list, "\n", &linesave);

 

    // first line in transfer list is the version number; currently

    // there's only version 1.

// recovery 5.0对应的api是1

    if (strcmp(line, "1") != 0) {

        ErrorAbort(state, "unexpected transfer list version [%s]\n", line);

        goto done;

    }

 

    // second line in transfer list is the total number of blocks we

    // expect to write.

    line = strtok_r(NULL, "\n", &linesave);

    int total_blocks = strtol(line, NULL, 0);

    // shouldn't happen, but avoid divide by zero.避免除以0

    if (total_blocks == 0) ++total_blocks;

    int blocks_so_far = 0;

 

    uint8_t* buffer = NULL;

    size_t buffer_alloc = 0;

 

    // third and subsequent lines are all individual transfer commands.

// 在这个for循环中依次读取每行命令

    for (line = strtok_r(NULL, "\n", &linesave); line;

         line = strtok_r(NULL, "\n", &linesave)) {

// style代表每行前的命令名称，如move，bsdiff等

        char* style;

        style = strtok_r(line, " ", &wordsave);

 

        if (strcmp("move", style) == 0) {

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* src = parse_range(word);

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* tgt = parse_range(word);

 

            printf("  moving %d blocks\n", src->size);

 

            allocate(src->size * BLOCKSIZE, &buffer, &buffer_alloc);

            size_t p = 0;

            for (i = 0; i < src->count; ++i) {

                check_lseek(fd, (off64_t)src->pos[i*2] * BLOCKSIZE, SEEK_SET);

                size_t sz = (src->pos[i*2+1] - src->pos[i*2]) * BLOCKSIZE;

                readblock(fd, buffer+p, sz);

                p += sz;

            }

 

            p = 0;

            for (i = 0; i < tgt->count; ++i) {

                check_lseek(fd, (off64_t)tgt->pos[i*2] * BLOCKSIZE, SEEK_SET);

                size_t sz = (tgt->pos[i*2+1] - tgt->pos[i*2]) * BLOCKSIZE;

                writeblock(fd, buffer+p, sz);

                p += sz;

            }

 

            blocks_so_far += tgt->size;

            fprintf(cmd_pipe, "set_progress %.4f\n", (double)blocks_so_far / total_blocks);

            fflush(cmd_pipe);

 

            free(src);

            free(tgt);

 

        } else if (strcmp("zero", style) == 0 ||

                   (DEBUG_ERASE && strcmp("erase", style) == 0)) {

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* tgt = parse_range(word);

 

            printf("  zeroing %d blocks\n", tgt->size);

 

            allocate(BLOCKSIZE, &buffer, &buffer_alloc);

            memset(buffer, 0, BLOCKSIZE);

            for (i = 0; i < tgt->count; ++i) {

                check_lseek(fd, (off64_t)tgt->pos[i*2] * BLOCKSIZE, SEEK_SET);

                for (j = tgt->pos[i*2]; j < tgt->pos[i*2+1]; ++j) {

                    writeblock(fd, buffer, BLOCKSIZE);

                }

            }

 

            if (style[0] == 'z') {   // "zero" but not "erase"

                blocks_so_far += tgt->size;

                fprintf(cmd_pipe, "set_progress %.4f\n", (double)blocks_so_far / total_blocks);

                fflush(cmd_pipe);

            }

 

            free(tgt);

        } else if (strcmp("new", style) == 0) {

 

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* tgt = parse_range(word);

 

            printf("  writing %d blocks of new data\n", tgt->size);

 

            RangeSinkState rss;

            rss.fd = fd;

            rss.tgt = tgt;

            rss.p_block = 0;

            rss.p_remain = (tgt->pos[1] - tgt->pos[0]) * BLOCKSIZE;

            check_lseek(fd, (off64_t)tgt->pos[0] * BLOCKSIZE, SEEK_SET);

 

            pthread_mutex_lock(&nti.mu);

            nti.rss = &rss;

            pthread_cond_broadcast(&nti.cv);

            while (nti.rss) {

                pthread_cond_wait(&nti.cv, &nti.mu);

            }

            pthread_mutex_unlock(&nti.mu);

 

            blocks_so_far += tgt->size;

            fprintf(cmd_pipe, "set_progress %.4f\n", (double)blocks_so_far / total_blocks);

            fflush(cmd_pipe);

 

            free(tgt);

 

        } else if (strcmp("bsdiff", style) == 0 ||

                   strcmp("imgdiff", style) == 0) {

            word = strtok_r(NULL, " ", &wordsave);

            size_t patch_offset = strtoul(word, NULL, 0);

            word = strtok_r(NULL, " ", &wordsave);

            size_t patch_len = strtoul(word, NULL, 0);

 

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* src = parse_range(word);

            word = strtok_r(NULL, " ", &wordsave);

            RangeSet* tgt = parse_range(word);

 

            printf("  patching %d blocks to %d\n", src->size, tgt->size);

 

            // Read the source into memory.

            allocate(src->size * BLOCKSIZE, &buffer, &buffer_alloc);

            size_t p = 0;

            for (i = 0; i < src->count; ++i) {

                check_lseek(fd, (off64_t)src->pos[i*2] * BLOCKSIZE, SEEK_SET);

                size_t sz = (src->pos[i*2+1] - src->pos[i*2]) * BLOCKSIZE;

                readblock(fd, buffer+p, sz);

                p += sz;

            }

 

            Value patch_value;

            patch_value.type = VAL_BLOB;

            patch_value.size = patch_len;

            patch_value.data = (char*)(patch_start + patch_offset);

 

            RangeSinkState rss;

            rss.fd = fd;

            rss.tgt = tgt;

            rss.p_block = 0;

            rss.p_remain = (tgt->pos[1] - tgt->pos[0]) * BLOCKSIZE;

            check_lseek(fd, (off64_t)tgt->pos[0] * BLOCKSIZE, SEEK_SET);

 

            if (style[0] == 'i') {      // imgdiff

                ApplyImagePatch(buffer, src->size * BLOCKSIZE,

                                &patch_value,

                                &RangeSinkWrite, &rss, NULL, NULL);

            } else {

                ApplyBSDiffPatch(buffer, src->size * BLOCKSIZE,

                                 &patch_value, 0,

                                 &RangeSinkWrite, &rss, NULL);

            }

 

            // We expect the output of the patcher to fill the tgt ranges exactly.

            if (rss.p_block != tgt->count || rss.p_remain != 0) {

                fprintf(stderr, "range sink underrun?\n");

            }

 

            blocks_so_far += tgt->size;

            fprintf(cmd_pipe, "set_progress %.4f\n", (double)blocks_so_far / total_blocks);

            fflush(cmd_pipe);

 

            free(src);

            free(tgt);

        } else if (!DEBUG_ERASE && strcmp("erase", style) == 0) {

            struct stat st;

            if (fstat(fd, &st) == 0 && S_ISBLK(st.st_mode)) {

                word = strtok_r(NULL, " ", &wordsave);

                RangeSet* tgt = parse_range(word);

 

                printf("  erasing %d blocks\n", tgt->size);

 

                for (i = 0; i < tgt->count; ++i) {

                    uint64_t range[2];

                    // offset in bytes

                    range[0] = tgt->pos[i*2] * (uint64_t)BLOCKSIZE;

                    // len in bytes

                    range[1] = (tgt->pos[i*2+1] - tgt->pos[i*2]) * (uint64_t)BLOCKSIZE;

 

                    if (ioctl(fd, BLKDISCARD, &range) < 0) {

                        printf("    blkdiscard failed: %s\n", strerror(errno));

                    }

                }

 

                free(tgt);

            } else {

                printf("  ignoring erase (not block device)\n");

            }

        } else {

            fprintf(stderr, "unknown transfer style \"%s\"\n", style);

            exit(1);

        }

    }

 

    pthread_join(new_data_thread, NULL);

    success = true;

 

    free(buffer);

    printf("wrote %d blocks; expected %d\n", blocks_so_far, total_blocks);

    printf("max alloc needed was %zu\n", buffer_alloc);

 

  done:

    free(transfer_list);

    FreeValue(blockdev_filename);

    FreeValue(transfer_list_value);

    FreeValue(new_data_fn);

    FreeValue(patch_data_fn);

    return StringValue(success ? strdup("t") : strdup(""));

}