[万字] ferramenta de depuração eMMC | ferramenta de teste de desempenho eMMC/MMC MMC -utils | teste DD | teste FIO | teste IOZone | Kernal mmc test combate real

De acordo com JEDEC eMMC e experiência, é meticulosamente organizado, proteção original e reimpressão é proibida .

Homepage " Meta Storage - Blog CSDN "

abstrato

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:

  1. Ao inicializar, primeiro envie cmd0 para fazer o cartão entrar no estado ocioso ;
  2. 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;
  3. mmc_attach_sdio envia  cmd5  para ler o registro OCR para determinar se é sdio e, se for, liga o barramento sdio;
  4. 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;
  5. 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

  1. 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;
  2. 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
  3. 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

[1]   Descrição da estrutura mmc do kernel do Linux, incluindo como usar o mmc_test_Operation e o blog-CSDN de maintenance_kivy_xian

[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.

Acho que você gosta

Origin blog.csdn.net/vagrant0407/article/details/132112942
Recomendado
Clasificación