Changes between Version 33 and Version 34 of file_system

Timestamp:

Jan 14, 2016, 1:42:39 PM (9 years ago)

Author:

alain

Comment:

--

file_system

@@ -272 +272 @@
 
 === __int '''_fat_ioc_access'''( unsigned int use_irq ,  unsigned int to_mem ,  unsigned int lba , unsigned int buf_vaddr , unsigned int count )__ ===
-This function transfers one or several blocks between the block device and a memory buffer by calling the relevant driver.
- * '''use_irq''' : boolean (use descheduling mode if supported by the IOC driver)
- * '''to_mem''' : boolean (from block device to memory if non zero) 
- * '''lba''' : logical block address on block device
- * '''buf_vaddr''' : memory buffer virtual address
- * ''' count''' : number of blocks to be transferred
+This function transfers one or several blocks between the block device and a memory buffer by calling the relevant driver. The <use_irq>  boolean argument forces the descheduling mode if supported by the IOC driver.
+The <to_mem> boolean argument defines the transfer direction (from block device to memory if non zero). The 
+<lba> argument is the logical block address on the block device. The <buf_vaddr> argument is the memory buffer virtual address. The <count> argument is the number of blocks to be transferred.
 It returns 0 on success, or -1 on failure.
+
+=== __void '''_display_one_block'''( unsigned char* buf , char* string , unsigned int block_id )__ ===
+This debug function displays the content of a 512 bytes buffer <buf>, with an identifier defined by the <string> and <block_id> arguments.
+
+=== __void '''_display_fat_descriptor'''()__ ===
+This debug function displays the FAT descriptor content. 
+
+=== __void '''_get_name_from_long'''( unsigned char* buffer , char* name )__ ===
+This function extract a (partial) name from a LFN directory entry.
+
+=== __void '''_get_name_from_short'''( unsigned char* buffer , char* name )__ ===
+This function extract a name from a NORMAL directory entry.
+
+=== __unsigned int '''_get_levels_from_size'''( unsigned int size )__ ===
+This function returns the number of levels of a File-Cache from the size of the file.
+
+=== __unsigned int '''_get_name_from_path'''( char* pathname , char* name , unsigned int*  nb_read )__ ===
+This function analyses the <pathname> argument, from the character defined by the <nb_read> argument.
+It copies the found name in the <name> buffer (without '/'), and updates the <nb_read"> argument.
+It returns 0 on success. It returns 1 if one name length > NAME_MAX_SIZE characters.
+
+=== __unsigned int '''_get_last_name'''( char* pathname , char* name )__ ===
+This function scan the "pathname" argument, and copies in the <name> buffer the last name in <pathname>.
+It returns 0 on success.It returns 1 if one name length > NAME_MAX_SIZE characters.
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function accesses the Fat-Cache and returns in the "value"
+// argument the content of the FAT slot identified by the "cluster" argument.
+// It loads the missing cluster from block device into cache in case of miss.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _get_fat_entry( unsigned int  cluster,
+                                    unsigned int* value );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function writes a new "value" in the Fat-Cache, in the slot 
+// identified by the "cluster" argument.  
+// It loads the missing cluster from block device into cache in case of miss.
+// It returns 0 on success,
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _set_fat_entry( unsigned int  cluster,
+                                    unsigned int  value );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function introduces the inode identified by the <child> argument,
+// as a new child of the <parent> inode in the Inode-Tree.
+// All checking are supposed to be done by the caller.
+// Nor the File-Cache, neither the block device are modified.
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _add_inode_in_tree( fat_inode_t*  child,
+                                fat_inode_t*  parent );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function removes one inode identified by the <inode> argument 
+// from the Inode-Tree. All checking are supposed to be done by the caller.
+// Nor the File-Cache, neither the block device are modified.
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _remove_inode_from_tree( fat_inode_t* inode );
+
+//////////////////////////////////////////////////////////////////////////////////
+// This recursive function scan one File-Cache (or Fat-Cache) from root to leaves,
+// to writes all dirty clusters to block device, and reset the dirty bits.
+// The cache is identified by the <root> an <levels> arguments.
+// The <string> argument is only used for debug : inode name or Fat.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _update_device_from_cache( unsigned int      levels,
+                                               fat_cache_node_t* root,
+                                               char*             string );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function accesses directly the FS_INFO block on the block device, 
+// to update the "first_free_cluster" and "free_clusters_number" values,
+// using only the Fat-Descriptor single block buffer.
+// It return 0 on success.
+// It return 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _update_fs_info();
+
+//////////////////////////////////////////////////////////////////////////////
+// The following function read a data field (from one to four bytes) 
+// from an unsigned char[] buffer, taking endianness into account. 
+// The analysed field is defined by the <offset> and <size> arguments.
+//////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _read_entry( unsigned int    offset,
+                                 unsigned int    size,
+                                 unsigned char*  buffer,
+                                 unsigned int    little_indian );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function returns the lba of first sector in DATA region 
+// from the cluster index. The cluster index must be larger than 2. 
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _cluster_to_lba( unsigned int cluster );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function returns in the "nb_entries" argument the number of files
+// (or directories) contained in a directory identified by the "inode " pointer.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _get_nb_entries( fat_inode_t*   inode,
+                                     unsigned int*  nb_entries );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function search in the directory identified by the <parent>
+// inode pointer a child (file or directory) identified by its <name>.
+// It returns in the <inode> argument the searched child inode pointer.
+// If the searched name is not found in the Inode-Tree, the function accesses
+// the File-cache associated to the parent directory.
+// If the child exists on block device, the Inode-Tree is updated, and
+// a success code is returned.
+// If the file/dir does not exist on block device, a error code is returned.
+// It returns 0 if inode found.
+// It returns 1 if inode not found.
+// It returns 2 on error in cache access.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _get_child_from_parent( fat_inode_t*   parent,
+                                            char*          name,
+                                            fat_inode_t**  inode ); 
+
+/////////////////////////////////////////////////////////////////////////////////
+// For a file (or a directory) identified by the "pathname" argument, the
+// following function returns in the "inode" argument the inode pointer 
+// associated to the searched file (or directory), with code (0).
+// If the searched file (or directory) is not found, but the parent directory 
+// is found, it returns in the "inode" argument the pointer on the parent inode,
+// with code (1).  Finally, code (2) and code (3) are error codes.
+// Both the Inode-Tree and the involved Cache-Files are updated from the block
+// device in case of miss on one inode during the search in path.
+// Neither the Fat-Cache, nor the block device are updated.
+// It returns 0 if searched inode found
+// It returns 1 if searched inode not found but parent directory found
+// It returns 2 if searched inode not found and parent directory not found
+// It returns 3 if one name too long
+/////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _get_inode_from_path( char*          pathname,
+                                          fat_inode_t**  inode );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function checks if node "a" is an ancestor of inode "b".
+// It returns 0 on failure.
+// It returns 1 otherwise.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _is_ancestor( fat_inode_t* a,
+                                  fat_inode_t* b);
+
+//////////////////////////////////////////////////////////////////////////////////
+// This function computes the length and the number of LFN entries required
+// to store a node name in the "length" and "nb_lfn" arguments.
+// Short name (less than 13 characters) require 1 LFN entry.
+// Medium names (from 14 to 26 characters require 2 LFN entries.
+// Large names (up to 31 characters) require 3 LFN entries. 
+// It returns 0 on success.
+// It returns 1 if length larger than 31 characters.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _check_name_length( char* name,
+                                        unsigned int* length,
+                                        unsigned int* nb_lfn );
+
+//////////////////////////////////////////////////////////////////////////////////
+// For a node identified by the "inode" argument, this function updates the
+// "size" and "cluster" values in the entry of the parent directory File-Cache.
+// It set the dirty bit in the modified buffer of the parent directory File-Cache.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _update_dir_entry( fat_inode_t*  inode );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function add new "child" in Cache-File of "parent" directory.
+// It accesses the File_Cache associated to the parent directory, and scan the
+// clusters allocated to this directory to find the NO_MORE entry.
+// This entry will be the first modified entry in the directory.
+// Regarding the name storage, it uses LFN entries for all names. 
+// Therefore, it writes 1, 2, or 3 LFN entries (depending on the child name
+// actual length, it writes one NORMAL entry, and writes the new NOMORE entry.
+// It updates the dentry field in the child inode.
+// It set the dirty bit for all modified File-Cache buffers.
+// The block device is not modified by this function.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _add_dir_entry( fat_inode_t* child,
+                                    fat_inode_t* parent );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function invalidates all dir_entries associated to the "inode"
+// argument from its parent directory.
+// It set the dirty bit for all modified buffers in parent directory Cache-File.
+// The inode itself is not modified by this function.
+// The block device is not modified by this function.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _remove_dir_entry( fat_inode_t*  inode );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function add the special entries "." and ".." in the File-Cache
+// of the directory identified by the "child" argument.
+// The parent directory is defined by the "parent" argument.
+// The child directory File-Cache is supposed to be empty.
+// We use two NORMAL entries for these "." and ".." entries.
+// The block device is not modified by this function.
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _add_special_directories( fat_inode_t* child,
+                                      fat_inode_t* parent );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function releases all clusters allocated to a file or directory,
+// from the cluster index defined by the <cluster> argument, until the end 
+// of the FAT linked list.
+// It calls _get_fat_entry() and _set_fat_entry() functions to scan the FAT,
+// and to update the clusters chaining.
+// The FAT region on block device is updated.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _clusters_release( unsigned int cluster );
+
+//////////////////////////////////////////////////////////////////////////////////
+// This function allocate one cluster in FAT to a file (or directory) identified 
+// by the <inode> pointer. The allocated cluster index is returned in the
+// <cluster> argument.
+// It allocates also the associated buffers and buffer descriptors in Cache-File.
+// It calls _get_fat_entry() and _set_fat_entry() functions to update the
+// clusters chaining in the Cache-Fat. The FAT region on block device is updated.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _cluster_allocate( fat_inode_t*   inode, 
+                                       unsigned int*  cluster );
+
+//////////////////////////////////////////////////////////////////////////////////
+// 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.
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _release_cache_memory( fat_cache_node_t*  root,
+                                   unsigned int       levels );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function allocates and initializes a new cache node.
+// Its first child can be specified (used when adding a cache level).
+// The 63 other children are set to NULL.
+// It returns a pointer to a new Fat-Cache node.
+//////////////////////////////////////////////////////////////////////////////////
+
+static fat_cache_node_t* _allocate_one_cache_node( fat_cache_node_t* first_child );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function allocates and initializes a new inode, 
+// using the values defined by the arguments.
+// If the "cache_allocate" argument is true, an empty cache is allocated.
+// It returns a pointer on the new inode.
+//////////////////////////////////////////////////////////////////////////////////
+
+static fat_inode_t* _allocate_one_inode( char*        name,
+                                         unsigned int is_dir,
+                                         unsigned int cluster,
+                                         unsigned int size,
+                                         unsigned int count,
+                                         unsigned int dentry,
+                                         unsigned int cache_allocate );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function allocates a 4 Kbytes buffer and the associated cluster 
+// descriptor for the file (or directory) identified by the <inode> argument,
+// and updates the Cache_File slot identified by the <cluster_id> argument. 
+// The File-Cache slot must be empty.
+// It updates the buffer descriptor, using the <cluster> argument, that is 
+// the cluster index in FAT.  The cluster descriptor dirty field is set.
+// It traverse the 64-tree Cache-file from top to bottom to find the last level.
+//////////////////////////////////////////////////////////////////////////////////
+
+static void _allocate_one_buffer( fat_inode_t*    inode,
+                                  unsigned int    cluster_id,
+                                  unsigned int    cluster );
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function allocates one free cluster from the FAT  
+// and returns the cluster index in the <cluster> argument.
+// It updates the FAT slot, and the two FAT global variables: first_free_cluster,
+// and free_clusters_number.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _allocate_one_cluster( unsigned int*  cluster );
+
+/////////////////////////////////////////////////////////////////////////////
+// This function remove from the file system a file or a directory 
+// identified by the <inode> argument. 
+// The remove condition must be checked by the caller.
+// The relevant lock(s) must have been taken by te caller.
+// It returns 0 on success.
+// It returns 1 on error.
+/////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _remove_node_from_fs( fat_inode_t* inode );
+
+/////////////////////////////////////////////////////////////////////////////
+// This function return the cluster index and the size for a file 
+// identified by the "pathname" argument, scanning directly the block
+// device DATA region.
+// It is intended to be called only by the _fat_load_no_cache() function, 
+// it does not use the dynamically allocated File Caches, but uses only
+// the 4 Kbytes _fat_buffer_data. 
+// It returns 0 on success.
+// It returns 1 on error.
+/////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _file_info_no_cache( char*          pathname,
+                                         unsigned int*  file_cluster,
+                                         unsigned int*  file_size );
+
+/////////////////////////////////////////////////////////////////////////////
+// This function scan directly the FAT region on the block device, 
+// and returns in the "next" argument the value stored in the fat slot 
+// identified by the "cluster" argument.
+// It is intended to be called only by the _fat_load_no_cache() function,
+// as it does not use the dynamically allocated Fat-Cache, but uses only 
+// the 4 Kbytes _fat_buffer_fat.
+// It returns 0 on success.
+// It returns 1 on error.
+/////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _next_cluster_no_cache( unsigned int   cluster,
+                                            unsigned int*  next );
+
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following functions return the the size (bytes) of a FAT field, 
+// identified by an (offset,length) mnemonic defined in the fat32.h file.
+//////////////////////////////////////////////////////////////////////////////////
+
+static inline int get_length( int offset , int length ) { return length; }
+
+static inline int get_offset( int offset , int length ) { return offset; }
+
+//////////////////////////////////////////////////////////////////////////////////
+// The following function returns in the <desc> argument a pointer on a buffer 
+// descriptor contained in the Fat_Cache. 
+// The <cluster_id> argument is the buffer index in the FAT_Cache. 
+// In case of miss, a 4 Kbytesbuffer and a buffer descriptor are allocated 
+// from the local heap, and the missing cluster is loaded in the Fat_Cache.
+// It returns 0 on success.
+// It returns 1 on error.
+//////////////////////////////////////////////////////////////////////////////////
+
+static unsigned int _get_fat_cache_buffer( unsigned int        cluster_id,
+                                           fat_cache_desc_t**  desc );
+
+
+