2 * Copyright (c) 2014, 2017 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include "daemon-private.h"
25 #include "fatal-signal.h"
26 #include "ovs-thread.h"
27 #include "openvswitch/poll-loop.h"
28 #include "openvswitch/vlog.h"
30 VLOG_DEFINE_THIS_MODULE(daemon_windows
);
32 /* Constants for flock function */
33 #define LOCK_SHARED 0x0 /* Shared lock. */
34 #define LOCK_UNLOCK 0x80000000 /* Unlock. Custom value. */
36 static bool service_create
; /* Was --service specified? */
37 static bool service_started
; /* Have we dispatched service to start? */
39 /* --service-monitor: Should the service be restarted if it dies
43 bool detach
; /* Was --detach specified? */
44 static bool detached
; /* Running as the child process. */
45 static HANDLE write_handle
; /* End of pipe to write to parent. */
47 char *pidfile
; /* --pidfile: Name of pidfile (null if none). */
48 static FILE *filep_pidfile
; /* File pointer to access the pidfile. */
50 /* Handle to the Services Manager and the created service. */
51 static SC_HANDLE manager
, service
;
53 /* Handle to the status information structure for the current service. */
54 static SERVICE_STATUS_HANDLE hstatus
;
56 /* Hold the service's current status. */
57 static SERVICE_STATUS service_status
;
59 /* Handle to an event object used to wakeup from poll_block(). */
62 /* Hold the arguments sent to the main function. */
64 static char ***sargvp
;
66 static void check_service(void);
67 static void handle_scm_callback(void);
68 static void init_service_status(void);
69 static void set_config_failure_actions(void);
71 static bool detach_process(int argc
, char *argv
[]);
73 extern int main(int argc
, char *argv
[]);
79 "\nService options:\n"
80 " --service run in background as a service.\n"
81 " --service-monitor restart the service in case of an "
82 "unexpected failure. \n");
85 /* Sets up a following call to service_start() to detach from the foreground
86 * session, running this process in the background. */
93 /* Registers the call-back and configures the actions in case of a failure
94 * with the Windows services manager. */
96 service_start(int *argcp
, char **argvp
[])
101 SERVICE_TABLE_ENTRY service_table
[] = {
102 {(LPTSTR
)program_name
, (LPSERVICE_MAIN_FUNCTION
)main
},
106 /* If one of the command line option is "--detach", we create
107 * a new process in case of parent, wait for child to start and exit.
108 * In case of the child, we just return. We should not be creating a
109 * service in either case. */
110 if (detach_process(argc
, argv
)) {
114 /* 'service_started' is 'false' when service_start() is called the first
115 * time. It is 'true', when it is called the second time by the Windows
116 * services manager. */
117 if (service_started
) {
118 init_service_status();
120 wevent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
122 char *msg_buf
= ovs_lasterror_to_string();
123 VLOG_FATAL("Failed to create a event (%s).", msg_buf
);
126 poll_wevent_wait(wevent
);
128 /* Register the control handler. This function is called by the service
129 * manager to stop the service. */
130 hstatus
= RegisterServiceCtrlHandler(program_name
,
131 (LPHANDLER_FUNCTION
)control_handler
);
133 char *msg_buf
= ovs_lasterror_to_string();
134 VLOG_FATAL("Failed to register the service control handler (%s).",
139 set_config_failure_actions();
142 /* When the service control manager does the call back, it does not
143 * send the same arguments as sent to the main function during the
144 * service start. So, use the arguments passed over during the first
149 /* Enable default error mode so we can take advantage of WER
150 * (Windows Error Reporting) crash dumps.
151 * Being a service it does not allow for WER window pop-up.
152 * XXX implement our on crash dump collection mechanism. */
158 assert_single_threaded();
160 /* A reference to arguments passed to the main function the first time.
161 * We need it after the call-back from service control manager. */
165 /* We are only interested in the '--service' and '--service-monitor'
166 * options before the call-back from the service control manager. */
167 for (i
= 0; i
< argc
; i
++) {
168 if (!strcmp(argv
[i
], "--service")) {
169 service_create
= true;
170 } else if (!strcmp(argv
[i
], "--service-monitor")) {
175 /* If '--service' is not a command line option, run in foreground. */
176 if (!service_create
) {
180 /* If we have been configured to run as a service, then that service
181 * should already have been created either manually or through a start up
185 service_started
= true;
187 /* StartServiceCtrlDispatcher blocks and returns after the service is
189 if (!StartServiceCtrlDispatcher(service_table
)) {
190 char *msg_buf
= ovs_lasterror_to_string();
191 VLOG_FATAL("Failed at StartServiceCtrlDispatcher (%s)", msg_buf
);
196 /* This function is registered with the Windows services manager through
197 * a call to RegisterServiceCtrlHandler() and will be called by the Windows
198 * services manager asynchronously to stop the service. */
200 control_handler(DWORD request
)
203 case SERVICE_CONTROL_STOP
:
204 case SERVICE_CONTROL_SHUTDOWN
:
205 service_status
.dwCurrentState
= SERVICE_STOPPED
;
206 service_status
.dwWin32ExitCode
= NO_ERROR
;
208 SetServiceStatus(hstatus
, &service_status
);
216 /* Return 'true' if the Windows services manager has called the
217 * control_handler() and asked the program to terminate. */
219 should_service_stop(void)
221 if (service_started
) {
222 if (service_status
.dwCurrentState
!= SERVICE_RUNNING
) {
225 poll_wevent_wait(wevent
);
231 /* Set the service as stopped. The control manager will terminate the
232 * service soon after this call. Hence, this should ideally be the last
233 * call before termination. */
237 if (!service_started
) {
240 fatal_signal_atexit_handler();
245 service_status
.dwCurrentState
= SERVICE_STOPPED
;
246 service_status
.dwWin32ExitCode
= NO_ERROR
;
247 SetServiceStatus(hstatus
, &service_status
);
250 /* Call this function to signal that the daemon is ready. init_service()
251 * or control_handler() has already initalized/set the
252 * service_status.dwCurrentState .*/
254 service_complete(void)
257 SetServiceStatus(hstatus
, &service_status
);
261 /* Check whether 'program_name' has been created as a service. */
265 /* Establish a connection to the local service control manager. */
266 manager
= OpenSCManager(NULL
, NULL
, SC_MANAGER_ENUMERATE_SERVICE
);
268 char *msg_buf
= ovs_lasterror_to_string();
269 VLOG_FATAL("Failed to open the service control manager (%s).",
273 service
= OpenService(manager
, program_name
, SERVICE_ALL_ACCESS
);
275 char *msg_buf
= ovs_lasterror_to_string();
276 VLOG_FATAL("Failed to open service (%s).", msg_buf
);
280 /* Service status of a service can be checked asynchronously through
281 * tools like 'sc' or through Windows services manager and is set
282 * through a call to SetServiceStatus(). */
284 init_service_status()
286 /* The service runs in its own process. */
287 service_status
.dwServiceType
= SERVICE_WIN32_OWN_PROCESS
;
289 /* The control codes the service accepts. */
290 service_status
.dwControlsAccepted
= SERVICE_ACCEPT_STOP
|
291 SERVICE_ACCEPT_SHUTDOWN
;
293 /* Initialize the current state as SERVICE_RUNNING. */
294 service_status
.dwCurrentState
= SERVICE_RUNNING
;
296 /* The exit code to indicate if there was an error. */
297 service_status
.dwWin32ExitCode
= NO_ERROR
;
299 /* The checkpoint value the service increments periodically. Set as 0
300 * as we do not plan to periodically increment the value. */
301 service_status
.dwCheckPoint
= 0;
303 /* The estimated time required for the stop operation in ms. */
304 service_status
.dwWaitHint
= 1000;
307 /* In case of an unexpected termination, configure the action to be
310 set_config_failure_actions()
312 /* In case of a failure, restart the process the first two times
313 * After 'dwResetPeriod', the failure count is reset. */
314 SC_ACTION fail_action
[3] = {
315 {SC_ACTION_RESTART
, 0},
316 {SC_ACTION_RESTART
, 0},
319 SERVICE_FAILURE_ACTIONS service_fail_action
;
321 /* Reset failure count after (in seconds). */
322 service_fail_action
.dwResetPeriod
= 10;
324 /* Reboot message. */
325 service_fail_action
.lpRebootMsg
= NULL
;
327 /* The command line of the process. */
328 service_fail_action
.lpCommand
= NULL
;
330 /* Number of elements in 'fail_actions'. */
331 service_fail_action
.cActions
= sizeof(fail_action
)/sizeof(fail_action
[0]);
333 /* A pointer to an array of SC_ACTION structures. */
334 service_fail_action
.lpsaActions
= fail_action
;
336 if (!ChangeServiceConfig2(service
, SERVICE_CONFIG_FAILURE_ACTIONS
,
337 &service_fail_action
)) {
338 char *msg_buf
= ovs_lasterror_to_string();
339 VLOG_FATAL("Failed to configure service fail actions (%s).", msg_buf
);
343 /* When a daemon is passed the --detach option, we create a new
344 * process and pass an additional non-documented option called --pipe-handle.
345 * Through this option, the parent passes one end of a pipe handle. */
347 set_pipe_handle(const char *pipe_handle
)
349 write_handle
= (HANDLE
) atoi(pipe_handle
);
352 /* If one of the command line option is "--detach", creates
353 * a new process in case of parent, waits for child to start and exits.
354 * In case of the child, returns. */
356 detach_process(int argc
, char *argv
[])
358 SECURITY_ATTRIBUTES sa
;
360 PROCESS_INFORMATION pi
;
361 HANDLE read_pipe
, write_pipe
;
366 /* We are only interested in the '--detach' and '--pipe-handle'. */
367 for (i
= 0; i
< argc
; i
++) {
368 if (!detach
&& !strcmp(argv
[i
], "--detach")) {
370 } else if (!strncmp(argv
[i
], "--pipe-handle", 13)) {
371 /* If running as a child, return. */
377 /* Nothing to do if the option --detach is not set. */
382 /* Set the security attribute such that a process created will
383 * inherit the pipe handles. */
384 sa
.nLength
= sizeof(sa
);
385 sa
.lpSecurityDescriptor
= NULL
;
386 sa
.bInheritHandle
= TRUE
;
388 /* Create an anonymous pipe to communicate with the child. */
389 error
= CreatePipe(&read_pipe
, &write_pipe
, &sa
, 0);
391 VLOG_FATAL("CreatePipe failed (%s)", ovs_lasterror_to_string());
396 /* To the child, we pass an extra argument '--pipe-handle=write_pipe' */
397 buffer
= xasprintf("%s %s=%ld", GetCommandLine(), "--pipe-handle",
400 /* Create a detached child */
401 error
= CreateProcess(NULL
, buffer
, NULL
, NULL
, TRUE
, DETACHED_PROCESS
,
402 NULL
, NULL
, &si
, &pi
);
404 VLOG_FATAL("CreateProcess failed (%s)", ovs_lasterror_to_string());
407 /* Close one end of the pipe in the parent. */
408 CloseHandle(write_pipe
);
410 /* Block and wait for child to say it is ready. */
411 error
= ReadFile(read_pipe
, &ch
, 1, NULL
, NULL
);
413 VLOG_FATAL("Failed to read from child (%s)",
414 ovs_lasterror_to_string());
416 /* The child has successfully started and is ready. */
421 flock(FILE* fd
, int operation
)
426 hFile
= (HANDLE
)_get_osfhandle(fileno(fd
));
427 if (hFile
== INVALID_HANDLE_VALUE
) {
428 VLOG_FATAL("Failed to get PID file handle (%s).",
429 ovs_strerror(errno
));
432 if (operation
& LOCK_UNLOCK
) {
433 if (UnlockFileEx(hFile
, 0, 1, 0, &ov
) == 0) {
434 VLOG_FATAL("Failed to unlock PID file (%s).",
435 ovs_lasterror_to_string());
438 /* Use LOCKFILE_FAIL_IMMEDIATELY flag to avoid hang of another daemon that tries to
439 acquire exclusive lock over the same PID file */
440 if (LockFileEx(hFile
, operation
| LOCKFILE_FAIL_IMMEDIATELY
,
441 0, 1, 0, &ov
) == FALSE
) {
442 VLOG_FATAL("Failed to lock PID file (%s).",
443 ovs_lasterror_to_string());
452 /* Remove the shared lock on file */
453 flock(filep_pidfile
, LOCK_UNLOCK
);
454 fclose(filep_pidfile
);
461 /* If a pidfile has been configured, creates it and stores the running
462 * process's pid in it. Ensures that the pidfile will be deleted when the
469 error
= GetFileAttributes(pidfile
);
470 if (error
!= INVALID_FILE_ATTRIBUTES
) {
471 /* pidfile exists. Try to unlink() it. */
472 error
= unlink(pidfile
);
474 VLOG_FATAL("Failed to delete existing pidfile %s (%s)", pidfile
,
475 ovs_strerror(errno
));
479 filep_pidfile
= fopen(pidfile
, "w");
480 if (filep_pidfile
== NULL
) {
481 VLOG_FATAL("failed to open %s (%s)", pidfile
, ovs_strerror(errno
));
484 flock(filep_pidfile
, LOCKFILE_EXCLUSIVE_LOCK
);
486 fatal_signal_add_hook(unlink_pidfile
, NULL
, NULL
, true);
488 fprintf(filep_pidfile
, "%ld\n", (long int) getpid());
489 if (fflush(filep_pidfile
) == EOF
) {
490 VLOG_FATAL("Failed to write into the pidfile %s", pidfile
);
493 flock(filep_pidfile
, LOCK_SHARED
);
494 /* This will remove the exclusive lock. The shared lock will remain */
495 flock(filep_pidfile
, LOCK_UNLOCK
);
497 /* Don't close the pidfile till the process exits. */
501 daemonize_start(bool access_datapath OVS_UNUSED
)
509 daemonize_complete(void)
511 /* If running as a child because '--detach' option was specified,
512 * communicate with the parent to inform that the child is ready. */
516 close_standard_fds();
518 error
= WriteFile(write_handle
, "a", 1, NULL
, NULL
);
520 VLOG_FATAL("Failed to communicate with the parent (%s)",
521 ovs_lasterror_to_string());
529 daemon_become_new_user(bool access_datapath OVS_UNUSED
)
533 /* Returns the file name that would be used for a pidfile if 'name' were
534 * provided to set_pidfile(). The caller must free the returned string. */
536 make_pidfile_name(const char *name
)
539 if (strchr(name
, ':')) {
540 return xstrdup(name
);
542 return xasprintf("%s/%s", ovs_rundir(), name
);
545 return xasprintf("%s/%s.pid", ovs_rundir(), program_name
);
550 daemon_set_new_user(const char *user_spec OVS_UNUSED
)
552 VLOG_FATAL("--user options is not currently supported.");