WebSVN – HelenOS – Diff – /trunk/uspace/srv/fs/fat/fat_ops.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup fs
 * @{
 */
 
/**
 * @file    fat_ops.c
 * @brief   Implementation of VFS operations for the FAT file system server.
 */
 
#include "fat.h"
#include "fat_dentry.h"
#include "fat_fat.h"
#include "../../vfs/vfs.h"
#include <libfs.h>
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <ipc/devmap.h>
#include <async.h>
#include <errno.h>
#include <string.h>
#include <byteorder.h>
#include <libadt/hash_table.h>
#include <libadt/list.h>
#include <assert.h>
#include <futex.h>
#include <sys/mman.h>
#include <align.h>
 
#define BS_BLOCK        0
#define BS_SIZE         512
 
/** Futex protecting the list of cached free FAT nodes. */
static futex_t ffn_futex = FUTEX_INITIALIZER;
 
/** List of cached free FAT nodes. */
static LIST_INITIALIZE(ffn_head);
 
 
 
 
 
 
 
 
 
 
 
#define min(a, b)       ((a) < (b) ? (a) : (b))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
static int dev_phone = -1;      /* FIXME */
static void *dev_buffer = NULL;     /* FIXME */
 
/* TODO move somewhere else */
typedef struct {
    void *data;
    size_t size;
    bool dirty;
} block_t;
 
static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
{
    /* FIXME */
    block_t *b;
    off_t bufpos = 0;
    size_t buflen = 0;
    off_t pos = offset * bs;
 
    assert(dev_phone != -1);
    assert(dev_buffer);
 
    b = malloc(sizeof(block_t));
    if (!b)
        return NULL;
   
    b->data = malloc(bs);
    if (!b->data) {
        free(b);
        return NULL;
    }
    b->size = bs;
 
    if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,
        b->data, bs, bs)) {
        free(b->data);
        free(b);
        return NULL;
    }
 
    return b;
}
 
static void block_put(block_t *block)
{
    /* FIXME */
    free(block->data);
    free(block);
}
 
#define FAT1        0
 
#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
 
#define FAT_CLST_RES0   0x0000
#define FAT_CLST_RES1   0x0001
#define FAT_CLST_FIRST  0x0002
#define FAT_CLST_BAD    0xfff7
#define FAT_CLST_LAST1  0xfff8
#define FAT_CLST_LAST8  0xffff
 
/* internally used to mark root directory's parent */
#define FAT_CLST_ROOTPAR    FAT_CLST_RES0
/* internally used to mark root directory */
#define FAT_CLST_ROOT       FAT_CLST_RES1
 
#define fat_block_get(np, off) \
    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
 
static block_t *
_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
{
    block_t *bb;
    block_t *b;
    unsigned bps;
    unsigned spc;
    unsigned rscnt;     /* block address of the first FAT */
    unsigned fatcnt;
    unsigned rde;
    unsigned rds;       /* root directory size */
    unsigned sf;
    unsigned ssa;       /* size of the system area */
    unsigned clusters;
    fat_cluster_t clst = firstc;
    unsigned i;
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    fatcnt = FAT_BS(bb)->fatcnt;
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
    block_put(bb);
 
    rds = (sizeof(fat_dentry_t) * rde) / bps;
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
    ssa = rscnt + fatcnt * sf + rds;
 
    if (firstc == FAT_CLST_ROOT) {
        /* root directory special case */
        assert(offset < rds);
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
        return b;
    }
 
    clusters = offset / spc;
    for (i = 0; i < clusters; i++) {
        unsigned fsec;  /* sector offset relative to FAT1 */
        unsigned fidx;  /* FAT1 entry index */
 
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
        fidx = clst % (bps / sizeof(fat_cluster_t));
        /* read FAT1 */
        b = block_get(dev_handle, rscnt + fsec, bps);
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
        assert(clst != FAT_CLST_BAD);
        assert(clst < FAT_CLST_LAST1);
        block_put(b);
    }
 
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
        offset % spc, bps);
 
    return b;
}
 
/** Return number of blocks allocated to a file.
 *
 * @param dev_handle    Device handle of the device with the file.
 * @param firstc    First cluster of the file.
 *
 * @return      Number of blocks allocated to the file.
 */
static uint16_t
_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
{
    block_t *bb;
    block_t *b;
    unsigned bps;
    unsigned spc;
    unsigned rscnt;     /* block address of the first FAT */
    unsigned clusters = 0;
    fat_cluster_t clst = firstc;
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    block_put(bb);
 
    if (firstc == FAT_CLST_RES0) {
        /* No space allocated to the file. */
        return 0;
    }
 
    while (clst < FAT_CLST_LAST1) {
        unsigned fsec;  /* sector offset relative to FAT1 */
        unsigned fidx;  /* FAT1 entry index */
 
        assert(clst >= FAT_CLST_FIRST);
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
        fidx = clst % (bps / sizeof(fat_cluster_t));
        /* read FAT1 */
        b = block_get(dev_handle, rscnt + fsec, bps);
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
        assert(clst != FAT_CLST_BAD);
        block_put(b);
        clusters++;
    }
 
    return clusters * spc;
}
 
static void fat_node_initialize(fat_node_t *node)
{
    futex_initialize(&node->lock, 1);
    node->idx = NULL;
    node->type = 0;
    link_initialize(&node->ffn_link);
    node->size = 0;
    node->lnkcnt = 0;
    node->refcnt = 0;
    node->dirty = false;
}
 
