1 /*
2 * Copyright (c) 2013, The Linux Foundation. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above
10 * copyright notice, this list of conditions and the following
11 * disclaimer in the documentation and/or other materials provided
12 * with the distribution.
13 * * Neither the name of The Linux Foundation nor the names of its
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #define _LARGEFILE64_SOURCE /* enable lseek64() */
31
32 /******************************************************************************
33 * INCLUDE SECTION
34 ******************************************************************************/
35 #include <stdio.h>
36 #include <fcntl.h>
37 #include <string.h>
38 #include <errno.h>
39 #include <sys/stat.h>
40 #include <sys/ioctl.h>
41 #include <scsi/ufs/ioctl.h>
42 #include <scsi/ufs/ufs.h>
43 #include <unistd.h>
44 #include <linux/fs.h>
45 #include <limits.h>
46 #include <dirent.h>
47 #include <inttypes.h>
48 #include <linux/kernel.h>
49 #include <asm/byteorder.h>
50 #include <map>
51 #include <vector>
52 #include <string>
53 #define LOG_TAG "gpt-utils"
54 #include <cutils/log.h>
55 #include <cutils/properties.h>
56 #include "gpt-utils.h"
57 #ifdef __cplusplus
58 extern "C" {
59 #endif
60 #include "sparse_crc32.h"
61 #ifdef __cplusplus
62 }
63 #endif
64 #include <endian.h>
65
66
67 /******************************************************************************
68 * DEFINE SECTION
69 ******************************************************************************/
70 #define BLK_DEV_FILE "/dev/block/mmcblk0"
71 /* list the names of the backed-up partitions to be swapped */
72 /* extension used for the backup partitions - tzbak, abootbak, etc. */
73 #define BAK_PTN_NAME_EXT "bak"
74 #define XBL_PRIMARY "/dev/block/bootdevice/by-name/xbl"
75 #define XBL_BACKUP "/dev/block/bootdevice/by-name/xblbak"
76 #define XBL_AB_PRIMARY "/dev/block/bootdevice/by-name/xbl_a"
77 #define XBL_AB_SECONDARY "/dev/block/bootdevice/by-name/xbl_b"
78 /* GPT defines */
79 #define MAX_LUNS 26
80 //Size of the buffer that needs to be passed to the UFS ioctl
81 #define UFS_ATTR_DATA_SIZE 32
82 //This will allow us to get the root lun path from the path to the partition.
83 //i.e: from /dev/block/sdaXXX get /dev/block/sda. The assumption here is that
84 //the boot critical luns lie between sda to sdz which is acceptable because
85 //only user added external disks,etc would lie beyond that limit which do not
86 //contain partitions that interest us here.
87 #define PATH_TRUNCATE_LOC (sizeof("/dev/block/sda") - 1)
88
89 //From /dev/block/sda get just sda
90 #define LUN_NAME_START_LOC (sizeof("/dev/block/") - 1)
91 #define BOOT_LUN_A_ID 1
92 #define BOOT_LUN_B_ID 2
93 /******************************************************************************
94 * MACROS
95 ******************************************************************************/
96
97
98 #define GET_4_BYTES(ptr) ((uint32_t) *((uint8_t *)(ptr)) | \
99 ((uint32_t) *((uint8_t *)(ptr) + 1) << 8) | \
100 ((uint32_t) *((uint8_t *)(ptr) + 2) << 16) | \
101 ((uint32_t) *((uint8_t *)(ptr) + 3) << 24))
102
103 #define GET_8_BYTES(ptr) ((uint64_t) *((uint8_t *)(ptr)) | \
104 ((uint64_t) *((uint8_t *)(ptr) + 1) << 8) | \
105 ((uint64_t) *((uint8_t *)(ptr) + 2) << 16) | \
106 ((uint64_t) *((uint8_t *)(ptr) + 3) << 24) | \
107 ((uint64_t) *((uint8_t *)(ptr) + 4) << 32) | \
108 ((uint64_t) *((uint8_t *)(ptr) + 5) << 40) | \
109 ((uint64_t) *((uint8_t *)(ptr) + 6) << 48) | \
110 ((uint64_t) *((uint8_t *)(ptr) + 7) << 56))
111
112 #define PUT_4_BYTES(ptr, y) *((uint8_t *)(ptr)) = (y) & 0xff; \
113 *((uint8_t *)(ptr) + 1) = ((y) >> 8) & 0xff; \
114 *((uint8_t *)(ptr) + 2) = ((y) >> 16) & 0xff; \
115 *((uint8_t *)(ptr) + 3) = ((y) >> 24) & 0xff;
116
117 /******************************************************************************
118 * TYPES
119 ******************************************************************************/
120 using namespace std;
121 enum gpt_state {
122 GPT_OK = 0,
123 GPT_BAD_SIGNATURE,
124 GPT_BAD_CRC
125 };
126 //List of LUN's containing boot critical images.
127 //Required in the case of UFS devices
128 struct update_data {
129 char lun_list[MAX_LUNS][PATH_MAX];
130 uint32_t num_valid_entries;
131 };
132
133 /******************************************************************************
134 * FUNCTIONS
135 ******************************************************************************/
136 /**
137 * ==========================================================================
138 *
139 * \brief Read/Write len bytes from/to block dev
140 *
141 * \param [in] fd block dev file descriptor (returned from open)
142 * \param [in] rw RW flag: 0 - read, != 0 - write
143 * \param [in] offset block dev offset [bytes] - RW start position
144 * \param [in] buf Pointer to the buffer containing the data
145 * \param [in] len RW size in bytes. Buf must be at least that big
146 *
147 * \return 0 on success
148 *
149 * ==========================================================================
150 */
blk_rw(int fd,int rw,int64_t offset,uint8_t * buf,unsigned len)151 static int blk_rw(int fd, int rw, int64_t offset, uint8_t *buf, unsigned len)
152 {
153 int r;
154
155 if (lseek64(fd, offset, SEEK_SET) < 0) {
156 fprintf(stderr, "block dev lseek64 %" PRIi64 " failed: %s\n", offset,
157 strerror(errno));
158 return -1;
159 }
160
161 if (rw)
162 r = write(fd, buf, len);
163 else
164 r = read(fd, buf, len);
165
166 if (r < 0)
167 fprintf(stderr, "block dev %s failed: %s\n", rw ? "write" : "read",
168 strerror(errno));
169 else
170 r = 0;
171
172 return r;
173 }
174
175
176
177 /**
178 * ==========================================================================
179 *
180 * \brief Search within GPT for partition entry with the given name
181 * or it's backup twin (name-bak).
182 *
183 * \param [in] ptn_name Partition name to seek
184 * \param [in] pentries_start Partition entries array start pointer
185 * \param [in] pentries_end Partition entries array end pointer
186 * \param [in] pentry_size Single partition entry size [bytes]
187 *
188 * \return First partition entry pointer that matches the name or NULL
189 *
190 * ==========================================================================
191 */
gpt_pentry_seek(const char * ptn_name,const uint8_t * pentries_start,const uint8_t * pentries_end,uint32_t pentry_size)192 static uint8_t *gpt_pentry_seek(const char *ptn_name,
193 const uint8_t *pentries_start,
194 const uint8_t *pentries_end,
195 uint32_t pentry_size)
196 {
197 char *pentry_name;
198 unsigned len = strlen(ptn_name);
199
200 for (pentry_name = (char *) (pentries_start + PARTITION_NAME_OFFSET);
201 pentry_name < (char *) pentries_end; pentry_name += pentry_size) {
202 char name8[MAX_GPT_NAME_SIZE / 2];
203 unsigned i;
204
205 /* Partition names in GPT are UTF-16 - ignoring UTF-16 2nd byte */
206 for (i = 0; i < sizeof(name8); i++)
207 name8[i] = pentry_name[i * 2];
208 if (!strncmp(ptn_name, name8, len))
209 if (name8[len] == 0 || !strcmp(&name8[len], BAK_PTN_NAME_EXT))
210 return (uint8_t *) (pentry_name - PARTITION_NAME_OFFSET);
211 }
212
213 return NULL;
214 }
215
216
217
218 /**
219 * ==========================================================================
220 *
221 * \brief Swaps boot chain in GPT partition entries array
222 *
223 * \param [in] pentries_start Partition entries array start
224 * \param [in] pentries_end Partition entries array end
225 * \param [in] pentry_size Single partition entry size
226 *
227 * \return 0 on success, 1 if no backup partitions found
228 *
229 * ==========================================================================
230 */
gpt_boot_chain_swap(const uint8_t * pentries_start,const uint8_t * pentries_end,uint32_t pentry_size)231 static int gpt_boot_chain_swap(const uint8_t *pentries_start,
232 const uint8_t *pentries_end,
233 uint32_t pentry_size)
234 {
235 const char ptn_swap_list[][MAX_GPT_NAME_SIZE] = { PTN_SWAP_LIST };
236
237 int backup_not_found = 1;
238 unsigned i;
239
240 for (i = 0; i < ARRAY_SIZE(ptn_swap_list); i++) {
241 uint8_t *ptn_entry;
242 uint8_t *ptn_bak_entry;
243 uint8_t ptn_swap[PTN_ENTRY_SIZE];
244 //Skip the xbl partition on UFS devices. That is handled
245 //seperately.
246 if (gpt_utils_is_ufs_device() && !strncmp(ptn_swap_list[i],
247 PTN_XBL,
248 strlen(PTN_XBL)))
249 continue;
250
251 ptn_entry = gpt_pentry_seek(ptn_swap_list[i], pentries_start,
252 pentries_end, pentry_size);
253 if (ptn_entry == NULL)
254 continue;
255
256 ptn_bak_entry = gpt_pentry_seek(ptn_swap_list[i],
257 ptn_entry + pentry_size, pentries_end, pentry_size);
258 if (ptn_bak_entry == NULL) {
259 fprintf(stderr, "'%s' partition not backup - skip safe update\n",
260 ptn_swap_list[i]);
261 continue;
262 }
263
264 /* swap primary <-> backup partition entries */
265 memcpy(ptn_swap, ptn_entry, PTN_ENTRY_SIZE);
266 memcpy(ptn_entry, ptn_bak_entry, PTN_ENTRY_SIZE);
267 memcpy(ptn_bak_entry, ptn_swap, PTN_ENTRY_SIZE);
268 backup_not_found = 0;
269 }
270
271 return backup_not_found;
272 }
273
274
275
276 /**
277 * ==========================================================================
278 *
279 * \brief Sets secondary GPT boot chain
280 *
281 * \param [in] fd block dev file descriptor
282 * \param [in] boot Boot chain to switch to
283 *
284 * \return 0 on success
285 *
286 * ==========================================================================
287 */
gpt2_set_boot_chain(int fd,enum boot_chain boot)288 static int gpt2_set_boot_chain(int fd, enum boot_chain boot)
289 {
290 int64_t gpt2_header_offset;
291 uint64_t pentries_start_offset;
292 uint32_t gpt_header_size;
293 uint32_t pentry_size;
294 uint32_t pentries_array_size;
295
296 uint8_t *gpt_header = NULL;
297 uint8_t *pentries = NULL;
298 uint32_t crc;
299 uint32_t blk_size = 0;
300 int r;
301
302 if (ioctl(fd, BLKSSZGET, &blk_size) != 0) {
303 fprintf(stderr, "Failed to get GPT device block size: %s\n",
304 strerror(errno));
305 r = -1;
306 goto EXIT;
307 }
308 gpt_header = (uint8_t*)malloc(blk_size);
309 if (!gpt_header) {
310 fprintf(stderr, "Failed to allocate memory to hold GPT block\n");
311 r = -1;
312 goto EXIT;
313 }
314 gpt2_header_offset = lseek64(fd, 0, SEEK_END) - blk_size;
315 if (gpt2_header_offset < 0) {
316 fprintf(stderr, "Getting secondary GPT header offset failed: %s\n",
317 strerror(errno));
318 r = -1;
319 goto EXIT;
320 }
321
322 /* Read primary GPT header from block dev */
323 r = blk_rw(fd, 0, blk_size, gpt_header, blk_size);
324
325 if (r) {
326 fprintf(stderr, "Failed to read primary GPT header from blk dev\n");
327 goto EXIT;
328 }
329 pentries_start_offset =
330 GET_8_BYTES(gpt_header + PENTRIES_OFFSET) * blk_size;
331 pentry_size = GET_4_BYTES(gpt_header + PENTRY_SIZE_OFFSET);
332 pentries_array_size =
333 GET_4_BYTES(gpt_header + PARTITION_COUNT_OFFSET) * pentry_size;
334
335 pentries = (uint8_t *) calloc(1, pentries_array_size);
336 if (pentries == NULL) {
337 fprintf(stderr,
338 "Failed to alloc memory for GPT partition entries array\n");
339 r = -1;
340 goto EXIT;
341 }
342 /* Read primary GPT partititon entries array from block dev */
343 r = blk_rw(fd, 0, pentries_start_offset, pentries, pentries_array_size);
344 if (r)
345 goto EXIT;
346
347 crc = sparse_crc32(0, pentries, pentries_array_size);
348 if (GET_4_BYTES(gpt_header + PARTITION_CRC_OFFSET) != crc) {
349 fprintf(stderr, "Primary GPT partition entries array CRC invalid\n");
350 r = -1;
351 goto EXIT;
352 }
353
354 /* Read secondary GPT header from block dev */
355 r = blk_rw(fd, 0, gpt2_header_offset, gpt_header, blk_size);
356 if (r)
357 goto EXIT;
358
359 gpt_header_size = GET_4_BYTES(gpt_header + HEADER_SIZE_OFFSET);
360 pentries_start_offset =
361 GET_8_BYTES(gpt_header + PENTRIES_OFFSET) * blk_size;
362
363 if (boot == BACKUP_BOOT) {
364 r = gpt_boot_chain_swap(pentries, pentries + pentries_array_size,
365 pentry_size);
366 if (r)
367 goto EXIT;
368 }
369
370 crc = sparse_crc32(0, pentries, pentries_array_size);
371 PUT_4_BYTES(gpt_header + PARTITION_CRC_OFFSET, crc);
372
373 /* header CRC is calculated with this field cleared */
374 PUT_4_BYTES(gpt_header + HEADER_CRC_OFFSET, 0);
375 crc = sparse_crc32(0, gpt_header, gpt_header_size);
376 PUT_4_BYTES(gpt_header + HEADER_CRC_OFFSET, crc);
377
378 /* Write the modified GPT header back to block dev */
379 r = blk_rw(fd, 1, gpt2_header_offset, gpt_header, blk_size);
380 if (!r)
381 /* Write the modified GPT partititon entries array back to block dev */
382 r = blk_rw(fd, 1, pentries_start_offset, pentries,
383 pentries_array_size);
384
385 EXIT:
386 if(gpt_header)
387 free(gpt_header);
388 if (pentries)
389 free(pentries);
390 return r;
391 }
392
393 /**
394 * ==========================================================================
395 *
396 * \brief Checks GPT state (header signature and CRC)
397 *
398 * \param [in] fd block dev file descriptor
399 * \param [in] gpt GPT header to be checked
400 * \param [out] state GPT header state
401 *
402 * \return 0 on success
403 *
404 * ==========================================================================
405 */
gpt_get_state(int fd,enum gpt_instance gpt,enum gpt_state * state)406 static int gpt_get_state(int fd, enum gpt_instance gpt, enum gpt_state *state)
407 {
408 int64_t gpt_header_offset;
409 uint32_t gpt_header_size;
410 uint8_t *gpt_header = NULL;
411 uint32_t crc;
412 uint32_t blk_size = 0;
413
414 *state = GPT_OK;
415
416 if (ioctl(fd, BLKSSZGET, &blk_size) != 0) {
417 fprintf(stderr, "Failed to get GPT device block size: %s\n",
418 strerror(errno));
419 goto error;
420 }
421 gpt_header = (uint8_t*)malloc(blk_size);
422 if (!gpt_header) {
423 fprintf(stderr, "gpt_get_state:Failed to alloc memory for header\n");
424 goto error;
425 }
426 if (gpt == PRIMARY_GPT)
427 gpt_header_offset = blk_size;
428 else {
429 gpt_header_offset = lseek64(fd, 0, SEEK_END) - blk_size;
430 if (gpt_header_offset < 0) {
431 fprintf(stderr, "gpt_get_state:Seek to end of GPT part fail\n");
432 goto error;
433 }
434 }
435
436 if (blk_rw(fd, 0, gpt_header_offset, gpt_header, blk_size)) {
437 fprintf(stderr, "gpt_get_state: blk_rw failed\n");
438 goto error;
439 }
440 if (memcmp(gpt_header, GPT_SIGNATURE, sizeof(GPT_SIGNATURE)))
441 *state = GPT_BAD_SIGNATURE;
442 gpt_header_size = GET_4_BYTES(gpt_header + HEADER_SIZE_OFFSET);
443
444 crc = GET_4_BYTES(gpt_header + HEADER_CRC_OFFSET);
445 /* header CRC is calculated with this field cleared */
446 PUT_4_BYTES(gpt_header + HEADER_CRC_OFFSET, 0);
447 if (sparse_crc32(0, gpt_header, gpt_header_size) != crc)
448 *state = GPT_BAD_CRC;
449 free(gpt_header);
450 return 0;
451 error:
452 if (gpt_header)
453 free(gpt_header);
454 return -1;
455 }
456
457
458
459 /**
460 * ==========================================================================
461 *
462 * \brief Sets GPT header state (used to corrupt and fix GPT signature)
463 *
464 * \param [in] fd block dev file descriptor
465 * \param [in] gpt GPT header to be checked
466 * \param [in] state GPT header state to set (GPT_OK or GPT_BAD_SIGNATURE)
467 *
468 * \return 0 on success
469 *
470 * ==========================================================================
471 */
gpt_set_state(int fd,enum gpt_instance gpt,enum gpt_state state)472 static int gpt_set_state(int fd, enum gpt_instance gpt, enum gpt_state state)
473 {
474 int64_t gpt_header_offset;
475 uint32_t gpt_header_size;
476 uint8_t *gpt_header = NULL;
477 uint32_t crc;
478 uint32_t blk_size = 0;
479
480 if (ioctl(fd, BLKSSZGET, &blk_size) != 0) {
481 fprintf(stderr, "Failed to get GPT device block size: %s\n",
482 strerror(errno));
483 goto error;
484 }
485 gpt_header = (uint8_t*)malloc(blk_size);
486 if (!gpt_header) {
487 fprintf(stderr, "Failed to alloc memory for gpt header\n");
488 goto error;
489 }
490 if (gpt == PRIMARY_GPT)
491 gpt_header_offset = blk_size;
492 else {
493 gpt_header_offset = lseek64(fd, 0, SEEK_END) - blk_size;
494 if (gpt_header_offset < 0) {
495 fprintf(stderr, "Failed to seek to end of GPT device\n");
496 goto error;
497 }
498 }
499 if (blk_rw(fd, 0, gpt_header_offset, gpt_header, blk_size)) {
500 fprintf(stderr, "Failed to r/w gpt header\n");
501 goto error;
502 }
503 if (state == GPT_OK)
504 memcpy(gpt_header, GPT_SIGNATURE, sizeof(GPT_SIGNATURE));
505 else if (state == GPT_BAD_SIGNATURE)
506 *gpt_header = 0;
507 else {
508 fprintf(stderr, "gpt_set_state: Invalid state\n");
509 goto error;
510 }
511
512 gpt_header_size = GET_4_BYTES(gpt_header + HEADER_SIZE_OFFSET);
513
514 /* header CRC is calculated with this field cleared */
515 PUT_4_BYTES(gpt_header + HEADER_CRC_OFFSET, 0);
516 crc = sparse_crc32(0, gpt_header, gpt_header_size);
517 PUT_4_BYTES(gpt_header + HEADER_CRC_OFFSET, crc);
518
519 if (blk_rw(fd, 1, gpt_header_offset, gpt_header, blk_size)) {
520 fprintf(stderr, "gpt_set_state: blk write failed\n");
521 goto error;
522 }
523 return 0;
524 error:
525 if(gpt_header)
526 free(gpt_header);
527 return -1;
528 }
529
get_scsi_node_from_bootdevice(const char * bootdev_path,char * sg_node_path,size_t buf_size)530 int get_scsi_node_from_bootdevice(const char *bootdev_path,
531 char *sg_node_path,
532 size_t buf_size)
533 {
534 char sg_dir_path[PATH_MAX] = {0};
535 char real_path[PATH_MAX] = {0};
536 DIR *scsi_dir = NULL;
537 struct dirent *de;
538 int node_found = 0;
539 if (!bootdev_path || !sg_node_path) {
540 fprintf(stderr, "%s : invalid argument\n",
541 __func__);
542 goto error;
543 }
544 if (readlink(bootdev_path, real_path, sizeof(real_path) - 1) < 0) {
545 fprintf(stderr, "failed to resolve link for %s(%s)\n",
546 bootdev_path,
547 strerror(errno));
548 goto error;
549 }
550 if(strlen(real_path) < PATH_TRUNCATE_LOC + 1){
551 fprintf(stderr, "Unrecognized path :%s:\n",
552 real_path);
553 goto error;
554 }
555 //For the safe side in case there are additional partitions on
556 //the XBL lun we truncate the name.
557 real_path[PATH_TRUNCATE_LOC] = '\0';
558 if(strlen(real_path) < LUN_NAME_START_LOC + 1){
559 fprintf(stderr, "Unrecognized truncated path :%s:\n",
560 real_path);
561 goto error;
562 }
563 //This will give us /dev/block/sdb/device/scsi_generic
564 //which contains a file sgY whose name gives us the path
565 //to /dev/sgY which we return
566 snprintf(sg_dir_path, sizeof(sg_dir_path) - 1,
567 "/sys/block/%s/device/scsi_generic",
568 &real_path[LUN_NAME_START_LOC]);
569 scsi_dir = opendir(sg_dir_path);
570 if (!scsi_dir) {
571 fprintf(stderr, "%s : Failed to open %s(%s)\n",
572 __func__,
573 sg_dir_path,
574 strerror(errno));
575 goto error;
576 }
577 while((de = readdir(scsi_dir))) {
578 if (de->d_name[0] == '.')
579 continue;
580 else if (!strncmp(de->d_name, "sg", 2)) {
581 snprintf(sg_node_path,
582 buf_size -1,
583 "/dev/%s",
584 de->d_name);
585 fprintf(stderr, "%s:scsi generic node is :%s:\n",
586 __func__,
587 sg_node_path);
588 node_found = 1;
589 break;
590 }
591 }
592 if(!node_found) {
593 fprintf(stderr,"%s: Unable to locate scsi generic node\n",
594 __func__);
595 goto error;
596 }
597 closedir(scsi_dir);
598 return 0;
599 error:
600 if (scsi_dir)
601 closedir(scsi_dir);
602 return -1;
603 }
604
set_boot_lun(char * sg_dev,uint8_t boot_lun_id)605 int set_boot_lun(char *sg_dev, uint8_t boot_lun_id)
606 {
607 int fd = -1;
608 int rc;
609 struct ufs_ioctl_query_data *data = NULL;
610 size_t ioctl_data_size = sizeof(struct ufs_ioctl_query_data) + UFS_ATTR_DATA_SIZE;
611
612 data = (struct ufs_ioctl_query_data*)malloc(ioctl_data_size);
613 if (!data) {
614 fprintf(stderr, "%s: Failed to alloc query data struct\n",
615 __func__);
616 goto error;
617 }
618 memset(data, 0, ioctl_data_size);
619 data->opcode = UPIU_QUERY_OPCODE_WRITE_ATTR;
620 data->idn = QUERY_ATTR_IDN_BOOT_LU_EN;
621 data->buf_size = UFS_ATTR_DATA_SIZE;
622 data->buffer[0] = boot_lun_id;
623 fd = open(sg_dev, O_RDWR);
624 if (fd < 0) {
625 fprintf(stderr, "%s: Failed to open %s(%s)\n",
626 __func__,
627 sg_dev,
628 strerror(errno));
629 goto error;
630 }
631 rc = ioctl(fd, UFS_IOCTL_QUERY, data);
632 if (rc) {
633 fprintf(stderr, "%s: UFS query ioctl failed(%s)\n",
634 __func__,
635 strerror(errno));
636 goto error;
637 }
638 close(fd);
639 free(data);
640 return 0;
641 error:
642 if (fd >= 0)
643 close(fd);
644 if (data)
645 free(data);
646 return -1;
647 }
648
649 //Swtich betwieen using either the primary or the backup
650 //boot LUN for boot. This is required since UFS boot partitions
651 //cannot have a backup GPT which is what we use for failsafe
652 //updates of the other 'critical' partitions. This function will
653 //not be invoked for emmc targets and on UFS targets is only required
654 //to be invoked for XBL.
655 //
656 //The algorithm to do this is as follows:
657 //- Find the real block device(eg: /dev/block/sdb) that corresponds
658 // to the /dev/block/bootdevice/by-name/xbl(bak) symlink
659 //
660 //- Once we have the block device 'node' name(sdb in the above example)
661 // use this node to to locate the scsi generic device that represents
662 // it by checking the file /sys/block/sdb/device/scsi_generic/sgY
663 //
664 //- Once we locate sgY we call the query ioctl on /dev/sgy to switch
665 //the boot lun to either LUNA or LUNB
gpt_utils_set_xbl_boot_partition(enum boot_chain chain)666 int gpt_utils_set_xbl_boot_partition(enum boot_chain chain)
667 {
668 struct stat st;
669 ///sys/block/sdX/device/scsi_generic/
670 char sg_dev_node[PATH_MAX] = {0};
671 uint8_t boot_lun_id = 0;
672 const char *boot_dev = NULL;
673
674 if (chain == BACKUP_BOOT) {
675 boot_lun_id = BOOT_LUN_B_ID;
676 if (!stat(XBL_BACKUP, &st))
677 boot_dev = XBL_BACKUP;
678 else if (!stat(XBL_AB_SECONDARY, &st))
679 boot_dev = XBL_AB_SECONDARY;
680 else {
681 fprintf(stderr, "%s: Failed to locate secondary xbl\n",
682 __func__);
683 goto error;
684 }
685 } else if (chain == NORMAL_BOOT) {
686 boot_lun_id = BOOT_LUN_A_ID;
687 if (!stat(XBL_PRIMARY, &st))
688 boot_dev = XBL_PRIMARY;
689 else if (!stat(XBL_AB_PRIMARY, &st))
690 boot_dev = XBL_AB_PRIMARY;
691 else {
692 fprintf(stderr, "%s: Failed to locate primary xbl\n",
693 __func__);
694 goto error;
695 }
696 } else {
697 fprintf(stderr, "%s: Invalid boot chain id\n", __func__);
698 goto error;
699 }
700 //We need either both xbl and xblbak or both xbl_a and xbl_b to exist at
701 //the same time. If not the current configuration is invalid.
702 if((stat(XBL_PRIMARY, &st) ||
703 stat(XBL_BACKUP, &st)) &&
704 (stat(XBL_AB_PRIMARY, &st) ||
705 stat(XBL_AB_SECONDARY, &st))) {
706 fprintf(stderr, "%s:primary/secondary XBL prt not found(%s)\n",
707 __func__,
708 strerror(errno));
709 goto error;
710 }
711 fprintf(stderr, "%s: setting %s lun as boot lun\n",
712 __func__,
713 boot_dev);
714 if (get_scsi_node_from_bootdevice(boot_dev,
715 sg_dev_node,
716 sizeof(sg_dev_node))) {
717 fprintf(stderr, "%s: Failed to get scsi node path for xblbak\n",
718 __func__);
719 goto error;
720 }
721 if (set_boot_lun(sg_dev_node, boot_lun_id)) {
722 fprintf(stderr, "%s: Failed to set xblbak as boot partition\n",
723 __func__);
724 goto error;
725 }
726 return 0;
727 error:
728 return -1;
729 }
730
gpt_utils_is_ufs_device()731 int gpt_utils_is_ufs_device()
732 {
733 char bootdevice[PROPERTY_VALUE_MAX] = {0};
734 property_get("ro.boot.bootdevice", bootdevice, "N/A");
735 if (strlen(bootdevice) < strlen(".ufshc") + 1)
736 return 0;
737 return (!strncmp(&bootdevice[strlen(bootdevice) - strlen(".ufshc")],
738 ".ufshc",
739 sizeof(".ufshc")));
740 }
741 //dev_path is the path to the block device that contains the GPT image that
742 //needs to be updated. This would be the device which holds one or more critical
743 //boot partitions and their backups. In the case of EMMC this function would
744 //be invoked only once on /dev/block/mmcblk1 since it holds the GPT image
745 //containing all the partitions For UFS devices it could potentially be
746 //invoked multiple times, once for each LUN containing critical image(s) and
747 //their backups
prepare_partitions(enum boot_update_stage stage,const char * dev_path)748 int prepare_partitions(enum boot_update_stage stage, const char *dev_path)
749 {
750 int r = 0;
751 int fd = -1;
752 int is_ufs = gpt_utils_is_ufs_device();
753 enum gpt_state gpt_prim, gpt_second;
754 enum boot_update_stage internal_stage;
755 struct stat xbl_partition_stat;
756 struct stat ufs_dir_stat;
757
758 if (!dev_path) {
759 fprintf(stderr, "%s: Invalid dev_path\n",
760 __func__);
761 r = -1;
762 goto EXIT;
763 }
764 fd = open(dev_path, O_RDWR);
765 if (fd < 0) {
766 fprintf(stderr, "%s: Opening '%s' failed: %s\n",
767 __func__,
768 BLK_DEV_FILE,
769 strerror(errno));
770 r = -1;
771 goto EXIT;
772 }
773 r = gpt_get_state(fd, PRIMARY_GPT, &gpt_prim) ||
774 gpt_get_state(fd, SECONDARY_GPT, &gpt_second);
775 if (r) {
776 fprintf(stderr, "%s: Getting GPT headers state failed\n",
777 __func__);
778 goto EXIT;
779 }
780
781 /* These 2 combinations are unexpected and unacceptable */
782 if (gpt_prim == GPT_BAD_CRC || gpt_second == GPT_BAD_CRC) {
783 fprintf(stderr, "%s: GPT headers CRC corruption detected, aborting\n",
784 __func__);
785 r = -1;
786 goto EXIT;
787 }
788 if (gpt_prim == GPT_BAD_SIGNATURE && gpt_second == GPT_BAD_SIGNATURE) {
789 fprintf(stderr, "%s: Both GPT headers corrupted, aborting\n",
790 __func__);
791 r = -1;
792 goto EXIT;
793 }
794
795 /* Check internal update stage according GPT headers' state */
796 if (gpt_prim == GPT_OK && gpt_second == GPT_OK)
797 internal_stage = UPDATE_MAIN;
798 else if (gpt_prim == GPT_BAD_SIGNATURE)
799 internal_stage = UPDATE_BACKUP;
800 else if (gpt_second == GPT_BAD_SIGNATURE)
801 internal_stage = UPDATE_FINALIZE;
802 else {
803 fprintf(stderr, "%s: Abnormal GPTs state: primary (%d), secondary (%d), "
804 "aborting\n", __func__, gpt_prim, gpt_second);
805 r = -1;
806 goto EXIT;
807 }
808
809 /* Stage already set - ready for update, exitting */
810 if ((int) stage == (int) internal_stage - 1)
811 goto EXIT;
812 /* Unexpected stage given */
813 if (stage != internal_stage) {
814 r = -1;
815 goto EXIT;
816 }
817
818 switch (stage) {
819 case UPDATE_MAIN:
820 if (is_ufs) {
821 if(stat(XBL_PRIMARY, &xbl_partition_stat)||
822 stat(XBL_BACKUP, &xbl_partition_stat)){
823 //Non fatal error. Just means this target does not
824 //use XBL but relies on sbl whose update is handled
825 //by the normal methods.
826 fprintf(stderr, "%s: xbl part not found(%s).Assuming sbl in use\n",
827 __func__,
828 strerror(errno));
829 } else {
830 //Switch the boot lun so that backup boot LUN is used
831 r = gpt_utils_set_xbl_boot_partition(BACKUP_BOOT);
832 if(r){
833 fprintf(stderr, "%s: Failed to set xbl backup partition as boot\n",
834 __func__);
835 goto EXIT;
836 }
837 }
838 }
839 //Fix up the backup GPT table so that it actually points to
840 //the backup copy of the boot critical images
841 fprintf(stderr, "%s: Preparing for primary partition update\n",
842 __func__);
843 r = gpt2_set_boot_chain(fd, BACKUP_BOOT);
844 if (r) {
845 if (r < 0)
846 fprintf(stderr,
847 "%s: Setting secondary GPT to backup boot failed\n",
848 __func__);
849 /* No backup partitions - do not corrupt GPT, do not flag error */
850 else
851 r = 0;
852 goto EXIT;
853 }
854 //corrupt the primary GPT so that the backup(which now points to
855 //the backup boot partitions is used)
856 r = gpt_set_state(fd, PRIMARY_GPT, GPT_BAD_SIGNATURE);
857 if (r) {
858 fprintf(stderr, "%s: Corrupting primary GPT header failed\n",
859 __func__);
860 goto EXIT;
861 }
862 break;
863 case UPDATE_BACKUP:
864 if (is_ufs) {
865 if(stat(XBL_PRIMARY, &xbl_partition_stat)||
866 stat(XBL_BACKUP, &xbl_partition_stat)){
867 //Non fatal error. Just means this target does not
868 //use XBL but relies on sbl whose update is handled
869 //by the normal methods.
870 fprintf(stderr, "%s: xbl part not found(%s).Assuming sbl in use\n",
871 __func__,
872 strerror(errno));
873 } else {
874 //Switch the boot lun so that backup boot LUN is used
875 r = gpt_utils_set_xbl_boot_partition(NORMAL_BOOT);
876 if(r) {
877 fprintf(stderr, "%s: Failed to set xbl backup partition as boot\n",
878 __func__);
879 goto EXIT;
880 }
881 }
882 }
883 //Fix the primary GPT header so that is used
884 fprintf(stderr, "%s: Preparing for backup partition update\n",
885 __func__);
886 r = gpt_set_state(fd, PRIMARY_GPT, GPT_OK);
887 if (r) {
888 fprintf(stderr, "%s: Fixing primary GPT header failed\n",
889 __func__);
890 goto EXIT;
891 }
892 //Corrupt the scondary GPT header
893 r = gpt_set_state(fd, SECONDARY_GPT, GPT_BAD_SIGNATURE);
894 if (r) {
895 fprintf(stderr, "%s: Corrupting secondary GPT header failed\n",
896 __func__);
897 goto EXIT;
898 }
899 break;
900 case UPDATE_FINALIZE:
901 //Undo the changes we had made in the UPDATE_MAIN stage so that the
902 //primary/backup GPT headers once again point to the same set of
903 //partitions
904 fprintf(stderr, "%s: Finalizing partitions\n",
905 __func__);
906 r = gpt2_set_boot_chain(fd, NORMAL_BOOT);
907 if (r < 0) {
908 fprintf(stderr, "%s: Setting secondary GPT to normal boot failed\n",
909 __func__);
910 goto EXIT;
911 }
912
913 r = gpt_set_state(fd, SECONDARY_GPT, GPT_OK);
914 if (r) {
915 fprintf(stderr, "%s: Fixing secondary GPT header failed\n",
916 __func__);
917 goto EXIT;
918 }
919 break;
920 default:;
921 }
922
923 EXIT:
924 if (fd >= 0) {
925 fsync(fd);
926 close(fd);
927 }
928 return r;
929 }
930
add_lun_to_update_list(char * lun_path,struct update_data * dat)931 int add_lun_to_update_list(char *lun_path, struct update_data *dat)
932 {
933 uint32_t i = 0;
934 struct stat st;
935 if (!lun_path || !dat){
936 fprintf(stderr, "%s: Invalid data",
937 __func__);
938 return -1;
939 }
940 if (stat(lun_path, &st)) {
941 fprintf(stderr, "%s: Unable to access %s. Skipping adding to list",
942 __func__,
943 lun_path);
944 return -1;
945 }
946 if (dat->num_valid_entries == 0) {
947 fprintf(stderr, "%s: Copying %s into lun_list[%d]\n",
948 __func__,
949 lun_path,
950 i);
951 strlcpy(dat->lun_list[0], lun_path,
952 PATH_MAX * sizeof(char));
953 dat->num_valid_entries = 1;
954 } else {
955 for (i = 0; (i < dat->num_valid_entries) &&
956 (dat->num_valid_entries < MAX_LUNS - 1); i++) {
957 //Check if the current LUN is not already part
958 //of the lun list
959 if (!strncmp(lun_path,dat->lun_list[i],
960 strlen(dat->lun_list[i]))) {
961 //LUN already in list..Return
962 return 0;
963 }
964 }
965 fprintf(stderr, "%s: Copying %s into lun_list[%d]\n",
966 __func__,
967 lun_path,
968 dat->num_valid_entries);
969 //Add LUN path lun list
970 strlcpy(dat->lun_list[dat->num_valid_entries], lun_path,
971 PATH_MAX * sizeof(char));
972 dat->num_valid_entries++;
973 }
974 return 0;
975 }
976
prepare_boot_update(enum boot_update_stage stage)977 int prepare_boot_update(enum boot_update_stage stage)
978 {
979 int r, fd;
980 int is_ufs = gpt_utils_is_ufs_device();
981 struct stat ufs_dir_stat;
982 struct update_data data;
983 int rcode = 0;
984 uint32_t i = 0;
985 int is_error = 0;
986 const char ptn_swap_list[][MAX_GPT_NAME_SIZE] = { PTN_SWAP_LIST };
987 //Holds /dev/block/bootdevice/by-name/*bak entry
988 char buf[PATH_MAX] = {0};
989 //Holds the resolved path of the symlink stored in buf
990 char real_path[PATH_MAX] = {0};
991
992 if (!is_ufs) {
993 //emmc device. Just pass in path to mmcblk0
994 return prepare_partitions(stage, BLK_DEV_FILE);
995 } else {
996 //Now we need to find the list of LUNs over
997 //which the boot critical images are spread
998 //and set them up for failsafe updates.To do
999 //this we find out where the symlinks for the
1000 //each of the paths under
1001 ///dev/block/bootdevice/by-name/PTN_SWAP_LIST
1002 //actually point to.
1003 fprintf(stderr, "%s: Running on a UFS device\n",
1004 __func__);
1005 memset(&data, '\0', sizeof(struct update_data));
1006 for (i=0; i < ARRAY_SIZE(ptn_swap_list); i++) {
1007 //XBL on UFS does not follow the convention
1008 //of being loaded based on well known GUID'S.
1009 //We take care of switching the UFS boot LUN
1010 //explicitly later on.
1011 if (!strncmp(ptn_swap_list[i],
1012 PTN_XBL,
1013 strlen(PTN_XBL)))
1014 continue;
1015 snprintf(buf, sizeof(buf),
1016 "%s/%sbak",
1017 BOOT_DEV_DIR,
1018 ptn_swap_list[i]);
1019 if (stat(buf, &ufs_dir_stat)) {
1020 continue;
1021 }
1022 if (readlink(buf, real_path, sizeof(real_path) - 1) < 0)
1023 {
1024 fprintf(stderr, "%s: readlink error. Skipping %s",
1025 __func__,
1026 strerror(errno));
1027 } else {
1028 if(strlen(real_path) < PATH_TRUNCATE_LOC + 1){
1029 fprintf(stderr, "Unknown path.Skipping :%s:\n",
1030 real_path);
1031 } else {
1032 real_path[PATH_TRUNCATE_LOC] = '\0';
1033 add_lun_to_update_list(real_path, &data);
1034 }
1035 }
1036 memset(buf, '\0', sizeof(buf));
1037 memset(real_path, '\0', sizeof(real_path));
1038 }
1039 for (i=0; i < data.num_valid_entries; i++) {
1040 fprintf(stderr, "%s: Preparing %s for update stage %d\n",
1041 __func__,
1042 data.lun_list[i],
1043 stage);
1044 rcode = prepare_partitions(stage, data.lun_list[i]);
1045 if (rcode != 0)
1046 {
1047 fprintf(stderr, "%s: Failed to prepare %s.Continuing..\n",
1048 __func__,
1049 data.lun_list[i]);
1050 is_error = 1;
1051 }
1052 }
1053 }
1054 if (is_error)
1055 return -1;
1056 return 0;
1057 }
1058
1059 //Given a parttion name(eg: rpm) get the path to the block device that
1060 //represents the GPT disk the partition resides on. In the case of emmc it
1061 //would be the default emmc dev(/dev/mmcblk0). In the case of UFS we look
1062 //through the /dev/block/bootdevice/by-name/ tree for partname, and resolve
1063 //the path to the LUN from there.
get_dev_path_from_partition_name(const char * partname,char * buf,size_t buflen)1064 static int get_dev_path_from_partition_name(const char *partname,
1065 char *buf,
1066 size_t buflen)
1067 {
1068 struct stat st;
1069 char path[PATH_MAX] = {0};
1070 if (!partname || !buf || buflen < ((PATH_TRUNCATE_LOC) + 1)) {
1071 ALOGE("%s: Invalid argument", __func__);
1072 goto error;
1073 }
1074 if (gpt_utils_is_ufs_device()) {
1075 //Need to find the lun that holds partition partname
1076 snprintf(path, sizeof(path),
1077 "%s/%s",
1078 BOOT_DEV_DIR,
1079 partname);
1080 if (stat(path, &st)) {
1081 goto error;
1082 }
1083 if (readlink(path, buf, buflen) < 0)
1084 {
1085 goto error;
1086 } else {
1087 buf[PATH_TRUNCATE_LOC] = '\0';
1088 }
1089 } else {
1090 snprintf(buf, buflen, "/dev/mmcblk0");
1091 }
1092 return 0;
1093
1094 error:
1095 return -1;
1096 }
1097
gpt_utils_get_partition_map(vector<string> & ptn_list,map<string,vector<string>> & partition_map)1098 int gpt_utils_get_partition_map(vector<string>& ptn_list,
1099 map<string, vector<string>>& partition_map) {
1100 char devpath[PATH_MAX] = {'\0'};
1101 map<string, vector<string>>::iterator it;
1102 if (ptn_list.size() < 1) {
1103 fprintf(stderr, "%s: Invalid ptn list\n", __func__);
1104 return -1;
1105 }
1106 //Go through the passed in list
1107 for (uint32_t i = 0; i < ptn_list.size(); i++)
1108 {
1109 //Key in the map is the path to the device that holds the
1110 //partition
1111 if (get_dev_path_from_partition_name(ptn_list[i].c_str(),
1112 devpath,
1113 sizeof(devpath))) {
1114 //Not necessarily an error. The partition may just
1115 //not be present.
1116 continue;
1117 }
1118 string path = devpath;
1119 it = partition_map.find(path);
1120 if (it != partition_map.end()) {
1121 it->second.push_back(ptn_list[i]);
1122 } else {
1123 vector<string> str_vec;
1124 str_vec.push_back( ptn_list[i]);
1125 partition_map.insert(pair<string, vector<string>>
1126 (path, str_vec));
1127 }
1128 memset(devpath, '\0', sizeof(devpath));
1129 }
1130 return 0;
1131 }
1132
1133 //Get the block size of the disk represented by decsriptor fd
gpt_get_block_size(int fd)1134 static uint32_t gpt_get_block_size(int fd)
1135 {
1136 uint32_t block_size = 0;
1137 if (fd < 0) {
1138 ALOGE("%s: invalid descriptor",
1139 __func__);
1140 goto error;
1141 }
1142 if (ioctl(fd, BLKSSZGET, &block_size) != 0) {
1143 ALOGE("%s: Failed to get GPT dev block size : %s",
1144 __func__,
1145 strerror(errno));
1146 goto error;
1147 }
1148 return block_size;
1149 error:
1150 return 0;
1151 }
1152
1153 //Write the GPT header present in the passed in buffer back to the
1154 //disk represented by fd
gpt_set_header(uint8_t * gpt_header,int fd,enum gpt_instance instance)1155 static int gpt_set_header(uint8_t *gpt_header, int fd,
1156 enum gpt_instance instance)
1157 {
1158 uint32_t block_size = 0;
1159 off_t gpt_header_offset = 0;
1160 if (!gpt_header || fd < 0) {
1161 ALOGE("%s: Invalid arguments",
1162 __func__);
1163 goto error;
1164 }
1165 block_size = gpt_get_block_size(fd);
1166 ALOGI("%s: Block size is : %d", __func__, block_size);
1167 if (block_size == 0) {
1168 ALOGE("%s: Failed to get block size", __func__);
1169 goto error;
1170 }
1171 if (instance == PRIMARY_GPT)
1172 gpt_header_offset = block_size;
1173 else
1174 gpt_header_offset = lseek64(fd, 0, SEEK_END) - block_size;
1175 if (gpt_header_offset <= 0) {
1176 ALOGE("%s: Failed to get gpt header offset",__func__);
1177 goto error;
1178 }
1179 ALOGI("%s: Writing back header to offset %ld", __func__,
1180 gpt_header_offset);
1181 if (blk_rw(fd, 1, gpt_header_offset, gpt_header, block_size)) {
1182 ALOGE("%s: Failed to write back GPT header", __func__);
1183 goto error;
1184 }
1185 return 0;
1186 error:
1187 return -1;
1188 }
1189
1190 //Read out the GPT header for the disk that contains the partition partname
gpt_get_header(const char * partname,enum gpt_instance instance)1191 static uint8_t* gpt_get_header(const char *partname, enum gpt_instance instance)
1192 {
1193 uint8_t* hdr = NULL;
1194 char devpath[PATH_MAX] = {0};
1195 int64_t hdr_offset = 0;
1196 uint32_t block_size = 0;
1197 int fd = -1;
1198 if (!partname) {
1199 ALOGE("%s: Invalid partition name", __func__);
1200 goto error;
1201 }
1202 if (get_dev_path_from_partition_name(partname, devpath, sizeof(devpath))
1203 != 0) {
1204 ALOGE("%s: Failed to resolve path for %s",
1205 __func__,
1206 partname);
1207 goto error;
1208 }
1209 fd = open(devpath, O_RDWR);
1210 if (fd < 0) {
1211 ALOGE("%s: Failed to open %s : %s",
1212 __func__,
1213 devpath,
1214 strerror(errno));
1215 goto error;
1216 }
1217 block_size = gpt_get_block_size(fd);
1218 if (block_size == 0)
1219 {
1220 ALOGE("%s: Failed to get gpt block size for %s",
1221 __func__,
1222 partname);
1223 goto error;
1224 }
1225
1226 hdr = (uint8_t*)malloc(block_size);
1227 if (!hdr) {
1228 ALOGE("%s: Failed to allocate memory for gpt header",
1229 __func__);
1230 }
1231 if (instance == PRIMARY_GPT)
1232 hdr_offset = block_size;
1233 else {
1234 hdr_offset = lseek64(fd, 0, SEEK_END) - block_size;
1235 }
1236 if (hdr_offset < 0) {
1237 ALOGE("%s: Failed to get gpt header offset",
1238 __func__);
1239 goto error;
1240 }
1241 if (blk_rw(fd, 0, hdr_offset, hdr, block_size)) {
1242 ALOGE("%s: Failed to read GPT header from device",
1243 __func__);
1244 goto error;
1245 }
1246 close(fd);
1247 return hdr;
1248 error:
1249 if (fd >= 0)
1250 close(fd);
1251 if (hdr)
1252 free(hdr);
1253 return NULL;
1254 }
1255
1256 //Returns the partition entry array based on the
1257 //passed in buffer which contains the gpt header.
1258 //The fd here is the descriptor for the 'disk' which
1259 //holds the partition
gpt_get_pentry_arr(uint8_t * hdr,int fd)1260 static uint8_t* gpt_get_pentry_arr(uint8_t *hdr, int fd)
1261 {
1262 uint64_t pentries_start = 0;
1263 uint32_t pentry_size = 0;
1264 uint32_t block_size = 0;
1265 uint32_t pentries_arr_size = 0;
1266 uint8_t *pentry_arr = NULL;
1267 int rc = 0;
1268 if (!hdr) {
1269 ALOGE("%s: Invalid header", __func__);
1270 goto error;
1271 }
1272 if (fd < 0) {
1273 ALOGE("%s: Invalid fd", __func__);
1274 goto error;
1275 }
1276 block_size = gpt_get_block_size(fd);
1277 if (!block_size) {
1278 ALOGE("%s: Failed to get gpt block size for",
1279 __func__);
1280 goto error;
1281 }
1282 pentries_start = GET_8_BYTES(hdr + PENTRIES_OFFSET) * block_size;
1283 pentry_size = GET_4_BYTES(hdr + PENTRY_SIZE_OFFSET);
1284 pentries_arr_size =
1285 GET_4_BYTES(hdr + PARTITION_COUNT_OFFSET) * pentry_size;
1286 pentry_arr = (uint8_t*)calloc(1, pentries_arr_size);
1287 if (!pentry_arr) {
1288 ALOGE("%s: Failed to allocate memory for partition array",
1289 __func__);
1290 goto error;
1291 }
1292 rc = blk_rw(fd, 0,
1293 pentries_start,
1294 pentry_arr,
1295 pentries_arr_size);
1296 if (rc) {
1297 ALOGE("%s: Failed to read partition entry array",
1298 __func__);
1299 goto error;
1300 }
1301 return pentry_arr;
1302 error:
1303 if (pentry_arr)
1304 free(pentry_arr);
1305 return NULL;
1306 }
1307
gpt_set_pentry_arr(uint8_t * hdr,int fd,uint8_t * arr)1308 static int gpt_set_pentry_arr(uint8_t *hdr, int fd, uint8_t* arr)
1309 {
1310 uint32_t block_size = 0;
1311 uint64_t pentries_start = 0;
1312 uint32_t pentry_size = 0;
1313 uint32_t pentries_arr_size = 0;
1314 int rc = 0;
1315 if (!hdr || fd < 0 || !arr) {
1316 ALOGE("%s: Invalid argument", __func__);
1317 goto error;
1318 }
1319 block_size = gpt_get_block_size(fd);
1320 if (!block_size) {
1321 ALOGE("%s: Failed to get gpt block size for",
1322 __func__);
1323 goto error;
1324 }
1325 ALOGI("%s : Block size is %d", __func__, block_size);
1326 pentries_start = GET_8_BYTES(hdr + PENTRIES_OFFSET) * block_size;
1327 pentry_size = GET_4_BYTES(hdr + PENTRY_SIZE_OFFSET);
1328 pentries_arr_size =
1329 GET_4_BYTES(hdr + PARTITION_COUNT_OFFSET) * pentry_size;
1330 ALOGI("%s: Writing partition entry array of size %d to offset %" PRIu64,
1331 __func__,
1332 pentries_arr_size,
1333 pentries_start);
1334 rc = blk_rw(fd, 1,
1335 pentries_start,
1336 arr,
1337 pentries_arr_size);
1338 if (rc) {
1339 ALOGE("%s: Failed to read partition entry array",
1340 __func__);
1341 goto error;
1342 }
1343 return 0;
1344 error:
1345 return -1;
1346 }
1347
1348
1349
1350 //Allocate a handle used by calls to the "gpt_disk" api's
gpt_disk_alloc()1351 struct gpt_disk * gpt_disk_alloc()
1352 {
1353 struct gpt_disk *disk;
1354 disk = (struct gpt_disk *)malloc(sizeof(struct gpt_disk));
1355 if (!disk) {
1356 ALOGE("%s: Failed to allocate memory", __func__);
1357 goto end;
1358 }
1359 memset(disk, 0, sizeof(struct gpt_disk));
1360 end:
1361 return disk;
1362 }
1363
1364 //Free previously allocated/initialized handle
gpt_disk_free(struct gpt_disk * disk)1365 void gpt_disk_free(struct gpt_disk *disk)
1366 {
1367 if (!disk)
1368 return;
1369 if (disk->hdr)
1370 free(disk->hdr);
1371 if (disk->hdr_bak)
1372 free(disk->hdr_bak);
1373 if (disk->pentry_arr)
1374 free(disk->pentry_arr);
1375 if (disk->pentry_arr_bak)
1376 free(disk->pentry_arr_bak);
1377 free(disk);
1378 return;
1379 }
1380
1381 //fills up the passed in gpt_disk struct with information about the
1382 //disk represented by path dev. Returns 0 on success and -1 on error.
gpt_disk_get_disk_info(const char * dev,struct gpt_disk * dsk)1383 int gpt_disk_get_disk_info(const char *dev, struct gpt_disk *dsk)
1384 {
1385 struct gpt_disk *disk = NULL;
1386 int fd = -1;
1387 uint32_t gpt_header_size = 0;
1388
1389 if (!dsk || !dev) {
1390 ALOGE("%s: Invalid arguments", __func__);
1391 goto error;
1392 }
1393 disk = dsk;
1394 disk->hdr = gpt_get_header(dev, PRIMARY_GPT);
1395 if (!disk->hdr) {
1396 ALOGE("%s: Failed to get primary header", __func__);
1397 goto error;
1398 }
1399 gpt_header_size = GET_4_BYTES(disk->hdr + HEADER_SIZE_OFFSET);
1400 disk->hdr_crc = sparse_crc32(0, disk->hdr, gpt_header_size);
1401 disk->hdr_bak = gpt_get_header(dev, PRIMARY_GPT);
1402 if (!disk->hdr_bak) {
1403 ALOGE("%s: Failed to get backup header", __func__);
1404 goto error;
1405 }
1406 disk->hdr_bak_crc = sparse_crc32(0, disk->hdr_bak, gpt_header_size);
1407
1408 //Descriptor for the block device. We will use this for further
1409 //modifications to the partition table
1410 if (get_dev_path_from_partition_name(dev,
1411 disk->devpath,
1412 sizeof(disk->devpath)) != 0) {
1413 ALOGE("%s: Failed to resolve path for %s",
1414 __func__,
1415 dev);
1416 goto error;
1417 }
1418 fd = open(disk->devpath, O_RDWR);
1419 if (fd < 0) {
1420 ALOGE("%s: Failed to open %s: %s",
1421 __func__,
1422 disk->devpath,
1423 strerror(errno));
1424 goto error;
1425 }
1426 disk->pentry_arr = gpt_get_pentry_arr(disk->hdr, fd);
1427 if (!disk->pentry_arr) {
1428 ALOGE("%s: Failed to obtain partition entry array",
1429 __func__);
1430 goto error;
1431 }
1432 disk->pentry_arr_bak = gpt_get_pentry_arr(disk->hdr_bak, fd);
1433 if (!disk->pentry_arr_bak) {
1434 ALOGE("%s: Failed to obtain backup partition entry array",
1435 __func__);
1436 goto error;
1437 }
1438 disk->pentry_size = GET_4_BYTES(disk->hdr + PENTRY_SIZE_OFFSET);
1439 disk->pentry_arr_size =
1440 GET_4_BYTES(disk->hdr + PARTITION_COUNT_OFFSET) *
1441 disk->pentry_size;
1442 disk->pentry_arr_crc = GET_4_BYTES(disk->hdr + PARTITION_CRC_OFFSET);
1443 disk->pentry_arr_bak_crc = GET_4_BYTES(disk->hdr_bak +
1444 PARTITION_CRC_OFFSET);
1445 disk->block_size = gpt_get_block_size(fd);
1446 close(fd);
1447 disk->is_initialized = GPT_DISK_INIT_MAGIC;
1448 return 0;
1449 error:
1450 if (fd >= 0)
1451 close(fd);
1452 return -1;
1453 }
1454
1455 //Get pointer to partition entry from a allocated gpt_disk structure
gpt_disk_get_pentry(struct gpt_disk * disk,const char * partname,enum gpt_instance instance)1456 uint8_t* gpt_disk_get_pentry(struct gpt_disk *disk,
1457 const char *partname,
1458 enum gpt_instance instance)
1459 {
1460 uint8_t *ptn_arr = NULL;
1461 if (!disk || !partname || disk->is_initialized != GPT_DISK_INIT_MAGIC) {
1462 ALOGE("%s: Invalid argument",__func__);
1463 goto error;
1464 }
1465 ptn_arr = (instance == PRIMARY_GPT) ?
1466 disk->pentry_arr : disk->pentry_arr_bak;
1467 return (gpt_pentry_seek(partname, ptn_arr,
1468 ptn_arr + disk->pentry_arr_size ,
1469 disk->pentry_size));
1470 error:
1471 return NULL;
1472 }
1473
1474 //Update CRC values for the various components of the gpt_disk
1475 //structure. This function should be called after any of the fields
1476 //have been updated before the structure contents are written back to
1477 //disk.
gpt_disk_update_crc(struct gpt_disk * disk)1478 int gpt_disk_update_crc(struct gpt_disk *disk)
1479 {
1480 uint32_t gpt_header_size = 0;
1481 if (!disk || (disk->is_initialized != GPT_DISK_INIT_MAGIC)) {
1482 ALOGE("%s: invalid argument", __func__);
1483 goto error;
1484 }
1485 //Recalculate the CRC of the primary partiton array
1486 disk->pentry_arr_crc = sparse_crc32(0,
1487 disk->pentry_arr,
1488 disk->pentry_arr_size);
1489 //Recalculate the CRC of the backup partition array
1490 disk->pentry_arr_bak_crc = sparse_crc32(0,
1491 disk->pentry_arr_bak,
1492 disk->pentry_arr_size);
1493 //Update the partition CRC value in the primary GPT header
1494 PUT_4_BYTES(disk->hdr + PARTITION_CRC_OFFSET, disk->pentry_arr_crc);
1495 //Update the partition CRC value in the backup GPT header
1496 PUT_4_BYTES(disk->hdr_bak + PARTITION_CRC_OFFSET,
1497 disk->pentry_arr_bak_crc);
1498 //Update the CRC value of the primary header
1499 gpt_header_size = GET_4_BYTES(disk->hdr + HEADER_SIZE_OFFSET);
1500 //Header CRC is calculated with its own CRC field set to 0
1501 PUT_4_BYTES(disk->hdr + HEADER_CRC_OFFSET, 0);
1502 PUT_4_BYTES(disk->hdr_bak + HEADER_CRC_OFFSET, 0);
1503 disk->hdr_crc = sparse_crc32(0, disk->hdr, gpt_header_size);
1504 disk->hdr_bak_crc = sparse_crc32(0, disk->hdr_bak, gpt_header_size);
1505 PUT_4_BYTES(disk->hdr + HEADER_CRC_OFFSET, disk->hdr_crc);
1506 PUT_4_BYTES(disk->hdr_bak + HEADER_CRC_OFFSET, disk->hdr_bak_crc);
1507 return 0;
1508 error:
1509 return -1;
1510 }
1511
1512 //Write the contents of struct gpt_disk back to the actual disk
gpt_disk_commit(struct gpt_disk * disk)1513 int gpt_disk_commit(struct gpt_disk *disk)
1514 {
1515 int fd = -1;
1516 if (!disk || (disk->is_initialized != GPT_DISK_INIT_MAGIC)){
1517 ALOGE("%s: Invalid args", __func__);
1518 goto error;
1519 }
1520 fd = open(disk->devpath, O_RDWR);
1521 if (fd < 0) {
1522 ALOGE("%s: Failed to open %s: %s",
1523 __func__,
1524 disk->devpath,
1525 strerror(errno));
1526 goto error;
1527 }
1528 ALOGI("%s: Writing back primary GPT header", __func__);
1529 //Write the primary header
1530 if(gpt_set_header(disk->hdr, fd, PRIMARY_GPT) != 0) {
1531 ALOGE("%s: Failed to update primary GPT header",
1532 __func__);
1533 goto error;
1534 }
1535 ALOGI("%s: Writing back primary partition array", __func__);
1536 //Write back the primary partition array
1537 if (gpt_set_pentry_arr(disk->hdr, fd, disk->pentry_arr)) {
1538 ALOGE("%s: Failed to write primary GPT partition arr",
1539 __func__);
1540 goto error;
1541 }
1542 close(fd);
1543 return 0;
1544 error:
1545 if (fd >= 0)
1546 close(fd);
1547 return -1;
1548 }
1549