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

Changeset f01fea3 in mainline


Ignore:
Timestamp:
2011-08-02T19:08:36Z (10 years ago)
Author:
Oleg Romanenko <romanenko.oleg@…>
Branches:
lfn, master
Children:
8f54827
Parents:
1f1d96a
Message:

Implement exfat_node_get_core

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/exfat/exfat_ops.c

    r1f1d96a rf01fea3  
    6262#define EXFAT_NODE(node)        ((node) ? (exfat_node_t *) (node)->data : NULL)
    6363#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
    64 
     64#define DPS(bs) (BPS((bs)) / sizeof(exfat_dentry_t))
    6565
    6666/** Mutex protecting the list of cached free FAT nodes. */
     
    259259{
    260260        block_t *b=NULL;
    261         //exfat_bs_t *bs;
    262         //exfat_dentry_t *d;
     261        exfat_bs_t *bs;
     262        exfat_dentry_t *d;
    263263        exfat_node_t *nodep = NULL;
    264264        int rc;
     
    290290                return rc;
    291291
    292         //bs = block_bb_get(idxp->devmap_handle);
    293 
    294         /* Access to exFAT directory and read two entries:
    295          * file entry and stream entry
    296          */
    297         /*
    298         exfat_directory_t di;
    299         exfat_dentry_t *de;
    300         exfat_directory_open(&di, ???);
    301         exfat_directory_seek(&di, idxp->pdi);
    302         exfat_directory_get(&di, &de);
    303 
    304         switch (exfat_classify_dentry(de)) {
     292        bs = block_bb_get(idxp->devmap_handle);
     293
     294        rc = exfat_block_get_by_clst(&b, bs, idxp->devmap_handle,
     295            idxp->parent_fragmented, idxp->pfc, NULL,
     296            (idxp->pdi * sizeof(exfat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
     297        if (rc != EOK) {
     298                (void) exfat_node_put(FS_NODE(nodep));
     299                return rc;
     300        }
     301
     302        d = ((exfat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
     303        switch (exfat_classify_dentry(d)) {
    305304        case EXFAT_DENTRY_FILE:
    306                 nodep->type = (de->file.attr & EXFAT_ATTR_SUBDIR)?
     305                nodep->type = (d->file.attr & EXFAT_ATTR_SUBDIR)?
    307306                    EXFAT_DIRECTORY : EXFAT_FILE;
    308                 exfat_directory_next(&di);
    309                 exfat_directory_get(&di, &de);
    310                 nodep->firtsc = de->stream.firstc;
    311                 nodep->size = de->stream.data_size;
    312                 nodep->fragmented = (de->stream.flags & 0x02) == 0;
     307                rc = block_put(b);
     308                if (rc != EOK) {
     309                        (void) exfat_node_put(FS_NODE(nodep));
     310                        return rc;
     311                }
     312                rc = exfat_block_get_by_clst(&b, bs, idxp->devmap_handle,
     313                        idxp->parent_fragmented, idxp->pfc, NULL,
     314                        ((idxp->pdi+1) * sizeof(exfat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
     315                if (rc != EOK) {
     316                        (void) exfat_node_put(FS_NODE(nodep));
     317                        return rc;
     318                }
     319                d = ((exfat_dentry_t *)b->data) + ((idxp->pdi+1) % DPS(bs));
     320               
     321                nodep->firstc = d->stream.firstc;
     322                nodep->size = d->stream.data_size;
     323                nodep->fragmented = (d->stream.flags & 0x02) == 0;
    313324                break;
    314325        case EXFAT_DENTRY_BITMAP:
    315326                nodep->type = EXFAT_BITMAP;
    316                 nodep->firstc = de->bitmap.firstc;
    317                 nodep->size = de->bitmap.size;
    318                 nodep->fragmented = false;
     327                nodep->firstc = d->bitmap.firstc;
     328                nodep->size = d->bitmap.size;
     329                nodep->fragmented = true;
    319330                break;
    320331        case EXFAT_DENTRY_UCTABLE:
    321332                nodep->type = EXFAT_UCTABLE;
    322                 nodep->firstc = de->uctable.firstc;
    323                 nodep->size = de->uctable.size;
    324                 nodep->fragmented = false;
     333                nodep->firstc = d->uctable.firstc;
     334                nodep->size = d->uctable.size;
     335                nodep->fragmented = true;
    325336                break;
    326337        default:
     
    333344        case EXFAT_DENTRY_NAME:
    334345                (void) block_put(b);
    335                 (void) fat_node_put(FS_NODE(nodep));
     346                (void) exfat_node_put(FS_NODE(nodep));
    336347                return ENOENT;
    337348        }
    338         */
    339 
    340         /* Read the block that contains the dentry of interest. */
    341         /*
    342         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
    343             (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    344         if (rc != EOK) {
    345                 (void) fat_node_put(FS_NODE(nodep));
    346                 return rc;
    347         }
    348 
    349         d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
    350         */
    351349
    352350        nodep->lnkcnt = 1;
     
    393391int exfat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    394392{
     393        /* TODO */
    395394        *rfn = NULL;
    396395        return EOK;
     
    428427int exfat_node_put(fs_node_t *fn)
    429428{
     429        /* TODO */
    430430        return EOK;
    431431}
     
    433433int exfat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
    434434{
     435        /* TODO */
    435436        *rfn = NULL;
    436437        return EOK;
     
    439440int exfat_destroy_node(fs_node_t *fn)
    440441{
     442        /* TODO */
    441443        return EOK;
    442444}
     
    444446int exfat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    445447{
     448        /* TODO */
    446449        return EOK;
    447450}
     
    449452int exfat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    450453{
     454        /* TODO */
    451455        return EOK;
    452456}
Note: See TracChangeset for help on using the changeset viewer.