datapath: Fix kernel style issues.
[sliver-openvswitch.git] / lib / daemon-windows.c
1 /*
2  * Copyright (c) 2014 Nicira, Inc.
3  *
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:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  */
16
17 #include <config.h>
18 #include "daemon.h"
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include "poll-loop.h"
22 #include "vlog.h"
23
24 #pragma comment(lib, "advapi32")
25
26 VLOG_DEFINE_THIS_MODULE(daemon);
27
28 static bool detach;             /* Was --service specified? */
29 static bool detached;           /* Have we already detached? */
30
31 /* --service-monitor: Should the service be restarted if it dies
32  * unexpectedly? */
33 static bool monitor;
34
35 /* Handle to the Services Manager and the created service. */
36 static SC_HANDLE manager, service;
37
38 /* Handle to the status information structure for the current service. */
39 static SERVICE_STATUS_HANDLE hstatus;
40
41 /* Hold the service's current status. */
42 static SERVICE_STATUS service_status;
43
44 /* Handle to an event object used to wakeup from poll_block(). */
45 static HANDLE wevent;
46
47 /* Hold the arguments sent to the main function. */
48 static int sargc;
49 static char ***sargvp;
50
51 static void check_service(void);
52 static void handle_scm_callback(void);
53 static void init_service_status(void);
54 static void set_config_failure_actions(void);
55
56 extern int main(int argc, char *argv[]);
57
58 void
59 daemon_usage(void)
60 {
61     printf(
62         "\nService options:\n"
63         "  --service               run in background as a service.\n"
64         "  --service-monitor       restart the service in case of an "
65                                    "unexpected failure. \n",
66         ovs_rundir(), program_name);
67 }
68
69 /* Registers the call-back and configures the actions in case of a failure
70  * with the Windows services manager. */
71 void
72 service_start(int *argcp, char **argvp[])
73 {
74     int argc = *argcp;
75     char **argv = *argvp;
76     int i;
77     SERVICE_TABLE_ENTRY service_table[] = {
78         {(LPTSTR)program_name, (LPSERVICE_MAIN_FUNCTION)main},
79         {NULL, NULL}
80     };
81
82     /* 'detached' is 'false' when service_start() is called the first time.
83      * It is 'true', when it is called the second time by the Windows services
84      * manager. */
85     if (detached) {
86         init_service_status();
87
88         wevent = CreateEvent(NULL, TRUE, FALSE, NULL);
89         if (!wevent) {
90             char *msg_buf = ovs_lasterror_to_string();
91             VLOG_FATAL("Failed to create a event (%s).", msg_buf);
92         }
93
94         poll_fd_wait_event(0, wevent, POLLIN);
95
96         /* Register the control handler. This function is called by the service
97          * manager to stop the service. */
98         hstatus = RegisterServiceCtrlHandler(program_name,
99                                          (LPHANDLER_FUNCTION)control_handler);
100         if (!hstatus) {
101             char *msg_buf = ovs_lasterror_to_string();
102             VLOG_FATAL("Failed to register the service control handler (%s).",
103                         msg_buf);
104         }
105
106         if (monitor) {
107             set_config_failure_actions();
108         }
109
110         /* When the service control manager does the call back, it does not
111          * send the same arguments as sent to the main function during the
112          * service start. So, use the arguments passed over during the first
113          * time. */
114         *argcp = sargc;
115         *argvp = *sargvp;
116
117         /* XXX: Windows implementation cannot have a unixctl commands in the
118         * traditional sense of unix domain sockets. If an implementation is
119         * done that involves 'unixctl' vlog commands the following call is
120         * needed to make sure that the unixctl commands for vlog get
121         * registered in a daemon, even before the first log message. */
122         vlog_init();
123
124         return;
125     }
126
127     assert_single_threaded();
128
129     /* A reference to arguments passed to the main function the first time.
130      * We need it after the call-back from service control manager. */
131     sargc = argc;
132     sargvp = argvp;
133
134     /* We are only interested in the '--service' and '--service-monitor'
135      * options before the call-back from the service control manager. */
136     for (i = 0; i < argc; i ++) {
137         if (!strcmp(argv[i], "--service")) {
138             detach = true;
139         } else if (!strcmp(argv[i], "--service-monitor")) {
140             monitor = true;
141         }
142     }
143
144     /* If '--service' is not a command line option, run in foreground. */
145     if (!detach) {
146         return;
147     }
148
149     /* If we have been configured to run as a service, then that service
150      * should already have been created either manually or through a start up
151      * script. */
152     check_service();
153
154     detached = true;
155
156     /* StartServiceCtrlDispatcher blocks and returns after the service is
157      * stopped. */
158     if (!StartServiceCtrlDispatcher(service_table)) {
159         char *msg_buf = ovs_lasterror_to_string();
160         VLOG_FATAL("Failed at StartServiceCtrlDispatcher (%s)", msg_buf);
161     }
162     exit(0);
163 }
164
165 /* This function is registered with the Windows services manager through
166  * a call to RegisterServiceCtrlHandler() and will be called by the Windows
167  * services manager asynchronously to stop the service. */
168 void
169 control_handler(DWORD request)
170 {
171     switch (request) {
172     case SERVICE_CONTROL_STOP:
173     case SERVICE_CONTROL_SHUTDOWN:
174         service_status.dwCurrentState = SERVICE_STOPPED;
175         service_status.dwWin32ExitCode = NO_ERROR;
176         SetEvent(wevent);
177         break;
178
179     default:
180         break;
181     }
182 }
183
184 /* Return 'true' if the Windows services manager has called the
185  * control_handler() and asked the program to terminate. */
186 bool
187 should_service_stop(void)
188 {
189     if (detached) {
190         if (service_status.dwCurrentState != SERVICE_RUNNING) {
191             return true;
192         } else {
193             poll_fd_wait_event(0, wevent, POLLIN);
194         }
195     }
196     return false;
197 }
198
199 /* Set the service as stopped. The control manager will terminate the
200  * service soon after this call. Hence, this should ideally be the last
201  * call before termination. */
202 void
203 service_stop()
204 {
205     ResetEvent(wevent);
206     CloseHandle(wevent);
207
208     service_status.dwCurrentState = SERVICE_STOPPED;
209     service_status.dwWin32ExitCode = NO_ERROR;
210     SetServiceStatus(hstatus, &service_status);
211 }
212
213 /* Call this function to signal that the daemon is ready. init_service()
214  * or control_handler() has already initalized/set the
215  * service_status.dwCurrentState .*/
216 static void
217 service_complete(void)
218 {
219     if (hstatus) {
220         SetServiceStatus(hstatus, &service_status);
221     }
222 }
223
224 /* Check whether 'program_name' has been created as a service. */
225 static void
226 check_service()
227 {
228     /* Establish a connection to the local service control manager. */
229     manager = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
230     if (!manager) {
231         char *msg_buf = ovs_lasterror_to_string();
232         VLOG_FATAL("Failed to open the service control manager (%s).",
233                    msg_buf);
234     }
235
236     service = OpenService(manager, program_name, SERVICE_ALL_ACCESS);
237     if (!service) {
238         char *msg_buf = ovs_lasterror_to_string();
239         VLOG_FATAL("Failed to open service (%s).", msg_buf);
240     }
241 }
242
243 /* Service status of a service can be checked asynchronously through
244  * tools like 'sc' or through Windows services manager and is set
245  * through a call to SetServiceStatus(). */
246 static void
247 init_service_status()
248 {
249     /* The service runs in its own process. */
250     service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
251
252     /* The control codes the service accepts. */
253     service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP |
254                                             SERVICE_ACCEPT_SHUTDOWN;
255
256     /* Initialize the current state as SERVICE_RUNNING. */
257     service_status.dwCurrentState = SERVICE_RUNNING;
258
259     /* The exit code to indicate if there was an error. */
260     service_status.dwWin32ExitCode = NO_ERROR;
261
262     /* The checkpoint value the service increments periodically. Set as 0
263      * as we do not plan to periodically increment the value. */
264     service_status.dwCheckPoint = 0;
265
266     /* The estimated time required for the stop operation in ms. */
267     service_status.dwWaitHint = 1000;
268 }
269
270 /* In case of an unexpected termination, configure the action to be
271  * taken. */
272 static void
273 set_config_failure_actions()
274 {
275     /* In case of a failure, restart the process the first two times
276      * After 'dwResetPeriod', the failure count is reset. */
277     SC_ACTION fail_action[3] = {
278         {SC_ACTION_RESTART, 0},
279         {SC_ACTION_RESTART, 0},
280         {SC_ACTION_NONE, 0}
281     };
282     SERVICE_FAILURE_ACTIONS service_fail_action;
283
284     /* Reset failure count after (in seconds). */
285     service_fail_action.dwResetPeriod = 10;
286
287     /* Reboot message. */
288     service_fail_action.lpRebootMsg = NULL;
289
290     /* The command line of the process. */
291     service_fail_action.lpCommand = NULL;
292
293     /* Number of elements in 'fail_actions'. */
294     service_fail_action.cActions = sizeof(fail_action)/sizeof(fail_action[0]);
295
296     /* A pointer to an array of SC_ACTION structures. */
297     service_fail_action.lpsaActions = fail_action;
298
299     if (!ChangeServiceConfig2(service, SERVICE_CONFIG_FAILURE_ACTIONS,
300                               &service_fail_action)) {
301         char *msg_buf = ovs_lasterror_to_string();
302         VLOG_FATAL("Failed to configure service fail actions (%s).", msg_buf);
303     }
304 }
305
306 \f
307 /* Stub functions to handle daemonize related calls in non-windows platform. */
308 bool
309 get_detach()
310 {
311     return false;
312 }
313
314 void
315 daemon_save_fd(int fd OVS_UNUSED)
316 {
317 }
318
319 void
320 daemonize(void)
321 {
322 }
323
324 void daemonize_start(void)
325 {
326 }
327
328 void
329 daemonize_complete(void)
330 {
331     service_complete();
332 }