Seguindo a minha pergunta TF101 Android: dispositivo de bloco de imagem via adb no qual tentei sem êxito salvar uma imagem não processada de um dispositivo de bloco pelo redirecionamento de saída, esta pergunta tenta determinar o que deu errado.
Situação :
Um dispositivo de bloco em um dispositivo Android foi lido duas vezes.
- Uma vez (sem êxito) com: adb shell su -c "dd if = / dev / block / mmcblk0p7" | pv> faulty.raw
- Uma vez (com êxito), não com o redirecionamento de saída, mas usando o netcat, resultando em successful.raw
O sistema de arquivos é ext4. Os arquivos de imagem brutos foram comparados com o seguinte comando:
cmp -l faulty.raw successful.raw | mawk 'function oct2dec(oct, dec) {for (i = 1; i <= length(oct); i++) {dec *= 8; dec += substr(oct, i, 1)}; return dec} {printf "%08X %02X %02X\n", $1, oct2dec($2), oct2dec($3)}' | head -n 100
A saída resultante mostra apenas as diferenças nos dois arquivos no formato hexadecimal. A primeira coluna é o deslocamento do arquivo, a segunda coluna fornece o valor na imagem com defeito e a terceira coluna o valor na imagem com êxito.
Alguém pode ver o que deu errado com o comando usando o redirecionamento de saída dessa comparação binária? Além disso: a imagem (defeituosa) pode ser recuperada aplicando alguma correção? Os tamanhos dos arquivos são comparáveis
0000040D AE 37
0000040E 5D 8A
0000040F 22 2A
00000411 1D BE
00000412 03 01
0000042D 2B 30
0000042E AD 47
0000042F 1B 20
00000431 2B 30
00000432 AD 47
00000433 1B 20
00000435 B7 B9
00000490 0D 3D
00000491 2E 1E
00000493 30 D8
00000494 7B ED
00000495 56 44
00000498 4B 8B
00000499 62 59
0000049B 20 C0
0000049C 4D 6B
0000049D 2C BF
000004A0 0D 3D
000004A1 2E 1E
000004A3 68 10
000004A4 B6 49
000004A5 61 59
000004A8 4B 8B
000004A9 62 59
000004BB E0 C0
000004BC 16 46
000004BD AD 82
000004C3 20 C0
000004C4 4D 6B
000004C5 2C BF
000004E9 58 00
000004EA 40 00
000004EB 17 00
0000050D 0D 0A
0000050E 0D F3
0000050F 0A 02
00000510 F3 00
00000511 02 03
00000513 03 00
0000051D 00 FA
0000051E 00 79
0000051F FA 00
00000520 79 00
00000521 00 05
00000522 00 06
00000523 05 00
00000524 06 00
00000525 00 FA
00000526 00 79
00000527 FA 00
00000528 79 00
00000529 00 06
0000052A 00 06
0000052B 06 00
0000052C 06 00
0000052D 00 05
0000052E 00 86
0000052F 05 00
00000530 86 00
0000055D 00 1C
00000561 1C 02
00000563 02 00
00000579 00 14
0000057A 00 D2
0000057B 50 63
0000057C 4F 12
0000057D 54 00
0000057E 12 00
00001001 00 03
00001002 00 04
00001003 03 00
00001004 04 00
00001005 00 04
00001006 00 04
00001007 04 00
00001008 04 00
00001009 00 05
0000100A 00 04
0000100B 05 00
0000100C 04 00
0000100F 00 F6
00001010 00 1F
00001011 F6 01
00001012 1F 00
00001013 01 04
00001015 04 00
00001021 00 03
00001022 00 84
00001023 03 00
00001024 84 00
00001025 00 04
00001026 00 84
00001027 04 00
00001028 84 00
00001029 00 05
Teoria de trabalho
Isso pode ser devido a uma incompatibilidade de página de código entre o dispositivo Android e o dispositivo que está executando o ADB? Eu estou pensando isso por duas razões:
- Os bytes correspondentes geralmente são "00", que acredito serem conservados em diferentes páginas de código.
- Parece haver um número surpreendente de conversões diretas byte1 -> byte2. Muitos para serem inteiramente devidos ao acaso.
Exemplos:
- 20 -> C0 (ver 0000049B e 000004C3)
- 62 -> 59 (consulte 00000499 e 000004A9)
- 0D -> 3D (consulte 00000490 e 000004A0, mas diferente em 0000050D e 0000050E)
- 1B -> 20 (consulte 0000042F e 00000433)
- 2B -> 30 (consulte 0000042D e 00000431)
- 2C -> BF (consulte 0000049D e 000004C5)
- 2E -> 1E (consulte 00000491 e 000004A1)
- 4B -> 8B (consulte 00000498 e 000004A8)
- 4D -> 6B (ver 0000049C e 000004C4)
- AD -> 47 (consulte 0000042E abd 00000432, mas diferente em 000004BD)
Como você pode ver, uma consistência notável. As diferenças podem ocorrer devido a alterações no dispositivo de bloco entre as duas leituras do arquivo de imagem.
Alguém pode identificar a página de código do primeiro arquivo? (Se essa teoria realmente se mantiver.)