LK / classic AOSP aboot · source analysis

fastboot flash와 partition write

partition 이름을 찾고 raw 또는 sparse image를 eMMC에 쓰며 성공 응답을 결정하는 경로를 읽습니다.

AOSP LK commit 9d6e28f는 이 글의 코드 분석 기준이다. 제품의 unlock 정책·저장 장치 완료 조건·복구 절차는 해당 보드 구현에서 별도로 확인한다.

Series
20 / 20
Baseline
AOSP 9d6e28f
Commit
9d6e28f24ba0
Source
app/aboot/aboot.c:1340-1428 (발췌 범위)

고정 LK aboot의 flash:와 erase:는 실제로 무엇을 쓰는가?

eMMC 부팅 경로에서 flash:는 cmd_flash_mmc()로 등록된다. 이 함수는 조건부 SSD 처리를 거친 뒤 sparse magic에 따라 raw와 sparse callback을 고른다. erase:는 별도 cmd_erase_mmc()로 등록된다.

raw의 일반 partition 경로는 이름·offset, boot/recovery magic, 크기, mmc_write() 결과를 검사한다. 여기서 호출되는 fastboot_okay()는 별도 readback·flush·전원 차단 복구 확인을 뜻하지 않는다.

분석 경계

이 페이지는 classic AOSP aboot의 commit 9d6e28f에 한정한다. 현대 Android A/B·AVB·rollback 정책이나 보드별 eMMC 구현을 이 코드에 소급하지 않는다.

호스트 입력에서 매체 쓰기까지의 책임

그림 1. eMMC fastboot callback의 입력·분기·출력 경계
호스트 입력aboot 판단매체·응답
01arg + download buffer
02cmd_flash_mmc()
sparse magic
03raw / sparse / 특수 partition 분기
04mmc_write() 또는 write_partition()
FAIL / OKAY
별도 명령

erase:는 이 flash chain 안의 선행 단계가 아니라 cmd_erase_mmc()로 등록된다.

고정 aboot.c의 callback 등록과 eMMC writer를 그렸다. NAND 부팅의 cmd_flash()/cmd_erase()는 별도 경로다.

flash: 실행 분기

그림 2. cmd_flash_mmc()가 raw와 sparse callback을 고르는 순서
flash: → cmd_flash_mmc
SSD_ENABLE이면 조건부 변환
sparse header magic 판별
raw 또는 sparse callback
분기별 FAIL/OKAY 호출

등록은 target_is_emmc_boot() 조건에 달린다. raw의 partition 대상은 write_partition()이라는 특수 경로를 타며, 일반 raw partition lookup과 크기 검사를 그대로 거친다고 해석하면 안 된다. erase:는 이 화살표에 없다.

고정 소스가 실제로 검사하는 값

좁은 화면에서는 표를 좌우로 밀어 각 분기의 쓰기와 응답 경계를 확인한다.

입력/분기이 callback의 검사쓰기 호출응답 경계
flash:partition raw일반 partition offset·크기 검사 대신 특수 분기write_partition(sz, data)오류면 FAIL; 반환 성공 뒤 OKAY
flash:<name> rawoffset 0 거부, boot/recovery magic, ROUND_TO_PAGE(sz,511) > sizemmc_write(ptn, sz, data)검사·write 오류면 FAIL/return; 나머지 OKAY
flash:<name> sparseoffset, 입력 sz의 정렬 크기, chunk별 일부 길이·종류, 최종 block 수RAW chunk마다 mmc_write(); DONT_CARE는 건너뜀최종 block 수 불일치 시 FAIL 뒤 OKAY 호출 줄에도 도달
erase:<name> eMMCpartition offset 0 거부offset부터 512바이트에 0 기록write 오류면 FAIL; 그 외 OKAY

sparse 경로의 ROUND_TO_PAGE(sz,511)은 입력 buffer 길이를 비교한다. 이 표가 확장된 output 전체의 partition 범위 검사나 CRC 검증을 보장한다는 뜻은 아니다.

명령별 기록 경로와 검증의 빈칸

그림의 실선 순서는 고정 aboot.c의 호출 순서다. 제품에 추가해야 할 안전 검사는 아래 코드의 실행 단계와 섞지 않았다.

그림 3. eMMC flash:와 erase:는 서로 다른 명령