static uint16_t fat_bps_get(dev_handle_t dev_handle)
{
    block_t *bb;
    uint16_t bps;
   
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    assert(bb != NULL);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    block_put(bb);
 
    return bps;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
static void fat_node_sync(fat_node_t *node)
{
    /* TODO */
}
 
/** Internal version of fat_node_get().
 *
 * @param idxp      Locked index structure.
 */
static void *fat_node_get_core(fat_idx_t *idxp)
{
    block_t *b;
    fat_dentry_t *d;
    fat_node_t *nodep = NULL;
    unsigned bps;
    unsigned dps;
 
    if (idxp->nodep) {
        /*
         * We are lucky.
         * The node is already instantiated in memory.
         */
        futex_down(&idxp->nodep->lock);
        if (!idxp->nodep->refcnt++)
            list_remove(&idxp->nodep->ffn_link);
        futex_up(&idxp->nodep->lock);
        return idxp->nodep;
    }
 
    /*
     * We must instantiate the node from the file system.
     */
   
    assert(idxp->pfc);
 
    futex_down(&ffn_futex);
    if (!list_empty(&ffn_head)) {
        /* Try to use a cached free node structure. */
        fat_idx_t *idxp_tmp;
        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
            goto skip_cache;
        idxp_tmp = nodep->idx;
        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
            futex_up(&nodep->lock);
            goto skip_cache;
        }
        list_remove(&nodep->ffn_link);
        futex_up(&ffn_futex);
        if (nodep->dirty)
            fat_node_sync(nodep);
        idxp_tmp->nodep = NULL;
        futex_up(&nodep->lock);
        futex_up(&idxp_tmp->lock);
    } else {
skip_cache:
        /* Try to allocate a new node structure. */
        futex_up(&ffn_futex);
        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
        if (!nodep)
            return NULL;
    }
    fat_node_initialize(nodep);
 
    bps = fat_bps_get(idxp->dev_handle);
    dps = bps / sizeof(fat_dentry_t);
 
    /* Read the block that contains the dentry of interest. */
    b = _fat_block_get(idxp->dev_handle, idxp->pfc,
        (idxp->pdi * sizeof(fat_dentry_t)) / bps);
    assert(b);
 
    d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
    if (d->attr & FAT_ATTR_SUBDIR) {
        /*
         * The only directory which does not have this bit set is the
         * root directory itself. The root directory node is handled
         * and initialized elsewhere.
         */
        nodep->type = FAT_DIRECTORY;
        /*
         * Unfortunately, the 'size' field of the FAT dentry is not
         * defined for the directory entry type. We must determine the
         * size of the directory by walking the FAT.
         */
        nodep->size = bps * _fat_blcks_get(idxp->dev_handle,
            uint16_t_le2host(d->firstc));
    } else {
        nodep->type = FAT_FILE;
        nodep->size = uint32_t_le2host(d->size);
    }
    nodep->firstc = uint16_t_le2host(d->firstc);
    nodep->lnkcnt = 1;
    nodep->refcnt = 1;
 
    block_put(b);
 
    /* Link the idx structure with the node structure. */
    nodep->idx = idxp;
    idxp->nodep = nodep;
 
    return nodep;
}
 
/** Instantiate a FAT in-core node. */
static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
{
    void *node;
    fat_idx_t *idxp;
 
    idxp = fat_idx_get_by_index(dev_handle, index);
    if (!idxp)
        return NULL;
    /* idxp->lock held */
    node = fat_node_get_core(idxp);
    futex_up(&idxp->lock);
    return node;
}
 
static void fat_node_put(void *node)
{
    fat_node_t *nodep = (fat_node_t *)node;
 
    futex_down(&nodep->lock);
    if (!--nodep->refcnt) {
        futex_down(&ffn_futex);
        list_append(&nodep->ffn_link, &ffn_head);
        futex_up(&ffn_futex);
    }
    futex_up(&nodep->lock);
}
 
static void *fat_create(int flags)
{
    return NULL;    /* not supported at the moment */
}
 
static int fat_destroy(void *node)
{
    return ENOTSUP; /* not supported at the moment */
}
 
static bool fat_link(void *prnt, void *chld, const char *name)
{
    return false;   /* not supported at the moment */
}
 
static int fat_unlink(void *prnt, void *chld)
{
    return ENOTSUP; /* not supported at the moment */
}
 
static void *fat_match(void *prnt, const char *component)
{
    fat_node_t *parentp = (fat_node_t *)prnt;
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
    unsigned i, j;
    unsigned bps;       /* bytes per sector */
    unsigned dps;       /* dentries per sector */
    unsigned blocks;
    fat_dentry_t *d;
    block_t *b;
 
    futex_down(&parentp->idx->lock);
    bps = fat_bps_get(parentp->idx->dev_handle);
    dps = bps / sizeof(fat_dentry_t);
    blocks = parentp->size / bps + (parentp->size % bps != 0);
    for (i = 0; i < blocks; i++) {
        unsigned dentries;
       
        b = fat_block_get(parentp, i);
        dentries = (i == blocks - 1) ?
            parentp->size % sizeof(fat_dentry_t) :
            dps;
        for (j = 0; j < dentries; j++) {
            d = ((fat_dentry_t *)b->data) + j;
            switch (fat_classify_dentry(d)) {
            case FAT_DENTRY_SKIP:
                continue;
            case FAT_DENTRY_LAST:
                block_put(b);
                futex_up(&parentp->idx->lock);
                return NULL;
            default:
            case FAT_DENTRY_VALID:
                dentry_name_canonify(d, name);
                break;
            }
            if (stricmp(name, component) == 0) {
                /* hit */
                void *node;
                /*
                 * Assume tree hierarchy for locking.  We
                 * already have the parent and now we are going
                 * to lock the child.  Never lock in the oposite
                 * order.
                 */
                fat_idx_t *idx = fat_idx_get_by_pos(
                    parentp->idx->dev_handle, parentp->firstc,
                    i * dps + j);
                futex_up(&parentp->idx->lock);
                if (!idx) {
                    /*
                     * Can happen if memory is low or if we
                     * run out of 32-bit indices.
                     */
                    block_put(b);
                    return NULL;
                }
                node = fat_node_get_core(idx);
                futex_up(&idx->lock);
                block_put(b);
                return node;
            }
        }
        block_put(b);
    }
    futex_up(&parentp->idx->lock);
    return NULL;
}
 
static fs_index_t fat_index_get(void *node)
{
    fat_node_t *fnodep = (fat_node_t *)node;
    if (!fnodep)
        return 0;
    return fnodep->idx->index;
}
 
static size_t fat_size_get(void *node)
{
    return ((fat_node_t *)node)->size;
}
 
static unsigned fat_lnkcnt_get(void *node)
{
    return ((fat_node_t *)node)->lnkcnt;
}
 
