Changeset 18622

Timestamp:

08/24/06 18:58:48 (2 years ago)

Author:

axeld

Message:

Process groups are no longer searched via their team/session, but by using a separate
hash. This also allows them to stay valid after the group leader died when there are
other teams left in it. This closes bug #1.

Location:

haiku/trunk

Files:

• headers/private/kernel/thread_types.h (modified) (2 diffs)
• src/system/kernel/team.c (modified) (12 diffs)

haiku/trunk/headers/private/kernel/thread_types.h

@@ -58 +58 @@
 struct process_session {
         pid_t                           id;
-        struct list                     groups;
+        int32                           group_count;
 };
 
 struct process_group {
-        struct list_link        link;
+        struct process_group *next;     // next in hash
         struct process_session *session;
         pid_t                           id;
@@ -87 +87 @@
 
 struct team {
-        struct team             *next;                  /* next team in the hash */
+        struct team             *next;                  // next in hash
         struct team             *siblings_next;
         struct team             *parent;

haiku/trunk/src/system/kernel/team.c

@@ -64 +64 @@
 
 
-// team list
 static void *sTeamHash = NULL;
+static void *sGroupHash = NULL;
 static struct team *sKernelTeam = NULL;
 
@@ -83 +83 @@
 static int team_struct_compare(void *_p, const void *_key);
 static uint32 team_struct_hash(void *_p, const void *_key, uint32 range);
+static int process_group_compare(void *_p, const void *_key);
+static uint32 process_group_hash(void *_p, const void *_key, uint32 range);
 static void free_strings_array(char **strings, int32 count);
 static status_t user_copy_strings_array(char * const *strings, int32 count, char ***_strings);
@@ -176 +178 @@
 
         // create the team hash table
-        sTeamHash = hash_init(15, offsetof(struct team, next),
+        sTeamHash = hash_init(16, offsetof(struct team, next),
                 &team_struct_compare, &team_struct_hash);
+
+        sGroupHash = hash_init(16, offsetof(struct process_group, next),
+                &process_group_compare, &process_group_hash);
 
         // create initial session and process groups
@@ -362 +367 @@
 
 
+static int
+process_group_compare(void *_group, const void *_key)
+{
+        struct process_group *group = _group;
+        const struct team_key *key = _key;
+
+        if (group->id == key->id)
+                return 0;
+
+        return 1;
+}
+
+
+static uint32
+process_group_hash(void *_group, const void *_key, uint32 range)
+{
+        struct process_group *group = _group;
+        const struct team_key *key = _key;
+
+        if (group != NULL)
+                return group->id % range;
+
+        return (uint32)key->id % range;
+}
+
+
 /** Quick check to see if we have a valid team ID.
  */
@@ -390 +421 @@
 {
         struct team_key key;
-
         key.id = id;
 
@@ -483 +513 @@
 
 
+/**     You must hold the team lock when calling this function. */
+
 static void
 insert_group_into_session(struct process_session *session, struct process_group *group)
@@ -490 +522 @@
 
         group->session = session;
-        list_add_link_to_tail(&session->groups, group);
-}
-
+        hash_insert(sGroupHash, group);
+        session->group_count++;
+}
+
+
+/**     You must hold the team lock when calling this function. */
 
 static void
@@ -521 +556 @@
                 return;
 
-        list_remove_link(group);
+        hash_remove(sGroupHash, group);
 
         // we cannot free the resource here, so we're keeping the group link
         // around - this way it'll be freed by free_process_group()
-        if (!list_is_empty(&session->groups))
+        if (--session->group_count > 0)
                 group->session = NULL;
 }
@@ -633 +668 @@
 
         session->id = id;
-        list_init(&session->groups);
+        session->group_count = 0;
 
         return session;
@@ -1518 +1553 @@
 get_process_group_locked(struct team *team, pid_t id)
 {
-        struct list *groups = &team->group->session->groups;
-        struct process_group *group = NULL;
-        
-        // ToDo: a process group lasts as long as its last member - and
-        //      that doesn't have to be the process leader. IOW we need
-        //      a separate hash table for those groups without a leader.
-
-        // a short cut when the current team's group is asked for
-        if (team->group->id == id)
-                return team->group;
-
-        while ((group = list_get_next_item(groups, group)) != NULL) {
-                if (group->id == id)
-                        return group;
-        }
+        struct process_group *group;
+        struct team_key key;
+        key.id = id;
+
+        group = (struct process_group *)hash_lookup(sGroupHash, &key);
+        if (group != NULL && team->group->session == group->session)
+                return group;
 
         return NULL;
@@ -2338 +2365 @@
                         insert_team_into_group(group, team);
                 } else {
-                        struct process_session *session = team->group->session;
-                        struct process_group *group = NULL;
-
                         // check if this team can have the group ID; there must be one matching
                         // process ID in the team's session
 
-                        while ((group = list_get_next_item(&session->groups, group)) != NULL) {
-                                if (group->id == groupID)
-                                        break;
-                        }
-
+                        struct process_group *group = get_process_group_locked(team, groupID);
                         if (group) {
                                 // we got a group, let's move the team there
@@ -2362 +2382 @@
         restore_interrupts(state);
 
-        if (status != B_OK && group != NULL)
+        if (status != B_OK && group != NULL) {
+                // in case of error, the group hasn't been added into the hash
                 team_delete_process_group(group);
+        }
 
         team_delete_process_group(freeGroup);