aboot_init()의 등록 조건이 eMMC인 경우를 나타낸다.

flash: → cmd_flash_mmc()

01선택적 SSD 처리 후 sparse magic 확인

02raw이면 cmd_flash_mmc_img()

03sparse이면 cmd_flash_mmc_sparse_img()

04각 callback의 검사·쓰기·응답

erase: → cmd_erase_mmc()

01이름으로 partition index·offset 조회

02offset 0이면 FAIL/return

03mmc_write(ptn, 512, zero)

04write 결과에 따라 FAIL 또는 OKAY

그림 4. raw와 sparse writer의 검사 차이

같은 flash: 요청이어도 magic에 따라 검사 대상과 기록 단위가 달라진다.

raw 일반 partition

01partition offset 조회; 0이면 중단

02boot/recovery면 BOOT_MAGIC 확인

03정렬된 sz와 partition size 비교

04한 번 mmc_write(ptn, sz, data)

05반환 오류면 FAIL; 그 외 OKAY

sparse image

01offset·입력 sz 검사

02RAW chunk만 누적 offset에 기록

03DONT_CARE는 block cursor만 증가

04CRC case는 별도 CRC 계산 없이 처리; FILL case 없음

05block 수 불일치: FAIL 호출 뒤 OKAY 줄 도달

원본 코드

아래 코드는 LK / classic AOSP aboot AOSP 9d6e28f의 app/aboot/aboot.c에서 1340-1428줄을 그대로 가져온 것이다.

