Changeset a20fbe7 in rtems


Ignore:
Timestamp:
Nov 28, 2012, 1:43:32 PM (7 years ago)
Author:
Ralf Kirchner <ralf.kirchner@…>
Branches:
4.11, master
Children:
42a22f08
Parents:
5877a10f
git-author:
Ralf Kirchner <ralf.kirchner@…> (11/28/12 13:43:32)
git-committer:
Sebastian Huber <sebastian.huber@…> (12/05/12 14:26:48)
Message:

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.

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libfs/src/dosfs/fat.c

    r5877a10f ra20fbe7  
    1818#include <errno.h>
    1919#include <stdlib.h>
     20#include <stdint.h>
    2021
    2122#include <rtems/libio_.h>
     
    2425#include "fat_fat_operations.h"
    2526
     27static int
     28 _fat_block_release(fat_fs_info_t *fs_info);
     29
     30static ssize_t
     31 fat_cluster_read(fat_fs_info_t                       *fs_info,
     32                  uint32_t                             cln,
     33                  void                                *buff);
     34
     35static ssize_t
     36 fat_cluster_write(fat_fs_info_t                      *fs_info,
     37                   uint32_t                            cln,
     38                   const void                         *buff);
     39
    2640int
    27 fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,
    28                rtems_bdbuf_buffer **buf)
     41fat_buf_access(fat_fs_info_t   *fs_info,
     42               const uint32_t   sec_num,
     43               const int        op_type,
     44               uint8_t        **sec_buf)
    2945{
    3046    rtems_status_code sc = RTEMS_SUCCESSFUL;
    31     uint8_t           i;
    32     bool              sec_of_fat;
    33 
    34 
    35     if (fs_info->c.state == FAT_CACHE_EMPTY)
    36     {
     47    uint32_t          blk = fat_sector_num_to_block_num (fs_info,
     48                                                         sec_num);
     49    uint32_t          blk_ofs = fat_sector_offset_to_block_offset (fs_info,
     50                                                                   sec_num,
     51                                                                   0);
     52
     53    if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
     54    {
     55        fat_buf_release(fs_info);
     56
    3757        if (op_type == FAT_OP_TYPE_READ)
    3858            sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
     
    4161        if (sc != RTEMS_SUCCESSFUL)
    4262            rtems_set_errno_and_return_minus_one(EIO);
    43         fs_info->c.blk_num = blk;
     63        fs_info->c.blk_num = sec_num;
    4464        fs_info->c.modified = 0;
    4565        fs_info->c.state = FAT_CACHE_ACTUAL;
    4666    }
    47 
    48     sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
    49                   (fs_info->c.blk_num < fs_info->vol.rdir_loc));
    50 
    51     if (fs_info->c.blk_num != blk)
    52     {
    53         if (fs_info->c.modified)
    54         {
    55             if (sec_of_fat && !fs_info->vol.mirror)
    56                 memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
    57                        fs_info->vol.bps);
    58 
    59             sc = rtems_bdbuf_release_modified(fs_info->c.buf);
    60             fs_info->c.state = FAT_CACHE_EMPTY;
    61             fs_info->c.modified = 0;
    62             if (sc != RTEMS_SUCCESSFUL)
    63                 rtems_set_errno_and_return_minus_one(EIO);
    64 
    65             if (sec_of_fat && !fs_info->vol.mirror)
    66             {
    67                 rtems_bdbuf_buffer *b;
    68 
    69                 for (i = 1; i < fs_info->vol.fats; i++)
    70                 {
    71                     sc = rtems_bdbuf_get(fs_info->vol.dd,
    72                                          fs_info->c.blk_num +
    73                                          fs_info->vol.fat_length * i,
    74                                          &b);
    75                     if ( sc != RTEMS_SUCCESSFUL)
    76                         rtems_set_errno_and_return_minus_one(ENOMEM);
    77                     memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
    78                     sc = rtems_bdbuf_release_modified(b);
    79                     if ( sc != RTEMS_SUCCESSFUL)
    80                         rtems_set_errno_and_return_minus_one(ENOMEM);
    81                 }
    82             }
    83         }
    84         else
    85         {
    86             sc = rtems_bdbuf_release(fs_info->c.buf);
    87             fs_info->c.state = FAT_CACHE_EMPTY;
    88             if (sc != RTEMS_SUCCESSFUL)
    89                 rtems_set_errno_and_return_minus_one(EIO);
    90 
    91         }
    92         if (op_type == FAT_OP_TYPE_READ)
    93             sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
    94         else
    95             sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
    96         if (sc != RTEMS_SUCCESSFUL)
    97             rtems_set_errno_and_return_minus_one(EIO);
    98         fs_info->c.blk_num = blk;
    99         fs_info->c.state = FAT_CACHE_ACTUAL;
    100     }
    101     *buf = fs_info->c.buf;
     67    *sec_buf = &fs_info->c.buf->buffer[blk_ofs];
    10268    return RC_OK;
    10369}
     
    10773{
    10874    rtems_status_code sc = RTEMS_SUCCESSFUL;
    109     uint8_t           i;
    110     bool              sec_of_fat;
    11175
    11276    if (fs_info->c.state == FAT_CACHE_EMPTY)
    11377        return RC_OK;
    11478
    115     sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
    116                   (fs_info->c.blk_num < fs_info->vol.rdir_loc));
    117 
    11879    if (fs_info->c.modified)
    11980    {
     81        uint32_t sec_num = fs_info->c.blk_num;
     82        bool     sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
     83                              (sec_num < fs_info->vol.rdir_loc));
     84        uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
     85        uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
     86                                                             sec_num,
     87                                                             0);
     88
    12089        if (sec_of_fat && !fs_info->vol.mirror)
    121             memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
     90            memcpy(fs_info->sec_buf,
     91                   fs_info->c.buf->buffer + blk_ofs,
     92                   fs_info->vol.bps);
    12293
    12394        sc = rtems_bdbuf_release_modified(fs_info->c.buf);
     
    12899        if (sec_of_fat && !fs_info->vol.mirror)
    129100        {
    130             rtems_bdbuf_buffer *b;
     101            uint8_t i;
    131102
    132103            for (i = 1; i < fs_info->vol.fats; i++)
    133104            {
    134                 sc = rtems_bdbuf_get(fs_info->vol.dd,
    135                                      fs_info->c.blk_num +
    136                                      fs_info->vol.fat_length * i,
    137                                      &b);
     105                rtems_bdbuf_buffer *bd;
     106
     107                sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
     108                blk = fat_sector_num_to_block_num(fs_info, sec_num);
     109                blk_ofs = fat_sector_offset_to_block_offset(fs_info,
     110                                                            sec_num,
     111                                                            0);
     112
     113                if (blk_ofs == 0
     114                    && fs_info->vol.bps == fs_info->vol.bytes_per_block)
     115                {
     116                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
     117                }
     118                else
     119                {
     120                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
     121                }
    138122                if ( sc != RTEMS_SUCCESSFUL)
    139123                    rtems_set_errno_and_return_minus_one(ENOMEM);
    140                 memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
    141                 sc = rtems_bdbuf_release_modified(b);
     124                memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
     125                sc = rtems_bdbuf_release_modified(bd);
    142126                if ( sc != RTEMS_SUCCESSFUL)
    143127                    rtems_set_errno_and_return_minus_one(ENOMEM);
     
    183167    int                     rc = RC_OK;
    184168    ssize_t                 cmpltd = 0;
    185     uint32_t                blk = start;
     169    uint32_t                sec_num = start;
    186170    uint32_t                ofs = offset;
    187     rtems_bdbuf_buffer     *block = NULL;
     171    uint8_t                *sec_buf;
    188172    uint32_t                c = 0;
    189173
    190174    while (count > 0)
    191175    {
    192         rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
     176        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
    193177        if (rc != RC_OK)
    194178            return -1;
    195179
    196180        c = MIN(count, (fs_info->vol.bps - ofs));
    197         memcpy((buff + cmpltd), (block->buffer + ofs), c);
     181        memcpy((buff + cmpltd), (sec_buf + ofs), c);
    198182
    199183        count -= c;
    200184        cmpltd += c;
    201         blk++;
     185        sec_num++;
    202186        ofs = 0;
    203187    }
     
    232216    int                 rc = RC_OK;
    233217    ssize_t             cmpltd = 0;
    234     uint32_t            blk = start;
     218    uint32_t            sec_num = start;
    235219    uint32_t            ofs = offset;
    236     rtems_bdbuf_buffer *block = NULL;
     220    uint8_t            *sec_buf;
    237221    uint32_t            c = 0;
    238222
     
    241225        c = MIN(count, (fs_info->vol.bps - ofs));
    242226
    243         if (c == fs_info->vol.bps)
    244             rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
     227        if (c == fs_info->vol.bytes_per_block)
     228            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
    245229        else
    246             rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
     230            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
    247231        if (rc != RC_OK)
    248232            return -1;
    249233
    250         memcpy((block->buffer + ofs), (buff + cmpltd), c);
     234        memcpy((sec_buf + ofs), (buff + cmpltd), c);
    251235
    252236        fat_buf_mark_modified(fs_info);
     
    254238        count -= c;
    255239        cmpltd +=c;
    256         blk++;
     240        sec_num++;
    257241        ofs = 0;
    258242    }
     
    268252{
    269253    int                 rc = RC_OK;
    270     uint32_t            blk = start;
     254    uint32_t            sec_num = start;
    271255    uint32_t            ofs = offset;
    272     rtems_bdbuf_buffer *block = NULL;
     256    uint8_t            *sec_buf;
    273257    uint32_t            c = 0;
    274258
     
    278262
    279263        if (c == fs_info->vol.bps)
    280             rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
     264            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
    281265        else
    282             rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
     266            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
    283267        if (rc != RC_OK)
    284268            return -1;
    285269
    286         memset((block->buffer + ofs), 0, c);
     270        memset((block + ofs), 0, c);
    287271
    288272        fat_buf_mark_modified(fs_info);
    289273
    290274        count -= c;
    291         blk++;
     275        sec_num++;
    292276        ofs = 0;
    293277    }
     
    363347    return _fat_block_write(fs_info, fsec, 0,
    364348                          fs_info->vol.spc << fs_info->vol.sec_log2, buff);
     349}
     350
     351static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
     352{
     353    return (sec_num & (vol->spc - 1)) == 0;
    365354}
    366355
     
    445434        rtems_set_errno_and_return_minus_one( EINVAL );
    446435    }
    447 
    448436    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
    449437         i >>= 1, vol->sec_mul++);
    450438    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
    451439         i >>= 1, vol->sec_log2++);
     440
     441    vol->bytes_per_block = vol->bps;
     442    vol->bytes_per_block_log2 = vol->sec_log2;
     443    vol->sectors_per_block = 1;
    452444
    453445    vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
     
    639631    }
    640632
     633    /*
     634     * If possible we will use the cluster size as bdbuf block size for faster
     635     * file access. This requires that certain sectors are aligned to cluster
     636     * borders.
     637     */
     638    if (is_cluster_aligned(vol, vol->data_fsec)
     639        && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
     640    {
     641        vol->bytes_per_block = vol->bpc;
     642        vol->bytes_per_block_log2 = vol->bpc_log2;
     643        vol->sectors_per_block = vol->spc;
     644        sc = rtems_bdbuf_set_block_size (vol->dd, vol->bytes_per_block, true);
     645        if (RTEMS_SUCCESSFUL != sc)
     646        {
     647            close(vol->fd);
     648            free(fs_info->vhash);
     649            free(fs_info->rhash);
     650            free(fs_info->uino);
     651            rtems_set_errno_and_return_minus_one( EIO );
     652        }
     653    }
     654
    641655    return RC_OK;
    642656}
  • cpukit/libfs/src/dosfs/fat.h

    r5877a10f ra20fbe7  
    299299    uint16_t           bpc;            /* bytes per cluster */
    300300    uint8_t            bpc_log2;       /* log2 of bytes per cluster */
     301    uint8_t            sectors_per_block;    /* sectors per bdbuf block */
     302    uint16_t           bytes_per_block;      /* number of bytes for the bduf block device handling */
     303    uint8_t            bytes_per_block_log2; /* log2 of bytes_per_block */
    301304    uint8_t            fats;           /* number of FATs */
    302305    uint8_t            type;           /* FAT type */
     
    437440}
    438441
     442static inline uint32_t
     443 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
     444                              const uint32_t sector_number)
     445{
     446  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
     447}
     448
     449static inline uint32_t
     450 fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
     451                                    const uint32_t sector,
     452                                    const uint32_t sector_offset)
     453{
     454  return sector_offset +
     455           ((sector -
     456              fat_block_num_to_sector_num (fs_info,
     457                  fat_sector_num_to_block_num (fs_info, sector)))
     458            << fs_info->vol.sec_log2);
     459}
     460
    439461static inline void
    440462fat_buf_mark_modified(fat_fs_info_t *fs_info)
     
    444466
    445467int
    446 fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,
    447                rtems_bdbuf_buffer **buf);
     468fat_buf_access(fat_fs_info_t  *fs_info,
     469               uint32_t        sec_num,
     470               int             op_type,
     471               uint8_t       **sec_buf);
    448472
    449473int
     
    470494                 uint32_t                              count);
    471495
    472 int
    473 _fat_block_release(fat_fs_info_t *fs_info);
    474 
    475 ssize_t
    476 fat_cluster_read(fat_fs_info_t                        *fs_info,
    477                   uint32_t                             cln,
    478                   void                                *buff);
    479 
    480 ssize_t
    481 fat_cluster_write(fat_fs_info_t                        *fs_info,
    482                    uint32_t                             cln,
    483                    const void                          *buff);
     496
    484497
    485498int
  • cpukit/libfs/src/dosfs/fat_fat_operations.c

    r5877a10f ra20fbe7  
    236236{
    237237    int                     rc = RC_OK;
    238     rtems_bdbuf_buffer     *block0 = NULL;
     238    uint8_t                *sec_buf;
    239239    uint32_t                sec = 0;
    240240    uint32_t                ofs = 0;
     
    248248    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
    249249
    250     rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
     250    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
    251251    if (rc != RC_OK)
    252252        return rc;
     
    259259             * align problems for some architectures
    260260             */
    261             *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));
     261            *ret_val = (*(sec_buf + ofs));
    262262            if ( ofs == (fs_info->vol.bps - 1) )
    263263            {
    264264                rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
    265                                     &block0);
     265                                    &sec_buf);
    266266                if (rc != RC_OK)
    267267                    return rc;
    268268
    269                 *ret_val |= (*((uint8_t   *)(block0->buffer)))<<8;
     269                *ret_val |= *sec_buf << 8;
    270270            }
    271271            else
    272272            {
    273                 *ret_val |= (*((uint8_t   *)(block0->buffer + ofs + 1)))<<8;
     273                *ret_val |= *(sec_buf + ofs + 1) << 8;
    274274            }
    275275
     
    281281
    282282        case FAT_FAT16:
    283             *ret_val = *((uint16_t   *)(block0->buffer + ofs));
     283            *ret_val = *((uint16_t   *)(sec_buf + ofs));
    284284            *ret_val = CF_LE_W(*ret_val);
    285285            break;
    286286
    287287        case FAT_FAT32:
    288             *ret_val = *((uint32_t   *)(block0->buffer + ofs));
     288            *ret_val = *((uint32_t   *)(sec_buf + ofs));
    289289            *ret_val = CF_LE_L(*ret_val);
    290290            break;
     
    323323    uint16_t            fat16_clv = 0;
    324324    uint32_t            fat32_clv = 0;
    325     rtems_bdbuf_buffer *block0 = NULL;
     325    uint8_t            *sec_buf = NULL;
    326326
    327327    /* sanity check */
     
    333333    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
    334334
    335     rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
     335    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
    336336    if (rc != RC_OK)
    337337        return rc;
     
    343343            {
    344344                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;
    345                 *((uint8_t   *)(block0->buffer + ofs)) =
    346                         (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
    347 
    348                 *((uint8_t   *)(block0->buffer + ofs)) =
    349                         (*((uint8_t   *)(block0->buffer + ofs))) |
    350                         (uint8_t  )(fat16_clv & 0x00FF);
     345                *(sec_buf + ofs) &= 0x0F;
     346
     347                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
    351348
    352349                fat_buf_mark_modified(fs_info);
     
    355352                {
    356353                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
    357                                         &block0);
     354                                        &sec_buf);
    358355                    if (rc != RC_OK)
    359356                        return rc;
    360357
    361                      *((uint8_t   *)(block0->buffer)) &= 0x00;
    362 
    363                      *((uint8_t   *)(block0->buffer)) =
    364                             (*((uint8_t   *)(block0->buffer))) |
    365                             (uint8_t  )((fat16_clv & 0xFF00)>>8);
     358                     *sec_buf &= 0x00;
     359
     360                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
    366361
    367362                     fat_buf_mark_modified(fs_info);
     
    369364                else
    370365                {
    371                     *((uint8_t   *)(block0->buffer + ofs + 1)) &= 0x00;
    372 
    373                     *((uint8_t   *)(block0->buffer + ofs + 1)) =
    374                             (*((uint8_t   *)(block0->buffer + ofs + 1))) |
    375                             (uint8_t  )((fat16_clv & 0xFF00)>>8);
     366                    *(sec_buf + ofs + 1) &= 0x00;
     367
     368                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
    376369                }
    377370            }
     
    379372            {
    380373                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;
    381                 *((uint8_t   *)(block0->buffer + ofs)) &= 0x00;
    382 
    383                 *((uint8_t   *)(block0->buffer + ofs)) =
    384                         (*((uint8_t   *)(block0->buffer + ofs))) |
    385                         (uint8_t  )(fat16_clv & 0x00FF);
     374                *(sec_buf + ofs) &= 0x00;
     375
     376                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
    386377
    387378                fat_buf_mark_modified(fs_info);
     
    390381                {
    391382                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
    392                                         &block0);
     383                                        &sec_buf);
    393384                    if (rc != RC_OK)
    394385                        return rc;
    395386
    396                     *((uint8_t   *)(block0->buffer)) =
    397                             (*((uint8_t   *)(block0->buffer))) & 0xF0;
    398 
    399                     *((uint8_t   *)(block0->buffer)) =
    400                             (*((uint8_t   *)(block0->buffer))) |
    401                             (uint8_t  )((fat16_clv & 0xFF00)>>8);
     387                    *sec_buf &= 0xF0;
     388
     389                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
    402390
    403391                    fat_buf_mark_modified(fs_info);
     
    405393                else
    406394                {
    407                     *((uint8_t   *)(block0->buffer + ofs + 1)) =
    408                       (*((uint8_t   *)(block0->buffer + ofs + 1))) & 0xF0;
    409 
    410                     *((uint8_t   *)(block0->buffer + ofs+1)) =
    411                            (*((uint8_t   *)(block0->buffer + ofs+1))) |
    412                            (uint8_t  )((fat16_clv & 0xFF00)>>8);
     395                    *(sec_buf + ofs + 1) &= 0xF0;
     396
     397                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
    413398                }
    414399            }
     
    416401
    417402        case FAT_FAT16:
    418             *((uint16_t   *)(block0->buffer + ofs)) =
     403            *((uint16_t   *)(sec_buf + ofs)) =
    419404                    (uint16_t  )(CT_LE_W(in_val));
    420405            fat_buf_mark_modified(fs_info);
     
    424409            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
    425410
    426             *((uint32_t   *)(block0->buffer + ofs)) =
    427             (*((uint32_t   *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
    428 
    429             *((uint32_t   *)(block0->buffer + ofs)) =
    430                    fat32_clv | (*((uint32_t   *)(block0->buffer + ofs)));
     411            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
     412
     413            *((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
    431414
    432415            fat_buf_mark_modified(fs_info);
  • cpukit/libfs/src/dosfs/msdos_file.c

    r5877a10f ra20fbe7  
    192192    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;
    193193    fat_file_fd_t     *fat_fd = loc->node_access;
     194    uint32_t           cl_mask = fs_info->fat.vol.bpc - 1;
    194195
    195196    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
     
    203204    buf->st_rdev = 0ll;
    204205    buf->st_size = fat_fd->fat_file_size;
    205     buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
    206     buf->st_blksize = fs_info->fat.vol.bps;
     206    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
     207      >> FAT_SECTOR512_BITS;
     208    buf->st_blksize = fs_info->fat.vol.bpc;
    207209    buf->st_mtime = fat_fd->mtime;
    208210
  • testsuites/fstests/mdosfs_support/fs_support.c

    r5877a10f ra20fbe7  
    2929    OEMName:             "RTEMS",
    3030    VolLabel:            "RTEMSDisk",
    31     sectors_per_cluster: 0,
     31    sectors_per_cluster: 2,
    3232    fat_num:             0,
    3333    files_per_root_dir:  0,
Note: See TracChangeset for help on using the changeset viewer.