Changeset 62273d1 in mainline for uspace/srv

Timestamp:

2019-08-07T04:27:24Z (6 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

2f44fafd

Parents:

70d28e8

git-author:

Michal Koutný <xm.koutny+hos@…> (2015-10-08 21:46:22)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-07 04:27:24)

Message:

taskman: Implement simple task exit monitoring

Location:

uspace/srv/taskman

Files:

• main.c (modified) (6 diffs)
• task.c (modified) (6 diffs)
• task.h (modified) (1 diff)

uspace/srv/taskman/main.c

@@ -79 +79 @@
         async_exchange_end(exch);
 
+        // TODO leak? what happens with referenced sessions
         free(sess_ref);
 
@@ -116 +117 @@
         int rc = task_set_retval(icall);
         async_answer_0(iid, rc);
+}
+
+static void task_exit_event(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+        printf("%s:%i\n", __func__, __LINE__);
+        // TODO design substitution for taskmon (monitoring)
+        task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall));
+        task_terminated(id, (task_exit_t)arg);
 }
 
@@ -161 +170 @@
                 async_answer_0(iid, ENOMEM);
         }
-        
 
         /* Create callback connection */
@@ -170 +178 @@
                 return;
         }
+
+        /* Remember task_id */
+        int rc = task_id_intro(icall);
+
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                free(sess_ref);
+                return;
+        }
         async_answer_0(iid, EOK);
 
+        /* Notify spawners */
         link_initialize(&sess_ref->link);
         prodcons_produce(&sess_queue, &sess_ref->link);
@@ -220 +238 @@
         printf(NAME ": HelenOS task manager\n");
 
+        /* Initialization */
         prodcons_initialize(&sess_queue);
         int rc = task_init();
@@ -226 +245 @@
         }
 
+        rc = async_event_subscribe(EVENT_EXIT, task_exit_event, (void *)EVENT_EXIT);
+        if (rc != EOK) {
+                printf("Cannot register for exit events (%i).\n", rc);
+                return rc;
+        }
+
+        rc = async_event_subscribe(EVENT_FAULT, task_exit_event, (void *)EVENT_FAULT);
+        if (rc != EOK) {
+                printf("Cannot register for fault events (%i).\n", rc);
+                return rc;
+        }
+
         /* We're service too */
         rc = service_register(SERVICE_TASKMAN);
         if (rc != EOK) {
-                printf("Cannot register at naming service (%i).", rc);
+                printf("Cannot register at naming service (%i).\n", rc);
                 return rc;
         }

uspace/srv/taskman/task.c

@@ -52 +52 @@
         
         task_id_t id;    /**< Task ID. */
-        bool finished;   /**< Task is done. */
+        task_exit_t exit;/**< Task is done. */
         bool have_rval;  /**< Task returned a value. */
         int retval;      /**< The return value. */
@@ -185 +185 @@
                 
                 hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link);
-                if (!ht->finished)
+                if (ht->exit == TASK_EXIT_RUNNING)
                         continue;
                 
                 if (!(pr->callid & IPC_CALLID_NOTIFICATION)) {
-                        texit = ht->have_rval ? TASK_EXIT_NORMAL :
-                            TASK_EXIT_UNEXPECTED;
+                        texit = ht->exit;
                         async_answer_2(pr->callid, EOK, texit,
                             ht->retval);
@@ -216 +215 @@
         }
         
-        if (ht->finished) {
-                task_exit_t texit = ht->have_rval ? TASK_EXIT_NORMAL :
-                    TASK_EXIT_UNEXPECTED;
+        if (ht->exit != TASK_EXIT_RUNNING) {
+                task_exit_t texit = ht->exit;
                 async_answer_2(callid, EOK, texit, ht->retval);
                 return;
@@ -242 +240 @@
 }
 
-int ns_task_id_intro(ipc_call_t *call)
-{
-        
-        task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
-
-        ht_link_t *link = hash_table_find(&phone_to_id, &call->in_phone_hash);
+int task_id_intro(ipc_call_t *call)
+{
+        // TODO think about task_id reuse and this
+        // R lock
+        ht_link_t *link = hash_table_find(&task_hash_table, &call->in_task_id);
+        // R unlock
         if (link != NULL)
                 return EEXISTS;
-        
-        p2i_entry_t *entry = (p2i_entry_t *) malloc(sizeof(p2i_entry_t));
-        if (entry == NULL)
-                return ENOMEM;
         
         hashed_task_t *ht = (hashed_task_t *) malloc(sizeof(hashed_task_t));
         if (ht == NULL)
                 return ENOMEM;
-        
-        /*
-         * Insert into the phone-to-id map.
-         */
-        
-        entry->in_phone_hash = call->in_phone_hash;
-        entry->id = id;
-        hash_table_insert(&phone_to_id, &entry->link);
-        
+
         /*
          * Insert into the main table.
          */
-        
-        ht->id = id;
-        ht->finished = false;
+        ht->id = call->in_task_id;
+        ht->exit = TASK_EXIT_RUNNING;
         ht->have_rval = false;
         ht->retval = -1;
+        // W lock
         hash_table_insert(&task_hash_table, &ht->link);
-        
-        return EOK;
-}
-
-static int get_id_by_phone(sysarg_t phone_hash, task_id_t *id)
-{
-        ht_link_t *link = hash_table_find(&phone_to_id, &phone_hash);
-        if (link == NULL)
-                return ENOENT;
-        
-        p2i_entry_t *entry = hash_table_get_inst(link, p2i_entry_t, link);
-        *id = entry->id;
+        // W unlock
         
         return EOK;
@@ -302 +277 @@
             hash_table_get_inst(link, hashed_task_t, link) : NULL;
         
-        if ((ht == NULL) || (ht->finished))
-                return EOK; // TODO EINVAL when registration works;
-        
-        ht->finished = true;
+        if ((ht == NULL) || (ht->exit != TASK_EXIT_RUNNING))
+                return EINVAL;
+        
+        // TODO process additional flag to retval
         ht->have_rval = true;
         ht->retval = IPC_GET_ARG1(*call);
@@ -314 +289 @@
 }
 
-int ns_task_disconnect(ipc_call_t *call)
-{
-        task_id_t id;
-        int rc = get_id_by_phone(call->in_phone_hash, &id);
-        if (rc != EOK)
-                return rc;
-        
-        /* Delete from phone-to-id map. */
-        hash_table_remove(&phone_to_id, &call->in_phone_hash);
-        
+void task_terminated(task_id_t id, task_exit_t texit)
+{
         /* Mark task as finished. */
+        // R lock
         ht_link_t *link = hash_table_find(&task_hash_table, &id);
+        // R unlock
         if (link == NULL)
-                return EOK;
+                return;
 
         hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link);
         
-        ht->finished = true;
-        
+        ht->exit = texit;
         process_pending_wait();
-        hash_table_remove(&task_hash_table, &id);
-        
-        return EOK;
+
+        // W lock
+        hash_table_remove_item(&task_hash_table, &ht->link);
+        // W unlock
 }
 

uspace/srv/taskman/task.h

@@ -44 +44 @@
 extern int task_set_retval(ipc_call_t *);
 
-extern int ns_task_id_intro(ipc_call_t *);
-extern int ns_task_disconnect(ipc_call_t *);
-
+extern int task_id_intro(ipc_call_t *);
+extern void task_terminated(task_id_t, task_exit_t);
 
 #endif