Changeset e27cf669 in mainline for uspace/srv/fs/tmpfs/tmpfs_ops.c


Ignore:
Timestamp:
2010-02-09T20:19:23Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
fb150d78
Parents:
975e7e9 (diff), eb73a50 (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 mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r975e7e9 re27cf669  
    147147hash_table_t nodes;
    148148
    149 #define NODES_KEY_INDEX 0
    150 #define NODES_KEY_DEV   1
     149#define NODES_KEY_DEV   0       
     150#define NODES_KEY_INDEX 1
    151151
    152152/* Implementation of hash table interface for the nodes hash table. */
     
    160160        tmpfs_node_t *nodep = hash_table_get_instance(item, tmpfs_node_t,
    161161            nh_link);
    162         return (nodep->index == key[NODES_KEY_INDEX] &&
    163             nodep->dev_handle == key[NODES_KEY_DEV]);
     162       
     163        switch (keys) {
     164        case 1:
     165                return (nodep->dev_handle == key[NODES_KEY_DEV]);
     166        case 2:
     167                return ((nodep->dev_handle == key[NODES_KEY_DEV]) &&
     168                    (nodep->index == key[NODES_KEY_INDEX]));
     169        default:
     170                assert((keys == 1) || (keys == 2));
     171        }
     172
     173        return 0;
    164174}
    165175
    166176static void nodes_remove_callback(link_t *item)
    167177{
     178        tmpfs_node_t *nodep = hash_table_get_instance(item, tmpfs_node_t,
     179            nh_link);
     180
     181        while (!list_empty(&nodep->cs_head)) {
     182                tmpfs_dentry_t *dentryp = list_get_instance(nodep->cs_head.next,
     183                    tmpfs_dentry_t, link);
     184
     185                assert(nodep->type == TMPFS_DIRECTORY);
     186                list_remove(&dentryp->link);
     187                free(dentryp);
     188        }
     189
     190        if (nodep->data) {
     191                assert(nodep->type == TMPFS_FILE);
     192                free(nodep->data);
     193        }
     194        free(nodep->bp);
     195        free(nodep);
    168196}
    169197
     
    215243}
    216244
     245static void tmpfs_instance_done(dev_handle_t dev_handle)
     246{
     247        unsigned long key[] = {
     248                [NODES_KEY_DEV] = dev_handle
     249        };
     250        /*
     251         * Here we are making use of one special feature of our hash table
     252         * implementation, which allows to remove more items based on a partial
     253         * key match. In the following, we are going to remove all nodes
     254         * matching our device handle. The nodes_remove_callback() function will
     255         * take care of resource deallocation.
     256         */
     257        hash_table_remove(&nodes, key, 1);
     258}
     259
    217260int tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    218261{
     
    237280{
    238281        unsigned long key[] = {
    239                 [NODES_KEY_INDEX] = index,
    240                 [NODES_KEY_DEV] = dev_handle
     282                [NODES_KEY_DEV] = dev_handle,
     283                [NODES_KEY_INDEX] = index
    241284        };
    242285        link_t *lnk = hash_table_find(&nodes, key);
     
    296339        /* Insert the new node into the nodes hash table. */
    297340        unsigned long key[] = {
    298                 [NODES_KEY_INDEX] = nodep->index,
    299                 [NODES_KEY_DEV] = nodep->dev_handle
     341                [NODES_KEY_DEV] = nodep->dev_handle,
     342                [NODES_KEY_INDEX] = nodep->index
    300343        };
    301344        hash_table_insert(&nodes, key, &nodep->nh_link);
     
    312355
    313356        unsigned long key[] = {
    314                 [NODES_KEY_INDEX] = nodep->index,
    315                 [NODES_KEY_DEV] = nodep->dev_handle
     357                [NODES_KEY_DEV] = nodep->dev_handle,
     358                [NODES_KEY_INDEX] = nodep->index
    316359        };
    317360        hash_table_remove(&nodes, key, 2);
    318361
    319         if (nodep->type == TMPFS_FILE)
    320                 free(nodep->data);
    321         free(nodep->bp);
    322         free(nodep);
     362        /*
     363         * The nodes_remove_callback() function takes care of the actual
     364         * resource deallocation.
     365         */
    323366        return EOK;
    324367}
     
    398441{
    399442        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     443        fs_node_t *rootfn;
    400444        int rc;
    401 
    402         /* accept the mount options */
    403         ipc_callid_t callid;
    404         size_t size;
    405         if (!async_data_write_receive(&callid, &size)) {
    406                 ipc_answer_0(callid, EINVAL);
    407                 ipc_answer_0(rid, EINVAL);
    408                 return;
    409         }
    410         char *opts = malloc(size + 1);
    411         if (!opts) {
    412                 ipc_answer_0(callid, ENOMEM);
    413                 ipc_answer_0(rid, ENOMEM);
    414                 return;
    415         }
    416         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    417         if (retval != EOK) {
    418                 ipc_answer_0(rid, retval);
     445       
     446        /* Accept the mount options. */
     447        char *opts;
     448        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
     449        if (rc != EOK) {
     450                ipc_answer_0(rid, rc);
     451                return;
     452        }
     453
     454        /* Check if this device is not already mounted. */
     455        rc = tmpfs_root_get(&rootfn, dev_handle);
     456        if ((rc == EOK) && (rootfn)) {
     457                (void) tmpfs_node_put(rootfn);
    419458                free(opts);
    420                 return;
    421         }
    422         opts[size] = '\0';
     459                ipc_answer_0(rid, EEXIST);
     460                return;
     461        }
    423462
    424463        /* Initialize TMPFS instance. */
    425464        if (!tmpfs_instance_init(dev_handle)) {
     465                free(opts);
    426466                ipc_answer_0(rid, ENOMEM);
    427467                return;
    428468        }
    429469
    430         fs_node_t *rootfn;
    431470        rc = tmpfs_root_get(&rootfn, dev_handle);
    432471        assert(rc == EOK);
     
    442481                    rootp->lnkcnt);
    443482        }
     483        free(opts);
    444484}
    445485
     
    447487{
    448488        libfs_mount(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
     489}
     490
     491void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
     492{
     493        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     494
     495        tmpfs_instance_done(dev_handle);
     496        ipc_answer_0(rid, EOK);
     497}
     498
     499void tmpfs_unmount(ipc_callid_t rid, ipc_call_t *request)
     500{
     501        libfs_unmount(&tmpfs_libfs_ops, rid, request);
    449502}
    450503
     
    465518        link_t *hlp;
    466519        unsigned long key[] = {
    467                 [NODES_KEY_INDEX] = index,
    468520                [NODES_KEY_DEV] = dev_handle,
     521                [NODES_KEY_INDEX] = index
    469522        };
    470523        hlp = hash_table_find(&nodes, key);
     
    539592        link_t *hlp;
    540593        unsigned long key[] = {
    541                 [NODES_KEY_INDEX] = index,
    542                 [NODES_KEY_DEV] = dev_handle
     594                [NODES_KEY_DEV] = dev_handle,
     595                [NODES_KEY_INDEX] = index
    543596        };
    544597        hlp = hash_table_find(&nodes, key);
     
    603656        link_t *hlp;
    604657        unsigned long key[] = {
    605                 [NODES_KEY_INDEX] = index,
    606                 [NODES_KEY_DEV] = dev_handle
     658                [NODES_KEY_DEV] = dev_handle,
     659                [NODES_KEY_INDEX] = index
    607660        };
    608661        hlp = hash_table_find(&nodes, key);
     
    646699        link_t *hlp;
    647700        unsigned long key[] = {
    648                 [NODES_KEY_INDEX] = index,
    649                 [NODES_KEY_DEV] = dev_handle
     701                [NODES_KEY_DEV] = dev_handle,
     702                [NODES_KEY_INDEX] = index
    650703        };
    651704        hlp = hash_table_find(&nodes, key);
Note: See TracChangeset for help on using the changeset viewer.