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

Changeset e2ab36f1 in mainline


Ignore:
Timestamp:
2011-08-19T12:38:09Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
36b16bc, 9247c02c
Parents:
903bac0a
Message:

Track client data by client task ID instead of client task hash.

Files:
10 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/ipc/ipc.h

    r903bac0a re2ab36f1  
    4040#include <synch/mutex.h>
    4141#include <synch/waitq.h>
     42#include <typedefs.h>
    4243
    4344#define IPC_MAX_PHONES  32
     
    9899        sysarg_t args[IPC_CALL_LEN];
    99100        /** Task which made or forwarded the call with IPC_FF_ROUTE_FROM_ME. */
    100         struct task *task;
     101        task_id_t task_id;
    101102        /** Phone which made or last masqueraded this call. */
    102103        phone_t *phone;
  • kernel/generic/src/ipc/event.c

    r903bac0a re2ab36f1  
    161161                                IPC_SET_ARG5(call->data, a5);
    162162                               
     163                                call->data.task_id = TASK ? TASK->taskid : 0;
     164                               
    163165                                irq_spinlock_lock(&event->answerbox->irq_lock, true);
    164166                                list_append(&call->link, &event->answerbox->irq_notifs);
  • kernel/generic/src/ipc/ipc.c

    r903bac0a re2ab36f1  
    294294                atomic_inc(&phone->active_calls);
    295295                call->data.phone = phone;
    296                 call->data.task = TASK;
     296                call->data.task_id = TASK->taskid;
    297297        }
    298298       
     
    406406                        call->caller_phone = call->data.phone;
    407407                call->data.phone = newphone;
    408                 call->data.task = TASK;
     408                call->data.task_id = TASK->taskid;
    409409        }
    410410       
  • kernel/generic/src/ipc/sysipc.c

    r903bac0a re2ab36f1  
    5454#include <mm/as.h>
    5555#include <print.h>
     56#include <macros.h>
    5657
    5758/**
     
    375376                                    IPC_GET_ARG2(*olddata),
    376377                                    IPC_GET_ARG3(*olddata),
    377                                     (sysarg_t) olddata->task,
    378                                     (sysarg_t) TASK);
     378                                    LOWER32(olddata->task_id),
     379                                    UPPER32(olddata->task_id));
    379380                                IPC_SET_RETVAL(answer->data, rc);
    380381                        }
  • uspace/lib/c/generic/async.c

    r903bac0a re2ab36f1  
    112112#include <mem.h>
    113113#include <stdlib.h>
     114#include <macros.h>
    114115#include "private/async.h"
    115116
     
    138139        link_t link;
    139140       
    140         sysarg_t in_task_hash;
     141        sysarg_t in_task_id;
    141142        atomic_t refcnt;
    142143        void *data;
     
    150151        link_t link;
    151152       
    152         /** Incoming client task hash. */
    153         sysarg_t in_task_hash;
     153        /** Incoming client task ID. */
     154        task_id_t in_task_id;
    154155       
    155156        /** Incoming phone hash. */
     
    283284{
    284285        assert(key);
     286        assert(keys == 2);
    285287        assert(item);
    286288       
    287289        client_t *client = hash_table_get_instance(item, client_t, link);
    288         return (key[0] == client->in_task_hash);
     290        return (key[0] == LOWER32(client->in_task_id) &&
     291            (key[1] == UPPER32(client->in_task_id)));
    289292}
    290293
     
    574577}
    575578
    576 static client_t *async_client_get(sysarg_t client_hash, bool create)
    577 {
    578         unsigned long key = client_hash;
     579static client_t *async_client_get(task_id_t client_id, bool create)
     580{
     581        unsigned long key[2] = {
     582                LOWER32(client_id),
     583                UPPER32(client_id),
     584        };
    579585        client_t *client = NULL;
    580586
    581587        futex_down(&async_futex);
    582         link_t *lnk = hash_table_find(&client_hash_table, &key);
     588        link_t *lnk = hash_table_find(&client_hash_table, key);
    583589        if (lnk) {
    584590                client = hash_table_get_instance(lnk, client_t, link);
     
    587593                client = malloc(sizeof(client_t));
    588594                if (client) {
    589                         client->in_task_hash = client_hash;
     595                        client->in_task_id = client_id;
    590596                        client->data = async_client_data_create();
    591597               
    592598                        atomic_set(&client->refcnt, 1);
    593                         hash_table_insert(&client_hash_table, &key, &client->link);
     599                        hash_table_insert(&client_hash_table, key, &client->link);
    594600                }
    595601        }
     
    602608{
    603609        bool destroy;
    604         unsigned long key = client->in_task_hash;
     610        unsigned long key[2] = {
     611                LOWER32(client->in_task_id),
     612                UPPER32(client->in_task_id)
     613        };
    605614       
    606615        futex_down(&async_futex);
    607616       
    608617        if (atomic_predec(&client->refcnt) == 0) {
    609                 hash_table_remove(&client_hash_table, &key, 1);
     618                hash_table_remove(&client_hash_table, key, 2);
    610619                destroy = true;
    611620        } else
     
    628637}
    629638
    630 void *async_get_client_data_by_hash(sysarg_t client_hash)
    631 {
    632         client_t *client = async_client_get(client_hash, false);
     639void *async_get_client_data_by_id(task_id_t client_id)
     640{
     641        client_t *client = async_client_get(client_id, false);
    633642        if (!client)
    634643                return NULL;
     
    641650}
    642651
    643 void async_put_client_data_by_hash(sysarg_t client_hash)
    644 {
    645         client_t *client = async_client_get(client_hash, false);
     652void async_put_client_data_by_id(task_id_t client_id)
     653{
     654        client_t *client = async_client_get(client_id, false);
    646655
    647656        assert(client);
     
    680689         */
    681690
    682         client_t *client = async_client_get(fibril_connection->in_task_hash, true);
     691        client_t *client = async_client_get(fibril_connection->in_task_id, true);
    683692        if (!client) {
    684693                ipc_answer_0(fibril_connection->callid, ENOMEM);
     
    737746 * particular fibrils.
    738747 *
    739  * @param in_task_hash  Identification of the incoming connection.
     748 * @param in_task_id    Identification of the incoming connection.
    740749 * @param in_phone_hash Identification of the incoming connection.
    741750 * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
     
    751760 *
    752761 */
    753 fid_t async_new_connection(sysarg_t in_task_hash, sysarg_t in_phone_hash,
     762fid_t async_new_connection(task_id_t in_task_id, sysarg_t in_phone_hash,
    754763    ipc_callid_t callid, ipc_call_t *call,
    755764    async_client_conn_t cfibril, void *carg)
     
    763772        }
    764773       
    765         conn->in_task_hash = in_task_hash;
     774        conn->in_task_id = in_task_id;
    766775        conn->in_phone_hash = in_phone_hash;
    767776        list_initialize(&conn->msg_queue);
     
    822831        case IPC_M_CONNECT_ME_TO:
    823832                /* Open new connection with fibril, etc. */
    824                 async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
     833                async_new_connection(call->in_task_id, IPC_GET_ARG5(*call),
    825834                    callid, call, client_connection, NULL);
    826835                return;
     
    970979{
    971980        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
    972             1, &client_hash_table_ops))
     981            2, &client_hash_table_ops))
    973982                abort();
    974983       
  • uspace/lib/c/include/async.h

    r903bac0a re2ab36f1  
    176176extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t);
    177177
    178 extern fid_t async_new_connection(sysarg_t, sysarg_t, ipc_callid_t,
     178extern fid_t async_new_connection(task_id_t, sysarg_t, ipc_callid_t,
    179179    ipc_call_t *, async_client_conn_t, void *);
    180180
     
    186186extern void async_set_client_data_destructor(async_client_data_dtor_t);
    187187extern void *async_get_client_data(void);
    188 extern void *async_get_client_data_by_hash(sysarg_t);
    189 extern void async_put_client_data_by_hash(sysarg_t);
     188extern void *async_get_client_data_by_id(task_id_t);
     189extern void async_put_client_data_by_id(task_id_t);
    190190
    191191extern void async_set_client_connection(async_client_conn_t);
  • uspace/lib/c/include/ipc/common.h

    r903bac0a re2ab36f1  
    3939#include <abi/ipc/ipc.h>
    4040#include <atomic.h>
     41#include <task.h>
    4142
    4243#define IPC_FLAG_BLOCKING  0x01
     
    4445typedef struct {
    4546        sysarg_t args[IPC_CALL_LEN];
    46         sysarg_t in_task_hash;
     47        task_id_t in_task_id;
    4748        sysarg_t in_phone_hash;
    4849} ipc_call_t;
  • uspace/srv/vfs/vfs.c

    r903bac0a re2ab36f1  
    3636 */
    3737
     38#include <vfs/vfs.h>
    3839#include <ipc/services.h>
    3940#include <abi/ipc/event.h>
     
    4748#include <as.h>
    4849#include <atomic.h>
    49 #include <vfs/vfs.h>
     50#include <macros.h>
    5051#include "vfs.h"
    5152
     
    143144        case VFS_TASK_STATE_CHANGE:
    144145                if (IPC_GET_ARG1(*call) == VFS_PASS_HANDLE)
    145                         vfs_pass_handle(IPC_GET_ARG4(*call),
    146                             IPC_GET_ARG5(*call), (int) IPC_GET_ARG2(*call));
     146                        vfs_pass_handle(
     147                            (task_id_t) MERGE_LOUP32(IPC_GET_ARG4(*call),
     148                            IPC_GET_ARG5(*call)), call->in_task_id,
     149                            (int) IPC_GET_ARG2(*call));
    147150                break;
    148151        default:
  • uspace/srv/vfs/vfs.h

    r903bac0a re2ab36f1  
    4141#include <bool.h>
    4242#include <ipc/vfs.h>
     43#include <task.h>
    4344
    4445#ifndef dprintf
     
    188189extern void vfs_client_data_destroy(void *);
    189190
    190 extern void vfs_pass_handle(sysarg_t, sysarg_t, int);
     191extern void vfs_pass_handle(task_id_t, task_id_t, int);
    191192extern int vfs_wait_handle_internal(void);
    192193
  • uspace/srv/vfs/vfs_file.c

    r903bac0a re2ab36f1  
    4444#include <fibril_synch.h>
    4545#include <adt/list.h>
     46#include <task.h>
    4647#include "vfs.h"
    4748
     
    346347}
    347348
    348 void vfs_pass_handle(sysarg_t donor_hash, sysarg_t acceptor_hash, int donor_fd)
     349void vfs_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
    349350{
    350351        vfs_client_data_t *donor_data = NULL;
     
    355356        int acceptor_fd;
    356357
    357         acceptor_data = async_get_client_data_by_hash(acceptor_hash);
     358        acceptor_data = async_get_client_data_by_id(acceptor_id);
    358359        if (!acceptor_data)
    359360                return;
     
    365366        bh->handle = -1;
    366367
    367         donor_data = async_get_client_data_by_hash(donor_hash);
     368        donor_data = async_get_client_data_by_id(donor_id);
    368369        if (!donor_data)
    369370                goto out;
     
    402403
    403404        if (donor_data)
    404                 async_put_client_data_by_hash(donor_hash);
     405                async_put_client_data_by_id(donor_id);
    405406        if (acceptor_data)
    406                 async_put_client_data_by_hash(acceptor_hash);
     407                async_put_client_data_by_id(acceptor_id);
    407408        if (donor_file)
    408409                _vfs_file_put(donor_data, donor_file);
Note: See TracChangeset for help on using the changeset viewer.