static bool fat_has_children(void *node)
{
    fat_node_t *nodep = (fat_node_t *)node;
    unsigned bps;
    unsigned dps;
    unsigned blocks;
    block_t *b;
    unsigned i, j;
 
    if (nodep->type != FAT_DIRECTORY)
        return false;
 
    futex_down(&nodep->idx->lock);
    bps = fat_bps_get(nodep->idx->dev_handle);
    dps = bps / sizeof(fat_dentry_t);
 
    blocks = nodep->size / bps + (nodep->size % bps != 0);
 
    for (i = 0; i < blocks; i++) {
        unsigned dentries;
        fat_dentry_t *d;
   
        b = fat_block_get(nodep, i);
        dentries = (i == blocks - 1) ?
            nodep->size % sizeof(fat_dentry_t) :
            dps;
        for (j = 0; j < dentries; j++) {
            d = ((fat_dentry_t *)b->data) + j;
            switch (fat_classify_dentry(d)) {
            case FAT_DENTRY_SKIP:
                continue;
            case FAT_DENTRY_LAST:
                block_put(b);
                futex_up(&nodep->idx->lock);
                return false;
            default:
            case FAT_DENTRY_VALID:
                block_put(b);
                futex_up(&nodep->idx->lock);
                return true;
            }
            block_put(b);
            futex_up(&nodep->idx->lock);
            return true;
        }
        block_put(b);
    }
 
    futex_up(&nodep->idx->lock);
    return false;
}
 
static void *fat_root_get(dev_handle_t dev_handle)
{
    return fat_node_get(dev_handle, 0);
}
 
static char fat_plb_get_char(unsigned pos)
{
    return fat_reg.plb_ro[pos % PLB_SIZE];
}
 
static bool fat_is_directory(void *node)
{
    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
}
 
static bool fat_is_file(void *node)
{
    return ((fat_node_t *)node)->type == FAT_FILE;
}
 
/** libfs operations */
libfs_ops_t fat_libfs_ops = {
    .match = fat_match,
    .node_get = fat_node_get,
    .node_put = fat_node_put,
    .create = fat_create,
    .destroy = fat_destroy,
    .link = fat_link,
    .unlink = fat_unlink,
    .index_get = fat_index_get,
    .size_get = fat_size_get,
    .lnkcnt_get = fat_lnkcnt_get,
    .has_children = fat_has_children,
    .root_get = fat_root_get,
    .plb_get_char = fat_plb_get_char,
    .is_directory = fat_is_directory,
    .is_file = fat_is_file
};
 
void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    block_t *bb;
    uint16_t bps;
    uint16_t rde;
    int rc;
 
    /*
     * For now, we don't bother to remember dev_handle, dev_phone or
     * dev_buffer in some data structure. We use global variables because we
     * know there will be at most one mount on this file system.
     * Of course, this is a huge TODO item.
     */
    dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE,
        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
   
    if (!dev_buffer) {
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
 
    if (dev_phone < 0) {
        munmap(dev_buffer, BS_SIZE);
        ipc_answer_0(rid, dev_phone);
        return;
    }
 
    rc = ipc_share_out_start(dev_phone, dev_buffer,
        AS_AREA_READ | AS_AREA_WRITE);
    if (rc != EOK) {
            munmap(dev_buffer, BS_SIZE);
        ipc_answer_0(rid, rc);
        return;
    }
 
    /* Read the number of root directory entries. */
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
    block_put(bb);
 
    if (bps != BS_SIZE) {
        munmap(dev_buffer, BS_SIZE);
        ipc_answer_0(rid, ENOTSUP);
        return;
    }
 
    rc = fat_idx_init_by_dev_handle(dev_handle);
    if (rc != EOK) {
            munmap(dev_buffer, BS_SIZE);
        ipc_answer_0(rid, rc);
        return;
    }
 
    /* Initialize the root node. */
    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
    if (!rootp) {
            munmap(dev_buffer, BS_SIZE);
        fat_idx_fini_by_dev_handle(dev_handle);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    fat_node_initialize(rootp);
 
    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
    if (!ridxp) {
            munmap(dev_buffer, BS_SIZE);
        free(rootp);
        fat_idx_fini_by_dev_handle(dev_handle);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
    assert(ridxp->index == 0);
    /* ridxp->lock held */
 
    rootp->type = FAT_DIRECTORY;
    rootp->firstc = FAT_CLST_ROOT;
    rootp->refcnt = 1;
    rootp->lnkcnt = 0;  /* FS root is not linked */
    rootp->size = rde * sizeof(fat_dentry_t);
    rootp->idx = ridxp;
    ridxp->nodep = rootp;
   
    futex_up(&ridxp->lock);
 
    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
}
 
void fat_mount(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_answer_0(rid, ENOTSUP);
}
 
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
{
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
}
 
void fat_read(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    off_t pos = (off_t)IPC_GET_ARG3(*request);
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
    uint16_t bps = fat_bps_get(dev_handle);
    size_t bytes;
    block_t *b;
 
    if (!nodep) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
 
    ipc_callid_t callid;
    size_t len;
    if (!ipc_data_read_receive(&callid, &len)) {
        fat_node_put(nodep);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    if (nodep->type == FAT_FILE) {
        /*
         * Our strategy for regular file reads is to read one block at
         * most and make use of the possibility to return less data than
         * requested. This keeps the code very simple.
         */
        bytes = min(len, bps - pos % bps);
        b = fat_block_get(nodep, pos / bps);
        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
            bytes);
        block_put(b);
    } else {
        unsigned bnum;
        off_t spos = pos;
        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
        fat_dentry_t *d;
 
        assert(nodep->type == FAT_DIRECTORY);
        assert(nodep->size % bps == 0);
        assert(bps % sizeof(fat_dentry_t) == 0);
 
        /*
         * Our strategy for readdir() is to use the position pointer as
         * an index into the array of all dentries. On entry, it points
         * to the first unread dentry. If we skip any dentries, we bump
         * the position pointer accordingly.
         */
        bnum = (pos * sizeof(fat_dentry_t)) / bps;
        while (bnum < nodep->size / bps) {
            off_t o;
 
            b = fat_block_get(nodep, bnum);
            for (o = pos % (bps / sizeof(fat_dentry_t));
                o < bps / sizeof(fat_dentry_t);
                o++, pos++) {
                d = ((fat_dentry_t *)b->data) + o;
                switch (fat_classify_dentry(d)) {
                case FAT_DENTRY_SKIP:
                    continue;
                case FAT_DENTRY_LAST:
                    block_put(b);
                    goto miss;
                default:
                case FAT_DENTRY_VALID:
                    dentry_name_canonify(d, name);
                    block_put(b);
                    goto hit;
                }
            }
            block_put(b);
            bnum++;
        }
miss:
        fat_node_put(nodep);
        ipc_answer_0(callid, ENOENT);
        ipc_answer_1(rid, ENOENT, 0);
        return;
hit:
        (void) ipc_data_read_finalize(callid, name, strlen(name) + 1);
        bytes = (pos - spos) + 1;
    }
 
    fat_node_put(nodep);
    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
}
 
/** Fill the gap between EOF and a new file position.
 *
 * @param nodep     FAT node with the gap.
 * @param mcl       First cluster in an independent cluster chain that will
 *          be later appended to the end of the node's own cluster
 *          chain. If pos is still in the last allocated cluster,
 *          this argument is ignored.
 * @param pos       Position in the last node block.
 */
static void
fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
{
    uint16_t bps;
    unsigned spc;
    block_t *bb, *b;
    off_t o, boundary;
 
    bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    block_put(bb);
   
    boundary = ROUND_UP(nodep->size, bps * spc);
 
    /* zero out already allocated space */
    for (o = nodep->size - 1; o < pos && o < boundary;
        o = ALIGN_DOWN(o + bps, bps)) {
        b = fat_block_get(nodep, o / bps);
        memset(b->data + o % bps, 0, bps - o % bps);
        b->dirty = true;        /* need to sync node */
        block_put(b);
    }
   
    if (o >= pos)
        return;
   
    /* zero out the initial part of the new cluster chain */
    for (o = boundary; o < pos; o += bps) {
        b = _fat_block_get(nodep->idx->dev_handle, mcl,
            (o - boundary) / bps);
        memset(b->data, 0, min(bps, pos - o));
        b->dirty = true;        /* need to sync node */
        block_put(b);
    }
}
 
static void
fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,
    fat_cluster_t value)
{
    /* TODO */
}
 
static void
fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
    unsigned nclsts)
{
    /* TODO */
}
 
