MemoryManager - Theldus

###########################################################
#PROPOSITO: Simples gerenciador de memoria                #
#                                                         #
#NOTAS: Isto e(ou deveria ser) um simples gerenciador     #
#       de memoria que segue a estrutura abaixo para      #
#       cada campo adicionado.                            #
#                                                         #
###########################################################
# #Disponivel#Tamanho memoria#Localizacao atual memoria#  #
###########################################################
#                             ^--Ponteiro retornado       #
#                                aponta aqui              #
#         O ponteiro retornado, aponta para o inicio      #
#         da regiao de memoria a comecar a ser escrita    #
#        -(ate onde testei nao haviam leaks)-             #
#-(memoria so e liberada efetivamente no termino do prog)-#
#                                                         #
#Para montar e linkar:                                    #
#as theldus.s -o theldus.o                                #
#ld theldus.o -o libtheldus.so -shared                    #
#                                                         #
#Para usar:                                               #
#LD_PRELOAD=./libtheldus.so ./seuprogemC          #
#                             #
#*Seu programa para fazer uso do gerenciador, devera      #
#utilizar malloc e free, :D               #
#     --Funciona somente em sistemas Linux x86--          #
#                             #
#by Theldus 2014                                          #
###########################################################

.section .data
#######VARIAVEIS GLOBAIS########

#Aponta inicio da memoria
heap_begin:
.long 0

#Aponta para 1 posicao a frente do Break
current_break:
.long 0

pos_free:
.long 0

size_field:
.long 0

popup: .ascii "\n###########################\n#Theldus MemoryManager, :D#\n###########################\n\0"
.equ len_Popup, .-popup

######INFORMACAO DO HEADER####
#  1byte avail / 4bytes size #

#Tamanho do header
.equ HEADER_SIZE, 5
#Campo 'disponivel' no header
.equ HDR_AVAIL,0
#Campo tamanho no header
.equ HDR_SIZE,1
#Tamanho minimo para particionar 'bloco'
.equ TAM_MIN,HEADER_SIZE+1


###########CONSTANTES###########
.equ INDISP, 0
.equ DISP, 1
.equ SYS_BRK, 45

.equ SYSCALL, 0x80

.section .text

#############Funcao Malloc_Init#############
#                                          #
#Apenas inicializa as posicoes inicias do  #
#break e do heap.                          #
#                                          #
#       -nao requer parametros-            #
############################################

.globl malloc_init
.type  malloc_init,@function
malloc_init:
pushl %ebp
movl  %esp,%ebp

#Propaganda, hu3hu3hu3#
movl $4,%eax
movl $2,%ebx
movl $popup,%ecx
movl $len_Popup,%edx
int  $SYSCALL

movl $0,%eax
movl $0,%ebx
movl $0,%ecx
movl $0,%edx
######################

movl $SYS_BRK,%eax
movl $0,%ebx
int  $SYSCALL

incl %eax    #<-- obtem primeira posicao inacessivel memoria
movl %eax,heap_begin
movl %eax,current_break

movl %ebp,%esp
popl %ebp
ret

#############Funcao Malloc##################
#                                          #
#Reserva espaco na heap de acordo com o    #
#o tamanho informado em 8(%ebp).           #
#                                          #
#8(%ebp)=ecx (tamanho a ser reservado)     #
#eax=pos heap analisada momento            #
#ebx=breakpoint atual                      #
#ecx=tamanho a ser alocado                 #
#edx=espaco da posicao atual do heap       #
#-4,-8 e -12(%ebp)=eventual temp           #
############################################

.globl malloc
.type  malloc,@function
malloc:
pushl %ebp
movl  %esp,%ebp
subl  $12,%esp

#Assegura da inicializacao correta do Heap e Break#
cmpl $0,current_break
jne  alloc_begin
call malloc_init
###################################################

alloc_begin:
movl 8(%ebp),%ecx       #tamanho a ser alocado
movl heap_begin,%eax    #inicio heap / posicao do heap analisada no momento
movl current_break,%ebx #break point atual

movl $0,pos_free
movl $0,size_field

alloc_start:

#se true, e necessario syscall para alocar espaco, :D
cmpl %ebx,%eax
je   new_space

#obtem espaco da primeira posicao do heap#
movl HDR_SIZE(%eax),%edx

