OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/common/service_process_util_posix.h" | 5 #include "chrome/common/service_process_util_posix.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/message_loop/message_loop_proxy.h" | 9 #include "base/message_loop/message_loop_proxy.h" |
10 #include "base/posix/eintr_wrapper.h" | 10 #include "base/posix/eintr_wrapper.h" |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
70 // not, but we don't ever expect it to be called. | 70 // not, but we don't ever expect it to be called. |
71 static void SigTermHandler(int sig, siginfo_t* info, void* uap) { | 71 static void SigTermHandler(int sig, siginfo_t* info, void* uap) { |
72 // TODO(dmaclach): add security here to make sure that we are being shut | 72 // TODO(dmaclach): add security here to make sure that we are being shut |
73 // down by an appropriate process. | 73 // down by an appropriate process. |
74 int message = ServiceProcessTerminateMonitor::kTerminateMessage; | 74 int message = ServiceProcessTerminateMonitor::kTerminateMessage; |
75 if (write(g_signal_socket, &message, sizeof(message)) < 0) { | 75 if (write(g_signal_socket, &message, sizeof(message)) < 0) { |
76 DPLOG(ERROR) << "write"; | 76 DPLOG(ERROR) << "write"; |
77 } | 77 } |
78 } | 78 } |
79 | 79 |
80 ServiceProcessState::StateData::StateData() : set_action_(false) { | 80 ServiceProcessState::StateData::StateData() : set_action(false) { |
81 memset(sockets_, -1, sizeof(sockets_)); | 81 memset(sockets, -1, sizeof(sockets)); |
82 memset(&old_action_, 0, sizeof(old_action_)); | 82 memset(&old_action, 0, sizeof(old_action)); |
83 } | 83 } |
84 | 84 |
85 void ServiceProcessState::StateData::SignalReady(base::WaitableEvent* signal, | 85 void ServiceProcessState::StateData::SignalReady(base::WaitableEvent* signal, |
86 bool* success) { | 86 bool* success) { |
87 DCHECK_EQ(g_signal_socket, -1); | 87 DCHECK_EQ(g_signal_socket, -1); |
88 DCHECK(!signal->IsSignaled()); | 88 DCHECK(!signal->IsSignaled()); |
89 *success = base::MessageLoopForIO::current()->WatchFileDescriptor( | 89 *success = base::MessageLoopForIO::current()->WatchFileDescriptor( |
90 sockets_[0], | 90 sockets[0], |
91 true, | 91 true, |
92 base::MessageLoopForIO::WATCH_READ, | 92 base::MessageLoopForIO::WATCH_READ, |
93 &watcher_, | 93 &watcher, |
94 terminate_monitor_.get()); | 94 terminate_monitor.get()); |
95 if (!*success) { | 95 if (!*success) { |
96 DLOG(ERROR) << "WatchFileDescriptor"; | 96 DLOG(ERROR) << "WatchFileDescriptor"; |
97 signal->Signal(); | 97 signal->Signal(); |
98 return; | 98 return; |
99 } | 99 } |
100 g_signal_socket = sockets_[1]; | 100 g_signal_socket = sockets[1]; |
101 | 101 |
102 // Set up signal handler for SIGTERM. | 102 // Set up signal handler for SIGTERM. |
103 struct sigaction action; | 103 struct sigaction action; |
104 memset(&action, 0, sizeof(action)); | 104 memset(&action, 0, sizeof(action)); |
105 action.sa_sigaction = SigTermHandler; | 105 action.sa_sigaction = SigTermHandler; |
106 sigemptyset(&action.sa_mask); | 106 sigemptyset(&action.sa_mask); |
107 action.sa_flags = SA_SIGINFO; | 107 action.sa_flags = SA_SIGINFO; |
108 *success = sigaction(SIGTERM, &action, &old_action_) == 0; | 108 *success = sigaction(SIGTERM, &action, &old_action) == 0; |
109 if (!*success) { | 109 if (!*success) { |
110 DPLOG(ERROR) << "sigaction"; | 110 DPLOG(ERROR) << "sigaction"; |
111 signal->Signal(); | 111 signal->Signal(); |
112 return; | 112 return; |
113 } | 113 } |
114 | 114 |
115 // If the old_action is not default, somebody else has installed a | 115 // If the old_action is not default, somebody else has installed a |
116 // a competing handler. Our handler is going to override it so it | 116 // a competing handler. Our handler is going to override it so it |
117 // won't be called. If this occurs it needs to be fixed. | 117 // won't be called. If this occurs it needs to be fixed. |
118 DCHECK_EQ(old_action_.sa_handler, SIG_DFL); | 118 DCHECK_EQ(old_action.sa_handler, SIG_DFL); |
119 set_action_ = true; | 119 set_action = true; |
120 | 120 |
121 #if defined(OS_MACOSX) | 121 #if defined(OS_MACOSX) |
122 *success = WatchExecutable(); | 122 *success = WatchExecutable(); |
123 if (!*success) { | 123 if (!*success) { |
124 DLOG(ERROR) << "WatchExecutable"; | 124 DLOG(ERROR) << "WatchExecutable"; |
125 signal->Signal(); | 125 signal->Signal(); |
126 return; | 126 return; |
127 } | 127 } |
128 #elif defined(OS_POSIX) | 128 #elif defined(OS_POSIX) |
129 initializing_lock_.reset(); | 129 initializing_lock.reset(); |
130 #endif // OS_POSIX | 130 #endif // OS_POSIX |
131 signal->Signal(); | 131 signal->Signal(); |
132 } | 132 } |
133 | 133 |
134 ServiceProcessState::StateData::~StateData() { | 134 ServiceProcessState::StateData::~StateData() { |
135 if (sockets_[0] != -1) { | 135 if (sockets[0] != -1) { |
136 if (IGNORE_EINTR(close(sockets_[0]))) { | 136 if (IGNORE_EINTR(close(sockets[0]))) { |
137 DPLOG(ERROR) << "close"; | 137 DPLOG(ERROR) << "close"; |
138 } | 138 } |
139 } | 139 } |
140 if (sockets_[1] != -1) { | 140 if (sockets[1] != -1) { |
141 if (IGNORE_EINTR(close(sockets_[1]))) { | 141 if (IGNORE_EINTR(close(sockets[1]))) { |
142 DPLOG(ERROR) << "close"; | 142 DPLOG(ERROR) << "close"; |
143 } | 143 } |
144 } | 144 } |
145 if (set_action_) { | 145 if (set_action) { |
146 if (sigaction(SIGTERM, &old_action_, NULL) < 0) { | 146 if (sigaction(SIGTERM, &old_action, NULL) < 0) { |
147 DPLOG(ERROR) << "sigaction"; | 147 DPLOG(ERROR) << "sigaction"; |
148 } | 148 } |
149 } | 149 } |
150 g_signal_socket = -1; | 150 g_signal_socket = -1; |
151 } | 151 } |
152 | 152 |
153 void ServiceProcessState::CreateState() { | 153 void ServiceProcessState::CreateState() { |
154 DCHECK(!state_); | 154 DCHECK(!state_); |
155 state_ = new StateData; | 155 state_ = new StateData; |
156 | 156 |
157 // Explicitly adding a reference here (and removing it in TearDownState) | 157 // Explicitly adding a reference here (and removing it in TearDownState) |
158 // because StateData is refcounted on Mac and Linux so that methods can | 158 // because StateData is refcounted on Mac and Linux so that methods can |
159 // be called on other threads. | 159 // be called on other threads. |
160 // It is not refcounted on Windows at this time. | 160 // It is not refcounted on Windows at this time. |
161 state_->AddRef(); | 161 state_->AddRef(); |
162 } | 162 } |
163 | 163 |
164 bool ServiceProcessState::SignalReady( | 164 bool ServiceProcessState::SignalReady( |
165 base::MessageLoopProxy* message_loop_proxy, | 165 base::MessageLoopProxy* message_loop_proxy, |
166 const base::Closure& terminate_task) { | 166 const base::Closure& terminate_task) { |
167 DCHECK(state_); | 167 DCHECK(state_); |
168 | 168 |
169 #if defined(OS_POSIX) && !defined(OS_MACOSX) | 169 #if defined(OS_POSIX) && !defined(OS_MACOSX) |
170 state_->running_lock_.reset(TakeServiceRunningLock(true)); | 170 state_->running_lock.reset(TakeServiceRunningLock(true)); |
171 if (state_->running_lock_.get() == NULL) { | 171 if (state_->running_lock.get() == NULL) { |
172 return false; | 172 return false; |
173 } | 173 } |
174 #endif | 174 #endif |
175 state_->terminate_monitor_.reset( | 175 state_->terminate_monitor.reset( |
176 new ServiceProcessTerminateMonitor(terminate_task)); | 176 new ServiceProcessTerminateMonitor(terminate_task)); |
177 if (pipe(state_->sockets_) < 0) { | 177 if (pipe(state_->sockets) < 0) { |
178 DPLOG(ERROR) << "pipe"; | 178 DPLOG(ERROR) << "pipe"; |
179 return false; | 179 return false; |
180 } | 180 } |
181 base::WaitableEvent signal_ready(true, false); | 181 base::WaitableEvent signal_ready(true, false); |
182 bool success = false; | 182 bool success = false; |
183 | 183 |
184 message_loop_proxy->PostTask(FROM_HERE, | 184 message_loop_proxy->PostTask(FROM_HERE, |
185 base::Bind(&ServiceProcessState::StateData::SignalReady, | 185 base::Bind(&ServiceProcessState::StateData::SignalReady, |
186 state_, | 186 state_, |
187 &signal_ready, | 187 &signal_ready, |
188 &success)); | 188 &success)); |
189 signal_ready.Wait(); | 189 signal_ready.Wait(); |
190 return success; | 190 return success; |
191 } | 191 } |
192 | 192 |
193 void ServiceProcessState::TearDownState() { | 193 void ServiceProcessState::TearDownState() { |
194 if (state_) { | 194 if (state_) { |
195 state_->Release(); | 195 state_->Release(); |
196 state_ = NULL; | 196 state_ = NULL; |
197 } | 197 } |
198 } | 198 } |
OLD | NEW |