Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rbc216a0 r9d58539  
    6161        async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
    6262        size_t refcount;
    63         ht_link_t link;
     63        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#define SERVICES_BUCKETS     256
     76
    7377/* Implementation of hash table interface for the nodes hash table. */
    74 
    75 static size_t services_key_hash(void *key)
    76 {
    77         return *(service_id_t*)key;
    78 }
    79 
    80 static 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 
    86 static 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 
    92 static void services_remove_callback(ht_link_t *item)
    93 {
    94         free(hash_table_get_inst(item, service_t, link));
    95 }
    96 
    97 static hash_table_ops_t services_ops = {
     78static hash_index_t services_hash(unsigned long key[])
     79{
     80        return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS;
     81}
     82
     83static int services_compare(unsigned long key[], hash_count_t keys, link_t *item)
     84{
     85        service_t *dev = hash_table_get_instance(item, service_t, link);
     86        return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]);
     87}
     88
     89static void services_remove_callback(link_t *item)
     90{
     91        free(hash_table_get_instance(item, service_t, link));
     92}
     93
     94static hash_table_operations_t services_ops = {
    9895        .hash = services_hash,
    99         .key_hash = services_key_hash,
    100         .key_equal = services_key_equal,
    101         .equal = 0,
     96        .compare = services_compare,
    10297        .remove_callback = services_remove_callback
    10398};
    … …  
    234229                /* Device node */
    235230               
     231                unsigned long key[] = {
     232                        [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id
     233                };
     234                link_t *lnk;
     235               
    236236                fibril_mutex_lock(&services_mutex);
    237                 ht_link_t *lnk;
    238237restart:
    239                 lnk = hash_table_find(&services, &node->service_id);
     238                lnk = hash_table_find(&services, key);
    240239                if (lnk == NULL) {
    241240                        service_t *dev = (service_t *) malloc(sizeof(service_t));
    … …  
    257256                         * below.
    258257                         */
    259                         hash_table_insert(&services, &dev->link);
     258                        hash_table_insert(&services, key, &dev->link);
    260259                       
    261260                        /*
    … …  
    280279                                 * entry and free the device structure.
    281280                                 */
    282                                 hash_table_remove(&services, &node->service_id);
     281                                hash_table_remove(&services, key, SERVICES_KEYS);
    283282                                fibril_mutex_unlock(&services_mutex);
    284283                               
    … …  
    289288                        dev->sess = sess;
    290289                } else {
    291                         service_t *dev = hash_table_get_inst(lnk, service_t, link);
     290                        service_t *dev = hash_table_get_instance(lnk, service_t, link);
    292291                       
    293292                        if (!dev->sess) {
    … …  
    451450bool locfs_init(void)
    452451{
    453         if (!hash_table_create(&services, 0,  0, &services_ops))
     452        if (!hash_table_create(&services, SERVICES_BUCKETS,
     453            SERVICES_KEYS, &services_ops))
    454454                return false;
    455455       
    … …  
    555555                /* Device node */
    556556               
     557                unsigned long key[] = {
     558                        [SERVICES_KEY_HANDLE] = (unsigned long) index
     559                };
     560               
    557561                fibril_mutex_lock(&services_mutex);
    558                 ht_link_t *lnk = hash_table_find(&services, &index);
     562                link_t *lnk = hash_table_find(&services, key);
    559563                if (lnk == NULL) {
    560564                        fibril_mutex_unlock(&services_mutex);
    … …  
    562566                }
    563567               
    564                 service_t *dev = hash_table_get_inst(lnk, service_t, link);
     568                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    565569                assert(dev->sess);
    566570               
    … …  
    617621        if (type == LOC_OBJECT_SERVICE) {
    618622                /* Device node */
     623                unsigned long key[] = {
     624                        [SERVICES_KEY_HANDLE] = (unsigned long) index
     625                };
    619626               
    620627                fibril_mutex_lock(&services_mutex);
    621                 ht_link_t *lnk = hash_table_find(&services, &index);
     628                link_t *lnk = hash_table_find(&services, key);
    622629                if (lnk == NULL) {
    623630                        fibril_mutex_unlock(&services_mutex);
    … …  
    625632                }
    626633               
    627                 service_t *dev = hash_table_get_inst(lnk, service_t, link);
     634                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    628635                assert(dev->sess);
    629636               
    … …  
    684691       
    685692        if (type == LOC_OBJECT_SERVICE) {
     693                unsigned long key[] = {
     694                        [SERVICES_KEY_HANDLE] = (unsigned long) index
     695                };
    686696               
    687697                fibril_mutex_lock(&services_mutex);
    688                 ht_link_t *lnk = hash_table_find(&services, &index);
     698                link_t *lnk = hash_table_find(&services, key);
    689699                if (lnk == NULL) {
    690700                        fibril_mutex_unlock(&services_mutex);
    … …  
    692702                }
    693703               
    694                 service_t *dev = hash_table_get_inst(lnk, service_t, link);
     704                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    695705                assert(dev->sess);
    696706                dev->refcount--;
    … …  
    698708                if (dev->refcount == 0) {
    699709                        async_hangup(dev->sess);
    700                         hash_table_remove(&services, &index);
     710                        hash_table_remove(&services, key, SERVICES_KEYS);
    701711                }
    702712               
    … …  
    722732       
    723733        if (type == LOC_OBJECT_SERVICE) {
    724 
     734                unsigned long key[] = {
     735                        [SERVICES_KEY_HANDLE] = (unsigned long) index
     736                };
     737               
    725738                fibril_mutex_lock(&services_mutex);
    726                 ht_link_t *lnk = hash_table_find(&services, &index);
     739                link_t *lnk = hash_table_find(&services, key);
    727740                if (lnk == NULL) {
    728741                        fibril_mutex_unlock(&services_mutex);
    … …  
    730743                }
    731744               
    732                 service_t *dev = hash_table_get_inst(lnk, service_t, link);
     745                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    733746                assert(dev->sess);
    734747               
Note: See TracChangeset for help on using the changeset viewer.