Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 9a1d8ab in mainline


Ignore:
Timestamp:
2010-07-28T15:27:13Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
0b749a3, 482dde7, c0e1be7
Parents:
14f2100 (diff), dba4a23 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jakub/helenos/fs.

This merge adds two important optimizations for appending files and doing
sequential I/O on them.

Location:
uspace/srv/fs/fat
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/fat/fat.h

    r14f2100 r9a1d8ab  
    4848
    4949#define min(a, b)               ((a) < (b) ? (a) : (b))
     50
     51/*
     52 * Convenience macros for accessing some frequently used boot sector members.
     53 */
     54#define BPS(bs)         uint16_t_le2host((bs)->bps)
     55#define SPC(bs)         (bs)->spc
     56#define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
     57#define FATCNT(bs)      (bs)->fatcnt
     58#define SF(bs)          uint16_t_le2host((bs)->sec_per_fat)
     59#define RDE(bs)         uint16_t_le2host((bs)->root_ent_max)
     60#define TS(bs)          (uint16_t_le2host((bs)->totsec16) != 0 ? \
     61                        uint16_t_le2host((bs)->totsec16) : \
     62                        uint32_t_le2host(bs->totsec32))
    5063
    5164#define BS_BLOCK                0
     
    198211        unsigned                refcnt;
    199212        bool                    dirty;
     213
     214        /*
     215         * Cache of the node's last and "current" cluster to avoid some
     216         * unnecessary FAT walks.
     217         */
     218        /* Node's last cluster in FAT. */
     219        bool            lastc_cached_valid;
     220        fat_cluster_t   lastc_cached_value;
     221        /* Node's "current" cluster, i.e. where the last I/O took place. */
     222        bool            currc_cached_valid;
     223        aoff64_t        currc_cached_bn;
     224        fat_cluster_t   currc_cached_value;
    200225} fat_node_t;
    201226
  • uspace/srv/fs/fat/fat_fat.c

    r14f2100 r9a1d8ab  
    4949#include <mem.h>
    5050
     51/*
     52 * Convenience macros for computing some frequently used values from the
     53 * primitive boot sector members.
     54 */
     55#define RDS(bs)         ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \
     56                        (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0)
     57#define SSA(bs)         (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs))
     58
     59#define CLBN2PBN(bs, cl, bn) \
     60        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
     61
    5162/**
    5263 * The fat_alloc_lock mutex protects all copies of the File Allocation Table
     
    7485{
    7586        block_t *b;
    76         unsigned bps;
    77         unsigned rscnt;         /* block address of the first FAT */
    7887        uint16_t clusters = 0;
    7988        fat_cluster_t clst = firstc;
    8089        int rc;
    81 
    82         bps = uint16_t_le2host(bs->bps);
    83         rscnt = uint16_t_le2host(bs->rscnt);
    8490
    8591        if (firstc == FAT_CLST_RES0) {
     
    99105                if (lastc)
    100106                        *lastc = clst;  /* remember the last cluster number */
    101                 fsec = (clst * sizeof(fat_cluster_t)) / bps;
    102                 fidx = clst % (bps / sizeof(fat_cluster_t));
     107                fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
     108                fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
    103109                /* read FAT1 */
    104                 rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
     110                rc = block_get(&b, dev_handle, RSCNT(bs) + fsec,
     111                    BLOCK_FLAGS_NONE);
    105112                if (rc != EOK)
    106113                        return rc;
     
    125132 * @param block         Pointer to a block pointer for storing result.
    126133 * @param bs            Buffer holding the boot sector of the file system.
    127  * @param dev_handle    Device handle of the file system.
    128  * @param firstc        First cluster used by the file. Can be zero if the file
    129  *                      is empty.
     134 * @param nodep         FAT node.
    130135 * @param bn            Block number.
    131136 * @param flags         Flags passed to libblock.
     
    134139 */
    135140int
     141fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,
     142    aoff64_t bn, int flags)
     143{
     144        fat_cluster_t firstc = nodep->firstc;
     145        fat_cluster_t currc;
     146        aoff64_t relbn = bn;
     147        int rc;
     148
     149        if (!nodep->size)
     150                return ELIMIT;
     151
     152        if (nodep->firstc == FAT_CLST_ROOT)
     153                goto fall_through;
     154
     155        if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
     156            nodep->lastc_cached_valid) {
     157                /*
     158                 * This is a request to read a block within the last cluster
     159                 * when fortunately we have the last cluster number cached.
     160                 */
     161                return block_get(block, nodep->idx->dev_handle,
     162                    CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
     163        }
     164
     165        if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {
     166                /*
     167                 * We can start with the cluster cached by the previous call to
     168                 * fat_block_get().
     169                 */
     170                firstc = nodep->currc_cached_value;
     171                relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);
     172        }
     173
     174fall_through:
     175        rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc,
     176            &currc, relbn, flags);
     177        if (rc != EOK)
     178                return rc;
     179       
     180        /*
     181         * Update the "current" cluster cache.
     182         */
     183        nodep->currc_cached_valid = true;
     184        nodep->currc_cached_bn = bn;
     185        nodep->currc_cached_value = currc;
     186
     187        return rc;
     188}
     189
     190/** Read block from file located on a FAT file system.
     191 *
     192 * @param block         Pointer to a block pointer for storing result.
     193 * @param bs            Buffer holding the boot sector of the file system.
     194 * @param dev_handle    Device handle of the file system.
     195 * @param fcl           First cluster used by the file. Can be zero if the file
     196 *                      is empty.
     197 * @param clp           If not NULL, address where the cluster containing bn
     198 *                      will be stored.
     199 *                      stored
     200 * @param bn            Block number.
     201 * @param flags         Flags passed to libblock.
     202 *
     203 * @return              EOK on success or a negative error code.
     204 */
     205int
    136206_fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
    137     fat_cluster_t firstc, aoff64_t bn, int flags)
    138 {
    139         unsigned bps;
    140         unsigned rscnt;         /* block address of the first FAT */
    141         unsigned rde;
    142         unsigned rds;           /* root directory size */
    143         unsigned sf;
    144         unsigned ssa;           /* size of the system area */
     207    fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
     208{
    145209        uint16_t clusters;
    146210        unsigned max_clusters;
    147         fat_cluster_t lastc;
     211        fat_cluster_t c;
    148212        int rc;
    149213
     
    151215         * This function can only operate on non-zero length files.
    152216         */
    153         if (firstc == FAT_CLST_RES0)
     217        if (fcl == FAT_CLST_RES0)
    154218                return ELIMIT;
    155219
    156         bps = uint16_t_le2host(bs->bps);
    157         rscnt = uint16_t_le2host(bs->rscnt);
    158         rde = uint16_t_le2host(bs->root_ent_max);
    159         sf = uint16_t_le2host(bs->sec_per_fat);
    160 
    161         rds = (sizeof(fat_dentry_t) * rde) / bps;
    162         rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
    163         ssa = rscnt + bs->fatcnt * sf + rds;
    164 
    165         if (firstc == FAT_CLST_ROOT) {
     220        if (fcl == FAT_CLST_ROOT) {
    166221                /* root directory special case */
    167                 assert(bn < rds);
    168                 rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
    169                     flags);
     222                assert(bn < RDS(bs));
     223                rc = block_get(block, dev_handle,
     224                    RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
    170225                return rc;
    171226        }
    172227
    173         max_clusters = bn / bs->spc;
    174         rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
    175             max_clusters);
     228        max_clusters = bn / SPC(bs);
     229        rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters);
    176230        if (rc != EOK)
    177231                return rc;
    178232        assert(clusters == max_clusters);
    179233
    180         rc = block_get(block, dev_handle,
    181             ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
     234        rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags);
     235
     236        if (clp)
     237                *clp = c;
    182238
    183239        return rc;
     
    198254int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
    199255{
    200         uint16_t bps;
    201         unsigned spc;
    202256        block_t *b;
    203257        aoff64_t o, boundary;
    204258        int rc;
    205259
    206         bps = uint16_t_le2host(bs->bps);
    207         spc = bs->spc;
    208        
    209         boundary = ROUND_UP(nodep->size, bps * spc);
     260        boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs));
    210261
    211262        /* zero out already allocated space */
    212263        for (o = nodep->size; o < pos && o < boundary;
    213             o = ALIGN_DOWN(o + bps, bps)) {
    214                 int flags = (o % bps == 0) ?
     264            o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {
     265                int flags = (o % BPS(bs) == 0) ?
    215266                    BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
    216                 rc = fat_block_get(&b, bs, nodep, o / bps, flags);
    217                 if (rc != EOK)
    218                         return rc;
    219                 memset(b->data + o % bps, 0, bps - o % bps);
     267                rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);
     268                if (rc != EOK)
     269                        return rc;
     270                memset(b->data + o % BPS(bs), 0, BPS(bs) - o % BPS(bs));
    220271                b->dirty = true;                /* need to sync node */
    221272                rc = block_put(b);
     
    228279       
    229280        /* zero out the initial part of the new cluster chain */
    230         for (o = boundary; o < pos; o += bps) {
     281        for (o = boundary; o < pos; o += BPS(bs)) {
    231282                rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
    232                     (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
    233                 if (rc != EOK)
    234                         return rc;
    235                 memset(b->data, 0, min(bps, pos - o));
     283                    NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
     284                if (rc != EOK)
     285                        return rc;
     286                memset(b->data, 0, min(BPS(bs), pos - o));
    236287                b->dirty = true;                /* need to sync node */
    237288                rc = block_put(b);
     
    257308{
    258309        block_t *b;
    259         uint16_t bps;
    260         uint16_t rscnt;
    261         uint16_t sf;
    262310        fat_cluster_t *cp;
    263311        int rc;
    264312
    265         bps = uint16_t_le2host(bs->bps);
    266         rscnt = uint16_t_le2host(bs->rscnt);
    267         sf = uint16_t_le2host(bs->sec_per_fat);
    268 
    269         rc = block_get(&b, dev_handle, rscnt + sf * fatno +
    270             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
     313        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
     314            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    271315        if (rc != EOK)
    272316                return rc;
    273         cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
     317        cp = (fat_cluster_t *)b->data +
     318            clst % (BPS(bs) / sizeof(fat_cluster_t));
    274319        *value = uint16_t_le2host(*cp);
    275320        rc = block_put(b);
     
    293338{
    294339        block_t *b;
    295         uint16_t bps;
    296         uint16_t rscnt;
    297         uint16_t sf;
    298340        fat_cluster_t *cp;
    299341        int rc;
    300342
    301         bps = uint16_t_le2host(bs->bps);
    302         rscnt = uint16_t_le2host(bs->rscnt);
    303         sf = uint16_t_le2host(bs->sec_per_fat);
    304 
    305         assert(fatno < bs->fatcnt);
    306         rc = block_get(&b, dev_handle, rscnt + sf * fatno +
    307             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
     343        assert(fatno < FATCNT(bs));
     344        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
     345            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    308346        if (rc != EOK)
    309347                return rc;
    310         cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
     348        cp = (fat_cluster_t *)b->data +
     349            clst % (BPS(bs) / sizeof(fat_cluster_t));
    311350        *cp = host2uint16_t_le(value);
    312351        b->dirty = true;                /* need to sync block */
     
    364403    fat_cluster_t *mcl, fat_cluster_t *lcl)
    365404{
    366         uint16_t bps;
    367         uint16_t rscnt;
    368         uint16_t sf;
    369         uint32_t ts;
    370         unsigned rde;
    371         unsigned rds;
    372         unsigned ssa;
    373405        block_t *blk;
    374406        fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
     
    380412        if (!lifo)
    381413                return ENOMEM;
    382        
    383         bps = uint16_t_le2host(bs->bps);
    384         rscnt = uint16_t_le2host(bs->rscnt);
    385         sf = uint16_t_le2host(bs->sec_per_fat);
    386         rde = uint16_t_le2host(bs->root_ent_max);
    387         ts = (uint32_t) uint16_t_le2host(bs->totsec16);
    388         if (ts == 0)
    389                 ts = uint32_t_le2host(bs->totsec32);
    390 
    391         rds = (sizeof(fat_dentry_t) * rde) / bps;
    392         rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
    393         ssa = rscnt + bs->fatcnt * sf + rds;
    394414       
    395415        /*
     
    397417         */
    398418        fibril_mutex_lock(&fat_alloc_lock);
    399         for (b = 0, cl = 0; b < sf; b++) {
    400                 rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
     419        for (b = 0, cl = 0; b < SF(bs); b++) {
     420                rc = block_get(&blk, dev_handle, RSCNT(bs) + b,
     421                    BLOCK_FLAGS_NONE);
    401422                if (rc != EOK)
    402423                        goto error;
    403                 for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
     424                for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) {
    404425                        /*
    405426                         * Check if the cluster is physically there. This check
     
    408429                         * from the size of the file allocation table.
    409430                         */
    410                         if ((cl >= 2) && ((cl - 2) * bs->spc + ssa >= ts)) {
     431                        if ((cl >= 2) &&
     432                            ((cl - 2) * SPC(bs) + SSA(bs) >= TS(bs))) {
    411433                                rc = block_put(blk);
    412434                                if (rc != EOK)
     
    511533 * @param nodep         Node representing the file.
    512534 * @param mcl           First cluster of the cluster chain to append.
     535 * @param lcl           Last cluster of the cluster chain to append.
    513536 *
    514537 * @return              EOK on success or a negative error code.
    515538 */
    516 int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
     539int
     540fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
     541    fat_cluster_t lcl)
    517542{
    518543        dev_handle_t dev_handle = nodep->idx->dev_handle;
    519         fat_cluster_t lcl;
     544        fat_cluster_t lastc;
    520545        uint16_t numc;
    521546        uint8_t fatno;
    522547        int rc;
    523548
    524         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
    525             (uint16_t) -1);
    526         if (rc != EOK)
    527                 return rc;
    528 
    529         if (numc == 0) {
    530                 /* No clusters allocated to the node yet. */
    531                 nodep->firstc = mcl;
    532                 nodep->dirty = true;            /* need to sync node */
    533                 return EOK;
     549        if (nodep->lastc_cached_valid) {
     550                lastc = nodep->lastc_cached_value;
     551                nodep->lastc_cached_valid = false;
     552        } else {
     553                rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lastc,
     554                    &numc, (uint16_t) -1);
     555                if (rc != EOK)
     556                        return rc;
     557
     558                if (numc == 0) {
     559                        /* No clusters allocated to the node yet. */
     560                        nodep->firstc = mcl;
     561                        nodep->dirty = true;    /* need to sync node */
     562                        return EOK;
     563                }
    534564        }
    535565
    536566        for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
    537                 rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl,
     567                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lastc,
    538568                    mcl);
    539569                if (rc != EOK)
    540570                        return rc;
    541571        }
     572
     573        nodep->lastc_cached_valid = true;
     574        nodep->lastc_cached_value = lcl;
    542575
    543576        return EOK;
     
    548581 * @param bs            Buffer holding the boot sector of the file system.
    549582 * @param nodep         FAT node where the chopping will take place.
    550  * @param lastc         Last cluster which will remain in the node. If this
     583 * @param lcl           Last cluster which will remain in the node. If this
    551584 *                      argument is FAT_CLST_RES0, then all clusters will
    552585 *                      be chopped off.
     
    554587 * @return              EOK on success or a negative return code.
    555588 */
    556 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
    557 {
    558         int rc;
    559 
     589int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
     590{
     591        int rc;
    560592        dev_handle_t dev_handle = nodep->idx->dev_handle;
    561         if (lastc == FAT_CLST_RES0) {
     593
     594        /*
     595         * Invalidate cached cluster numbers.
     596         */
     597        nodep->lastc_cached_valid = false;
     598        if (nodep->currc_cached_value != lcl)
     599                nodep->currc_cached_valid = false;
     600
     601        if (lcl == FAT_CLST_RES0) {
    562602                /* The node will have zero size and no clusters allocated. */
    563603                rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
     
    570610                unsigned fatno;
    571611
    572                 rc = fat_get_cluster(bs, dev_handle, FAT1, lastc, &nextc);
     612                rc = fat_get_cluster(bs, dev_handle, FAT1, lcl, &nextc);
    573613                if (rc != EOK)
    574614                        return rc;
     
    576616                /* Terminate the cluster chain in all copies of FAT. */
    577617                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
    578                         rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
     618                        rc = fat_set_cluster(bs, dev_handle, fatno, lcl,
    579619                            FAT_CLST_LAST1);
    580620                        if (rc != EOK)
     
    588628        }
    589629
     630        /*
     631         * Update and re-enable the last cluster cache.
     632         */
     633        nodep->lastc_cached_valid = true;
     634        nodep->lastc_cached_value = lcl;
     635
    590636        return EOK;
    591637}
     
    596642        int i;
    597643        block_t *b;
    598         unsigned bps;
    599         int rc;
    600 
    601         bps = uint16_t_le2host(bs->bps);
    602        
    603         for (i = 0; i < bs->spc; i++) {
    604                 rc = _fat_block_get(&b, bs, dev_handle, c, i,
     644        int rc;
     645
     646        for (i = 0; i < SPC(bs); i++) {
     647                rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i,
    605648                    BLOCK_FLAGS_NOREAD);
    606649                if (rc != EOK)
    607650                        return rc;
    608                 memset(b->data, 0, bps);
     651                memset(b->data, 0, BPS(bs));
    609652                b->dirty = true;
    610653                rc = block_put(b);
  • uspace/srv/fs/fat/fat_fat.h

    r14f2100 r9a1d8ab  
    6464    fat_cluster_t *, uint16_t *, uint16_t);
    6565
    66 #define fat_block_get(b, bs, np, bn, flags) \
    67     _fat_block_get((b), (bs), (np)->idx->dev_handle, (np)->firstc, (bn), \
    68     (flags))
    69 
     66extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
     67    aoff64_t, int);
    7068extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
    71     fat_cluster_t, aoff64_t, int);
     69    fat_cluster_t, fat_cluster_t *, aoff64_t, int);
    7270
    7371extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
    74     fat_cluster_t);
     72    fat_cluster_t, fat_cluster_t);
    7573extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
    7674    fat_cluster_t);
  • uspace/srv/fs/fat/fat_ops.c

    r14f2100 r9a1d8ab  
    6060#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
    6161
     62#define DPS(bs)         (BPS((bs)) / sizeof(fat_dentry_t))
     63#define BPC(bs)         (BPS((bs)) * SPC((bs)))
     64
    6265/** Mutex protecting the list of cached free FAT nodes. */
    6366static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
     
    101104        node->refcnt = 0;
    102105        node->dirty = false;
     106        node->lastc_cached_valid = false;
     107        node->lastc_cached_value = FAT_CLST_LAST1;
     108        node->currc_cached_valid = false;
     109        node->currc_cached_bn = 0;
     110        node->currc_cached_value = FAT_CLST_LAST1;
    103111}
    104112
     
    108116        fat_bs_t *bs;
    109117        fat_dentry_t *d;
    110         uint16_t bps;
    111         unsigned dps;
    112118        int rc;
    113119       
     
    115121
    116122        bs = block_bb_get(node->idx->dev_handle);
    117         bps = uint16_t_le2host(bs->bps);
    118         dps = bps / sizeof(fat_dentry_t);
    119123       
    120124        /* Read the block that contains the dentry of interest. */
    121125        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
    122             (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     126            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
     127            BLOCK_FLAGS_NONE);
    123128        if (rc != EOK)
    124129                return rc;
    125130
    126         d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
     131        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % DPS(bs));
    127132
    128133        d->firstc = host2uint16_t_le(node->firstc);
     
    266271        fat_dentry_t *d;
    267272        fat_node_t *nodep = NULL;
    268         unsigned bps;
    269         unsigned spc;
    270         unsigned dps;
    271273        int rc;
    272274
     
    298300
    299301        bs = block_bb_get(idxp->dev_handle);
    300         bps = uint16_t_le2host(bs->bps);
    301         spc = bs->spc;
    302         dps = bps / sizeof(fat_dentry_t);
    303302
    304303        /* Read the block that contains the dentry of interest. */
    305         rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
    306             (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     304        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
     305            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    307306        if (rc != EOK) {
    308307                (void) fat_node_put(FS_NODE(nodep));
     
    310309        }
    311310
    312         d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
     311        d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
    313312        if (d->attr & FAT_ATTR_SUBDIR) {
    314313                /*
     
    330329                        return rc;
    331330                }
    332                 nodep->size = bps * spc * clusters;
     331                nodep->size = BPS(bs) * SPC(bs) * clusters;
    333332        } else {
    334333                nodep->type = FAT_FILE;
     
    368367        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
    369368        unsigned i, j;
    370         unsigned bps;           /* bytes per sector */
    371         unsigned dps;           /* dentries per sector */
    372369        unsigned blocks;
    373370        fat_dentry_t *d;
     
    377374        fibril_mutex_lock(&parentp->idx->lock);
    378375        bs = block_bb_get(parentp->idx->dev_handle);
    379         bps = uint16_t_le2host(bs->bps);
    380         dps = bps / sizeof(fat_dentry_t);
    381         blocks = parentp->size / bps;
     376        blocks = parentp->size / BPS(bs);
    382377        for (i = 0; i < blocks; i++) {
    383378                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     
    386381                        return rc;
    387382                }
    388                 for (j = 0; j < dps; j++) {
     383                for (j = 0; j < DPS(bs); j++) {
    389384                        d = ((fat_dentry_t *)b->data) + j;
    390385                        switch (fat_classify_dentry(d)) {
     
    414409                                fat_idx_t *idx = fat_idx_get_by_pos(
    415410                                    parentp->idx->dev_handle, parentp->firstc,
    416                                     i * dps + j);
     411                                    i * DPS(bs) + j);
    417412                                fibril_mutex_unlock(&parentp->idx->lock);
    418413                                if (!idx) {
     
    513508        fat_bs_t *bs;
    514509        fat_cluster_t mcl, lcl;
    515         uint16_t bps;
    516510        int rc;
    517511
    518512        bs = block_bb_get(dev_handle);
    519         bps = uint16_t_le2host(bs->bps);
    520513        if (flags & L_DIRECTORY) {
    521514                /* allocate a cluster */
     
    546539                nodep->type = FAT_DIRECTORY;
    547540                nodep->firstc = mcl;
    548                 nodep->size = bps * bs->spc;
     541                nodep->size = BPS(bs) * SPC(bs);
    549542        } else {
    550543                nodep->type = FAT_FILE;
     
    609602        block_t *b;
    610603        unsigned i, j;
    611         uint16_t bps;
    612         unsigned dps;
    613604        unsigned blocks;
    614605        fat_cluster_t mcl, lcl;
     
    640631        fibril_mutex_lock(&parentp->idx->lock);
    641632        bs = block_bb_get(parentp->idx->dev_handle);
    642         bps = uint16_t_le2host(bs->bps);
    643         dps = bps / sizeof(fat_dentry_t);
    644 
    645         blocks = parentp->size / bps;
     633
     634        blocks = parentp->size / BPS(bs);
    646635
    647636        for (i = 0; i < blocks; i++) {
     
    651640                        return rc;
    652641                }
    653                 for (j = 0; j < dps; j++) {
     642                for (j = 0; j < DPS(bs); j++) {
    654643                        d = ((fat_dentry_t *)b->data) + j;
    655644                        switch (fat_classify_dentry(d)) {
     
    691680                return rc;
    692681        }
    693         rc = fat_append_clusters(bs, parentp, mcl);
     682        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    694683        if (rc != EOK) {
    695684                (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
     
    697686                return rc;
    698687        }
    699         parentp->size += bps * bs->spc;
     688        parentp->size += BPS(bs) * SPC(bs);
    700689        parentp->dirty = true;          /* need to sync node */
    701690        rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     
    771760
    772761        childp->idx->pfc = parentp->firstc;
    773         childp->idx->pdi = i * dps + j;
     762        childp->idx->pdi = i * DPS(bs) + j;
    774763        fibril_mutex_unlock(&childp->idx->lock);
    775764
     
    793782        fat_bs_t *bs;
    794783        fat_dentry_t *d;
    795         uint16_t bps;
    796784        block_t *b;
    797785        bool has_children;
     
    812800        fibril_mutex_lock(&childp->idx->lock);
    813801        bs = block_bb_get(childp->idx->dev_handle);
    814         bps = uint16_t_le2host(bs->bps);
    815802
    816803        rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
    817             (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
     804            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    818805            BLOCK_FLAGS_NONE);
    819806        if (rc != EOK)
    820807                goto error;
    821808        d = (fat_dentry_t *)b->data +
    822             (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
     809            (childp->idx->pdi % (BPS(bs) / sizeof(fat_dentry_t)));
    823810        /* mark the dentry as not-currently-used */
    824811        d->name[0] = FAT_DENTRY_ERASED;
     
    852839        fat_bs_t *bs;
    853840        fat_node_t *nodep = FAT_NODE(fn);
    854         unsigned bps;
    855         unsigned dps;
    856841        unsigned blocks;
    857842        block_t *b;
     
    866851        fibril_mutex_lock(&nodep->idx->lock);
    867852        bs = block_bb_get(nodep->idx->dev_handle);
    868         bps = uint16_t_le2host(bs->bps);
    869         dps = bps / sizeof(fat_dentry_t);
    870 
    871         blocks = nodep->size / bps;
     853
     854        blocks = nodep->size / BPS(bs);
    872855
    873856        for (i = 0; i < blocks; i++) {
     
    879862                        return rc;
    880863                }
    881                 for (j = 0; j < dps; j++) {
     864                for (j = 0; j < DPS(bs); j++) {
    882865                        d = ((fat_dentry_t *)b->data) + j;
    883866                        switch (fat_classify_dentry(d)) {
     
    976959        enum cache_mode cmode;
    977960        fat_bs_t *bs;
    978         uint16_t bps;
    979         uint16_t rde;
    980961       
    981962        /* Accept the mount options */
     
    1014995        bs = block_bb_get(dev_handle);
    1015996       
    1016         /* Read the number of root directory entries. */
    1017         bps = uint16_t_le2host(bs->bps);
    1018         rde = uint16_t_le2host(bs->root_ent_max);
    1019 
    1020         if (bps != BS_SIZE) {
     997        if (BPS(bs) != BS_SIZE) {
    1021998                block_fini(dev_handle);
    1022999                ipc_answer_0(rid, ENOTSUP);
     
    10251002
    10261003        /* Initialize the block cache */
    1027         rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
     1004        rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
    10281005        if (rc != EOK) {
    10291006                block_fini(dev_handle);
     
    10871064        rootp->refcnt = 1;
    10881065        rootp->lnkcnt = 0;      /* FS root is not linked */
    1089         rootp->size = rde * sizeof(fat_dentry_t);
     1066        rootp->size = RDE(bs) * sizeof(fat_dentry_t);
    10901067        rootp->idx = ridxp;
    10911068        ridxp->nodep = rootp;
     
    11651142        fat_node_t *nodep;
    11661143        fat_bs_t *bs;
    1167         uint16_t bps;
    11681144        size_t bytes;
    11691145        block_t *b;
     
    11911167
    11921168        bs = block_bb_get(dev_handle);
    1193         bps = uint16_t_le2host(bs->bps);
    11941169
    11951170        if (nodep->type == FAT_FILE) {
     
    12041179                        (void) async_data_read_finalize(callid, NULL, 0);
    12051180                } else {
    1206                         bytes = min(len, bps - pos % bps);
     1181                        bytes = min(len, BPS(bs) - pos % BPS(bs));
    12071182                        bytes = min(bytes, nodep->size - pos);
    1208                         rc = fat_block_get(&b, bs, nodep, pos / bps,
     1183                        rc = fat_block_get(&b, bs, nodep, pos / BPS(bs),
    12091184                            BLOCK_FLAGS_NONE);
    12101185                        if (rc != EOK) {
     
    12141189                                return;
    12151190                        }
    1216                         (void) async_data_read_finalize(callid, b->data + pos % bps,
    1217                             bytes);
     1191                        (void) async_data_read_finalize(callid,
     1192                            b->data + pos % BPS(bs), bytes);
    12181193                        rc = block_put(b);
    12191194                        if (rc != EOK) {
     
    12301205
    12311206                assert(nodep->type == FAT_DIRECTORY);
    1232                 assert(nodep->size % bps == 0);
    1233                 assert(bps % sizeof(fat_dentry_t) == 0);
     1207                assert(nodep->size % BPS(bs) == 0);
     1208                assert(BPS(bs) % sizeof(fat_dentry_t) == 0);
    12341209
    12351210                /*
     
    12391214                 * the position pointer accordingly.
    12401215                 */
    1241                 bnum = (pos * sizeof(fat_dentry_t)) / bps;
    1242                 while (bnum < nodep->size / bps) {
     1216                bnum = (pos * sizeof(fat_dentry_t)) / BPS(bs);
     1217                while (bnum < nodep->size / BPS(bs)) {
    12431218                        aoff64_t o;
    12441219
     
    12471222                        if (rc != EOK)
    12481223                                goto err;
    1249                         for (o = pos % (bps / sizeof(fat_dentry_t));
    1250                             o < bps / sizeof(fat_dentry_t);
     1224                        for (o = pos % (BPS(bs) / sizeof(fat_dentry_t));
     1225                            o < BPS(bs) / sizeof(fat_dentry_t);
    12511226                            o++, pos++) {
    12521227                                d = ((fat_dentry_t *)b->data) + o;
     
    13061281        size_t bytes, size;
    13071282        block_t *b;
    1308         uint16_t bps;
    1309         unsigned spc;
    1310         unsigned bpc;           /* bytes per cluster */
    13111283        aoff64_t boundary;
    13121284        int flags = BLOCK_FLAGS_NONE;
     
    13341306
    13351307        bs = block_bb_get(dev_handle);
    1336         bps = uint16_t_le2host(bs->bps);
    1337         spc = bs->spc;
    1338         bpc = bps * spc;
    13391308
    13401309        /*
     
    13451314         * value signalizing a smaller number of bytes written.
    13461315         */
    1347         bytes = min(len, bps - pos % bps);
    1348         if (bytes == bps)
     1316        bytes = min(len, BPS(bs) - pos % BPS(bs));
     1317        if (bytes == BPS(bs))
    13491318                flags |= BLOCK_FLAGS_NOREAD;
    13501319       
    1351         boundary = ROUND_UP(nodep->size, bpc);
     1320        boundary = ROUND_UP(nodep->size, BPC(bs));
    13521321        if (pos < boundary) {
    13531322                /*
     
    13641333                        return;
    13651334                }
    1366                 rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
     1335                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    13671336                if (rc != EOK) {
    13681337                        (void) fat_node_put(fn);
     
    13711340                        return;
    13721341                }
    1373                 (void) async_data_write_finalize(callid, b->data + pos % bps,
    1374                     bytes);
     1342                (void) async_data_write_finalize(callid,
     1343                    b->data + pos % BPS(bs), bytes);
    13751344                b->dirty = true;                /* need to sync block */
    13761345                rc = block_put(b);
     
    13961365                fat_cluster_t mcl, lcl;
    13971366 
    1398                 nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
     1367                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13991368                /* create an independent chain of nclsts clusters in all FATs */
    14001369                rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
     
    14151384                        return;
    14161385                }
    1417                 rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
    1418                     flags);
     1386                rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
     1387                    (pos / BPS(bs)) % SPC(bs), flags);
    14191388                if (rc != EOK) {
    14201389                        (void) fat_free_clusters(bs, dev_handle, mcl);
     
    14241393                        return;
    14251394                }
    1426                 (void) async_data_write_finalize(callid, b->data + pos % bps,
    1427                     bytes);
     1395                (void) async_data_write_finalize(callid,
     1396                    b->data + pos % BPS(bs), bytes);
    14281397                b->dirty = true;                /* need to sync block */
    14291398                rc = block_put(b);
     
    14381407                 * node's cluster chain.
    14391408                 */
    1440                 rc = fat_append_clusters(bs, nodep, mcl);
     1409                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14411410                if (rc != EOK) {
    14421411                        (void) fat_free_clusters(bs, dev_handle, mcl);
     
    14621431        fat_node_t *nodep;
    14631432        fat_bs_t *bs;
    1464         uint16_t bps;
    1465         uint8_t spc;
    1466         unsigned bpc;   /* bytes per cluster */
    14671433        int rc;
    14681434
     
    14791445
    14801446        bs = block_bb_get(dev_handle);
    1481         bps = uint16_t_le2host(bs->bps);
    1482         spc = bs->spc;
    1483         bpc = bps * spc;
    14841447
    14851448        if (nodep->size == size) {
     
    14911454                 */
    14921455                rc = EINVAL;
    1493         } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
     1456        } else if (ROUND_UP(nodep->size, BPC(bs)) == ROUND_UP(size, BPC(bs))) {
    14941457                /*
    14951458                 * The node will be shrunk, but no clusters will be deallocated.
     
    15091472                        fat_cluster_t lastc;
    15101473                        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
    1511                             &lastc, NULL, (size - 1) / bpc);
     1474                            &lastc, NULL, (size - 1) / BPC(bs));
    15121475                        if (rc != EOK)
    15131476                                goto out;
Note: See TracChangeset for help on using the changeset viewer.