Changes in uspace/srv/ns/task.c [c7bbf029:adb49f58] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/ns/task.c

    rc7bbf029 radb49f58  
    3939#include <stdio.h>
    4040#include <macros.h>
    41 #include <malloc.h>
    4241#include "task.h"
    4342#include "ns.h"
    4443
    4544#define TASK_HASH_TABLE_CHAINS  256
    46 #define P2I_HASH_TABLE_CHAINS   256
     45#define P2I_HASH_TABLE_CHAINS  256
     46
     47static int get_id_by_phone(ipcarg_t phone_hash, task_id_t *id);
    4748
    4849/* TODO:
     
    5657typedef struct {
    5758        link_t link;
    58        
    59         task_id_t id;    /**< Task ID. */
    60         bool finished;   /**< Task is done. */
    61         bool have_rval;  /**< Task returned a value. */
    62         int retval;      /**< The return value. */
     59        task_id_t id;   /**< Task ID. */
     60        bool finished;  /**< Task is done. */
     61        bool have_rval; /**< Task returned a value. */
     62        int retval;     /**< The return value. */
    6363} hashed_task_t;
    6464
     
    7171 *
    7272 */
    73 static hash_index_t task_hash(unsigned long key[])
     73static hash_index_t task_hash(unsigned long *key)
    7474{
    7575        assert(key);
    76         return (LOWER32(key[0]) % TASK_HASH_TABLE_CHAINS);
     76        return (LOWER32(*key) % TASK_HASH_TABLE_CHAINS);
    7777}
    7878
     
    124124typedef struct {
    125125        link_t link;
    126         sysarg_t in_phone_hash;  /**< Incoming phone hash. */
    127         task_id_t id;            /**< Task ID. */
     126        ipcarg_t phash;    /**< Task ID. */
     127        task_id_t id;    /**< Task ID. */
    128128} p2i_entry_t;
    129129
     
    131131 *
    132132 * @param key Array of keys.
    133  *
    134133 * @return Hash index corresponding to key[0].
    135134 *
    136135 */
    137 static hash_index_t p2i_hash(unsigned long key[])
     136static hash_index_t p2i_hash(unsigned long *key)
    138137{
    139138        assert(key);
    140         return (key[0] % TASK_HASH_TABLE_CHAINS);
     139        return (*key % TASK_HASH_TABLE_CHAINS);
    141140}
    142141
     
    155154        assert(keys == 1);
    156155        assert(item);
    157        
    158         p2i_entry_t *entry = hash_table_get_instance(item, p2i_entry_t, link);
    159        
    160         return (key[0] == entry->in_phone_hash);
     156
     157        p2i_entry_t *e = hash_table_get_instance(item, p2i_entry_t, link);
     158
     159        return (key[0] == e->phash);
    161160}
    162161
     
    198197                return ENOMEM;
    199198        }
    200        
     199
    201200        if (!hash_table_create(&phone_to_id, P2I_HASH_TABLE_CHAINS,
    202201            1, &p2i_ops)) {
     
    206205       
    207206        list_initialize(&pending_wait);
     207       
    208208        return EOK;
    209209}
     
    238238                            ht->retval);
    239239                }
    240                
     240
    241241                hash_table_remove(&task_hash_table, keys, 2);
    242242                list_remove(cur);
     
    248248void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid)
    249249{
    250         sysarg_t retval;
     250        ipcarg_t retval;
    251251        task_exit_t texit;
    252        
     252
    253253        unsigned long keys[2] = {
    254254                LOWER32(id),
    255255                UPPER32(id)
    256256        };
    257        
     257
    258258        link_t *link = hash_table_find(&task_hash_table, keys);
    259259        hashed_task_t *ht = (link != NULL) ?
    260260            hash_table_get_instance(link, hashed_task_t, link) : NULL;
    261        
     261
    262262        if (ht == NULL) {
    263263                /* No such task exists. */
    264                 ipc_answer_0(callid, ENOENT);
    265                 return;
    266         }
    267        
     264                retval = ENOENT;
     265                goto out;
     266        }
     267
    268268        if (!ht->finished) {
    269269                /* Add to pending list */
     
    275275                }
    276276               
    277                 link_initialize(&pr->link);
    278277                pr->id = id;
    279278                pr->callid = callid;
     
    294293int ns_task_id_intro(ipc_call_t *call)
    295294{
     295        task_id_t id;
    296296        unsigned long keys[2];
    297        
    298         task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
     297        link_t *link;
     298        p2i_entry_t *e;
     299        hashed_task_t *ht;
     300
     301        id = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
     302
    299303        keys[0] = call->in_phone_hash;
    300        
    301         link_t *link = hash_table_find(&phone_to_id, keys);
     304
     305        link = hash_table_find(&phone_to_id, keys);
    302306        if (link != NULL)
    303307                return EEXISTS;
    304        
    305         p2i_entry_t *entry = (p2i_entry_t *) malloc(sizeof(p2i_entry_t));
    306         if (entry == NULL)
     308
     309        e = (p2i_entry_t *) malloc(sizeof(p2i_entry_t));
     310        if (e == NULL)
    307311                return ENOMEM;
    308        
    309         hashed_task_t *ht = (hashed_task_t *) malloc(sizeof(hashed_task_t));
     312
     313        ht = (hashed_task_t *) malloc(sizeof(hashed_task_t));
    310314        if (ht == NULL)
    311315                return ENOMEM;
    312        
    313         /*
    314          * Insert into the phone-to-id map.
    315          */
    316        
    317         link_initialize(&entry->link);
    318         entry->in_phone_hash = call->in_phone_hash;
    319         entry->id = id;
    320         hash_table_insert(&phone_to_id, keys, &entry->link);
    321        
    322         /*
    323          * Insert into the main table.
    324          */
    325        
     316
     317        /* Insert to phone-to-id map. */
     318
     319        link_initialize(&e->link);
     320        e->phash = call->in_phone_hash;
     321        e->id = id;
     322        hash_table_insert(&phone_to_id, keys, &e->link);
     323
     324        /* Insert to main table. */
     325
    326326        keys[0] = LOWER32(id);
    327327        keys[1] = UPPER32(id);
    328        
     328
    329329        link_initialize(&ht->link);
    330330        ht->id = id;
     
    333333        ht->retval = -1;
    334334        hash_table_insert(&task_hash_table, keys, &ht->link);
    335        
     335
    336336        return EOK;
    337337}
    338338
    339 static int get_id_by_phone(sysarg_t phone_hash, task_id_t *id)
    340 {
    341         unsigned long keys[1] = {phone_hash};
    342        
    343         link_t *link = hash_table_find(&phone_to_id, keys);
    344         if (link == NULL)
    345                 return ENOENT;
    346        
    347         p2i_entry_t *entry = hash_table_get_instance(link, p2i_entry_t, link);
    348         *id = entry->id;
    349        
    350         return EOK;
    351 }
    352 
    353339int ns_task_retval(ipc_call_t *call)
    354340{
    355341        task_id_t id;
    356         int rc = get_id_by_phone(call->in_phone_hash, &id);
     342        unsigned long keys[2];
     343        int rc;
     344
     345        rc = get_id_by_phone(call->in_phone_hash, &id);
    357346        if (rc != EOK)
    358347                return rc;
    359        
    360         unsigned long keys[2] = {
    361                 LOWER32(id),
    362                 UPPER32(id)
    363         };
     348
     349        keys[0] = LOWER32(id);
     350        keys[1] = UPPER32(id);
    364351       
    365352        link_t *link = hash_table_find(&task_hash_table, keys);
     
    367354            hash_table_get_instance(link, hashed_task_t, link) : NULL;
    368355       
    369         if ((ht == NULL) || (ht->finished))
     356        if ((ht == NULL) || ht->finished)
    370357                return EINVAL;
    371        
     358
    372359        ht->finished = true;
    373360        ht->have_rval = true;
    374361        ht->retval = IPC_GET_ARG1(*call);
    375        
     362
    376363        return EOK;
    377364}
     
    380367{
    381368        unsigned long keys[2];
    382        
    383369        task_id_t id;
    384         int rc = get_id_by_phone(call->in_phone_hash, &id);
     370        int rc;
     371
     372        rc = get_id_by_phone(call->in_phone_hash, &id);
    385373        if (rc != EOK)
    386374                return rc;
    387        
     375
    388376        /* Delete from phone-to-id map. */
    389377        keys[0] = call->in_phone_hash;
    390378        hash_table_remove(&phone_to_id, keys, 1);
    391        
     379
    392380        /* Mark task as finished. */
    393381        keys[0] = LOWER32(id);
    394382        keys[1] = UPPER32(id);
    395        
     383
    396384        link_t *link = hash_table_find(&task_hash_table, keys);
    397385        hashed_task_t *ht =
     
    399387        if (ht == NULL)
    400388                return EOK;
    401        
     389
    402390        ht->finished = true;
    403        
     391
     392        return EOK;
     393}
     394
     395static int get_id_by_phone(ipcarg_t phone_hash, task_id_t *id)
     396{
     397        unsigned long keys[1];
     398        link_t *link;
     399        p2i_entry_t *e;
     400
     401        keys[0] = phone_hash;
     402        link = hash_table_find(&phone_to_id, keys);
     403        if (link == NULL)
     404                return ENOENT;
     405
     406        e = hash_table_get_instance(link, p2i_entry_t, link);
     407        *id = e->id;
     408
    404409        return EOK;
    405410}
Note: See TracChangeset for help on using the changeset viewer.