drm: Fix various static analysis issues
v2 cover drm: Fix various static analysis issues
v2:
Rebased few patches to the latest.
Dropped one patch which was already merged.
Addressed the comments from Chris.
v1:
This patch set fixes various issues reported by a static analysis tool.
Praveen Paneri (11):
intel: Validate bo_fake before using.
intel: Validate output of realloc()
intel: Use snprintf instead of sprintf
intel: Validate pointer before using
xf86drm: Avoid negative array index value
xf86drmSL: Check function return value
intel: Validate memory allocations
drm: Validate memory allocations
xf86drmSL: Check memory allocation by SL_RANDOM_INIT()
xf86drmHash: Check memory allocation in HashHash()
xf86drm: Validate function return value
intel/intel_bufmgr_fake.c | 20 +++++++--- intel/intel_bufmgr_gem.c | 99 ++++++++++++++++++++++++++++++++++------------- intel/intel_decode.c | 14 ++++--- xf86drm.c | 77 ++++++++++++++++++++++++++++-------- xf86drmHash.c | 9 +++++ xf86drmSL.c | 7 ++++ 6 files changed, 171 insertions(+), 55 deletions(-)
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 1/11 intel: Validate bo_fake before using.
Check on bo_fake before dereferencing the object in functions evict_lru and evict_mru.
--- intel/intel_bufmgr_fake.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
intel/intel_bufmgr_fake.c +10 -6
@@ -557,8 +557,10 @@ evict_lru(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int max_fence) max_fence))return 0 ; -set_dirty (&bo_fake->bo); - bo_fake->block =NULL ; +if (bo_fake) { +set_dirty (&bo_fake->bo); + bo_fake->block =NULL ; + }free_block (bufmgr_fake, block,0 );return 1 ;
@@ -577,11 +579,13 @@ evict_mru(drm_intel_bufmgr_fake *bufmgr_fake) DRMLISTFOREACHSAFEREVERSE(block, tmp, &bufmgr_fake->lru) {drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) block->bo; -if (bo_fake && (bo_fake->flags &BM_NO_FENCE_SUBDATA )) -continue ; +if (bo_fake) { +if (bo_fake->flags &BM_NO_FENCE_SUBDATA ) +continue ; -set_dirty (&bo_fake->bo); - bo_fake->block =NULL ; +set_dirty (&bo_fake->bo); + bo_fake->block =NULL ; + }free_block (bufmgr_fake, block,0 );return 1 ;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 2/11 intel: Validate output of realloc()
In reply to Praveen Panerirealloc will return NULL if failed to allocate the extra memory requested. Return -ENOMEM from the function if it fails.
v2: Modifications to propagate relloc failure to caller functions
and skip the execbuffer ioctl. (Chris)
--- intel/intel_bufmgr_gem.c | 96 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 69 insertions(+), 27 deletions(-)
intel/intel_bufmgr_gem.c +69 -27
@@ -427,15 +427,17 @@ drm_intel_gem_bo_reference(drm_intel_bo *bo)* with the intersection of the memory type flags and the union of the * access flags. */ -static void +static int drm_intel_add_validate_buffer (drm_intel_bo *bo) {drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;int index; +struct drm_i915_gem_exec_object *exec_objects; +drm_intel_bo **exec_bos;if (bo_gem->validate_index !=-1 ) -return ; +return 0 ;/* Extend the array of validation entries as necessary. */ if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
@@ -444,12 +446,22 @@ drm_intel_add_validate_buffer(drm_intel_bo *bo)if (new_size ==0 ) new_size =5 ; - bufmgr_gem->exec_objects = -realloc (bufmgr_gem->exec_objects, -sizeof (*bufmgr_gem->exec_objects) * new_size); - bufmgr_gem->exec_bos = -realloc (bufmgr_gem->exec_bos, + exec_objects =realloc (bufmgr_gem->exec_objects, +sizeof (*bufmgr_gem->exec_objects) * new_size); +if (!exec_objects) { +return -ENOMEM ; + } + + bufmgr_gem->exec_objects = exec_objects; + + exec_bos =realloc (bufmgr_gem->exec_bos,sizeof (*bufmgr_gem->exec_bos) * new_size); +if (!exec_bos) { +return -ENOMEM ; + } + + bufmgr_gem->exec_bos = exec_bos; + bufmgr_gem->exec_size = new_size; }
@@ -463,20 +475,23 @@ drm_intel_add_validate_buffer(drm_intel_bo *bo) bufmgr_gem->exec_objects[index].offset =0 ; bufmgr_gem->exec_bos[index] = bo; bufmgr_gem->exec_count++; +return 0 ; } -static void +static int drm_intel_add_validate_buffer2 (drm_intel_bo *bo,int need_fence) {drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;int index; +struct drm_i915_gem_exec_object2 *exec2_objects; +drm_intel_bo **exec_bos;if (bo_gem->validate_index !=-1 ) {if (need_fence) bufmgr_gem->exec2_objects[bo_gem->validate_index].flags |=EXEC_OBJECT_NEEDS_FENCE ; -return ; +return 0 ; }/* Extend the array of validation entries as necessary. */
@@ -486,12 +501,19 @@ drm_intel_add_validate_buffer2(drm_intel_bo *bo, int need_fence)if (new_size ==0 ) new_size =5 ; - bufmgr_gem->exec2_objects = -realloc (bufmgr_gem->exec2_objects, + exec2_objects =realloc (bufmgr_gem->exec2_objects,sizeof (*bufmgr_gem->exec2_objects) * new_size); - bufmgr_gem->exec_bos = -realloc (bufmgr_gem->exec_bos, +if (!exec2_objects) +return -ENOMEM ; + + bufmgr_gem->exec2_objects = exec2_objects; + + exec_bos =realloc (bufmgr_gem->exec_bos,sizeof (*bufmgr_gem->exec_bos) * new_size); +if (!exec_bos) +return -ENOMEM ; + + bufmgr_gem->exec_bos = exec_bos; bufmgr_gem->exec_size = new_size; }
@@ -512,6 +534,7 @@ drm_intel_add_validate_buffer2(drm_intel_bo *bo, int need_fence)EXEC_OBJECT_NEEDS_FENCE ; } bufmgr_gem->exec_count++; +return 0 ; }#define RELOC_BUF_SIZE (x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
@@ -1931,14 +1954,14 @@ drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start)* validations to be performed and update the relocation buffers with * index values into the validation list. */ -static void +static int drm_intel_gem_bo_process_reloc (drm_intel_bo *bo) {drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; -int i; +int i, ret =0 ;if (bo_gem->relocs ==NULL ) -return ; +return 0 ;for (i =0 ; i < bo_gem->reloc_count; i++) {drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
@@ -1949,21 +1972,26 @@ drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)drm_intel_gem_bo_mark_mmaps_incoherent (bo);/* Continue walking the tree depth-first. */ -drm_intel_gem_bo_process_reloc (target_bo); + ret =drm_intel_gem_bo_process_reloc (target_bo); +if (ret) +break ;/* Add the target to the validate list */ -drm_intel_add_validate_buffer (target_bo); + ret =drm_intel_add_validate_buffer (target_bo); +if (ret) +break ; } +return ret; } -static void +static int drm_intel_gem_bo_process_reloc2 (drm_intel_bo *bo) {drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; -int i; +int i, ret =0 ;if (bo_gem->relocs ==NULL ) -return ; +return 0 ;for (i =0 ; i < bo_gem->reloc_count; i++) {drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
@@ -1975,14 +2003,19 @@ drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)drm_intel_gem_bo_mark_mmaps_incoherent (bo);/* Continue walking the tree depth-first. */ -drm_intel_gem_bo_process_reloc2 (target_bo); + ret =drm_intel_gem_bo_process_reloc2 (target_bo); +if (ret) +break ; need_fence = (bo_gem->reloc_target_info[i].flags &DRM_INTEL_RELOC_FENCE );/* Add the target to the validate list */ -drm_intel_add_validate_buffer2 (target_bo, need_fence); + ret =drm_intel_add_validate_buffer2 (target_bo, need_fence); +if (ret) +break ; } +return ret; }
@@ -2334,12 +2367,16 @@ drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,pthread_mutex_lock (&bufmgr_gem->lock);/* Update indices and set up the validate list. */ -drm_intel_gem_bo_process_reloc (bo); + ret =drm_intel_gem_bo_process_reloc (bo); +if (ret) + goto skip_execution;/* Add the batch buffer to the validation list. There are no * relocations pointing to it. */ -drm_intel_add_validate_buffer (bo); + ret =drm_intel_add_validate_buffer (bo); +if (ret) + goto skip_execution;memclear (execbuf); execbuf.buffers_ptr = (uintptr_t ) bufmgr_gem->exec_objects;
@@ -2370,6 +2407,7 @@ drm_intel_gem_bo_exec(drm_intel_bo *bo, int used, }drm_intel_update_buffer_offsets (bufmgr_gem); +skip_execution:if (bufmgr_gem->bufmgr.debug)drm_intel_gem_dump_validation_list (bufmgr_gem);
@@ -2421,12 +2459,16 @@ do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx,pthread_mutex_lock (&bufmgr_gem->lock);/* Update indices and set up the validate list. */ -drm_intel_gem_bo_process_reloc2 (bo); + ret =drm_intel_gem_bo_process_reloc2 (bo); +if (ret) + goto skip_execution;/* Add the batch buffer to the validation list. There are no relocations * pointing to it. */ -drm_intel_add_validate_buffer2 (bo,0 ); + ret =drm_intel_add_validate_buffer2 (bo,0 ); +if (ret) + goto skip_execution;memclear (execbuf); execbuf.buffers_ptr = (uintptr_t )bufmgr_gem->exec2_objects;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 3/11 intel: Use snprintf instead of sprintf
In reply to Praveen PaneriWe must have upper bound on what we are going to write into a fixed size buffer.
--- intel/intel_decode.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
intel/intel_decode.c +4 -4
@@ -767,7 +767,7 @@ static void i915_get_instruction_src0(uint32_t *data, int i, char *srcname)char swizzle[100 ];i915_get_instruction_src_name ((a0 >>7 ) &0x7 , src_nr, srcname); -sprintf (swizzle,".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, +snprintf (swizzle,sizeof (swizzle),".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, swizzle_w);if (strcmp (swizzle,".xyzw" ) !=0 )strcat (srcname, swizzle);
@@ -785,7 +785,7 @@ static void i915_get_instruction_src1(uint32_t *data, int i, char *srcname)char swizzle[100 ];i915_get_instruction_src_name ((a1 >>13 ) &0x7 , src_nr, srcname); -sprintf (swizzle,".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, +snprintf (swizzle,sizeof (swizzle),".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, swizzle_w);if (strcmp (swizzle,".xyzw" ) !=0 )strcat (srcname, swizzle);
@@ -802,7 +802,7 @@ static void i915_get_instruction_src2(uint32_t *data, int i, char *srcname)char swizzle[100 ];i915_get_instruction_src_name ((a2 >>21 ) &0x7 , src_nr, srcname); -sprintf (swizzle,".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, +snprintf (swizzle,sizeof (swizzle),".%s%s%s%s" , swizzle_x, swizzle_y, swizzle_z, swizzle_w);if (strcmp (swizzle,".xyzw" ) !=0 )strcat (srcname, swizzle);
@@ -931,7 +931,7 @@ i915_decode_dcl(struct drm_intel_decode *ctx, int i, char *instr_prefix)switch ((d0 >>19 ) &0x3 ) {case 1 : -sprintf (dcl_mask,".%s%s%s%s" , dcl_x, dcl_y, dcl_z, dcl_w); +snprintf (dcl_mask,sizeof (dcl_mask),".%s%s%s%s" , dcl_x, dcl_y, dcl_z, dcl_w);if (strcmp (dcl_mask,"." ) ==0 )fprintf (out,"bad (empty) dcl mask\n" );
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 4/11 intel: Validate pointer before using
In reply to Praveen PaneriMove the dereferencing below the check for valid ctx pointer.
--- intel/intel_decode.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
intel/intel_decode.c +3 -1
@@ -3901,12 +3901,14 @@ drm_intel_decode(struct drm_intel_decode *ctx)int ret;unsigned int index =0 ;uint32_t devid; -int size = ctx->base_count *4 ; +int size;void *temp;if (!ctx)return ; + size = ctx->base_count *4 ; +/* Put a scratch page full of obviously undefined data after * the batchbuffer. This lets us avoid a bunch of length * checking in statically sized packets.
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 5/11 xf86drm: Avoid negative array index value
In reply to Praveen PaneriVariable retcode can be negative as well. Put the correct condition on it before using it as array index.
--- xf86drm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
xf86drm.c +1 -1
@@ -661,7 +661,7 @@ static int drmOpenByName(const char *name, int type)if ((fd =open (proc_name,0 ,0 )) >=0 ) { retcode =read (fd, buf,sizeof (buf)-1 );close (fd); -if (retcode) { +if (retcode >0 ) { buf[retcode-1 ] ='\0' ;for (driver = pt = buf; *pt && *pt !=' ' ; ++pt) ;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 6/11 xf86drmSL: Check function return value
In reply to Praveen PaneriValidate the return value of SLCreateEntry() before using it.
v2: Rebased to the latest.
--- xf86drmSL.c | 2 ++ 1 file changed, 2 insertions(+)
xf86drmSL.c +2 -0
@@ -107,6 +107,7 @@ void *drmSLCreate(void) list->magic =SL_LIST_MAGIC ; list->level =0 ; list->head =SLCreateEntry (SL_MAX_LEVEL ,0 ,NULL ); +if (!list->head)return NULL ; list->count =0 ;for (i =0 ; i <=SL_MAX_LEVEL ; i++) list->head->forward[i] =NULL ;
@@ -173,6 +174,7 @@ int drmSLInsert(void *l, unsigned long key, void *value) } entry =SLCreateEntry (level, key, value); +if (!entry)return -ENOMEM ;/* Fix up forward pointers */ for (i =0 ; i <= level; i++) {
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 7/11 intel: Validate memory allocations
In reply to Praveen PaneriThis patch adds check for various malloc/calloc function if they were able to allocate memory as requested or not. Return appropriate error if the allocation fails.
v2: Rebased to the latest.
--- intel/intel_bufmgr_fake.c | 4 ++++ intel/intel_bufmgr_gem.c | 3 +++ intel/intel_decode.c | 2 ++ 3 files changed, 9 insertions(+)
intel/intel_bufmgr_fake.c +4 -0
@@ -1278,6 +1278,8 @@ drm_intel_fake_emit_reloc(drm_intel_bo *bo, uint32_t offset,if (bo_fake->relocs ==NULL ) { bo_fake->relocs =malloc (sizeof (struct fake_buffer_reloc ) *MAX_RELOCS ); +if (!bo_fake->relocs) +return -ENOMEM ; } r = &bo_fake->relocs[bo_fake->nr_relocs++];
@@ -1597,6 +1599,8 @@ drm_intel_bufmgr_fake_init(int fd, unsigned long low_offset,drm_intel_bufmgr_fake *bufmgr_fake; bufmgr_fake =calloc (1 ,sizeof (*bufmgr_fake)); +if (!bufmgr_fake) +return NULL ;if (pthread_mutex_init (&bufmgr_fake->lock,NULL ) !=0 ) {free (bufmgr_fake);
intel/intel_bufmgr_gem.c +3 -0
@@ -2081,6 +2081,9 @@ aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)unsigned int i; data =malloc (bo->size); +if (!data) +return ; +drm_intel_bo_get_subdata (bo, offset, size, data);/* Easy mode: write out bo with no relocations */
intel/intel_decode.c +2 -0
@@ -3914,6 +3914,8 @@ drm_intel_decode(struct drm_intel_decode *ctx)* checking in statically sized packets. */ temp =malloc (size +4096 ); +if (!temp) +return ;memcpy (temp, ctx->base_data, size);memset ((char *)temp + size,0xd0 ,4096 ); ctx->data = temp;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 8/11 drm: Validate memory allocations
In reply to Praveen PaneriThis patch adds check on various drmMalloc() calls if they were able to allocate memory as requested or not. Return appropriate error if the allocation fails.
--- xf86drm.c | 51 ++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 40 insertions(+), 11 deletions(-)
xf86drm.c +40 -11
@@ -186,6 +186,8 @@ drmHashEntry *drmGetEntry(int fd)if (drmHashLookup (drmHashTable, key, &value)) { entry =drmMalloc (sizeof (*entry)); +if (!entry) +return NULL ; entry->fd = fd; entry->f =NULL ; entry->tagTable =drmHashCreate ();
@@ -837,6 +839,8 @@ drmVersionPtr drmGetVersion(int fd) {drmVersionPtr retval;drm_version_t *version =drmMalloc (sizeof (*version)); +if (!version) +return NULL ;memclear (*version);
@@ -864,7 +868,9 @@ drmVersionPtr drmGetVersion(int fd)if (version->desc_len) version->desc[version->desc_len] ='\0' ; retval =drmMalloc (sizeof (*retval)); -drmCopyVersion (retval, version); +if (retval) +drmCopyVersion (retval, version); +drmFreeKernelVersion (version);return retval; }
@@ -886,6 +892,8 @@ drmVersionPtr drmGetVersion(int fd)drmVersionPtr drmGetLibVersion (int fd) {drm_version_t *version =drmMalloc (sizeof (*version)); +if (!version) +return NULL ;/* Version history: * NOTE THIS MUST NOT GO ABOVE VERSION 1.X due to drivers needing it
@@ -1294,14 +1302,25 @@ drmBufInfoPtr drmGetBufInfo(int fd) } retval =drmMalloc (sizeof (*retval)); +if (!retval) { +drmFree (info.list); +return NULL ; + } + retval->count = info.count; retval->list =drmMalloc (info.count *sizeof (*retval->list)); -for (i =0 ; i < info.count; i++) { - retval->list[i].count = info.list[i].count; - retval->list[i].size = info.list[i].size; - retval->list[i].low_mark = info.list[i].low_mark; - retval->list[i].high_mark = info.list[i].high_mark; +if (retval->list) { +for (i =0 ; i < info.count; i++) { + retval->list[i].count = info.list[i].count; + retval->list[i].size = info.list[i].size; + retval->list[i].low_mark = info.list[i].low_mark; + retval->list[i].high_mark = info.list[i].high_mark; + } + }else { +drmFree (retval); + retval =NULL ; } +drmFree (info.list);return retval; }
@@ -1345,13 +1364,23 @@ drmBufMapPtr drmMapBufs(int fd) } retval =drmMalloc (sizeof (*retval)); +if (!retval) { +drmFree (bufs.list); +return NULL ; + } + retval->count = bufs.count; retval->list =drmMalloc (bufs.count *sizeof (*retval->list)); -for (i =0 ; i < bufs.count; i++) { - retval->list[i].idx = bufs.list[i].idx; - retval->list[i].total = bufs.list[i].total; - retval->list[i].used =0 ; - retval->list[i].address = bufs.list[i].address; +if (retval->list) { +for (i =0 ; i < bufs.count; i++) { + retval->list[i].idx = bufs.list[i].idx; + retval->list[i].total = bufs.list[i].total; + retval->list[i].used =0 ; + retval->list[i].address = bufs.list[i].address; + } + }else { +drmFree (retval); + retval =NULL ; }drmFree (bufs.list);
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 9/11 xf86drmSL: Check memory allocation by SL_RANDOM_INIT()
In reply to Praveen PaneriIf the allocation fails, return -ENOMEM. Handle the return value at the caller funtion drmSLInsert() as well.
v2: Rebased to the latest.
--- xf86drmSL.c | 5 +++++ 1 file changed, 5 insertions(+)
xf86drmSL.c +5 -0
@@ -40,6 +40,7 @@#include <stdio.h> #include <stdlib.h> +#include <errno.h> #include "xf86drm.h"
@@ -92,6 +93,7 @@ static int SLRandomLevel(void)SL_RANDOM_DECL ;SL_RANDOM_INIT (SL_RANDOM_SEED ); +if (!state)return -ENOMEM ;while ((SL_RANDOM &0x01 ) && level <SL_MAX_LEVEL ) ++level;return level;
@@ -168,6 +170,9 @@ int drmSLInsert(void *l, unsigned long key, void *value) level =SLRandomLevel (); +if (level <0 ) +return level; +if (level > list->level) { level = ++list->level; update[level] = list->head;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 10/11 xf86drmHash: Check memory allocation in HashHash()
In reply to Praveen PaneridrmRandomCreate() can fail to allocate memory. In such case return an invalid hash value (0xffffffff) from HashHash() function.
Caller functions check the hash value and act accordingly.
v2: Rebased to the latest.
--- xf86drmHash.c | 9 +++++++++ 1 file changed, 9 insertions(+)
xf86drmHash.c +9 -0
@@ -75,6 +75,8 @@#include "xf86drmHash.h" #define HASH_MAGIC 0xdeadbeef +#define HASH_INVALID 0xffffffff/* A value that is out of bound */ +static unsigned long HashHash (unsigned long key) {
@@ -87,6 +89,8 @@ static unsigned long HashHash(unsigned long key)if (!init) {void *state; state =drmRandomCreate (37 ); +if (!state) +return HASH_INVALID ;for (i =0 ; i <256 ; i++) scatter[i] =drmRandom (state);drmRandomDestroy (state); ++init;
@@ -153,6 +157,9 @@ static HashBucketPtr HashFind(HashTablePtr table,if (h) *h = hash; +if (hash ==HASH_INVALID ) +return NULL ; +for (bucket = table->buckets[hash]; bucket; bucket = bucket->next) {if (bucket->key == key) {if (prev) {
@@ -194,6 +201,7 @@ int drmHashInsert(void *t, unsigned long key, void *value)if (table->magic !=HASH_MAGIC )return -1 ;/* Bad magic */ if (HashFind (table, key, &hash))return 1 ;/* Already in table */ +if (hash ==HASH_INVALID )return -1 ; bucket =drmMalloc (sizeof (*bucket));if (!bucket)return -1 ;/* Error */
@@ -217,6 +225,7 @@ int drmHashDelete(void *t, unsigned long key) bucket =HashFind (table, key, &hash); +if (hash ==HASH_INVALID )return -1 ;if (!bucket)return 1 ;/* Not found */ table->buckets[hash] = bucket->next;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 11/11 xf86drm: Validate function return value
In reply to Praveen PaneriReturn value of drmHashCreate() and drmGetEntry() functions can be NULL. It should be validated before being used.
--- xf86drm.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)
xf86drm.c +19 -5
@@ -178,20 +178,25 @@ static unsigned long drmGetKeyFromFd(int fd)drmHashEntry *drmGetEntry (int fd) {unsigned long key =drmGetKeyFromFd (fd); -void *value; +void *value =NULL ;drmHashEntry *entry;if (!drmHashTable) drmHashTable =drmHashCreate (); -if (drmHashLookup (drmHashTable, key, &value)) { +if (drmHashTable &&drmHashLookup (drmHashTable, key, &value)) { entry =drmMalloc (sizeof (*entry));if (!entry)return NULL ; entry->fd = fd; entry->f =NULL ; entry->tagTable =drmHashCreate (); -drmHashInsert (drmHashTable, key, entry); +if (entry->tagTable) { +drmHashInsert (drmHashTable, key, entry); + }else { +drmFree (entry); + entry =NULL ; + } }else { entry = value; }
@@ -1219,6 +1224,8 @@ int drmClose(int fd) {unsigned long key =drmGetKeyFromFd (fd);drmHashEntry *entry =drmGetEntry (fd); +if (!entry) +return -ENOMEM ;drmHashDestroy (entry->tagTable); entry->fd =0 ;
@@ -2258,6 +2265,8 @@ int drmGetInterruptFromBusID(int fd, int busnum, int devnum, int funcnum)int drmAddContextTag (int fd,drm_context_t context,void *tag) {drmHashEntry *entry =drmGetEntry (fd); +if (!entry) +return -ENOMEM ;if (drmHashInsert (entry->tagTable, context, tag)) {drmHashDelete (entry->tagTable, context);
@@ -2270,13 +2279,18 @@ int drmDelContextTag(int fd, drm_context_t context) {drmHashEntry *entry =drmGetEntry (fd); -return drmHashDelete (entry->tagTable, context); +if (entry) +return drmHashDelete (entry->tagTable, context); +return -ENOMEM ; }void *drmGetContextTag (int fd,drm_context_t context) { -drmHashEntry *entry =drmGetEntry (fd);void *value; +drmHashEntry *entry =drmGetEntry (fd); + +if (!entry) +return NULL ;if (drmHashLookup (entry->tagTable, context, &value))return NULL ;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx