De acordo com JEDEC eMMC e experiência, é meticulosamente organizado, proteção original e reimpressão é proibida .
Homepage " Meta Storage - Blog CSDN "
Texto completo 15000 palavras, conteúdo principal
Inicialização do eMMC no Linux
Ferramenta de depuração Linux eMMCMMC-utils
função mmc-utils
consumidor mmc-utils
Ferramenta de teste de desempenho Linux/Android eMMC
testes DD
teste FIO
teste IOZone
Kernal mmc_test
O conteúdo deste artigo é baseado em dicas práticas e não pode ser totalmente explicado para cada Ferramenta. Os leitores não precisam memorizá-lo automaticamente, apenas salvá-lo e usá-lo como um livro de referência.
Quanto à ferramenta, basta escolher a que mais lhe agrada, não existe a melhor, apenas a mais adequada. Se for relativamente simples de usar, basta usar MMC-utils e keneral mmc_test. Se você for mais aprofundado, use MMC-utils, DD test e FIO Test. DD é fácil de começar e FIO é relativamente profissional, mas é claro que será mais complicado de usar.
cartilha
Neste artigo, o Linux é usado para ilustrar, porque o Android é baseado no kernel do Linux, então o método neste artigo também é aplicável ao Android.
Inicialização do eMMC no Linux
Como SD, SDIO e MMC são muito semelhantes, como o Linux reconhece o MMC? O processo de identificação durante a inicialização do dispositivo é o seguinte:
- Ao inicializar, primeiro envie cmd0 para fazer o cartão entrar no estado ocioso ;
- Em seguida, envie cmd8 para verificar se o cartão é SD2.0. SD1.1 não suporta cmd8, então se não houver resposta ao enviar cmd8, o cartão é SD1.1, caso contrário é SD2.0;
- mmc_attach_sdio envia cmd5 para ler o registro OCR para determinar se é sdio e, se for, liga o barramento sdio;
- mmc_attach_sd envia comandos acmd55 e cmd41 para fazer o cartão entrar no estado de trabalho. Se passar, é considerado um cartão SD e vinculado ao barramento SD. O cartão mmc não suporta acmd55 e cmd41, portanto, se não houver resposta, o cartão é considerado um cartão mmc;
- Envie cmd1 em mmc_attach_mmc para julgar se é um cartão mmc e, se responder, vincule o barramento mmc. Se não houver resposta do cmd1, não é o cartão mmc.
Ferramenta de depuração Linux eMMCMMC -utils
[3] Ferramentas de depuração MMC para mmc-utils, mantidas por Ulf Hansson , você pode encontrá-las no seguinte repositório git público:
https://git.kernel.org/pub/scm/utils/mmc/mmc-utils .git
Esta ferramenta de código aberto é usada em um ambiente Linux. O núcleo do Android também é o Linux, e essa ferramenta também pode ser usada, pois a diferença entre o eMMC e o MMC é que um é soldado e o outro é plug-in. Esta ferramenta é aplicável tanto ao eMMC quanto ao MMC.
Vamos dar uma olhada nas funções primeiro.Você não precisa se lembrar de como usar cada função, apenas saber para que você pode usá-la.
função mmc-utils
A ferramenta mmc-utils pode fazer o seguinte:
- Imprimir e analisar dados extcsd .
- Determine o status de proteção contra gravação do eMMC.
- Defina o status de proteção contra gravação do eMMC .
- Defina o tamanho do setor de dados eMMC para 4 KB desativando a emulação.
- Crie uma partição geral GPAP.
- Habilite Enhance Area (área de usuário aprimorada).
- Ativa a confiabilidade de gravação para cada partição.
- Imprima a resposta para STATUS_SEND (CMD13).
- Habilite a partição Boot (inicialização).
- Defina as condições do barramento de bootstrap.
- Ative o recurso eMMC BKOPS .
- Ative permanentemente a função eMMC H/W Reset .
- Desabilite permanentemente a função eMMC H/W Reset .
- Envie o comando Sanitizar .
- A chave de autenticação do programa do dispositivo ( chave de autenticação , usada em RPMB ).
- Os valores do contador da partição RPMB serão lidos no dispositivo de saída padrão (como a tela).
- Leia do dispositivo RPMB para a saída.
- Gravar no dispositivo RPMB a partir do arquivo de dados .
- Ative o recurso eMMC Cache (caching).
- Desative o recurso eMMC Cache (caching).
- Imprimir e analisar dados CID .
- Imprimir e analisar dados CSD .
- Imprimir e analisar dados SCR .
Como usar MMC-utils
Você pode visualizar o uso através do mmc sem parâmetros
Usage:
mmc extcsd read <device>
Print extcsd data from <device>.
mmc writeprotect get <device>
Determine the eMMC writeprotect status of <device>.
mmc writeprotect set <device>
Set the eMMC writeprotect status of <device>.
This sets the eMMC to be write-protected until next boot.
mmc disable 512B emulation <device>
Set the eMMC data sector size to 4KB by disabling emulation on
<device>.
mmc enh_area set <-y|-n> <start KiB> <length KiB> <device>
Enable the enhanced user area for the <device>.
Dry-run only unless -y is passed.
NOTE! This is a one-time programmable (unreversible) change.
mmc write_reliability set <-y|-n> <partition> <device>
Enable write reliability per partition for the <device>.
Dry-run only unless -y is passed.
NOTE! This is a one-time programmable (unreversible) change.
mmc status get <device>
Print the response to STATUS_SEND (CMD13).
mmc bootpart enable <boot_partition> <send_ack> <device>
Enable the boot partition for the <device>.
To receive acknowledgment of boot from the card set <send_ack>
to 1, else set it to 0.
mmc bkops enable <device>
Enable the eMMC BKOPS feature on <device>.
NOTE! This is a one-time programmable (unreversible) change.
mmc hwreset enable <device>
Permanently enable the eMMC H/W Reset feature on <device>.
NOTE! This is a one-time programmable (unreversible) change.
mmc hwreset disable <device>
Permanently disable the eMMC H/W Reset feature on <device>.
NOTE! This is a one-time programmable (unreversible) change.
mmc sanitize <device>
Send Sanitize command to the <device>.
This will delete the unmapped memory region of the device.
mmc help|--help|-h
Show the help.
mmc <cmd> --help
Show detailed help for a command or subset of commands.
0.1
exemplo de uso
mmc extcsd ler /dev/mmc0
Ferramenta de teste de desempenho Linux/Android eMMC
Existem principalmente 4 ferramentas para testes de desempenho emmc do linux :
- DD
- FIO
- IOZone
- Geral mmc_test
Qual é o melhor? As pessoas têm opiniões diferentes, já que coloquei DD em primeiro lugar, vocês saberão qual eu gosto ^^
teste DD
escrever teste de desempenho
Dividimos em dois casos para testar
gravar no dispositivo de bloqueio
A partição de cache é geralmente usada para armazenar o pacote de atualização OTA. Em condições normais, a falha da montagem não afetará a operação normal do sistema, então usamos a partição de cache para o teste de gravação, primeiro encontre o arquivo de dispositivo de bloco correspondente para o cache
1 2 3 |
KKHi3751V810:/ #ls -l /dev/block/platform/soc/f9830000.emmc/by-name/cache < lrwxrwxrwx 1 root root 21 1970-01-01 08:00 /dev/block/platform/soc/f9830000.emmc/by-name/cache -> /dev/block/mmcblk0p18 KKHi3751V810: /# |
O arquivo de dispositivo de bloco da partição de cache é /dev/block/mmcblk0p18.
Escreva um teste:
1 2 3 4 5 6 |
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches KKHi3751V810:/ # busybox dd if=/dev/zero of=/dev/block/mmcblk0p18 bs=1M count=1024 conv=fsync 1024+0 registros em 1024+0 registros fora 1073741824 bytes (1,0 GB) copiados, 24,122624 segundos, 42,4 MB/s KKHi3751V810: /# |
O arquivo de entrada é /dev/zero, que é um dispositivo virtual, podemos pensar que a velocidade de leitura deste dispositivo é infinita, ou seja, a velocidade de leitura não afetará a velocidade de escrita.
bs=1M: grava 1M de cada vez
count=1024: escreve 1024 vezes, ou seja, a quantidade total de dados gravados é 1G
conv=fsync: antes do final de dd, sincroniza os dados com emmc, se este parâmetro não for adicionado , os dados ainda podem estar no cache. Para garantir a precisão dos dados, este parâmetro deve ser adicionado.
Repita o teste várias vezes, a velocidade é basicamente em torno de 42M/s.
gravar no arquivo
1 2 3 4 5 6 |
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches KKHi3751V810:/ # busybox dd if=/dev/zero of=/data/ddtest.bin bs=1M count=1024 conv=fsync < 1024+0 registros em 1024+0 registros fora 1073741824 bytes (1,0 GB) copiados, 30,607905 segundos, 33,5 MB/s KKHi3751V810: /# |
Repita o teste várias vezes, a velocidade é basicamente em torno de 33M/s. Comparado com a gravação direta de arquivos de dispositivo de bloco, é cerca de 10M/s mais lento. Isso pode ser um efeito do sistema de arquivos.
teste de leitura
ler dispositivo de bloco
Basta usar o exemplo que introduzimos acima para limpar o cache, então não vou repetir aqui.
Os dados obtidos no exemplo acima são de cerca de 203M/s.
ler arquivo
1 2 3 4 5 6 |
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches KKHi3751V810:/ # busybox dd if=/data/ddtest.bin of=/dev/null bs=1M count=1024 1024+0 registros em 1024+0 registros fora 1073741824 bytes (1,0 GB) copiados, 4,915286 segundos, 208,3 MB/s KKHi3751V810: /# |
Pegue o arquivo gerado ao testar a velocidade de gravação diretamente, repita o teste várias vezes e a velocidade é basicamente em torno de 208 MB/s.
teste FIO
Reimpresso de: linux emmc test - Zhihu
Você pode obter iops, ler e gravar a taxa de largura de banda e outras informações.
A velocidade de leitura e gravação está intimamente relacionada à profundidade da fila, tamanho do bloco, número de threads, etc., que está relacionada ao princípio de funcionamento do ssd
1. Leitura aleatória (leitura aleatória)
fio -filename=/tmp/test_randread -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=16k -size=30G -numjobs=10 -runtime=600 -group_reporting -name=mytest
Quando 10 tópicos
Grupo de status de execução 0 (todos os trabalhos):
READ: io=51200MB, aggrb=257806KB/s, minb=257806KB/s, maxb=257806KB/s, mint=203365msec, maxt=203365msec
quando um fio
Grupo de status de execução 0 (todos os trabalhos):
READ: io=1024.0MB, aggrb=27522KB/s, minb=27522KB/s, maxb=27522KB/s, mint=38099msec, maxt=38099msec
Quando 2 tópicos
Grupo de status de execução 0 (todos os trabalhos):
READ: io=2048.0MB, aggrb=48400KB/s, minb=48400KB/s, maxb=48400KB/s, mint=43329msec, maxt=43329msec
Gravação aleatória
fio -filename=./test_randread -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=1G -numjobs=10 -runtime=600 -group_reporting -name=mytest
Grupo de status de execução 0 (todos os trabalhos):
WRITE: io=10240MB, aggrb=66959KB/s, minb=66959KB/s, maxb=66959KB/s, mint=156599msec, maxt=156599msec
Estatísticas do disco (leitura/gravação):
sda: ios=1/655282, merge=0/86, ticks=0/135704, in_queue=135652, util=86,80%
leitura sequencial
fio -filename=./test_randread -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=1G -numjobs=5 -runtime=600 -group_reporting -name=mytest
Grupo de status de execução 0 (todos os trabalhos):
READ: io=5120.0MB, aggrb=45658KB/s, minb=45658KB/s, maxb=45658KB/s, mint=114829msec, maxt=114829msec
Gravação sequencial
fio -filename=./test_randread -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=1G -numjobs=5 -runtime=600 -group_reporting -name=mytest
Grupo de status de execução 0 (todos os trabalhos):
WRITE: io=2048.0MB, aggrb=15644KB/s, minb=15644KB/s, maxb=15644KB/s, mint=134053msec, maxt=134053msec
Sobre os problemas de funcionamento do fio
Execute o fio na plataforma Android e descubra que o fio não pode ser executado normalmente por dois motivos
- O programa executável fio importado é de 32 bits, mas a CPU atual é de 64 bits e o kernel em execução não possui bibliotecas relacionadas de 32 bits, incluindo /system/bin/linker, system/lib/libc.so lbc++. so .. . e outros vinculadores dinâmicos, bibliotecas compartilhadas, etc. necessários para a execução de programas de 32 bits; aqui deve ser explicado que a CPU de 64 bits e o Linux suportam a execução de programas de 32 bits em EL0, desde que estejam habilitados no kernel e os programas relevantes de 32 bits são executados importação de biblioteca;
- fio pode ser compilado em um programa estático, então a biblioteca da qual fio precisa depender também deve ser estática.a
- Em relação a seleção do compilador utilizado para compilar o fio, por rodar em ambiente linux que suporta android, o compilador utiliza a versão aarch-linux-android-gcc, pois as funções da biblioteca no kernel também são compiladas utilizando este compilador, e a camada de aplicativo e o compilador do kernel precisam ser consistentes.
Teste FIO em Ação
velocidade de gravação do arquivo
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches
KKHi3751V810:/ # fio -filename=/dev/block/mmcblk0p18 -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=1m -size=1G -numjobs=4 -runtime=60 -group_reporting -name=rand_write_1m
rand_write_1m: (g=0): rw=randwrite, bs=1M-1M/1M-1M/1M-1M, ioengine=psync, iodepth=1
...
fio-2.2.6
Starting 4 threads
Jobs: 3 (f=3): [w(3),_(1)] [98.1% done] [0KB/80734KB/0KB /s] [0/78/0 iops] [eta 00m:01s]
rand_write_1m: (groupid=0, jobs=4): err= 0: pid=8316: Wed Feb 12 21:03:34 2020
write: io=4096.0MB, bw=83067KB/s, iops=81, runt= 50493msec
clat (msec): min=10, max=1361, avg=48.60, stdev=44.45
lat (msec): min=10, max=1361, avg=48.86, stdev=44.44
clat percentiles (msec):
| 1.00th=[ 18], 5.00th=[ 22], 10.00th=[ 23], 20.00th=[ 26],
| 30.00th=[ 34], 40.00th=[ 37], 50.00th=[ 46], 60.00th=[ 48],
| 70.00th=[ 58], 80.00th=[ 65], 90.00th=[ 76], 95.00th=[ 87],
| 99.00th=[ 104], 99.50th=[ 114], 99.90th=[ 758], 99.95th=[ 1123],
| 99.99th=[ 1369]
bw (KB /s): min= 1343, max=41353, per=25.49%, avg=21171.93, stdev=4637.55
lat (msec) : 20=1.51%, 50=60.52%, 100=36.40%, 250=1.37%, 500=0.02%
lat (msec) : 750=0.05%, 1000=0.05%, 2000=0.07%
cpu : usr=0.43%, sys=1.13%, ctx=10620, majf=0, minf=6
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=4096/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=1
Run status group 0 (all jobs):
WRITE: io=4096.0MB, aggrb=83067KB/s, minb=83067KB/s, maxb=83067KB/s, mint=50493msec, maxt=50493msec
Disk stats (read/write):
mmcblk0: ios=54/8332, merge=5/888, ticks=60872/378355, in_queue=439181, util=100.00%
KKHi3751V810:/ #
A velocidade média de gravação de 4 threads é bw=83067KB/s, que é cerca de 80M/s, o que é mais de duas vezes mais rápido que dd.
velocidade de leitura do arquivo
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches
KKHi3751V810:/ # fio -filename=/dev/block/mmcblk0 -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=1m -size=1G -numjobs=4 -runtime=60 -group_reporting -name=rand_read_1m
rand_read_1m: (g=0): rw=randread, bs=1M-1M/1M-1M/1M-1M, ioengine=psync, iodepth=1
...
fio-2.2.6
Starting 4 threads
Jobs: 1 (f=1): [_(3),r(1)] [96.2% done] [148.5MB/0KB/0KB /s] [148/0/0 iops] [eta 00m:01s]
rand_read_1m: (groupid=0, jobs=4): err= 0: pid=7889: Wed Feb 12 20:56:21 2020
read : io=4096.0MB, bw=171813KB/s, iops=167, runt= 24412msec
clat (msec): min=4, max=9350, avg=19.50, stdev=215.06
lat (msec): min=4, max=9350, avg=19.50, stdev=215.06
clat percentiles (msec):
| 1.00th=[ 7], 5.00th=[ 8], 10.00th=[ 8], 20.00th=[ 11],
| 30.00th=[ 11], 40.00th=[ 11], 50.00th=[ 11], 60.00th=[ 14],
| 70.00th=[ 14], 80.00th=[ 14], 90.00th=[ 14], 95.00th=[ 14],
| 99.00th=[ 16], 99.50th=[ 30], 99.90th=[ 2638], 99.95th=[ 4113],
| 99.99th=[ 9372]
bw (KB /s): min= 964, max=145420, per=46.41%, avg=79740.53, stdev=25495.41
lat (msec) : 10=13.77%, 20=85.55%, 50=0.29%, 100=0.12%, 500=0.05%
lat (msec) : 750=0.05%, 2000=0.05%, >=2000=0.12%
cpu : usr=0.22%, sys=3.16%, ctx=9195, majf=0, minf=1030
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=4096/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=1
Run status group 0 (all jobs):
READ: io=4096.0MB, aggrb=171813KB/s, minb=171813KB/s, maxb=171813KB/s, mint=24412msec, maxt=24412msec
Disk stats (read/write):
mmcblk0: ios=8365/46, merge=15/47, ticks=633927/61332, in_queue=695214, util=99.20%
KKHi3751V810:/ #
A velocidade média de leitura de 4 threads é bw=171813KB/s, que é cerca de 170M/s.
teste IOZone
Não há iozone no código-fonte do sistema Android, temos que baixar e compilar no site oficial. A versão mais recente quando baixei é iozone3_489. Essa versão já tem Android.mk no código, basta colocar o código-fonte em o código-fonte do sistema Android e mm.
Teste aleatório de leitura e gravação:
KKHi3751V810:/ # echo 1 > /proc/sys/vm/drop_caches
KKHi3751V810:/ # iozone -azecI -+n -L64 -S32 -r1m -s1024m -i0 -i2 -w -f /data/iozonetest.bin
Iozone: Performance Test of File I/O
Version $Revision: 3.489 $
Compiled for 64 bit mode.
Build: linux-arm
Contributors:William Norcott, Don Capps, Isom Crawford, Kirby Collins
Al Slater, Scott Rhine, Mike Wisner, Ken Goss
Steve Landherr, Brad Smith, Mark Kelly, Dr. Alain CYR,
Randy Dunlap, Mark Montague, Dan Million, Gavin Brebner,
Jean-Marc Zucconi, Jeff Blomberg, Benny Halevy, Dave Boone,
Erik Habbinga, Kris Strecker, Walter Wong, Joshua Root,
Fabrice Bacchella, Zhenghua Xue, Qin Li, Darren Sawyer,
Vangel Bojaxhi, Ben England, Vikentsi Lapa,
Alexey Skidanov, Sudhir Kumar.
Run began: Wed Feb 12 20:47:58 2020
Auto Mode
Cross over of record size disabled.
Include fsync in write timing
Include close in write timing
O_DIRECT feature enabled
No retest option selected
Record Size 1024 kB
File size set to 1048576 kB
Setting no_unlink
Command line used: iozone -azecI -+n -L64 -S32 -r1m -s1024m -i0 -i2 -w -f /data/iozonetest.bin
Output is in kBytes/sec
Time Resolution = 0.000001 seconds.
Processor cache size set to 32 kBytes.
Processor cache line size set to 64 bytes.
File stride size set to 17 * record size.
random random bkwd record stride
kB reclen write rewrite read reread read write read rewrite read fwrite frewrite fread freread
1048576 1024 74782 0 199299 71520
iozone test complete.
KKHi3751V810:/ #
A partir dos resultados, a velocidade de leitura aleatória é de 199299 kB/s, que é cerca de 200M/s. A velocidade de gravação aleatória é de 71520 kB/s, que é cerca de 70M/s.
Repita o teste várias vezes, o resultado é semelhante e a velocidade de leitura é basicamente a mesma do dd. Escrever é quase duas vezes mais rápido que dd.
Kernal mmc_test
Reimpresso de: descrição da estrutura mmc do kernel do Linux, incluindo como usar o mmc_test_operation e o blog-CSDN de maintenance_kivy_xian
Use o mmc_test.ko que vem com o kernel linux para executar o teste funcional do mmc, incluindo configuração de velocidade, configuração de largura de barramento, operação múltipla, operação de ajuste, comando e leitura e gravação de dados básicos e outros testes característicos. Você pode seguir os passos abaixo:
1. CONFIG_MMC_BLOCK=n, CONFIG_MMC_TEST=y. Ou CONFIG_MMC_BLOCK=y, CONFIG_MMC_TEST=y. Se você escolher a última configuração, precisará vincular e desvincular manualmente no driver de barramento depois que o sistema estiver ativado, veja mais adiante;
2. CONFIG_DEBUG_FS=y, CONFIG_DEBUG_KERNEL=y, esses dois itens foram configurados no defconfig do kernel do nosso projeto, portanto não há necessidade de fazer alterações;
3. mount -t debugfs nenhum /sys/kernel/debug, este foi montado em nosso projeto, não há necessidade de alterar;
Depois de concluir os três itens acima, inicie o sistema. Se CONFIG_MMC_BLOCK=y na etapa 1, você precisará executar as seguintes operações primeiro:
etau:/ # ls sys/bus/mmc/devices/
mmc0:aaaa
etau:/sys/bus/mmc/drivers # ls
mmc_test/ mmcblk/
etau:/sys/bus/mmc/drivers # cd mmcblk/
etau:/sys/bus/mmc/drivers/mmcblk # ls -al
total 0
drwxr-xr-x 2 raiz raiz 0 2000-01-01 01:27 .
drwxr-xr-x 4 root root 0 2000-01-01 01:27 ..
--w------- 1 root root 4096 2000-01-01 01:28bind
lrwxrwxrwx 1 root root 0 2000-01-01 01:28 mmc0:aaaa ->../../../../devices/soc0/20a50000.rda-mmc0/mmc_host/mmc0/mmc0:aaaa
--w------- 1 root root 4096 2000-01-01 01:28uevent
--w------- 1 root root 4096 2000-01-01 01:28unbind
etau : / sys / bus / mmc / drivers / mmcblk # echo – n mmc0 : aaaa > unbind
etau:/sys/bus/mmc/drivers # cdmmc_test/
etau:/sys/bus/mmc/drivers/mmc_test # ls
vincular ueevento desvincular
etau : / sys / bus / mmc / drivers / mmc_test # echo – n mmc0 : aaaa > bind
Depois de concluir as operações acima, a ligação do driver mmc0:aaaa e mmc_test é concluída. As etapas subsequentes são exatamente as mesmas, como segue:
etau:/sys/kernel/debug/mmc0/mmc0:aaaa# cat testlist
1: Basic write (no data verification)
2: Basic read (no data verification)
3: Basic write (with data verification)
4: Basic read (with data verification)
5: Multi-block write
6: Multi-block read
7: Power of two block writes
8: Power of two block reads
9: Weird sized block writes
10: Weird sized block reads
11: Badly aligned write
12: Badly aligned read
13: Badly aligned multi-block write
14: Badly aligned multi-block read
15: Correct xfer_size at write (start failure)
16: Correct xfer_size at read (start failure)
17: Correct xfer_size at write (midway failure)
18: Correct xfer_size at read (midway failure)
19: Highmem write
20: Highmem read
21: Multi-block highmem write
22: Multi-block highmem read
23: Best-case read performance
24: Best-case write performance
25: Best-case read performance into scattered pages
26: Best-case write performance from scatteredpages
27: Single read performance by transfer size
28: Single write performance by transfer size
29: Single trim performance by transfer size
30: Consecutive read performance by transfer size
31: Consecutive write performance by transfer size
32: Consecutive trim performance by transfer size
33: Random read performance by transfer size
34: Random write performance by transfer size
35: Large sequential read into scattered pages
36: Large sequential write from scattered pages
37: Write performance with blocking req 4k to 4MB
38: Write performance with non-blocking req 4k to 4MB
39: Read performance with blocking req 4k to 4MB
40: Read performance with non-blocking req 4k to 4MB
41: Write performance blocking req 1 to 512 sg elems
42: Write performance non-blocking req 1 to 512 sg elems
43: Read performance blocking req 1 to 512 sg elems
44: Read performance non-blocking req 1 to 512 sg elems
45: Reset test
Em seguida, execute etau:/sys/kernel/debug/mmc0/mmc0:aaaa# echo 1 > test para ver os resultados do teste:
[314034.644348] mmc0: Iniciando testes de cardmmc0:aaaa...
[314034.645080] mmc0: Caso de teste 1. Basicwrite (sem verificação de dados)...
[314034.647583] mmc0: Resultado: OK
[314034.647827] mmc0: Testes concluídos.
referência
[2] teste emmc linux - Zhihu
[3] Introdução às ferramentas MMC — A documentação do Kernel do Linux
Isenção de responsabilidade :
Este artigo é organizado com base em informações públicas e tem como objetivo introduzir mais conhecimento sobre armazenamento.Os artigos contidos no artigo são apenas a opinião do autor e não constituem investimento ou aconselhamento comercial. Este artigo é apenas para aprendizado e comunicação, não para uso comercial. Se você tiver alguma dúvida ou violação, entre em contato com o autor.