Changeset 22185

Timestamp:

09/05/07 15:36:38 (15 months ago)

Author:

bonefish

Message:

* Some cleanup in _user_setpgid() (use of autolocking, don't use

shadowing variables).

* Resolved TODO: We wake up the parent if waiting in wait_for_child()

now, if the process group changes.

* Added another TODO: setpgid() is supposed to fail on a child after

it has executed exec*().

Files:

• haiku/trunk/src/system/kernel/team.cpp (modified) (6 diffs)

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

@@ -2412 +2412 @@
         struct thread *thread = thread_get_current_thread();
         struct team *currentTeam = thread->team;
-        struct process_group *group = NULL, *freeGroup = NULL;
         struct team *team;
-        cpu_status state;
         team_id teamID = -1;
-        status_t status = B_OK;
-
-        // TODO: we might want to notify waiting wait_for_child() threads in case
-        //      they wait for children of the former process group ID (see wait_test_4.cpp)
 
         if (groupID < 0)
@@ -2440 +2434 @@
                         return B_NOT_ALLOWED;
                 }
-
-                status = B_OK;
         } else {
-                state = disable_interrupts();
-                GRAB_THREAD_LOCK();
+                InterruptsSpinLocker _(thread_spinlock);
 
                 thread = thread_get_thread_struct_locked(processID);
@@ -2450 +2441 @@
                 // the thread must be the team's main thread, as that
                 // determines its process ID
-                if (thread != NULL && thread == thread->team->main_thread) {
-                        // check if the thread is in a child team of the calling team and
-                        // if it's already a process group leader and in the same session
-                        if (thread->team->parent != currentTeam
-                                || is_process_group_leader(thread->team)
-                                || thread->team->session_id != currentTeam->session_id)
-                                status = B_NOT_ALLOWED;
-                        else
-                                teamID = thread->team->id;
-                } else
-                        status = B_BAD_THREAD_ID;
-
-                RELEASE_THREAD_LOCK();
-                restore_interrupts(state);
-        }
-
-        if (status != B_OK)
-                return status;
+                if (thread == NULL && thread != thread->team->main_thread)
+                        return B_BAD_THREAD_ID;
+
+                // check if the thread is in a child team of the calling team and
+                // if it's already a process group leader and in the same session
+                if (thread->team->parent != currentTeam
+                        || is_process_group_leader(thread->team)
+                        || thread->team->session_id != currentTeam->session_id) {
+                        return B_NOT_ALLOWED;
+                }
+
+                // TODO: According to the standard, the call is also supposed to fail
+                // on a child, when the child already has executed exec*().
+
+                teamID = thread->team->id;
+        }
 
         // if the group ID is not specified, a new group should be created
@@ -2473 +2462 @@
                 groupID = processID;
 
+        struct process_group *group = NULL;
         if (groupID == processID) {
                 // We need to create a new process group for this team
@@ -2480 +2470 @@
         }
 
-        state = disable_interrupts();
-        GRAB_TEAM_LOCK();
+        status_t status = B_OK;
+        struct process_group *freeGroup = NULL;
+
+        InterruptsSpinLocker locker(team_spinlock);
 
         team = team_get_team_struct_locked(teamID);
         if (team != NULL) {
                 if (processID == groupID) {
-                        // we created a new process group, let us insert it into the team's session
+                        // we created a new process group, let us insert it into the team's
+                        // session
                         insert_group_into_session(team->group->session, group);
                         remove_team_from_group(team, &freeGroup);
                         insert_team_into_group(group, team);
                 } else {
-                        // check if this team can have the group ID; there must be one matching
-                        // process ID in the team's session
-
-                        struct process_group *group =
+                        // check if this team can have the group ID; there must be one
+                        // matching process ID in the team's session
+
+                        struct process_group *targetGroup =
                                 team_get_process_group_locked(team->group->session, groupID);
-                        if (group) {
+                        if (targetGroup != NULL) {
                                 // we got a group, let's move the team there
                                 remove_team_from_group(team, &freeGroup);
-                                insert_team_into_group(group, team);
+                                insert_team_into_group(targetGroup, team);
                         } else
                                 status = B_NOT_ALLOWED;
@@ -2506 +2499 @@
                 status = B_NOT_ALLOWED;
 
-        RELEASE_TEAM_LOCK();
-        restore_interrupts(state);
+        // Changing the process group might have changed the situation for a parent
+        // waiting in wait_for_child(). Hence we notify it.
+        if (status == B_OK) {
+                team->parent->dead_children->condition_variable.NotifyAll(false);
+                team->parent->stopped_children->condition_variable.NotifyAll(false);
+                team->parent->continued_children->condition_variable.NotifyAll(false);
+        }
+
+        locker.Unlock();
 
         if (status != B_OK && group != NULL) {