Changeset 265 for trunk/kernel/mm/mapper.h

Timestamp:

Jul 21, 2017, 7:36:08 AM (7 years ago)

Author:

alain

Message:

Fix several bugs in VFS.

File:

• trunk/kernel/mm/mapper.h (modified) (2 diffs)

trunk/kernel/mm/mapper.h

@@ -51 +51 @@
  * - The mapper_get_page() function that return a page descriptor pointer from a page
  *   index in file is in charge of handling the miss on the mapper cache.
- * - The vfs_mapper_move_page() function is used to handle miss on one specific page,
+ * - The vfs_mapper_move_page() function access the file system to handle a mapper miss,
  *   or update a dirty page on device.
- * - The vfs_mapper_load_all() functions is used to load all pages of a given directory
- *   into the mapper.
- * - the mapper_move() function is used to move data to or from an user buffer.
+ * - The vfs_mapper_load_all() functions is used to load all pages of a given file 
+ *   or directory into the mapper.
+ * - the mapper_move_user() function is used to move data to or from an user buffer.
  *   This user space buffer can be physically distributed in several clusters.
  * - In the present implementation the cache size for a given file increases on demand,
@@ -117 +117 @@
 
 /*******************************************************************************************
- * This function move data between a kernel mapper and an user buffer.
+ * This function move data between a mapper and an user or kernel buffer.
  * It must be called by a thread running in the cluster containing the mapper.
- * It split the data in fragments : one fragment is a set of contiguous bytes
- * stored in the same mapper page.  
- * It uses "hal_uspace" accesses to move fragments to/from the user buffer.
+ * - A kernel buffer must be entirely contained in the same cluster as the mapper.
+ * - An user buffer can be physically distributed in several clusters.
+ * In both cases, the data transfer is split in "fragments": one fragment contains 
+ * contiguous bytes in the same mapper page.
+ * - It uses "hal_uspace" accesses to move a fragment to/from the user buffer.
+ * - It uses a simple memcpy" access to move a fragment to/from a kernel buffer.
  * In case of write, the dirty bit is set for all pages written in the mapper.
  * The offset in the file descriptor is not modified by this function.
  *******************************************************************************************
- * @ mapper       : local pointer on local mapper.
- * @ to_buffer    : move data from mapper to buffer if true.
+ * @ mapper       : local pointer on mapper.
+ * @ to_buffer    : mapper -> buffer if true / buffer -> mapper if false.
+ * @ is_user      : user space buffer if true / kernel local buffer if false.
  * @ file_offset  : first byte to move in file.
- * @ buffer       : buffer address in user space.
+ * @ buffer       : pointer on buffer (local kernel buffer or user spaceaddress in user space.
  * @ size         : number of bytes to move.
  * returns O if success / returns EINVAL if error.
  ******************************************************************************************/
-error_t mapper_move( mapper_t * mapper,
-                     bool_t     to_buffer,
-                     uint32_t   file_offset,
-                     void     * buffer,
-                     uint32_t   size );
+error_t mapper_move_buffer( mapper_t * mapper,
+                            bool_t     to_buffer,
+                            bool_t     is_user,
+                            uint32_t   file_offset,
+                            void     * buffer,
+                            uint32_t   size );
 
 /*******************************************************************************************