Changeset 651 for soft

Timestamp:

Jul 22, 2015, 2:31:33 PM (9 years ago)

Author:

guerin

Message:

fat32: don't keep tree structure when releasing cache

This fixes a bunch of memleaks.

File:

• soft/giet_vm/giet_fat32/fat32.c (modified) (8 diffs)

soft/giet_vm/giet_fat32/fat32.c

@@ -407 +407 @@
 
 //////////////////////////////////////////////////////////////////////////////////
-// This recursive function scan one File-Cache (or Fat-Cache) from root to leaves.
-// The cache 64-Tree infrastructure is kept, but all memory allocated for 4 Kbytes 
-// buffers, and for buffer descriptors (in leaves) is released.
-// The cache is identified by the "root" an "levels" arguments.
+// This recursive function scans one File-Cache (or Fat-Cache) from root to
+// leaves. All memory allocated for 4KB buffers, and buffer descriptors (in
+// leaves) is released, along with the 64-Tree structure (root node is kept).
+// The cache is identified by the "root" and "levels" arguments.
 // It should not contain any dirty clusters.
-// It returns 0 if success.
-// It returns 1 if error.
-//////////////////////////////////////////////////////////////////////////////////
-
-static unsigned int _release_cache_memory( fat_cache_node_t*  root,
-                                           unsigned int       levels );
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _release_cache_memory( fat_cache_node_t*  root,
+                                   unsigned int       levels );
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -1397 +1395 @@
 
 ///////////////////////////////////////////////////////////////////
-static unsigned int _release_cache_memory( fat_cache_node_t*  root,
-                                           unsigned int       levels )
-{
-    unsigned int index;
-    unsigned int ret = 0;
+static void _release_cache_memory( fat_cache_node_t*  root,
+                                   unsigned int       levels )
+{
+    unsigned int i;
 
     if ( levels == 1 )  // last level => children are cluster descriptors
     {
-        for( index = 0 ; index < 64 ; index++ )
+        for( i = 0 ; i < 64 ; i++ )
         { 
-            fat_cache_desc_t* pdesc = root->children[index];
+            fat_cache_desc_t* pdesc = root->children[i];
 
             if ( pdesc != NULL )
@@ -1413 +1410 @@
                 // check dirty
                 if ( pdesc->dirty )
-                {
-                    _printf("\n[FAT_ERROR] in _release_cache_memory() : dirty cluster\n");
-                    ret = 1;
-                }
-                else
-                {
-                    _free( pdesc->buffer );
-                    _free( pdesc );
-                    root->children[index] = NULL;
-                }
+                    _printf("\n[FAT ERROR] in _release_cache_memory() : dirty cluster\n");
+
+                _free( pdesc->buffer );
+                _free( pdesc );
+                root->children[i] = NULL;
             }
         }
@@ -1428 +1420 @@
     else               // not the last level = recursive call on each children
     {
-        for( index = 0 ; index < 64 ; index++ )
+        for( i = 0 ; i < 64 ; i++ )
         { 
-            fat_cache_node_t*    cnode = root->children[index];
-
-            if ( cnode != NULL ) ret   = _release_cache_memory( root->children[index],
-                                                                levels - 1 );
-        }
-    }
-    return ret;
+            fat_cache_node_t* cnode = root->children[i];
+
+            if ( cnode != NULL )
+            {
+                _release_cache_memory( cnode, levels - 1 );
+                _free( cnode );
+                root->children[i] = NULL;
+            }
+        }
+    }
 }  // end _release_cache_memory()
 
@@ -2400 +2395 @@
 
     // release File-Cache
-    if ( _release_cache_memory( inode->cache,
-                                inode->levels ) ) return 1;
+    _release_cache_memory( inode->cache, inode->levels );
+    _free ( inode->cache );
 
     // remove inode from Inode-Tree
@@ -3005 +3000 @@
 // in the file descriptors array.
 // If the reference count is zero, it writes all dirty clusters on block device, 
-// and releases the memory allocated to the file_cache: The cache 64-Tree
-// infrastructure (depending on file size) is kept, but all buffers and all
-// buffer descriptors are released.
+// and releases the memory allocated to the File_Cache.
 /////////////////////////////////////////////////////////////////////////////////
 // Returns 0 on success.
@@ -3015 +3008 @@
 //  -3  : "File not open"
 //  -4  : "Cannot update DATA regions"
-//  -5  : "Cannot release memory"
 /////////////////////////////////////////////////////////////////////////////////
 int _fat_close( unsigned int fd_id )
@@ -3091 +3083 @@
 #endif
 
-        // release memory allocated to File-Cache
-        if ( _release_cache_memory( inode->cache,
-                                    inode-> levels ) )
-        {
-            _spin_lock_release( &_fat.fat_lock );
-            _printf("\n[FAT ERROR] in _fat_close() : cannot release cache memory "
-                    "for file <%s>\n", _fat.fd[fd_id].inode->name );
-            return -5;
-        }
+        // release memory allocated to File-Cache (keep cache root node)
+        _release_cache_memory( inode->cache, inode->levels );
 
 #if GIET_DEBUG_FAT