static int
fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
    fat_cluster_t *lcl)
{
    uint16_t bps;
    uint16_t rscnt;
    uint16_t sf;
    block_t *bb, *blk;
    fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
    unsigned found = 0; /* top of the free cluster number stack */
    unsigned b, c, cl;
 
    lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
    if (lifo)
        return ENOMEM;
   
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
    block_put(bb);
   
    /*
     * Search FAT1 for unused clusters.
     */
    for (b = 0, cl = 0; b < sf; blk++) {
        blk = block_get(dev_handle, rscnt + b, bps);
        for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
            fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
            if (*clst == FAT_CLST_RES0) {
                /*
                 * The cluster is free. Put it into our stack
                 * of found clusters and mark it as non-free.
                 */
                lifo[found] = cl;
                if (found == 0)
                    *clst = FAT_CLST_LAST1;
                else
                    *clst = lifo[found - 1];
                blk->dirty = true;  /* need to sync block */
                if (++found == nclsts) {
                    /* we are almost done */
                    block_put(blk);
                    /* update the shadow copies of FAT */
                    fat_alloc_shadow_clusters(dev_handle,
                        lifo, nclsts);
                    *mcl = lifo[found - 1];
                    *lcl = lifo[0];
                    free(lifo);
                    return EOK;
                }
            }
        }
        block_put(blk);
    }
 
    /*
     * We could not find enough clusters. Now we need to free the clusters
     * we have allocated so far.
     */
    while (found--)
        fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
   
    free(lifo);
    return ENOSPC;
}
 
static void
fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
{
}
 
void fat_write(ipc_callid_t rid, ipc_call_t *request)
{
    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    off_t pos = (off_t)IPC_GET_ARG3(*request);
    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
    size_t bytes;
    block_t *b, *bb;
    uint16_t bps;
    unsigned spc;
    off_t boundary;
   
    if (!nodep) {
        ipc_answer_0(rid, ENOENT);
        return;
    }
   
    /* XXX remove me when you are ready */
    {
        ipc_answer_0(rid, ENOTSUP);
        fat_node_put(nodep);
        return;
    }
 
    ipc_callid_t callid;
    size_t len;
    if (!ipc_data_write_receive(&callid, &len)) {
        fat_node_put(nodep);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    /*
     * In all scenarios, we will attempt to write out only one block worth
     * of data at maximum. There might be some more efficient approaches,
     * but this one greatly simplifies fat_write(). Note that we can afford
     * to do this because the client must be ready to handle the return
     * value signalizing a smaller number of bytes written.
     */
    bytes = min(len, bps - pos % bps);
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    block_put(bb);
   
    boundary = ROUND_UP(nodep->size, bps * spc);
    if (pos < boundary) {
        /*
         * This is the easier case - we are either overwriting already
         * existing contents or writing behind the EOF, but still within
         * the limits of the last cluster. The node size may grow to the
         * next block size boundary.
         */
        fat_fill_gap(nodep, FAT_CLST_RES0, pos);
        b = fat_block_get(nodep, pos / bps);
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
            bytes);
        b->dirty = true;        /* need to sync block */
        block_put(b);
        if (pos + bytes > nodep->size) {
            nodep->size = pos + bytes;
            nodep->dirty = true;    /* need to sync node */
        }
        fat_node_put(nodep);
        ipc_answer_1(rid, EOK, bytes); 
        return;
    } else {
        /*
         * This is the more difficult case. We must allocate new
         * clusters for the node and zero them out.
         */
        int status;
        unsigned nclsts;
        fat_cluster_t mcl, lcl;
   
        nclsts = (ROUND_UP(pos + bytes, bps * spc) - boundary) /
            bps * spc;
        /* create an independent chain of nclsts clusters in all FATs */
        status = fat_alloc_clusters(dev_handle, nclsts, &mcl, &lcl);
        if (status != EOK) {
            /* could not allocate a chain of nclsts clusters */
            fat_node_put(nodep);
            ipc_answer_0(callid, status);
            ipc_answer_0(rid, status);
            return;
        }
        /* zero fill any gaps */
        fat_fill_gap(nodep, mcl, pos);
        b = _fat_block_get(dev_handle, lcl, (pos / bps) % spc);
        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
            bytes);
        b->dirty = true;        /* need to sync block */
        block_put(b);
        /*
         * Append the cluster chain starting in mcl to the end of the
         * node's cluster chain.
         */
        fat_append_clusters(nodep, mcl);
        nodep->size = pos + bytes;
        nodep->dirty = true;        /* need to sync node */
        fat_node_put(nodep);
        ipc_answer_1(rid, EOK, bytes);
        return;
    }
}
 
/**
 * @}
 */
 

