Olá, estou tentando alterar o mapeamento de memória reservada em um sistema linux. Mas em determinado momento do cálculo os valores não batem, vejam só um exemplo:
[color=green]base=0x00000000 ( 0MB), size=1024MB
base=0x40000000 (1024MB), size= 256MB
base=0x50000000 (1280MB), size= 128MB [/color]
base=[color=red]0x58000000 /color, size= [color=brown]64MB[/color]
[color=green]base=0x5c000000 (1472MB), size= 32MB
base=0x5e000000 (1504MB), size= 16MB [/color]
O exemplo diz que:
[color=red]0x58000000[/color] = [color=blue]1408MB [/color]= [color=brown]64MB[/color]
[color=brown]64[/color] x 1024 x 1024 =[color=orange] 67108864[/color] Bytes
Vamos supor que eu queira trabalhar com o seguinte valor:[color=red] 0x65000000[/color]
Usando um conversor Hexadecimal/Decimal ficaria assim: [color=orange]1694498816[/color] Bytes
Convertendo o valor [color=orange]1694498816[/color] para MB seria [color=blue]1616MB[/color].
.
Na visão geral, depois de converter ficaria assim:
base=[color=red]0x65000000[/color] ([color=blue]1616MB[/color]), size= [color=brown]???[/color]
.
Eu não consigo achar o valor final “size” como mostrado no exemplo.
Estou me perdendo em algum lugar do cálculo, vocês entenderam?
Basicamente eu preciso saber qual a relação entre os valores MB e size:
base=0x00000000 ( [color=blue]0MB[/color]), [color=red]size=1024MB[/color]
base=0x40000000 ([color=blue]1024MB)[/color], [color=red]size=264MB[/color]
base=0x50000000 ([color=blue]1280MB)[/color], [color=red]size=128MB[/color]
base=0x58000000 ([color=blue]1408MB)[/color], [color=red]size=64MB[/color]
base=0x5c000000 ([color=blue]1472MB)[/color], [color=red]size=32MB[/color]
base=0x5e000000 ([color=blue]1504MB)[/color], [color=red]size=16MB[/color]
Assim, seguindo a lógica eu chegaria no resultado size abaixo:
base=0x65000000 (1616MB), size= ???
Não se esqueça que o mapeamento de memória para uma aplicação
a) É virtual (ou seja, o endereço de memória virtual não bate com o endereço de memória física - pode até se referir a uma região na partição de swap, em vez de um local na memória física)
b) Não precisa ser contínuo. Portanto, o tamanho não tem a ver com o endereço - pode ser menor que a diferença entre dois endereços, por exemplo. Tudo depende de como foi solicitada a alocação desse bloco de memória virtual.
Eu sei disso, não estou definindo o local, e sim a quantidade de memória reservado para determinadas funções.
Para isso eu preciso saber a relação desses números:
0MB, size=1024MB
1024MB, size=264MB
1280MB, size=128MB
1408MB, size=64MB
1472MB, size=32MB
1504MB, size=16MB
A partir do hexadecimal 0x60000000, por exemplo, eu só consigo chegar no valor da primeira coluna (1616).
Sabendo a relação entre os números acima eu poderia calcular quantos MB representa o 1616.
Talvez eu esteja entendendo errado, talvez minha pergunta não faça sentido. De qualquer forma, obrigado.
Se o mapeamento for contínuo, como é o caso que você mostrou, o tamanho do bloco ANTERIOR é a diferença entre o endereço do início do bloco ATUAL e do bloco ANTERIOR. Mas você quer o tamanho do bloco ATUAL sem saber o endereço inicial do PRÓXIMO bloco; aí como é que dá para fazer a conta?
Olá, amigo. Obrigado pela resposta.
Na verdade essa relação é apenas um exemplo que peguei na internet. Mas ao que parece os valores em hexadecimal variam (ainda não achei qual a base/cálculo que faz essa variação), mas as vezes 0x20000000 corresponde a 4mb, outras a 32mb.
Segue o meu código (não meu, do Linus Torvalds):
mi->nr_banks = 2;
mi->bank[0].start = UL(0x50000000);
mi->bank[0].size = (128 * 1024 * 1024);
mi->bank[0].node = PHYS_TO_NID(0x50000000);
mi->bank[1].start = UL(0x60000000);
mi->bank[1].size = PHYS_UNRESERVED_SIZE;
mi->bank[1].node = PHYS_TO_NID(0x60000000);
#define DRAM_END_ADDR (UL(0x65000000))
#define RESERVED_PMEM_END_ADDR (DRAM_END_ADDR)
#define RESERVED_G3D (32 * 1024 * 1024)
#define PHYS_UNRESERVED_SIZE (RESERVED_G3D - UL(0x60000000))
Eu precisaria entender o sistema de conversão/base hexadecimal que esse código usa, para assim poder alterar os valores coordenadamente. Aparantemente vem da função (UL) essa conversão. Na última linha do código que eu coloquei você pode ver ele subtraindo o hexadecimal convertido de um valor em kbytes.
De qualquer forma eu cheguei a conclusão de que poderia alterar os valores reservados para cada função sem alterar as bases hexadecimais, já fiz a alteração. Obrigado mais uma vez.
UL aparentemente é uma macro que expande para “(unsigned long)”. Ou seja, um simples cast. Senão, pode ser uma outra macro que pega o valor que está escrito (por exemplo, 0x50000000) e adiciona o sufixo “UL”, que em alguns compiladores C indica uma constante “unsigned long” - ou seja, 0x50000000UL.