Changeset 259 for soft/giet_vm/giet_fat32

Timestamp:

Dec 5, 2013, 12:45:34 PM (11 years ago)

Author:

devigne

Message:

giet_fat32/fat32.c :
Added _fat_write function. At the moment it does not support the creation of a
new file (the writing must exist in the disk image) and does not support the
allocation of additional cluster from the original file.

create_dmg :
Bug fix for support Linux (The tree files were not consistent with the
pathnames in boot.c).

giet_libs/stdlib.c and stdlib.h :
Added stdlib file. At the moment they only contain the atoi function.

giet_libs/stdio.h :
Bug fix in SYSCALL DEFINE. SYSCALL_FAT_READ, WRITE, CLOSE, LSEEK had the same
value.

Makefile :
Added compilation line for stdlib.o

File:

• soft/giet_vm/giet_fat32/fat32.c (modified) (1 diff)

soft/giet_vm/giet_fat32/fat32.c

@@ -1163 +1163 @@
                 unsigned int offset )    // nuber of sectors to skip in file
 {
-    _tty_get_lock( 0 );
-    _puts("\n[FAT ERROR] _fat_write() function not implemented\n");
-    _tty_release_lock( 0 );
-    return -1;
+
+    unsigned int spc = fat.sectors_per_cluster;
+
+    unsigned int file_size;         // number of bytes in file
+    unsigned int file_sectors;      // number of sectors in file
+    unsigned int cluster;           // cluster index 
+    unsigned int clusters_to_skip;  // number of clusters to skip because offset
+    unsigned int sectors_to_skip;   // number of sectors to skip in first iteration
+    unsigned int allocate;          // need allocate or not
+
+    // compute file size as a number of sectors 
+    file_size    = fat.fd[fd_id].file_size;
+    if ( file_size & 0x1FF ) file_sectors = (file_size >> 9) + 1;
+    else                     file_sectors = (file_size >> 9); 
+    
+    allocate = ( ((count + offset) / spc) > (file_sectors / spc) );
+
+#if GIET_DEBUG_FAT
+_tty_get_lock( 0 );
+_puts("\n[FAT DEBUG] Enter _fat_write() for file ");
+_puts( fat.fd[fd_id].name );
+_puts("\n - buffer base     = ");
+_putx( (unsigned int)buffer );
+_puts("\n - skipped sectors = ");
+_putd( offset );
+_puts("\n - write sectors    = "); 
+_putd( count );
+_puts("\n - file size (sectors)  = "); 
+_putd( file_sectors );
+_puts("\n - need allocate = "); 
+allocate ? _puts( "True" ) : _puts( "False");
+_tty_release_lock( 0 );
+#endif
+
+    if ( allocate  )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[FAT ERROR] in _fat_write() : \n");
+        _puts("we need to allocate more cluster... But this function is not implemented\n");
+        _tty_release_lock( 0 );
+        return -1;
+    }
+    // arguments checking
+    if ( fd_id >= GIET_OPEN_FILES_MAX )
+    { 
+        _tty_get_lock( 0 );
+        _puts("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n");
+        _tty_release_lock( 0 );
+        return -1;
+    }
+    if ( fat.fd[fd_id].used != 1 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[FAT ERROR] in _fat_write() : file not open\n");
+        _tty_release_lock( 0 );
+        return -1;
+    }
+    if ( ((unsigned int)buffer & 0x1FF) != 0 )
+    {
+        _tty_get_lock( 0 );
+        _puts("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n");
+        _tty_release_lock( 0 );
+        return -1;
+    }
+
+    // compute clusters and sectors to be skipped
+    clusters_to_skip = offset / spc;
+    sectors_to_skip  = offset % spc;
+    
+    // get first cluster index 
+    cluster = fat.fd[fd_id].first_cluster;
+
+#if GIET_DEBUG_FAT
+_tty_get_lock( 0 );
+_puts("\n - first cluster   = ");
+_putd( cluster );   
+_puts("\n - skiped clusters = ");
+_putd( clusters_to_skip );   
+_puts("\n");
+_tty_release_lock( 0 );
+#endif
+
+    // compute index of first cluster to be loaded
+    // as we may need to scan the FAT, we use the kernel mode
+    while ( clusters_to_skip )
+    {
+        cluster = get_next_cluster_id( IOC_KERNEL_MODE, cluster );
+        clusters_to_skip--;
+    }
+
+    // variables used in the loop on clusters
+    int             todo_sectors;   // number of sectors still to be loaded
+    unsigned int    lba;            // first sector index on device
+    unsigned int    iter_sectors;   // number of sectors to load in iteration
+    char*           src;            // pointer on target buffer
+
+    // initialize these variables for the first iteration 
+    todo_sectors  = count;
+    src           = (char*)buffer;
+    lba           = cluster_to_lba(cluster) + sectors_to_skip;
+    if( count < (spc - sectors_to_skip) ) iter_sectors = count;
+    else                                  iter_sectors = spc - sectors_to_skip; 
+
+    // loop on the clusters
+    while ( todo_sectors > 0 )
+    {
+
+#if GIET_DEBUG_FAT
+_tty_get_lock( 0 );
+_puts("\n[FAT DEBUG] _fat_write() IOC request : buf = ");
+_putx( (unsigned int)src );
+_puts(" / lba = ");
+_putd( lba );
+_puts(" / sectors = "); 
+_putd( iter_sectors );
+_puts("\n");  
+_tty_release_lock( 0 );
+#endif
+
+        if( _ioc_write( mode,              // mode for IOC driver
+                        lba,               // first sector index 
+                        src,               // buffer address
+                        iter_sectors ) )   // number of sectors
+        {
+            _tty_get_lock( 0 );
+            _puts("\n[FAT ERROR] in _fat_write() cannot write block ");
+            _putd( lba );
+            _puts("\n"); 
+            _tty_release_lock( 0 );
+            return -1;
+        }
+         
+        // update variables for next iteration
+        cluster      = get_next_cluster_id( mode, cluster );
+        todo_sectors = todo_sectors - iter_sectors;
+        src          = src + (iter_sectors << 9);
+        lba          = cluster_to_lba(cluster);
+        if ( todo_sectors > spc ) iter_sectors = spc;
+        else                      iter_sectors = todo_sectors;
+    }
+         
+    // returns number of sectors actually transfered
+    return count;
 }