Rev 3503	Rev 3505
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup fs	29	/** @addtogroup fs
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file fat_ops.c	34	* @file fat_ops.c
35	* @brief Implementation of VFS operations for the FAT file system server.	35	* @brief Implementation of VFS operations for the FAT file system server.
36	*/	36	*/
37		37
38	#include "fat.h"	38	#include "fat.h"
-		39	#include "fat_dentry.h"
-		40	#include "fat_fat.h"
39	#include "../../vfs/vfs.h"	41	#include "../../vfs/vfs.h"
40	#include <libfs.h>	42	#include <libfs.h>
41	#include <ipc/ipc.h>	43	#include <ipc/ipc.h>
42	#include <ipc/services.h>	44	#include <ipc/services.h>
43	#include <ipc/devmap.h>	45	#include <ipc/devmap.h>
44	#include <async.h>	46	#include <async.h>
45	#include <errno.h>	47	#include <errno.h>
46	#include <string.h>	48	#include <string.h>
47	#include <byteorder.h>	49	#include <byteorder.h>
48	#include <libadt/hash_table.h>	50	#include <libadt/hash_table.h>
49	#include <libadt/list.h>	51	#include <libadt/list.h>
50	#include <assert.h>	52	#include <assert.h>
51	#include <futex.h>	53	#include <futex.h>
52	#include <sys/mman.h>	54	#include <sys/mman.h>
53	#include <align.h>	55	#include <align.h>
54		56
55	#define BS_BLOCK 0	57	#define BS_BLOCK 0
56	#define BS_SIZE 512	58	#define BS_SIZE 512
57		59
58	/** Futex protecting the list of cached free FAT nodes. */	60	/** Futex protecting the list of cached free FAT nodes. */
59	static futex_t ffn_futex = FUTEX_INITIALIZER;	61	static futex_t ffn_futex = FUTEX_INITIALIZER;
60		62
61	/** List of cached free FAT nodes. */	63	/** List of cached free FAT nodes. */
62	static LIST_INITIALIZE(ffn_head);	64	static LIST_INITIALIZE(ffn_head);
63		65
64	#define FAT_NAME_LEN 8	-
65	#define FAT_EXT_LEN 3	-
66		-
67	#define FAT_PAD ' '	-
68		-
69	#define FAT_DENTRY_UNUSED 0x00	-
70	#define FAT_DENTRY_E5_ESC 0x05	-
71	#define FAT_DENTRY_DOT 0x2e	-
72	#define FAT_DENTRY_ERASED 0xe5	-
73		-
74	#define min(a, b) ((a) < (b) ? (a) : (b))	66	#define min(a, b) ((a) < (b) ? (a) : (b))
75		67
76	static void dentry_name_canonify(fat_dentry_t d, char buf)	-
77	{	-
78	int i;	-
79		-
80	for (i = 0; i < FAT_NAME_LEN; i++) {	-
81	if (d->name[i] == FAT_PAD)	-
82	break;	-
83	if (d->name[i] == FAT_DENTRY_E5_ESC)	-
84	*buf++ = 0xe5;	-
85	else	-
86	*buf++ = d->name[i];	-
87	}	-
88	if (d->ext[0] != FAT_PAD)	-
89	*buf++ = '.';	-
90	for (i = 0; i < FAT_EXT_LEN; i++) {	-
91	if (d->ext[i] == FAT_PAD) {	-
92	*buf = '\0';	-
93	return;	-
94	}	-
95	if (d->ext[i] == FAT_DENTRY_E5_ESC)	-
96	*buf++ = 0xe5;	-
97	else	-
98	*buf++ = d->ext[i];	-
99	}	-
100	*buf = '\0';	-
101	}	-
102		-
103	static int dev_phone = -1; /* FIXME */	68	static int dev_phone = -1; /* FIXME */
104	static void dev_buffer = NULL; / FIXME */	69	static void dev_buffer = NULL; / FIXME */
105		70
106	/* TODO move somewhere else */	71	/* TODO move somewhere else */
107	typedef struct {	72	typedef struct {
108	void *data;	73	void *data;
109	size_t size;	74	size_t size;
110	bool dirty;	75	bool dirty;
111	} block_t;	76	} block_t;
112		77
113	static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)	78	static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
114	{	79	{
115	/* FIXME */	80	/* FIXME */
116	block_t *b;	81	block_t *b;
117	off_t bufpos = 0;	82	off_t bufpos = 0;
118	size_t buflen = 0;	83	size_t buflen = 0;
119	off_t pos = offset * bs;	84	off_t pos = offset * bs;
120		85
121	assert(dev_phone != -1);	86	assert(dev_phone != -1);
122	assert(dev_buffer);	87	assert(dev_buffer);
123		88
124	b = malloc(sizeof(block_t));	89	b = malloc(sizeof(block_t));
125	if (!b)	90	if (!b)
126	return NULL;	91	return NULL;
127		92
128	b->data = malloc(bs);	93	b->data = malloc(bs);
129	if (!b->data) {	94	if (!b->data) {
130	free(b);	95	free(b);
131	return NULL;	96	return NULL;
132	}	97	}
133	b->size = bs;	98	b->size = bs;
134		99
135	if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,	100	if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,
136	b->data, bs, bs)) {	101	b->data, bs, bs)) {
137	free(b->data);	102	free(b->data);
138	free(b);	103	free(b);
139	return NULL;	104	return NULL;
140	}	105	}
141		106
142	return b;	107	return b;
143	}	108	}
144		109
145	static void block_put(block_t *block)	110	static void block_put(block_t *block)
146	{	111	{
147	/* FIXME */	112	/* FIXME */
148	free(block->data);	113	free(block->data);
149	free(block);	114	free(block);
150	}	115	}
151		116
152	#define FAT1 0	117	#define FAT1 0
153		118
154	#define FAT_BS(b) ((fat_bs_t *)((b)->data))	119	#define FAT_BS(b) ((fat_bs_t *)((b)->data))
155		120
156	#define FAT_CLST_RES0 0x0000	121	#define FAT_CLST_RES0 0x0000
157	#define FAT_CLST_RES1 0x0001	122	#define FAT_CLST_RES1 0x0001
158	#define FAT_CLST_FIRST 0x0002	123	#define FAT_CLST_FIRST 0x0002
159	#define FAT_CLST_BAD 0xfff7	124	#define FAT_CLST_BAD 0xfff7
160	#define FAT_CLST_LAST1 0xfff8	125	#define FAT_CLST_LAST1 0xfff8
161	#define FAT_CLST_LAST8 0xffff	126	#define FAT_CLST_LAST8 0xffff
162		127
163	/* internally used to mark root directory's parent */	128	/* internally used to mark root directory's parent */
164	#define FAT_CLST_ROOTPAR FAT_CLST_RES0	129	#define FAT_CLST_ROOTPAR FAT_CLST_RES0
165	/* internally used to mark root directory */	130	/* internally used to mark root directory */
166	#define FAT_CLST_ROOT FAT_CLST_RES1	131	#define FAT_CLST_ROOT FAT_CLST_RES1
167		132
168	#define fat_block_get(np, off) \	133	#define fat_block_get(np, off) \
169	_fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))	134	_fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
170		135
171	static block_t *	136	static block_t *
172	_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)	137	_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
173	{	138	{
174	block_t *bb;	139	block_t *bb;
175	block_t *b;	140	block_t *b;
176	unsigned bps;	141	unsigned bps;
177	unsigned spc;	142	unsigned spc;
178	unsigned rscnt; /* block address of the first FAT */	143	unsigned rscnt; /* block address of the first FAT */
179	unsigned fatcnt;	144	unsigned fatcnt;
180	unsigned rde;	145	unsigned rde;
181	unsigned rds; /* root directory size */	146	unsigned rds; /* root directory size */
182	unsigned sf;	147	unsigned sf;
183	unsigned ssa; /* size of the system area */	148	unsigned ssa; /* size of the system area */
184	unsigned clusters;	149	unsigned clusters;
185	fat_cluster_t clst = firstc;	150	fat_cluster_t clst = firstc;
186	unsigned i;	151	unsigned i;
187		152
188	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	153	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
189	bps = uint16_t_le2host(FAT_BS(bb)->bps);	154	bps = uint16_t_le2host(FAT_BS(bb)->bps);
190	spc = FAT_BS(bb)->spc;	155	spc = FAT_BS(bb)->spc;
191	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	156	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
192	fatcnt = FAT_BS(bb)->fatcnt;	157	fatcnt = FAT_BS(bb)->fatcnt;
193	rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);	158	rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
194	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	159	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
195	block_put(bb);	160	block_put(bb);
196		161
197	rds = (sizeof(fat_dentry_t) * rde) / bps;	162	rds = (sizeof(fat_dentry_t) * rde) / bps;
198	rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);	163	rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
199	ssa = rscnt + fatcnt * sf + rds;	164	ssa = rscnt + fatcnt * sf + rds;
200		165
201	if (firstc == FAT_CLST_ROOT) {	166	if (firstc == FAT_CLST_ROOT) {
202	/* root directory special case */	167	/* root directory special case */
203	assert(offset < rds);	168	assert(offset < rds);
204	b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);	169	b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
205	return b;	170	return b;
206	}	171	}
207		172
208	clusters = offset / spc;	173	clusters = offset / spc;
209	for (i = 0; i < clusters; i++) {	174	for (i = 0; i < clusters; i++) {
210	unsigned fsec; /* sector offset relative to FAT1 */	175	unsigned fsec; /* sector offset relative to FAT1 */
211	unsigned fidx; /* FAT1 entry index */	176	unsigned fidx; /* FAT1 entry index */
212		177
213	assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);	178	assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
214	fsec = (clst * sizeof(fat_cluster_t)) / bps;	179	fsec = (clst * sizeof(fat_cluster_t)) / bps;
215	fidx = clst % (bps / sizeof(fat_cluster_t));	180	fidx = clst % (bps / sizeof(fat_cluster_t));
216	/* read FAT1 */	181	/* read FAT1 */
217	b = block_get(dev_handle, rscnt + fsec, bps);	182	b = block_get(dev_handle, rscnt + fsec, bps);
218	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);	183	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
219	assert(clst != FAT_CLST_BAD);	184	assert(clst != FAT_CLST_BAD);
220	assert(clst < FAT_CLST_LAST1);	185	assert(clst < FAT_CLST_LAST1);
221	block_put(b);	186	block_put(b);
222	}	187	}
223		188
224	b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +	189	b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
225	offset % spc, bps);	190	offset % spc, bps);
226		191
227	return b;	192	return b;
228	}	193	}
229		194
230	/** Return number of blocks allocated to a file.	195	/** Return number of blocks allocated to a file.
231	*	196	*
232	* @param dev_handle Device handle of the device with the file.	197	* @param dev_handle Device handle of the device with the file.
233	* @param firstc First cluster of the file.	198	* @param firstc First cluster of the file.
234	*	199	*
235	* @return Number of blocks allocated to the file.	200	* @return Number of blocks allocated to the file.
236	*/	201	*/
237	static uint16_t	202	static uint16_t
238	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)	203	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
239	{	204	{
240	block_t *bb;	205	block_t *bb;
241	block_t *b;	206	block_t *b;
242	unsigned bps;	207	unsigned bps;
243	unsigned spc;	208	unsigned spc;
244	unsigned rscnt; /* block address of the first FAT */	209	unsigned rscnt; /* block address of the first FAT */
245	unsigned clusters = 0;	210	unsigned clusters = 0;
246	fat_cluster_t clst = firstc;	211	fat_cluster_t clst = firstc;
247		212
248	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	213	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
249	bps = uint16_t_le2host(FAT_BS(bb)->bps);	214	bps = uint16_t_le2host(FAT_BS(bb)->bps);
250	spc = FAT_BS(bb)->spc;	215	spc = FAT_BS(bb)->spc;
251	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	216	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
252	block_put(bb);	217	block_put(bb);
253		218
254	if (firstc == FAT_CLST_RES0) {	219	if (firstc == FAT_CLST_RES0) {
255	/* No space allocated to the file. */	220	/* No space allocated to the file. */
256	return 0;	221	return 0;
257	}	222	}
258		223
259	while (clst < FAT_CLST_LAST1) {	224	while (clst < FAT_CLST_LAST1) {
260	unsigned fsec; /* sector offset relative to FAT1 */	225	unsigned fsec; /* sector offset relative to FAT1 */
261	unsigned fidx; /* FAT1 entry index */	226	unsigned fidx; /* FAT1 entry index */
262		227
263	assert(clst >= FAT_CLST_FIRST);	228	assert(clst >= FAT_CLST_FIRST);
264	fsec = (clst * sizeof(fat_cluster_t)) / bps;	229	fsec = (clst * sizeof(fat_cluster_t)) / bps;
265	fidx = clst % (bps / sizeof(fat_cluster_t));	230	fidx = clst % (bps / sizeof(fat_cluster_t));
266	/* read FAT1 */	231	/* read FAT1 */
267	b = block_get(dev_handle, rscnt + fsec, bps);	232	b = block_get(dev_handle, rscnt + fsec, bps);
268	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);	233	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
269	assert(clst != FAT_CLST_BAD);	234	assert(clst != FAT_CLST_BAD);
270	block_put(b);	235	block_put(b);
271	clusters++;	236	clusters++;
272	}	237	}
273		238
274	return clusters * spc;	239	return clusters * spc;
275	}	240	}
276		241
277	static void fat_node_initialize(fat_node_t *node)	242	static void fat_node_initialize(fat_node_t *node)
278	{	243	{
279	futex_initialize(&node->lock, 1);	244	futex_initialize(&node->lock, 1);
280	node->idx = NULL;	245	node->idx = NULL;
281	node->type = 0;	246	node->type = 0;
282	link_initialize(&node->ffn_link);	247	link_initialize(&node->ffn_link);
283	node->size = 0;	248	node->size = 0;
284	node->lnkcnt = 0;	249	node->lnkcnt = 0;
285	node->refcnt = 0;	250	node->refcnt = 0;
286	node->dirty = false;	251	node->dirty = false;
287	}	252	}
288		253
289	static uint16_t fat_bps_get(dev_handle_t dev_handle)	254	static uint16_t fat_bps_get(dev_handle_t dev_handle)
290	{	255	{
291	block_t *bb;	256	block_t *bb;
292	uint16_t bps;	257	uint16_t bps;
293		258
294	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	259	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
295	assert(bb != NULL);	260	assert(bb != NULL);
296	bps = uint16_t_le2host(FAT_BS(bb)->bps);	261	bps = uint16_t_le2host(FAT_BS(bb)->bps);
297	block_put(bb);	262	block_put(bb);
298		263
299	return bps;	264	return bps;
300	}	265	}
301		-
302	typedef enum {	-
303	FAT_DENTRY_SKIP,	-
304	FAT_DENTRY_LAST,	-
305	FAT_DENTRY_VALID	-
306	} fat_dentry_clsf_t;	-
307		-
308	static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)	-
309	{	-
310	if (d->attr & FAT_ATTR_VOLLABEL) {	-
311	/* volume label entry */	-
312	return FAT_DENTRY_SKIP;	-
313	}	-
314	if (d->name[0] == FAT_DENTRY_ERASED) {	-
315	/* not-currently-used entry */	-
316	return FAT_DENTRY_SKIP;	-
317	}	-
318	if (d->name[0] == FAT_DENTRY_UNUSED) {	-
319	/* never used entry */	-
320	return FAT_DENTRY_LAST;	-
321	}	-
322	if (d->name[0] == FAT_DENTRY_DOT) {	-
323	/*	-
324	* Most likely '.' or '..'.	-
325	* It cannot occur in a regular file name.	-
326	*/	-
327	return FAT_DENTRY_SKIP;	-
328	}	-
329	return FAT_DENTRY_VALID;	-
330	}	-
331		266
332	static void fat_node_sync(fat_node_t *node)	267	static void fat_node_sync(fat_node_t *node)
333	{	268	{
334	/* TODO */	269	/* TODO */
335	}	270	}
336		271
337	/** Internal version of fat_node_get().	272	/** Internal version of fat_node_get().
338	*	273	*
339	* @param idxp Locked index structure.	274	* @param idxp Locked index structure.
340	*/	275	*/
341	static void fat_node_get_core(fat_idx_t idxp)	276	static void fat_node_get_core(fat_idx_t idxp)
342	{	277	{
343	block_t *b;	278	block_t *b;
344	fat_dentry_t *d;	279	fat_dentry_t *d;
345	fat_node_t *nodep = NULL;	280	fat_node_t *nodep = NULL;
346	unsigned bps;	281	unsigned bps;
347	unsigned dps;	282	unsigned dps;
348		283
349	if (idxp->nodep) {	284	if (idxp->nodep) {
350	/*	285	/*
351	* We are lucky.	286	* We are lucky.
352	* The node is already instantiated in memory.	287	* The node is already instantiated in memory.
353	*/	288	*/
354	futex_down(&idxp->nodep->lock);	289	futex_down(&idxp->nodep->lock);
355	if (!idxp->nodep->refcnt++)	290	if (!idxp->nodep->refcnt++)
356	list_remove(&idxp->nodep->ffn_link);	291	list_remove(&idxp->nodep->ffn_link);
357	futex_up(&idxp->nodep->lock);	292	futex_up(&idxp->nodep->lock);
358	return idxp->nodep;	293	return idxp->nodep;
359	}	294	}
360		295
361	/*	296	/*
362	* We must instantiate the node from the file system.	297	* We must instantiate the node from the file system.
363	*/	298	*/
364		299
365	assert(idxp->pfc);	300	assert(idxp->pfc);
366		301
367	futex_down(&ffn_futex);	302	futex_down(&ffn_futex);
368	if (!list_empty(&ffn_head)) {	303	if (!list_empty(&ffn_head)) {
369	/* Try to use a cached free node structure. */	304	/* Try to use a cached free node structure. */
370	fat_idx_t *idxp_tmp;	305	fat_idx_t *idxp_tmp;
371	nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);	306	nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
372	if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)	307	if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
373	goto skip_cache;	308	goto skip_cache;
374	idxp_tmp = nodep->idx;	309	idxp_tmp = nodep->idx;
375	if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {	310	if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
376	futex_up(&nodep->lock);	311	futex_up(&nodep->lock);
377	goto skip_cache;	312	goto skip_cache;
378	}	313	}
379	list_remove(&nodep->ffn_link);	314	list_remove(&nodep->ffn_link);
380	futex_up(&ffn_futex);	315	futex_up(&ffn_futex);
381	if (nodep->dirty)	316	if (nodep->dirty)
382	fat_node_sync(nodep);	317	fat_node_sync(nodep);
383	idxp_tmp->nodep = NULL;	318	idxp_tmp->nodep = NULL;
384	futex_up(&nodep->lock);	319	futex_up(&nodep->lock);
385	futex_up(&idxp_tmp->lock);	320	futex_up(&idxp_tmp->lock);
386	} else {	321	} else {
387	skip_cache:	322	skip_cache:
388	/* Try to allocate a new node structure. */	323	/* Try to allocate a new node structure. */
389	futex_up(&ffn_futex);	324	futex_up(&ffn_futex);
390	nodep = (fat_node_t *)malloc(sizeof(fat_node_t));	325	nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
391	if (!nodep)	326	if (!nodep)
392	return NULL;	327	return NULL;
393	}	328	}
394	fat_node_initialize(nodep);	329	fat_node_initialize(nodep);
395		330
396	bps = fat_bps_get(idxp->dev_handle);	331	bps = fat_bps_get(idxp->dev_handle);
397	dps = bps / sizeof(fat_dentry_t);	332	dps = bps / sizeof(fat_dentry_t);
398		333
399	/* Read the block that contains the dentry of interest. */	334	/* Read the block that contains the dentry of interest. */
400	b = _fat_block_get(idxp->dev_handle, idxp->pfc,	335	b = _fat_block_get(idxp->dev_handle, idxp->pfc,
401	(idxp->pdi * sizeof(fat_dentry_t)) / bps);	336	(idxp->pdi * sizeof(fat_dentry_t)) / bps);
402	assert(b);	337	assert(b);
403		338
404	d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);	339	d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
405	if (d->attr & FAT_ATTR_SUBDIR) {	340	if (d->attr & FAT_ATTR_SUBDIR) {
406	/*	341	/*
407	* The only directory which does not have this bit set is the	342	* The only directory which does not have this bit set is the
408	* root directory itself. The root directory node is handled	343	* root directory itself. The root directory node is handled
409	* and initialized elsewhere.	344	* and initialized elsewhere.
410	*/	345	*/
411	nodep->type = FAT_DIRECTORY;	346	nodep->type = FAT_DIRECTORY;
412	/*	347	/*
413	* Unfortunately, the 'size' field of the FAT dentry is not	348	* Unfortunately, the 'size' field of the FAT dentry is not
414	* defined for the directory entry type. We must determine the	349	* defined for the directory entry type. We must determine the
415	* size of the directory by walking the FAT.	350	* size of the directory by walking the FAT.
416	*/	351	*/
417	nodep->size = bps * _fat_blcks_get(idxp->dev_handle,	352	nodep->size = bps * _fat_blcks_get(idxp->dev_handle,
418	uint16_t_le2host(d->firstc));	353	uint16_t_le2host(d->firstc));
419	} else {	354	} else {
420	nodep->type = FAT_FILE;	355	nodep->type = FAT_FILE;
421	nodep->size = uint32_t_le2host(d->size);	356	nodep->size = uint32_t_le2host(d->size);
422	}	357	}
423	nodep->firstc = uint16_t_le2host(d->firstc);	358	nodep->firstc = uint16_t_le2host(d->firstc);
424	nodep->lnkcnt = 1;	359	nodep->lnkcnt = 1;
425	nodep->refcnt = 1;	360	nodep->refcnt = 1;
426		361
427	block_put(b);	362	block_put(b);
428		363
429	/* Link the idx structure with the node structure. */	364	/* Link the idx structure with the node structure. */
430	nodep->idx = idxp;	365	nodep->idx = idxp;
431	idxp->nodep = nodep;	366	idxp->nodep = nodep;
432		367
433	return nodep;	368	return nodep;
434	}	369	}
435		370
436	/** Instantiate a FAT in-core node. */	371	/** Instantiate a FAT in-core node. */
437	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)	372	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
438	{	373	{
439	void *node;	374	void *node;
440	fat_idx_t *idxp;	375	fat_idx_t *idxp;
441		376
442	idxp = fat_idx_get_by_index(dev_handle, index);	377	idxp = fat_idx_get_by_index(dev_handle, index);
443	if (!idxp)	378	if (!idxp)
444	return NULL;	379	return NULL;
445	/* idxp->lock held */	380	/* idxp->lock held */
446	node = fat_node_get_core(idxp);	381	node = fat_node_get_core(idxp);
447	futex_up(&idxp->lock);	382	futex_up(&idxp->lock);
448	return node;	383	return node;
449	}	384	}
450		385
451	static void fat_node_put(void *node)	386	static void fat_node_put(void *node)
452	{	387	{
453	fat_node_t nodep = (fat_node_t )node;	388	fat_node_t nodep = (fat_node_t )node;
454		389
455	futex_down(&nodep->lock);	390	futex_down(&nodep->lock);
456	if (!--nodep->refcnt) {	391	if (!--nodep->refcnt) {
457	futex_down(&ffn_futex);	392	futex_down(&ffn_futex);
458	list_append(&nodep->ffn_link, &ffn_head);	393	list_append(&nodep->ffn_link, &ffn_head);
459	futex_up(&ffn_futex);	394	futex_up(&ffn_futex);
460	}	395	}
461	futex_up(&nodep->lock);	396	futex_up(&nodep->lock);
462	}	397	}
463		398
464	static void *fat_create(int flags)	399	static void *fat_create(int flags)
465	{	400	{
466	return NULL; /* not supported at the moment */	401	return NULL; /* not supported at the moment */
467	}	402	}
468		403
469	static int fat_destroy(void *node)	404	static int fat_destroy(void *node)
470	{	405	{
471	return ENOTSUP; /* not supported at the moment */	406	return ENOTSUP; /* not supported at the moment */
472	}	407	}
473		408
474	static bool fat_link(void prnt, void chld, const char *name)	409	static bool fat_link(void prnt, void chld, const char *name)
475	{	410	{
476	return false; /* not supported at the moment */	411	return false; /* not supported at the moment */
477	}	412	}
478		413
479	static int fat_unlink(void prnt, void chld)	414	static int fat_unlink(void prnt, void chld)
480	{	415	{
481	return ENOTSUP; /* not supported at the moment */	416	return ENOTSUP; /* not supported at the moment */
482	}	417	}
483		418
484	static void fat_match(void prnt, const char *component)	419	static void fat_match(void prnt, const char *component)
485	{	420	{
486	fat_node_t parentp = (fat_node_t )prnt;	421	fat_node_t parentp = (fat_node_t )prnt;
487	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];	422	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
488	unsigned i, j;	423	unsigned i, j;
489	unsigned bps; /* bytes per sector */	424	unsigned bps; /* bytes per sector */
490	unsigned dps; /* dentries per sector */	425	unsigned dps; /* dentries per sector */
491	unsigned blocks;	426	unsigned blocks;
492	fat_dentry_t *d;	427	fat_dentry_t *d;
493	block_t *b;	428	block_t *b;
494		429
495	futex_down(&parentp->idx->lock);	430	futex_down(&parentp->idx->lock);
496	bps = fat_bps_get(parentp->idx->dev_handle);	431	bps = fat_bps_get(parentp->idx->dev_handle);
497	dps = bps / sizeof(fat_dentry_t);	432	dps = bps / sizeof(fat_dentry_t);
498	blocks = parentp->size / bps + (parentp->size % bps != 0);	433	blocks = parentp->size / bps + (parentp->size % bps != 0);

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/fat/fat_ops.c @ 3604 – Rev 3503 → 3505