Changeset bc216a0 in mainline for uspace/srv/fs/locfs/locfs_ops.c


Ignore:
Timestamp:
2012-08-07T22:13:44Z (13 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
da68871a
Parents:
b17518e
Message:

Refactored any users of hash_table to use opaque void* keys instead of the cumbersome unsigned long[] keys. Switched from the ad hoc computations of hashes of multiple values to hash_combine().

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/locfs/locfs_ops.c

    rb17518e rbc216a0  
    6161        async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
    6262        size_t refcount;
    63         link_t link;
     63        ht_link_t link;
    6464        fibril_condvar_t cv;      /**< Broadcast when completed. */
    6565} service_t;
    … …  
    7171static FIBRIL_MUTEX_INITIALIZE(services_mutex);
    7272
    73 #define SERVICES_KEYS        1
    74 #define SERVICES_KEY_HANDLE  0
    75 
    7673/* Implementation of hash table interface for the nodes hash table. */
    7774
    78 static size_t services_key_hash(unsigned long key[])
    79 {
    80         return key[SERVICES_KEY_HANDLE];
    81 }
    82 
    83 static size_t services_hash(const link_t *item)
    84 {
    85         service_t *dev = hash_table_get_instance(item, service_t, link);
    86         unsigned long key[] = {
    87                 [SERVICES_KEY_HANDLE] = dev->service_id
    88         };
    89        
    90         return services_key_hash(key);
    91 }
    92 
    93 static bool services_match(unsigned long key[], size_t keys, const link_t *item)
    94 {
    95         assert(keys == 1);
    96         service_t *dev = hash_table_get_instance(item, service_t, link);
    97         return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]);
    98 }
    99 
    100 static void services_remove_callback(link_t *item)
    101 {
    102         free(hash_table_get_instance(item, service_t, link));
     75static size_t services_key_hash(void *key)
     76{
     77        return *(service_id_t*)key;
     78}
     79
     80static size_t services_hash(const ht_link_t *item)
     81{
     82        service_t *dev = hash_table_get_inst(item, service_t, link);
     83        return dev->service_id;
     84}
     85
     86static bool services_key_equal(void *key, const ht_link_t *item)
     87{
     88        service_t *dev = hash_table_get_inst(item, service_t, link);
     89        return (dev->service_id == *(service_id_t*)key);
     90}
     91
     92static void services_remove_callback(ht_link_t *item)
     93{
     94        free(hash_table_get_inst(item, service_t, link));
    10395}
    10496
    … …  
    10698        .hash = services_hash,
    10799        .key_hash = services_key_hash,
    108         .match = services_match,
     100        .key_equal = services_key_equal,
    109101        .equal = 0,
    110102        .remove_callback = services_remove_callback
    … …  
    242234                /* Device node */
    243235               
    244                 unsigned long key[] = {
    245                         [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id
    246                 };
    247                 link_t *lnk;
    248                
    249236                fibril_mutex_lock(&services_mutex);
     237                ht_link_t *lnk;
    250238restart:
    251                 lnk = hash_table_find(&services, key);
     239                lnk = hash_table_find(&services, &node->service_id);
    252240                if (lnk == NULL) {
    253241                        service_t *dev = (service_t *) malloc(sizeof(service_t));
    … …  
    292280                                 * entry and free the device structure.
    293281                                 */
    294                                 hash_table_remove(&services, key, SERVICES_KEYS);
     282                                hash_table_remove(&services, &node->service_id);
    295283                                fibril_mutex_unlock(&services_mutex);
    296284                               
    … …  
    301289                        dev->sess = sess;
    302290                } else {
    303                         service_t *dev = hash_table_get_instance(lnk, service_t, link);
     291                        service_t *dev = hash_table_get_inst(lnk, service_t, link);
    304292                       
    305293                        if (!dev->sess) {
    … …  
    463451bool locfs_init(void)
    464452{
    465         if (!hash_table_create(&services, 0,  SERVICES_KEYS, &services_ops))
     453        if (!hash_table_create(&services, 0,  0, &services_ops))
    466454                return false;
    467455       
    … …  
    567555                /* Device node */
    568556               
    569                 unsigned long key[] = {
    570                         [SERVICES_KEY_HANDLE] = (unsigned long) index
    571                 };
    572                
    573557                fibril_mutex_lock(&services_mutex);
    574                 link_t *lnk = hash_table_find(&services, key);
     558                ht_link_t *lnk = hash_table_find(&services, &index);
    575559                if (lnk == NULL) {
    576560                        fibril_mutex_unlock(&services_mutex);
    … …  
    578562                }
    579563               
    580                 service_t *dev = hash_table_get_instance(lnk, service_t, link);
     564                service_t *dev = hash_table_get_inst(lnk, service_t, link);
    581565                assert(dev->sess);
    582566               
    … …  
    633617        if (type == LOC_OBJECT_SERVICE) {
    634618                /* Device node */
    635                 unsigned long key[] = {
    636                         [SERVICES_KEY_HANDLE] = (unsigned long) index
    637                 };
    638619               
    639620                fibril_mutex_lock(&services_mutex);
    640                 link_t *lnk = hash_table_find(&services, key);
     621                ht_link_t *lnk = hash_table_find(&services, &index);
    641622                if (lnk == NULL) {
    642623                        fibril_mutex_unlock(&services_mutex);
    … …  
    644625                }
    645626               
    646                 service_t *dev = hash_table_get_instance(lnk, service_t, link);
     627                service_t *dev = hash_table_get_inst(lnk, service_t, link);
    647628                assert(dev->sess);
    648629               
    … …  
    703684       
    704685        if (type == LOC_OBJECT_SERVICE) {
    705                 unsigned long key[] = {
    706                         [SERVICES_KEY_HANDLE] = (unsigned long) index
    707                 };
    708686               
    709687                fibril_mutex_lock(&services_mutex);
    710                 link_t *lnk = hash_table_find(&services, key);
     688                ht_link_t *lnk = hash_table_find(&services, &index);
    711689                if (lnk == NULL) {
    712690                        fibril_mutex_unlock(&services_mutex);
    … …  
    714692                }
    715693               
    716                 service_t *dev = hash_table_get_instance(lnk, service_t, link);
     694                service_t *dev = hash_table_get_inst(lnk, service_t, link);
    717695                assert(dev->sess);
    718696                dev->refcount--;
    … …  
    720698                if (dev->refcount == 0) {
    721699                        async_hangup(dev->sess);
    722                         hash_table_remove(&services, key, SERVICES_KEYS);
     700                        hash_table_remove(&services, &index);
    723701                }
    724702               
    … …  
    744722       
    745723        if (type == LOC_OBJECT_SERVICE) {
    746                 unsigned long key[] = {
    747                         [SERVICES_KEY_HANDLE] = (unsigned long) index
    748                 };
    749                
     724
    750725                fibril_mutex_lock(&services_mutex);
    751                 link_t *lnk = hash_table_find(&services, key);
     726                ht_link_t *lnk = hash_table_find(&services, &index);
    752727                if (lnk == NULL) {
    753728                        fibril_mutex_unlock(&services_mutex);
    … …  
    755730                }
    756731               
    757                 service_t *dev = hash_table_get_instance(lnk, service_t, link);
     732                service_t *dev = hash_table_get_inst(lnk, service_t, link);
    758733                assert(dev->sess);
    759734               
Note: See TracChangeset for help on using the changeset viewer.