generic/60[78]: ensure the initial DAX file flag state before test
[xfstests-dev.git] / dmapi / src / sample_hsm / migin.c
1 /*
2  * Master migration daemon
3  *
4  * The master migration daemon waits for events on a file and
5  * spawns a child process to handle the event
6  *
7  * This code was written by Peter Lawthers, and placed in the public
8  * domain for use by DMAPI implementors and app writers.
9  *
10  * Standard disclaimer:
11  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
12  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
13  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
14  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
15  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
16  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
17  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
18  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
19  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
20  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
21  * SUCH DAMAGE.
22  */
23
24 #include <sys/types.h>
25 #include <sys/time.h>
26 #include <sys/resource.h>
27 #include <sys/wait.h>
28
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include <string.h>
32 #include <signal.h>
33
34 #include <lib/hsm.h>
35
36 extern char     *optarg;
37 extern int       optind, optopt, opterr;
38 extern int       errno;
39 char            *Progname;
40 int              Verbose;
41 dm_sessid_t      sid = DM_NO_SESSION;
42
43 extern int       setup_dmapi(dm_sessid_t *);
44 extern void      err_msg(char *, ...);
45 extern void      errno_msg(char *, ...);
46
47 void             event_loop(dm_sessid_t);
48 int              set_events(dm_sessid_t, void *, size_t);
49 int              mk_daemon(char *);
50 void             spawn_kid(dm_sessid_t, dm_token_t, char *);
51 void             migin_exit(int);
52 void             usage(char *);
53 void             setup_signals();
54
55
56 void
57 usage(
58         char *prog)
59 {
60         fprintf(stderr, "Usage: %s ", prog);
61         fprintf(stderr, " <-v verbose> ");
62         fprintf(stderr, " <-l logfile> ");
63         fprintf(stderr, "filesystem \n");
64 }
65
66
67 int
68 main(
69         int     argc, 
70         char    *argv[])
71 {
72         
73         int              c;
74         int              error;
75         char            *fsname, *logfile;
76         void            *fs_hanp;
77         size_t           fs_hlen;
78
79
80         Progname  = argv[0];
81         fsname  = NULL;
82         logfile = NULL;
83
84         while ((c = getopt(argc, argv, "vl:")) != EOF) {
85                 switch (c) {
86                 case 'v':
87                         Verbose = 1;
88                         break;
89                 case 'l':
90                         logfile = optarg;
91                         break;
92                 case '?':
93                 default:
94                         usage(Progname);
95                         exit(1);
96                 }
97         }
98         if (optind >= argc) {
99                 usage(Progname);
100                 exit(1);
101         }
102         fsname = argv[optind];
103         if (fsname == NULL) {
104                 usage(Progname);
105                 exit(1);
106         }
107         /*
108          * If no logfile name is specified, we'll just send
109          * all output to some file in /tmp
110          */
111         if (logfile == NULL)
112                 logfile = LOG_DEFAULT;
113          
114
115         /*
116          * Turn ourselves into a daemon
117          */
118         if (!Verbose){
119                 error = mk_daemon(logfile);
120                 if (error) 
121                         exit(1);
122         }
123         setup_signals();
124         
125         /*
126          * Now we have our filesystem name and possibly a size threshold
127          * to look for. Init the dmapi, and get a filesystem handle so
128          * we can set up our events
129          */
130         error = setup_dmapi(&sid);
131         if (error) 
132                 exit(1);
133         
134         if (dm_path_to_fshandle(fsname, &fs_hanp, &fs_hlen) == -1) {
135                 errno_msg("Can't get filesystem handle");
136                 exit(1);
137         }
138
139
140         /*
141          * Set the event disposition so that our session will receive 
142          * the managed region events (read, write, and truncate)
143          */
144         error = set_events(sid, fs_hanp, fs_hlen);
145         if (error) 
146                 exit(1);
147         
148
149         /*
150          * Now wait forever for messages, spawning kids to
151          * do the actual work
152          */
153         event_loop(sid);
154         return(0);
155 }
156
157 /*
158  * Main event loop processing
159  */
160 void
161 event_loop(
162         dm_sessid_t     sid)
163 {
164         void            *msgbuf;
165         size_t           bufsize, rlen;
166         int              error;
167         dm_eventmsg_t   *msg;
168
169         /*
170          * We take a swag at a buffer size. If it's wrong, we can
171          * always resize it
172          */
173         bufsize = sizeof(dm_eventmsg_t) + sizeof(dm_data_event_t) + HANDLE_LEN;
174         bufsize *= 16;
175         msgbuf  = (void *)malloc(bufsize);
176         if (msgbuf == NULL) {
177                 err_msg("Can't allocate memory for buffer\n");
178                 goto out;
179         }
180
181         for (;;) {      
182                 error = dm_get_events(sid, ALL_AVAIL_MSGS, DM_EV_WAIT, bufsize,
183                                         msgbuf, &rlen);
184                 if (error == -1) {
185                         if (errno == E2BIG) {
186                                 free(msgbuf);
187                                 msgbuf = (void *)malloc(rlen);
188                                 if (msgbuf == NULL) {
189                                         err_msg("Can't resize msg buffer\n");
190                                         goto out;
191                                 }
192                                 continue;
193                         }
194                         errno_msg("Error getting events from DMAPI");
195                         goto out;
196                 }
197
198                 /*
199                  * Walk thru the message buffer, pull out each individual
200                  * message, and dispatch the messages to child processes
201                  * with the sid, token, and data. The children will
202                  * respond to the events.
203                  */
204                 msg = (dm_eventmsg_t *)msgbuf;
205                 while (msg != NULL ) {
206                         if (Verbose) {
207                                 fprintf(stderr, "Received %s, token %d\n",
208                                     (msg->ev_type == DM_EVENT_READ ? "read" : 
209                                     (msg->ev_type == DM_EVENT_WRITE ? "write" : "trunc")), msg->ev_token);
210                         }
211                         switch (msg->ev_type) {
212
213                         case DM_EVENT_READ:
214                                 spawn_kid(sid, msg->ev_token, RESTORE_FILE);
215                                 break;
216
217                         case DM_EVENT_WRITE:
218                         case DM_EVENT_TRUNCATE:
219                                 spawn_kid(sid, msg->ev_token, INVAL_FILE);
220                                 break;
221
222                         default:
223                                 err_msg("Invalid msg type %d\n", msg->ev_type);
224                                 break;
225                         }
226                         msg = DM_STEP_TO_NEXT(msg, dm_eventmsg_t *);
227                 }
228         }
229 out:
230         if (msgbuf != NULL)
231                 free(msgbuf);
232
233         migin_exit(0);
234 }
235
236 /*
237  * Fork and exec our worker bee to work on  the file. If 
238  * there is any error in fork/exec'ing the file, we have to
239  * supply the error return to the event. Once the child gets
240  * started, they will respond to the event for us.
241  */
242 void
243 spawn_kid(
244         dm_sessid_t      sid,
245         dm_token_t       token,
246         char            *action)
247 {
248         pid_t   pid;
249         char    sidbuf[10];
250         char    tokenbuf[10];
251
252         pid = fork();
253         if (pid == 0) {
254                 /*
255                  * We're in the child. Try and exec the worker bee
256                  */
257                 sprintf(sidbuf, "%d", sid);
258                 sprintf(tokenbuf, "%d", token);
259                 if (Verbose) {
260                         fprintf(stderr, "execl(%s, %s, %s, -s, %s, -t, %s, 0)\n",
261                                 WORKER_BEE, WORKER_BEE, action, sidbuf,
262                                 tokenbuf);
263                 }
264                 execlp("./"WORKER_BEE, WORKER_BEE, action, "-s", sidbuf, 
265                         "-t", tokenbuf, NULL);
266                 errno_msg("execlp of worker bee failed");
267                 (void)dm_respond_event(sid, token, DM_RESP_ABORT, 
268                                         errno, 0, 0);
269                 exit(1);
270         }
271
272         if (pid < 0) {
273                 err_msg("Can't fork worker bee\n");
274                 (void)dm_respond_event(sid, token, DM_RESP_ABORT, errno,
275                                         0, 0);
276                 return;
277         }
278         return;
279
280 }
281
282
283 /*
284  * Set the event disposition of the managed region events
285  */
286 int
287 set_events(
288         dm_sessid_t      sid,
289         void            *fs_hanp,
290         size_t           fs_hlen)
291 {
292         dm_eventset_t   eventlist;
293
294         DMEV_ZERO(eventlist);
295         DMEV_SET(DM_EVENT_READ, eventlist);
296         DMEV_SET(DM_EVENT_WRITE, eventlist);
297         DMEV_SET(DM_EVENT_TRUNCATE, eventlist);
298
299         if (dm_set_disp(sid, fs_hanp, fs_hlen, DM_NO_TOKEN, &eventlist, 
300                         DM_EVENT_MAX) == -1) 
301         {
302                 errno_msg("Can't set event disposition");
303                 return(1);
304         }
305         return(0);
306 }
307
308
309
310
311 /*
312  * Dissassociate ourselves from our tty, and close all files
313  */
314 int
315 mk_daemon(
316         char    *logfile)
317 {
318         int                     fd;
319         int                     i;
320         struct rlimit           lim;
321         pid_t                   pid;
322
323         if ((pid = fork()) == -1)
324                 return (-1);
325         if (pid)
326                 exit(0);
327
328         (void) setsid();
329
330         (void) chdir("/");
331
332         /*
333          * Determine how many open files we've got and close
334          * then all
335          */
336         if (getrlimit(RLIMIT_NOFILE, &lim) < 0 ) {
337                 errno_msg("Can't determine max number of open files");
338                 return(1);
339         }
340         for (i=0; i<lim.rlim_cur; i++)
341                 (void)close(i);
342
343         /*
344          * For error reporting, we re-direct stdout and stderr to a 
345          * logfile. 
346          */
347         if ((fd = open(logfile, O_WRONLY | O_CREAT | O_TRUNC, 0755)) < 0) {
348                 errno_msg("Can't open logfile %s", logfile);
349                 return(1);
350         }
351         (void)dup2(fd, STDOUT_FILENO);
352         (void)dup2(fd, STDERR_FILENO);
353         close(fd);
354
355         return(0);
356 }
357
358
359 void
360 setup_signals()
361 {
362         struct sigaction        act;
363
364         /*
365          * Set up signals so that we can wait for spawned children 
366          */
367         act.sa_handler = migin_exit;
368         act.sa_flags   = 0;
369         sigemptyset(&act.sa_mask);
370
371         (void)sigaction(SIGHUP, &act, NULL);
372         (void)sigaction(SIGINT, &act, NULL);
373         (void)sigaction(SIGQUIT, &act, NULL);
374         (void)sigaction(SIGTERM, &act, NULL);
375         (void)sigaction(SIGUSR1, &act, NULL);
376         (void)sigaction(SIGUSR1, &act, NULL);
377         (void)sigaction(SIGUSR2, &act, NULL);
378 }
379
380 void
381 migin_exit(int x)
382 {
383         int              error;
384
385         /*
386          * We could try and kill off all our kids, but we're not
387          * 'Mr. Mean', so we just wait for them to die.
388          */
389         err_msg("%s: waiting for all children to die...\n", Progname);
390         while (wait3((int *)0, WNOHANG, (struct rusage *)0) > 0)
391                 ;
392
393         fprintf(stdout, "\n");
394
395
396         /*
397          * XXXX         FIXME           XXX
398          * 
399          *      Should do a set_disp to 0 and then drain the session
400          *      queue as well. On the SGI, we'll need to make the
401          *      filesystem handle global so that we can get at it
402          */
403
404         error = dm_destroy_session(sid);
405         if (error == -1) {
406                 errno_msg("Can't shut down session\n");
407         }
408
409         exit(0);
410 }
411