commit9d6e28f24ba01e563d0b3801c6c6c95d756db623anchor · L1364void cmd_flash_mmc_img(const char *arg
1340
1341void cmd_erase_mmc(const char *arg, void *data, unsigned sz)
1342{
1343	unsigned long long ptn = 0;
1344	unsigned int out[512] = {0};
1345	int index = INVALID_PTN;
1346
1347	index = partition_get_index(arg);
1348	ptn = partition_get_offset(index);
1349
1350	if(ptn == 0) {
1351		fastboot_fail("Partition table doesn't exist\n");
1352		return;
1353	}
1354	/* Simple inefficient version of erase. Just writing
1355       0 in first block */
1356	if (mmc_write(ptn , 512, (unsigned int *)out)) {
1357		fastboot_fail("failed to erase partition");
1358		return;
1359	}
1360	fastboot_okay("");
1361}
1362
1363
1364void cmd_flash_mmc_img(const char *arg, void *data, unsigned sz)
1365{
1366	unsigned long long ptn = 0;
1367	unsigned long long size = 0;
1368	int index = INVALID_PTN;
1369
1370	if (!strcmp(arg, "partition"))
1371	{
1372		dprintf(INFO, "Attempt to write partition image.\n");
1373		if (write_partition(sz, (unsigned char *) data)) {
1374			fastboot_fail("failed to write partition");
1375			return;
1376		}
1377	}
1378	else
1379	{
1380		index = partition_get_index(arg);
1381		ptn = partition_get_offset(index);
1382		if(ptn == 0) {
1383			fastboot_fail("partition table doesn't exist");
1384			return;
1385		}
1386
1387		if (!strcmp(arg, "boot") || !strcmp(arg, "recovery")) {
1388			if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
1389				fastboot_fail("image is not a boot image");
1390				return;
1391			}
1392		}
1393
1394		size = partition_get_size(index);
1395		if (ROUND_TO_PAGE(sz,511) > size) {
1396			fastboot_fail("size too large");
1397			return;
1398		}
1399		else if (mmc_write(ptn , sz, (unsigned int *)data)) {
1400			fastboot_fail("flash write failure");
1401			return;
1402		}
1403	}
1404	fastboot_okay("");
1405	return;
1406}
1407
1408void cmd_flash_mmc_sparse_img(const char *arg, void *data, unsigned sz)
1409{
1410	unsigned int chunk;
1411	unsigned int chunk_data_sz;
1412	sparse_header_t *sparse_header;
1413	chunk_header_t *chunk_header;
1414	uint32_t total_blocks = 0;
1415	unsigned long long ptn = 0;
1416	unsigned long long size = 0;
1417	int index = INVALID_PTN;
1418
1419	index = partition_get_index(arg);
1420	ptn = partition_get_offset(index);
1421	if(ptn == 0) {
1422		fastboot_fail("partition table doesn't exist");
1423		return;
1424	}
1425
1426	size = partition_get_size(index);
1427	if (ROUND_TO_PAGE(sz,511) > size) {
1428		fastboot_fail("size too large");

발췌 범위와 읽기 기준

첫 원본 발췌는 cmd_erase_mmc(), raw writer, sparse writer 시작을 포함한다. 다음 발췌는 sparse RAW chunk 기록까지 이어진다. 명령 등록, SSD 조건부 처리, sparse 최종 block 수 판정은 원문 링크의 뒤쪽까지 함께 읽어야 한다.

코드 옆 번호는 고정 aboot.c의 원본 줄 번호다. 예를 들어 raw 진입은 L1364, sparse 진입은 L1408이다. fastboot_okay() 호출만으로 readback·flush·전원 차단 복구를 추론하지 않는다.

함께 읽어야 하는 원본 코드

첫 코드 조각만으로 동작이 완성되지 않는 경우 호출 매크로, 객체 정의와 실제 실행 목록을 같은 페이지에 묶었다. 각 조각은 같은 기준 commit에서 가져왔다.

01. Android sparse image를 chunk 단위로 기록

app/aboot/aboot.c 1398-1492줄이다.

fileapp/aboot/aboot.canchor · L1408void cmd_flash_mmc_sparse_img
1398		}
1399		else if (mmc_write(ptn , sz, (unsigned int *)data)) {
1400			fastboot_fail("flash write failure");
1401			return;
1402		}
1403	}
1404	fastboot_okay("");
1405	return;
1406}
1407
1408void cmd_flash_mmc_sparse_img(const char *arg, void *data, unsigned sz)
1409{
1410	unsigned int chunk;
1411	unsigned int chunk_data_sz;
1412	sparse_header_t *sparse_header;
1413	chunk_header_t *chunk_header;
1414	uint32_t total_blocks = 0;
1415	unsigned long long ptn = 0;
1416	unsigned long long size = 0;
1417	int index = INVALID_PTN;
1418
1419	index = partition_get_index(arg);
1420	ptn = partition_get_offset(index);
1421	if(ptn == 0) {
1422		fastboot_fail("partition table doesn't exist");
1423		return;
1424	}
1425
1426	size = partition_get_size(index);
1427	if (ROUND_TO_PAGE(sz,511) > size) {
1428		fastboot_fail("size too large");
1429		return;
1430	}
1431
1432	/* Read and skip over sparse image header */
1433	sparse_header = (sparse_header_t *) data;
1434	data += sparse_header->file_hdr_sz;
1435	if(sparse_header->file_hdr_sz > sizeof(sparse_header_t))
1436	{
1437		/* Skip the remaining bytes in a header that is longer than
1438		 * we expected.
1439		 */
1440		data += (sparse_header->file_hdr_sz - sizeof(sparse_header_t));
1441	}
1442
1443	dprintf (SPEW, "=== Sparse Image Header ===\n");
1444	dprintf (SPEW, "magic: 0x%x\n", sparse_header->magic);
1445	dprintf (SPEW, "major_version: 0x%x\n", sparse_header->major_version);
1446	dprintf (SPEW, "minor_version: 0x%x\n", sparse_header->minor_version);
1447	dprintf (SPEW, "file_hdr_sz: %d\n", sparse_header->file_hdr_sz);
1448	dprintf (SPEW, "chunk_hdr_sz: %d\n", sparse_header->chunk_hdr_sz);
1449	dprintf (SPEW, "blk_sz: %d\n", sparse_header->blk_sz);
1450	dprintf (SPEW, "total_blks: %d\n", sparse_header->total_blks);
1451	dprintf (SPEW, "total_chunks: %d\n", sparse_header->total_chunks);
1452
1453	/* Start processing chunks */
1454	for (chunk=0; chunk<sparse_header->total_chunks; chunk++)
1455	{
1456		/* Read and skip over chunk header */
1457		chunk_header = (chunk_header_t *) data;
1458		data += sizeof(chunk_header_t);
1459
1460		dprintf (SPEW, "=== Chunk Header ===\n");
1461		dprintf (SPEW, "chunk_type: 0x%x\n", chunk_header->chunk_type);
1462		dprintf (SPEW, "chunk_data_sz: 0x%x\n", chunk_header->chunk_sz);
1463		dprintf (SPEW, "total_size: 0x%x\n", chunk_header->total_sz);
1464
1465		if(sparse_header->chunk_hdr_sz > sizeof(chunk_header_t))
1466		{
1467			/* Skip the remaining bytes in a header that is longer than
1468			 * we expected.
1469			 */
1470			data += (sparse_header->chunk_hdr_sz - sizeof(chunk_header_t));
1471		}
1472
1473		chunk_data_sz = sparse_header->blk_sz * chunk_header->chunk_sz;
1474		switch (chunk_header->chunk_type)
1475		{
1476			case CHUNK_TYPE_RAW:
1477			if(chunk_header->total_sz != (sparse_header->chunk_hdr_sz +
1478											chunk_data_sz))
1479			{
1480				fastboot_fail("Bogus chunk size for chunk type Raw");
1481				return;
1482			}
1483
1484			if(mmc_write(ptn + ((uint64_t)total_blocks*sparse_header->blk_sz),
1485						chunk_data_sz,
1486						(unsigned int*)data))
1487			{
1488				fastboot_fail("flash write failure");
1489				return;
1490			}
1491			total_blocks += chunk_header->chunk_sz;
1492			data += chunk_data_sz;

분기와 결과를 소스 순서로 읽기

01

eMMC와 NAND 등록을 구분한다

target_is_emmc_boot()가 참일 때만 flash:/erase:가 각각 cmd_flash_mmc()/cmd_erase_mmc()에 연결된다. 거짓이면 별도 cmd_flash()/cmd_erase()가 등록된다.

eMMC callback의 동작을 NAND writer나 현대 fastboot 구현의 보편 규칙으로 확장하지 않는다.

02

raw의 특수 대상과 일반 대상을 분리한다

arg == "partition"이면 write_partition()을 호출한다. 그 외 이름은 index·offset을 얻고, boot/recovery magic과 크기를 확인한 뒤 mmc_write()를 호출한다. 같은 raw 이미지라도 대상 이름에 따라 검사 경계가 다르다.

03

sparse의 입력 크기와 출력 offset을 구별한다

진입부는 정렬한 입력 sz를 partition 크기와 비교한다. RAW chunk의 기록 주소는 ptn + total_blocks * blk_sz이고, DONT_CARE는 쓰지 않고 cursor만 전진한다. 이 함수에는 확장된 모든 출력 바이트가 partition 안에 있는지 검증하는 명시적 비교가 보이지 않는다.

04

응답 호출과 매체 검증을 구분한다

raw 경로의 검사·mmc_write() 오류는 fastboot_fail() 뒤 반환한다. sparse의 최종 total_blocks != total_blks 분기는 fastboot_fail() 뒤 반환하지 않고 fastboot_okay() 호출 줄로 내려간다. 실제 USB 응답 상태는 fastboot protocol 구현과 함께 확인해야 한다.

05

callback은 응답 뒤 호출자에게 돌아간다

이 코드는 Linux 진입점으로 비복귀 분기하지 않는다. OKAY나 FAIL은 명령 처리 결과이며, flash 내용의 독립적인 readback·flush·rollback 보증은 아니다.

제품 적용 전 따로 검증할 경계

01

partition 범위와 특수 이름

raw 일반 경로는 ROUND_TO_PAGE(sz,511)를 size와 비교하지만 partition 특수 기록은 이 경로를 거치지 않는다. sparse 경로는 입력 크기만 시작에서 비교하고 chunk별 확장 출력의 partition 경계를 별도로 확인하지 않는다. 쓰기 허용 목록, 실제 offset 단위와 매체 경계는 제품 코드에서 검증해야 한다.

02

sparse parser의 구현 범위

고정 switch에는 RAW, DONT_CARE, CRC와 unknown 실패만 있고 FILL 처리는 없다. CRC case도 checksum을 계산하지 않는다. header를 file_hdr_sz만큼 건너뛴 다음 확장 header이면 file_hdr_sz - sizeof(sparse_header_t)를 한 번 더 더한다. 받은 sz에 대한 각 header·payload 끝의 범위 검사, chunk 곱셈·누적 overflow 검사는 보이지 않는다. 형식 정의와 이 구현의 실제 지원 범위를 구별한다.

03

보안·지속성 권고는 실행 단계가 아니다

unlock/critical 권한, rollback index, flush/readback, redundant slot과 metadata commit은 제품의 요구 사항일 수 있지만 이 eMMC writer 함수에서 실행되는 단계로 그리지 않는다. 어떤 계층이 책임지는지는 보드의 전체 fastboot·storage·부팅 정책을 추적해 증명한다.

이 명령에서 쓰는 값과 매체 상태

대상출처사용 범위확인할 점
arg, data, szfastboot command/download callback 인자한 번의 flash/erase 명령이름과 입력 buffer 길이
index, ptn, sizepartition lookup 결과와 지역 변수선택된 raw/sparse/erase callbackoffset 0 실패, 특수 partition 예외
total_blocks, chunk headersparse payload와 누적 cursorsparse loopRAW·DONT_CARE·CRC별 증가와 확장 범위
eMMC blockmmc_write() 또는 write_partition()쓰기 뒤에도 지속될 수 있음함수 반환과 매체 지속성·전원 차단 결과를 구별
fastboot 응답 상태fastboot_fail()/fastboot_okay()명령 응답sparse block 수 불일치 분기의 연속 호출

고정 callback의 실제 실패 경계

분기조건코드의 동작별도 확인할 위험
raw / sparse / erasepartition offset 0fastboot_fail() 뒤 반환이름 매핑과 offset 0의 의미
raw boot/recoveryBOOT_MAGIC 불일치write 전 FAIL/returnmagic 외 이미지 전체 유효성
raw 일반입력 크기 초과 또는 mmc_write() 오류FAIL/return매체의 실제 지속성과 readback
sparse지원하지 않는 chunk 또는 RAW 길이 불일치FAIL/return이미 앞 chunk가 쓰였을 가능성
sparse최종 block 수 불일치FAIL 호출 뒤 OKAY 호출 줄까지 진행최종 USB 응답·부분 기록 상태
erase첫 512바이트 write 오류FAIL/returnpartition 전체 erase로 오인하지 않기

sparse는 chunk를 순차 기록하며 뒤쪽 검사 실패 시 앞서 쓴 block의 rollback 코드가 없다. 최종 block 수 불일치에서는 FAIL 뒤 OKAY 함수까지 호출하지만, fastboot_ack()가 COMMAND일 때만 응답하므로 첫 FAIL이 COMPLETE(또는 송신 실패의 ERROR)로 바꾼 뒤 두 번째 OKAY는 전송하지 않는다. 두 응답이 모두 호스트에 도착한다고 해석하지 않는다.

쓰지 않고 확인할 수 있는 증거

이 표의 확인은 장치를 flash하거나 erase하지 않는다. 제품 실행의 지속성·복구 검증은 별도 시험 매체와 복구 절차에서 수행한다.

목적읽기 전용 자료 또는 명령확인할 사실
빌드된 callbacknm -n build-*/lk.elf | grep -E 'cmd_flash_mmc(_img|_sparse_img)?$|cmd_erase_mmc$'사용 보드의 링크 이미지에 해당 함수명이 있는지 확인한다.
명령 등록고정 aboot.c의 fastboot_register("flash:")/"erase:"를 읽는다.target_is_emmc_boot()에 따른 callback 차이를 확인한다.
host read-only 응답시험 기기의 fastboot getvar productfastboot transport가 연결되고 product 변수가 게시됐는지 확인한다. slot/unlocked 변수는 이 코드에서 보장하지 않는다.
매체 구현사용 보드의 mmc_write(), write_partition()와 partition parser 소스offset 단위, 완료 조건, 실제 보호 정책을 별도로 추적한다.

분기 검증 순서

  1. 01
    소스에서 명령 분기표 작성

    eMMC/NAND 등록, raw/sparse magic, 특수 partition 대상과 별도 erase: callback을 표시한다. 장치 쓰기 없이 확인할 수 있다.

  2. 02
    읽기 전용 장치 정보 대조

    시험 기기의 fastboot getvar product 결과와 빌드 이미지·보드 설정을 맞춘다. 이 단계에서는 flash/erase 명령을 실행하지 않는다.

  3. 03
    복구 가능한 시험 매체에서 오류 주입

    raw write 실패, sparse 뒤쪽 chunk 실패와 최종 block 수 불일치를 각각 계측한다. host 응답, 앞서 쓴 block, 재부팅 결과를 분리해 기록한다.

원문과 다음 글