[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[273] mplayerxp
Brought to you by:
olov
Menu
▾
▴
[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[273] mplayerxp
|
From: <nic...@us...> - 2012-11-01 14:02:37
|
Revision: 273
http://mplayerxp.svn.sourceforge.net/mplayerxp/?rev=273&view=rev
Author: nickols_k
Date: 2012-11-01 14:02:30 +0000 (Thu, 01 Nov 2012)
Log Message:
-----------
new extensions of mp_malloc
Modified Paths:
--------------
mplayerxp/mplayer.c
mplayerxp/osdep/mp_malloc.c
mplayerxp/osdep/mplib.h
Modified: mplayerxp/mplayer.c
===================================================================
--- mplayerxp/mplayer.c 2012-11-01 08:38:09 UTC (rev 272)
+++ mplayerxp/mplayer.c 2012-11-01 14:02:30 UTC (rev 273)
@@ -172,9 +172,9 @@
static int mpxp_init_antiviral_protection(int verbose)
{
int rc;
- rc=mp_mprotect(antiviral_hole1,sizeof(antiviral_hole1),MP_PROT_NONE);
- rc|=mp_mprotect(antiviral_hole2,sizeof(antiviral_hole2),MP_PROT_NONE);
- rc|=mp_mprotect(antiviral_hole3,sizeof(antiviral_hole3),MP_PROT_NONE);
+ rc=mp_mprotect(antiviral_hole1,sizeof(antiviral_hole1),MP_DENY_ALL);
+ rc|=mp_mprotect(antiviral_hole2,sizeof(antiviral_hole2),MP_DENY_ALL);
+ rc|=mp_mprotect(antiviral_hole3,sizeof(antiviral_hole3),MP_DENY_ALL);
if(verbose) {
if(rc)
MSG_ERR("*** Error! Cannot initialize antiviral protection: '%s' ***!\n",strerror(errno));
@@ -187,7 +187,7 @@
static int mpxp_test_antiviral_protection(int verbose)
{
int rc;
- if(verbose) MSG_INFO("Right now MPlayerXP should make coredump!\n");
+ if(verbose) MSG_INFO("Your've specified test-av option!\nRight now MPlayerXP should make coredump!\n");
rc=antiviral_hole1[0]|antiviral_hole2[0]|antiviral_hole2[0];
MSG_ERR("Antiviral protection of MPlayerXP doesn't work!");
return rc;
@@ -2379,7 +2379,7 @@
int forced_subs_only=0;
seek_args_t seek_args = { 0, DEMUX_SEEK_CUR|DEMUX_SEEK_SECONDS };
- mp_init_malloc(1000,10,MPA_FLG_RANDOMIZER);
+ mp_init_malloc(1000,10,MPA_FLG_RANDOMIZER); // MPA_FLG_BACKTRACE
mpxp_init_structs();
priv_t*priv=mp_data->priv;
Modified: mplayerxp/osdep/mp_malloc.c
===================================================================
--- mplayerxp/osdep/mp_malloc.c 2012-11-01 08:38:09 UTC (rev 272)
+++ mplayerxp/osdep/mp_malloc.c 2012-11-01 14:02:30 UTC (rev 273)
@@ -6,112 +6,20 @@
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
+#include <signal.h>
#include <malloc.h>
+#include <limits.h>
#include <time.h>
+#include <unistd.h>
+#include <execinfo.h>
-#ifdef ENABLE_DEBUG_MALLOC
-any_t*my_malloc(size_t __size)
-{
- char *retval;
- long msize,mval;
- msize = __size;
- retval = mp_malloc(msize+2*sizeof(long));
- if(retval)
- {
- mval = (long)retval;
- memcpy(retval,&msize,sizeof(long));
- memcpy(retval+msize+sizeof(long),&mval,sizeof(long));
- retval += sizeof(long);
- }
-// printf("mp_malloc returns: %08X for size: %08X\n",retval,__size);
- return retval;
-}
+typedef struct mp_slot_s {
+ any_t* page_ptr;
+ size_t size;
+ size_t ncalls;
+ any_t* calls[10];
+}mp_slot_t;
-any_t*my_realloc(any_t*__ptr, size_t __size)
-{
- char *retval,*myptr;
- long crc,osize;
- long msize,mval;
- msize = __size;
- myptr = __ptr;
- if(__ptr)
- {
- memcpy(&osize,(char *)__ptr-sizeof(long),sizeof(long));
- memcpy(&crc,(char *)__ptr+osize,sizeof(long));
- if(crc != (long)((char *)__ptr-sizeof(long)))
- {
- printf("Internal error: my_realloc found out memory corruption!\n");
- printf("INFO: ptr=%p ptr[0]=%lX crc=%lX\n",
- __ptr,
- osize,
- crc);
-#ifdef __i386__
- __asm __volatile(".short 0xffff":::"memory");
-#endif
- }
- myptr -= sizeof(long);
- }
- retval = mp_realloc(myptr,__size+2*sizeof(long));
- {
- mval = (long)retval;
- memcpy(retval,&msize,sizeof(long));
- memcpy(retval+__size+sizeof(long),&mval,sizeof(long));
- retval += sizeof(long);
- }
- return retval;
-}
-
-any_t*my_calloc (size_t __nelem, size_t __size)
-{
- char *retval;
- long my_size;
- long msize,mval;
- msize = __nelem*__size;
- retval = mp_malloc(msize+2*sizeof(long));
- if(retval)
- {
- mval = (long)retval;
- memset(retval+sizeof(long),0,msize);
- memcpy(retval,&msize,sizeof(long));
- memcpy(retval+msize+sizeof(long),&mval,sizeof(long));
- retval += sizeof(long);
- }
- return retval;
-}
-
-void my_free(any_t*__ptr)
-{
- any_t*myptr;
- long crc,osize;
- if(__ptr)
- {
- myptr = (char *)__ptr-sizeof(long);
- memcpy(&osize,(char *)myptr,sizeof(long));
- memcpy(&crc,(char *)myptr+osize+sizeof(long),sizeof(long));
- if(crc != (long)myptr)
- {
- printf("Internal error: my_free found out memory corruption!\n");
- printf("INFO: ptr=%p ptr[0]=%lX crc=%lX\n",
- __ptr,
- osize,
- crc);
-#ifdef __i386__
- __asm __volatile(".short 0xffff":::"memory");
-#endif
- }
- mp_free((char *)__ptr-sizeof(long));
- }
-}
-
-char * my_strdup(const char *s)
-{
- any_t*a;
- a = my_malloc(strlen(s)+1);
- strcpy(a,s);
- return a;
-}
-#endif
-
typedef struct priv_s {
unsigned rnd_limit;
unsigned every_nth_call;
@@ -123,9 +31,156 @@
int enable_stat;
unsigned long long int stat_total_calls;
unsigned long long int stat_num_allocs;
+ mp_slot_t* slots;
+ size_t nslots;
}priv_t;
static priv_t* priv;
+static any_t* prot_page_align(any_t *ptr) { return (any_t*)(((unsigned long)ptr)&(~(__VM_PAGE_SIZE__-1))); }
+static size_t prot_fullsize(size_t size) {
+ unsigned npages = size/__VM_PAGE_SIZE__;
+ unsigned fullsize;
+ if(size%__VM_PAGE_SIZE__) npages++;
+ npages++;
+ fullsize=npages*__VM_PAGE_SIZE__;
+ return fullsize;
+}
+static any_t* prot_last_page(any_t* rp,size_t fullsize) { return rp+(fullsize-__VM_PAGE_SIZE__); }
+static void __prot_print_slots(void) {
+ size_t i;
+ for(i=0;i<priv->nslots;i++) {
+ MSG_INFO("slot[%u] address: %p size: %u\n",i,priv->slots[i].page_ptr,priv->slots[i].size);
+ }
+}
+
+static size_t prot_find_slot_idx(any_t* ptr) {
+ size_t i;
+ for(i=0;i<priv->nslots;i++) {
+ if(priv->slots[i].page_ptr==ptr) return i;
+ }
+ return UINT_MAX;
+}
+
+static mp_slot_t* prot_find_slot(any_t* ptr) {
+ size_t idx=prot_find_slot_idx(ptr);
+ if(idx!=UINT_MAX) return &priv->slots[idx];
+ return NULL;
+}
+
+static mp_slot_t* prot_append_slot(any_t*ptr,size_t size) {
+ mp_slot_t* slot;
+ if(!priv->slots) slot=malloc(sizeof(mp_slot_t));
+ else slot=realloc(priv->slots,sizeof(mp_slot_t)*(priv->nslots+1));
+ priv->slots=slot;
+ memset(&priv->slots[priv->nslots],0,sizeof(mp_slot_t));
+ priv->slots[priv->nslots].page_ptr=ptr;
+ priv->slots[priv->nslots].size=size;
+ priv->nslots++;
+ return &priv->slots[priv->nslots-1];
+}
+
+static void prot_free_slot(any_t* ptr) {
+ size_t idx=prot_find_slot_idx(ptr);
+ if(idx!=UINT_MAX) {
+ memmove(&priv->slots[idx],&priv->slots[idx+1],sizeof(mp_slot_t)*(priv->nslots-(idx+1)));
+ priv->slots=realloc(priv->slots,sizeof(mp_slot_t)*(priv->nslots-1));
+ priv->nslots--;
+ }
+}
+
+static any_t* __prot_malloc(size_t size) {
+ any_t* rp;
+ size_t fullsize=prot_fullsize(size);
+ rp=mp_memalign(__VM_PAGE_SIZE__,fullsize);
+ if(rp) {
+ prot_append_slot(rp,size);
+ // protect last page here
+ mprotect(prot_last_page(rp,fullsize),__VM_PAGE_SIZE__,MP_DENY_ALL);
+ rp+=fullsize-__VM_PAGE_SIZE__-size;
+ }
+ return rp;
+}
+
+static void __prot_free(any_t*ptr) {
+ any_t *page_ptr=prot_page_align(ptr);
+ free(page_ptr);
+ mp_slot_t* slot=prot_find_slot(page_ptr);
+ if(!slot) {
+ printf("Internal error! Can't find slot for address: %p\n",ptr);
+ __prot_print_slots();
+ kill(getpid(), SIGILL);
+ }
+ size_t fullsize=prot_fullsize(slot->size);
+ mprotect(prot_last_page(page_ptr,fullsize),__VM_PAGE_SIZE__,MP_PROT_READ|MP_PROT_WRITE);
+ prot_free_slot(ptr);
+}
+
+#define min(a,b) ((a)<(b)?(a):(b))
+static any_t* __prot_realloc(any_t*ptr,size_t size) {
+ any_t* rp;
+ if((rp=__prot_malloc(size))!=NULL && ptr) {
+ mp_slot_t* slot=prot_find_slot(prot_page_align(ptr));
+ if(!slot) {
+ printf("Internal error! Can't find slot for address: %p\n",ptr);
+ __prot_print_slots();
+ kill(getpid(), SIGILL);
+ }
+ memcpy(rp,ptr,min(slot->size,size));
+ __prot_free(ptr);
+ }
+ return rp;
+}
+
+static any_t* prot_malloc(size_t size) {
+ any_t* rp;
+ rp=__prot_malloc(size);
+ return rp;
+}
+
+static any_t* prot_realloc(any_t*ptr,size_t size) {
+ any_t* rp;
+ rp=__prot_realloc(ptr,size);
+ return rp;
+}
+
+static void prot_free(any_t*ptr) {
+ __prot_free(ptr);
+}
+
+static __always_inline any_t* bt_malloc(size_t size) {
+ any_t*rp;
+ mp_slot_t* slot;
+ rp=malloc(size);
+ if(rp) {
+ slot=prot_append_slot(rp,size);
+ slot->ncalls=backtrace(slot->calls,10);
+ }
+ return rp;
+}
+
+static __always_inline any_t* bt_realloc(any_t*ptr,size_t size) {
+ return realloc(ptr,size);
+}
+
+static __always_inline void bt_free(any_t*ptr) {
+ mp_slot_t* slot=prot_find_slot(ptr);
+ if(!slot) {
+ MSG_WARN("Internal error! Can't find slot for address: %p\n",ptr);
+ }
+ prot_free_slot(ptr);
+ free(ptr);
+}
+
+static void bt_print_slots(void) {
+ size_t i,j;
+ for(i=0;i<priv->nslots;i++) {
+ MSG_INFO("Alloc's address: %p size: %u bt_stack: %u\n",priv->slots[i].page_ptr,priv->slots[i].size,priv->slots[i].ncalls);
+ for(j=0;j<priv->slots[i].ncalls;j++) {
+ MSG_INFO(" %p\n",priv->slots[i].calls[j]);
+ }
+ }
+}
+/* ================== HEAD ======================= */
void mp_init_malloc(unsigned rnd_limit,unsigned every_nth_call,enum mp_malloc_e flags)
{
if(!priv) priv=malloc(sizeof(priv_t));
@@ -139,6 +194,7 @@
{
if(priv->num_allocs && verbose)
MSG_WARN("Warning! From %lli total calls of alloc() were not freed %lli buffers\n",priv->total_calls,priv->num_allocs);
+ if(priv->flags&MPA_FLG_BACKTRACE) bt_print_slots();
free(priv);
priv=NULL;
}
@@ -147,12 +203,14 @@
{
any_t* rb,*rnd_buff=NULL;
if(!priv) mp_init_malloc(1000,10,MPA_FLG_RANDOMIZER);
- if(priv->every_nth_call && priv->rnd_limit) {
+ if(priv->every_nth_call && priv->rnd_limit && !priv->flags) {
if(priv->total_calls%priv->every_nth_call==0) {
rnd_buff=malloc(rand()%priv->rnd_limit);
}
}
- rb = malloc(__size);
+ if(priv->flags&(MPA_FLG_BOUNDS_CHECK|MPA_FLG_BEFORE_CHECK)) rb=prot_malloc(__size);
+ else if(priv->flags&MPA_FLG_BACKTRACE) rb=bt_malloc(__size);
+ else rb=malloc(__size);
if(rnd_buff) free(rnd_buff);
priv->total_calls++;
priv->num_allocs++;
@@ -163,14 +221,35 @@
return rb;
}
-any_t* mp_realloc(any_t*__ptr, size_t __size) { return realloc(__ptr,__size); }
+any_t* mp_realloc(any_t*__ptr, size_t __size) {
+ any_t* rp;
+ if(priv->flags&(MPA_FLG_BOUNDS_CHECK|MPA_FLG_BEFORE_CHECK)) rp=prot_realloc(__ptr,__size);
+ else if(priv->flags&MPA_FLG_BACKTRACE) rp=bt_realloc(__ptr,__size);
+ else rp=realloc(__ptr,__size);
+ return rp;
+}
+void mp_free(any_t*__ptr)
+{
+ if(!priv) mp_init_malloc(1000,10,MPA_FLG_RANDOMIZER);
+ if(__ptr) {
+ if(priv->flags&(MPA_FLG_BOUNDS_CHECK|MPA_FLG_BEFORE_CHECK)) prot_free(__ptr);
+ else if(priv->flags&MPA_FLG_BACKTRACE) bt_free(__ptr);
+ else free(__ptr);
+ priv->num_allocs--;
+ if(priv->enable_stat) priv->stat_num_allocs--;
+ }
+}
+
+/* ================ APPENDIX ==================== */
+
any_t* mp_mallocz (size_t __size) {
any_t* rp;
rp=mp_malloc(__size);
if(rp) memset(rp,0,__size);
return rp;
}
+
/* randomizing of memalign is useless feature */
any_t* mp_memalign (size_t boundary, size_t __size)
{
@@ -180,20 +259,12 @@
return memalign(boundary,__size);
}
-void mp_free(any_t*__ptr)
-{
- if(!priv) mp_init_malloc(1000,10,MPA_FLG_RANDOMIZER);
- free(__ptr);
- priv->num_allocs--;
- if(priv->enable_stat) priv->stat_num_allocs--;
-}
-
char * mp_strdup(const char *src) {
char *rs=NULL;
if(src) {
unsigned len=strlen(src);
rs=mp_malloc(len+1);
- strcpy(rs,src);
+ if(rs) strcpy(rs,src);
}
return rs;
}
Modified: mplayerxp/osdep/mplib.h
===================================================================
--- mplayerxp/osdep/mplib.h 2012-11-01 08:38:09 UTC (rev 272)
+++ mplayerxp/osdep/mplib.h 2012-11-01 14:02:30 UTC (rev 273)
@@ -61,7 +61,7 @@
MP_PROT_READ =0x1, /* Page can be read. */
MP_PROT_WRITE =0x2, /* Page can be written. */
MP_PROT_EXEC =0x4, /* Page can be executed. */
- MP_PROT_NONE =0x0, /* Page can not be accessed. */
+ MP_DENY_ALL =0x0, /* Page can not be accessed. */
};
extern int __FASTCALL__ mp_mprotect(const any_t* addr,size_t len,enum mp_prot_e flags);
#endif
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