#se =, pos indisponivel
cmpb $INDISP,HDR_AVAIL(%eax)
jne  found
movl $0,pos_free
movl $0,size_field
jmp  next_position

#se <=, encontrado, :D:D
found:
cmpl %edx,%ecx
jle  space_found

#DISP e < do que tamanho requerido#
treat_small_space:
    cmpl $0,pos_free
    je   tss_firstPos

    #Header agora tambem fara parte dos dados, 5bytes extras, :D
    addl %edx,size_field
    addl $HEADER_SIZE,size_field

    #Se ainda <, va tentar de novo
    cmpl %ecx,size_field
    jl   next_position

    #Se >=, encontramos, :D#
    movl size_field,%edx

    movl pos_free,%eax
    movl %edx,HDR_SIZE(%eax)
    movb $INDISP,HDR_AVAIL(%eax)
    addl $HEADER_SIZE,%eax

    movl %ebp,%esp
    popl %ebp
    ret

    tss_firstPos:
        movl %eax,pos_free
        movl %edx,size_field

next_position:
    addl $HEADER_SIZE,%eax #<-- deslocamento para a proxima memoria
    addl %edx,%eax         #no header ja levando em conta o tamanho do header
                           #+ o tamanho reservado.
    jmp alloc_start

space_found:
    movb $INDISP,HDR_AVAIL(%eax) #<-- o HDR_SIZE nao e alterado pelo fato de a posicao
                     #atual poder ser >= a posicao exigida, entao ao alterar o size
                     #levaria a deslocamentos incorretos ao navegar pelo heap, :/

    #Verifica se o espaco encontrado e grande o suficiente para ser dividido em um novo 'bloco'#
    subl %ecx,%edx

    #Verifica se ha espaco minimo para divisao#
    cmpl $TAM_MIN,%edx
    jl   sf_nodivide

    #Se >=, preparamos os headers#
    movl %ecx,HDR_SIZE(%eax) #<- primeiro header, o que sera usado
    addl $HEADER_SIZE,%eax #<-- ajusta ponteiro para a 1a posicao livre da memoria
    movl %eax,-4(%ebp)

    #Primeiro bloco OK, agora segundo...#
    addl %ecx,%eax #<- eax aponta para novo header
    movb $DISP,HDR_AVAIL(%eax)
    subl $HEADER_SIZE,%edx
    movl %edx,HDR_SIZE(%eax)

    movl -4(%ebp),%eax

    movl %ebp,%esp
    popl %ebp
    ret

    sf_nodivide:
        addl $HEADER_SIZE,%eax
        movl %ebp,%esp
        popl %ebp
        ret

#para setarmos uma nova posicao para o break, precisamos: pos break+tamanho_header+qtd dados#
new_space:
    addl $HEADER_SIZE,%ebx
    addl %ecx,%ebx

    pushl %eax
    pushl %ebx
    pushl %ecx

    movl $SYS_BRK,%eax #<-- sobe o sysbreak atual para mapear + memoria, :D
    int  $SYSCALL

    cmpl $0,%eax
    je   new_space_error

    popl %ecx
    popl %ebx
    popl %eax

    #adiciona as flags de tamanho e 'status' para o header da memoria
    movb $INDISP,HDR_AVAIL(%eax)
    movl %ecx,HDR_SIZE(%eax)

    addl $HEADER_SIZE,%eax

    movl %ebx,current_break #<-- salva sysbreak atual

    #encerra
    movl %ebp,%esp
    popl %ebp
    ret

#impossivel alocar mais espaco# ;'(
new_space_error:
    movl $0,%eax
    movl %ebp,%esp
    popl %ebp
    ret

movl %ebp,%esp
popl %ebp
ret

############################################
#############Funcao Free####################
#                                          #
#Libera espaco na heap de acordo com o     #
#o tamanho informado em 8(%ebp).           #
#                                          #
#8(%ebp)=ecx (tamanho a ser desalocado)    #
############################################
.globl free
.type free,@function
free:
pushl %ebp
movl  %esp,%ebp

movl 8(%ebp),%eax
subl $HEADER_SIZE,%eax     #<- voltar ao ponto de inicio do header
movb $DISP,HDR_AVAIL(%eax)

movl %ebp,%esp
popl %ebp
ret