dosfs: Block size optimization

Change block size of bdbuf to the cluster size if the data clusters are
aligned on a cluster boundary.  This enables fast access to data
clusters.

1 files changed, 27 insertions, 44 deletions

diff --git a/cpukit/libfs/src/dosfs/fat_fat_operations.c b/cpukit/libfs/src/dosfs/fat_fat_operations.c
index e9485d4b18..291819d343 100644
--- a/cpukit/libfs/src/dosfs/fat_fat_operations.c
+++ b/cpukit/libfs/src/dosfs/fat_fat_operations.c
@@ -235,7 +235,7 @@ fat_get_fat_cluster(
     )
 {
     int                     rc = RC_OK;
-    rtems_bdbuf_buffer     *block0 = NULL;
+    uint8_t                *sec_buf;
     uint32_t                sec = 0;
     uint32_t                ofs = 0;
 
@@ -247,7 +247,7 @@ fat_get_fat_cluster(
           fs_info->vol.afat_loc;
     ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
 
-    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
+    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
     if (rc != RC_OK)
         return rc;
 
@@ -258,19 +258,19 @@ fat_get_fat_cluster(
              * we are enforced in complex computations for FAT12 to escape CPU
              * align problems for some architectures
              */
-            *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));
+            *ret_val = (*(sec_buf + ofs));
             if ( ofs == (fs_info->vol.bps - 1) )
             {
                 rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
-                                    &block0);
+                                    &sec_buf);
                 if (rc != RC_OK)
                     return rc;
 
-                *ret_val |= (*((uint8_t   *)(block0->buffer)))<<8;
+                *ret_val |= *sec_buf << 8;
             }
             else
             {
-                *ret_val |= (*((uint8_t   *)(block0->buffer + ofs + 1)))<<8;
+                *ret_val |= *(sec_buf + ofs + 1) << 8;
             }
 
             if ( FAT_CLUSTER_IS_ODD(cln) )
@@ -280,12 +280,12 @@ fat_get_fat_cluster(
             break;
 
         case FAT_FAT16:
-            *ret_val = *((uint16_t   *)(block0->buffer + ofs));
+            *ret_val = *((uint16_t   *)(sec_buf + ofs));
             *ret_val = CF_LE_W(*ret_val);
             break;
 
         case FAT_FAT32:
-            *ret_val = *((uint32_t   *)(block0->buffer + ofs));
+            *ret_val = *((uint32_t   *)(sec_buf + ofs));
             *ret_val = CF_LE_L(*ret_val);
             break;
 
@@ -322,7 +322,7 @@ fat_set_fat_cluster(
     uint32_t            ofs = 0;
     uint16_t            fat16_clv = 0;
     uint32_t            fat32_clv = 0;
-    rtems_bdbuf_buffer *block0 = NULL;
+    uint8_t            *sec_buf = NULL;
 
     /* sanity check */
     if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
@@ -332,7 +332,7 @@ fat_set_fat_cluster(
           fs_info->vol.afat_loc;
     ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
 
-    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
+    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
     if (rc != RC_OK)
         return rc;
 
@@ -342,80 +342,65 @@ fat_set_fat_cluster(
             if ( FAT_CLUSTER_IS_ODD(cln) )
             {
                 fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;
-                *((uint8_t   *)(block0->buffer + ofs)) =
-                        (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
+                *(sec_buf + ofs) &= 0x0F;
 
-                *((uint8_t   *)(block0->buffer + ofs)) =
-                        (*((uint8_t   *)(block0->buffer + ofs))) |
-                        (uint8_t  )(fat16_clv & 0x00FF);
+                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
 
                 fat_buf_mark_modified(fs_info);
 
                 if ( ofs == (fs_info->vol.bps - 1) )
                 {
                     rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
-                                        &block0);
+                                        &sec_buf);
                     if (rc != RC_OK)
                         return rc;
 
-                     *((uint8_t   *)(block0->buffer)) &= 0x00;
+                     *sec_buf &= 0x00;
 
-                     *((uint8_t   *)(block0->buffer)) =
-                            (*((uint8_t   *)(block0->buffer))) |
-                            (uint8_t  )((fat16_clv & 0xFF00)>>8);
+                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
 
                      fat_buf_mark_modified(fs_info);
                 }
                 else
                 {
-                    *((uint8_t   *)(block0->buffer + ofs + 1)) &= 0x00;
+                    *(sec_buf + ofs + 1) &= 0x00;
 
-                    *((uint8_t   *)(block0->buffer + ofs + 1)) =
-                            (*((uint8_t   *)(block0->buffer + ofs + 1))) |
-                            (uint8_t  )((fat16_clv & 0xFF00)>>8);
+                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
                 }
             }
             else
             {
                 fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;
-                *((uint8_t   *)(block0->buffer + ofs)) &= 0x00;
+                *(sec_buf + ofs) &= 0x00;
 
-                *((uint8_t   *)(block0->buffer + ofs)) =
-                        (*((uint8_t   *)(block0->buffer + ofs))) |
-                        (uint8_t  )(fat16_clv & 0x00FF);
+                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
 
                 fat_buf_mark_modified(fs_info);
 
                 if ( ofs == (fs_info->vol.bps - 1) )
                 {
                     rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
-                                        &block0);
+                                        &sec_buf);
                     if (rc != RC_OK)
                         return rc;
 
-                    *((uint8_t   *)(block0->buffer)) =
-                            (*((uint8_t   *)(block0->buffer))) & 0xF0;
+                    *sec_buf &= 0xF0;
 
-                    *((uint8_t   *)(block0->buffer)) =
-                            (*((uint8_t   *)(block0->buffer))) |
-                            (uint8_t  )((fat16_clv & 0xFF00)>>8);
+                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
 
                     fat_buf_mark_modified(fs_info);
                 }
                 else
                 {
-                    *((uint8_t   *)(block0->buffer + ofs + 1)) =
-                      (*((uint8_t   *)(block0->buffer + ofs + 1))) & 0xF0;
+                    *(sec_buf + ofs + 1) &= 0xF0;
 
-                    *((uint8_t   *)(block0->buffer + ofs+1)) =
-                           (*((uint8_t   *)(block0->buffer + ofs+1))) |
-                           (uint8_t  )((fat16_clv & 0xFF00)>>8);
+                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
                 }
             }
             break;
 
         case FAT_FAT16:
-            *((uint16_t   *)(block0->buffer + ofs)) =
+            *((uint16_t   *)(sec_buf + ofs)) =
                     (uint16_t  )(CT_LE_W(in_val));
             fat_buf_mark_modified(fs_info);
             break;
@@ -423,11 +408,9 @@ fat_set_fat_cluster(
         case FAT_FAT32:
             fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
 
-            *((uint32_t   *)(block0->buffer + ofs)) =
-            (*((uint32_t   *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
+            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
 
-            *((uint32_t   *)(block0->buffer + ofs)) =
-                   fat32_clv | (*((uint32_t   *)(block0->buffer + ofs)));
+            *((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
 
             fat_buf_mark_modified(fs_info);
             break;