GNU Linux-libre 6.9-gnu
[releases.git] / tools / hv / hv_vss_daemon.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * An implementation of the host initiated guest snapshot for Hyper-V.
4  *
5  * Copyright (C) 2013, Microsoft, Inc.
6  * Author : K. Y. Srinivasan <kys@microsoft.com>
7  */
8
9
10 #include <sys/types.h>
11 #include <sys/poll.h>
12 #include <sys/ioctl.h>
13 #include <sys/stat.h>
14 #include <sys/sysmacros.h>
15 #include <fcntl.h>
16 #include <stdio.h>
17 #include <mntent.h>
18 #include <stdlib.h>
19 #include <unistd.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <linux/fs.h>
24 #include <linux/major.h>
25 #include <linux/hyperv.h>
26 #include <syslog.h>
27 #include <getopt.h>
28 #include <stdbool.h>
29 #include <dirent.h>
30
31 static bool fs_frozen;
32
33 /* Don't use syslog() in the function since that can cause write to disk */
34 static int vss_do_freeze(char *dir, unsigned int cmd)
35 {
36         int ret, fd = open(dir, O_RDONLY);
37
38         if (fd < 0)
39                 return 1;
40
41         ret = ioctl(fd, cmd, 0);
42
43         /*
44          * If a partition is mounted more than once, only the first
45          * FREEZE/THAW can succeed and the later ones will get
46          * EBUSY/EINVAL respectively: there could be 2 cases:
47          * 1) a user may mount the same partition to different directories
48          *  by mistake or on purpose;
49          * 2) The subvolume of btrfs appears to have the same partition
50          * mounted more than once.
51          */
52         if (ret) {
53                 if ((cmd == FIFREEZE && errno == EBUSY) ||
54                     (cmd == FITHAW && errno == EINVAL)) {
55                         close(fd);
56                         return 0;
57                 }
58         }
59
60         close(fd);
61         return !!ret;
62 }
63
64 static bool is_dev_loop(const char *blkname)
65 {
66         char *buffer;
67         DIR *dir;
68         struct dirent *entry;
69         bool ret = false;
70
71         buffer = malloc(PATH_MAX);
72         if (!buffer) {
73                 syslog(LOG_ERR, "Can't allocate memory!");
74                 exit(1);
75         }
76
77         snprintf(buffer, PATH_MAX, "%s/loop", blkname);
78         if (!access(buffer, R_OK | X_OK)) {
79                 ret = true;
80                 goto free_buffer;
81         } else if (errno != ENOENT) {
82                 syslog(LOG_ERR, "Can't access: %s; error:%d %s!",
83                        buffer, errno, strerror(errno));
84         }
85
86         snprintf(buffer, PATH_MAX, "%s/slaves", blkname);
87         dir = opendir(buffer);
88         if (!dir) {
89                 if (errno != ENOENT)
90                         syslog(LOG_ERR, "Can't opendir: %s; error:%d %s!",
91                                buffer, errno, strerror(errno));
92                 goto free_buffer;
93         }
94
95         while ((entry = readdir(dir)) != NULL) {
96                 if (strcmp(entry->d_name, ".") == 0 ||
97                     strcmp(entry->d_name, "..") == 0)
98                         continue;
99
100                 snprintf(buffer, PATH_MAX, "%s/slaves/%s", blkname,
101                          entry->d_name);
102                 if (is_dev_loop(buffer)) {
103                         ret = true;
104                         break;
105                 }
106         }
107         closedir(dir);
108 free_buffer:
109         free(buffer);
110         return ret;
111 }
112
113 static int vss_operate(int operation)
114 {
115         char match[] = "/dev/";
116         FILE *mounts;
117         struct mntent *ent;
118         struct stat sb;
119         char errdir[1024] = {0};
120         char blkdir[23]; /* /sys/dev/block/XXX:XXX */
121         unsigned int cmd;
122         int error = 0, root_seen = 0, save_errno = 0;
123
124         switch (operation) {
125         case VSS_OP_FREEZE:
126                 cmd = FIFREEZE;
127                 break;
128         case VSS_OP_THAW:
129                 cmd = FITHAW;
130                 break;
131         default:
132                 return -1;
133         }
134
135         mounts = setmntent("/proc/mounts", "r");
136         if (mounts == NULL)
137                 return -1;
138
139         while ((ent = getmntent(mounts))) {
140                 if (strncmp(ent->mnt_fsname, match, strlen(match)))
141                         continue;
142                 if (stat(ent->mnt_fsname, &sb)) {
143                         syslog(LOG_ERR, "Can't stat: %s; error:%d %s!",
144                                ent->mnt_fsname, errno, strerror(errno));
145                 } else {
146                         sprintf(blkdir, "/sys/dev/block/%d:%d",
147                                 major(sb.st_rdev), minor(sb.st_rdev));
148                         if (is_dev_loop(blkdir))
149                                 continue;
150                 }
151                 if (hasmntopt(ent, MNTOPT_RO) != NULL)
152                         continue;
153                 if (strcmp(ent->mnt_type, "vfat") == 0)
154                         continue;
155                 if (strcmp(ent->mnt_dir, "/") == 0) {
156                         root_seen = 1;
157                         continue;
158                 }
159                 error |= vss_do_freeze(ent->mnt_dir, cmd);
160                 if (operation == VSS_OP_FREEZE) {
161                         if (error)
162                                 goto err;
163                         fs_frozen = true;
164                 }
165         }
166
167         endmntent(mounts);
168
169         if (root_seen) {
170                 error |= vss_do_freeze("/", cmd);
171                 if (operation == VSS_OP_FREEZE) {
172                         if (error)
173                                 goto err;
174                         fs_frozen = true;
175                 }
176         }
177
178         if (operation == VSS_OP_THAW && !error)
179                 fs_frozen = false;
180
181         goto out;
182 err:
183         save_errno = errno;
184         if (ent) {
185                 strncpy(errdir, ent->mnt_dir, sizeof(errdir)-1);
186                 endmntent(mounts);
187         }
188         vss_operate(VSS_OP_THAW);
189         fs_frozen = false;
190         /* Call syslog after we thaw all filesystems */
191         if (ent)
192                 syslog(LOG_ERR, "FREEZE of %s failed; error:%d %s",
193                        errdir, save_errno, strerror(save_errno));
194         else
195                 syslog(LOG_ERR, "FREEZE of / failed; error:%d %s", save_errno,
196                        strerror(save_errno));
197 out:
198         return error;
199 }
200
201 void print_usage(char *argv[])
202 {
203         fprintf(stderr, "Usage: %s [options]\n"
204                 "Options are:\n"
205                 "  -n, --no-daemon        stay in foreground, don't daemonize\n"
206                 "  -h, --help             print this help\n", argv[0]);
207 }
208
209 int main(int argc, char *argv[])
210 {
211         int vss_fd = -1, len;
212         int error;
213         struct pollfd pfd;
214         int     op;
215         struct hv_vss_msg vss_msg[1];
216         int daemonize = 1, long_index = 0, opt;
217         int in_handshake;
218         __u32 kernel_modver;
219
220         static struct option long_options[] = {
221                 {"help",        no_argument,       0,  'h' },
222                 {"no-daemon",   no_argument,       0,  'n' },
223                 {0,             0,                 0,  0   }
224         };
225
226         while ((opt = getopt_long(argc, argv, "hn", long_options,
227                                   &long_index)) != -1) {
228                 switch (opt) {
229                 case 'n':
230                         daemonize = 0;
231                         break;
232                 case 'h':
233                         print_usage(argv);
234                         exit(0);
235                 default:
236                         print_usage(argv);
237                         exit(EXIT_FAILURE);
238                 }
239         }
240
241         if (daemonize && daemon(1, 0))
242                 return 1;
243
244         openlog("Hyper-V VSS", 0, LOG_USER);
245         syslog(LOG_INFO, "VSS starting; pid is:%d", getpid());
246
247 reopen_vss_fd:
248         if (vss_fd != -1)
249                 close(vss_fd);
250         if (fs_frozen) {
251                 if (vss_operate(VSS_OP_THAW) || fs_frozen) {
252                         syslog(LOG_ERR, "failed to thaw file system: err=%d",
253                                errno);
254                         exit(EXIT_FAILURE);
255                 }
256         }
257
258         in_handshake = 1;
259         vss_fd = open("/dev/vmbus/hv_vss", O_RDWR);
260         if (vss_fd < 0) {
261                 syslog(LOG_ERR, "open /dev/vmbus/hv_vss failed; error: %d %s",
262                        errno, strerror(errno));
263                 exit(EXIT_FAILURE);
264         }
265         /*
266          * Register ourselves with the kernel.
267          */
268         vss_msg->vss_hdr.operation = VSS_OP_REGISTER1;
269
270         len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg));
271         if (len < 0) {
272                 syslog(LOG_ERR, "registration to kernel failed; error: %d %s",
273                        errno, strerror(errno));
274                 close(vss_fd);
275                 exit(EXIT_FAILURE);
276         }
277
278         pfd.fd = vss_fd;
279
280         while (1) {
281                 pfd.events = POLLIN;
282                 pfd.revents = 0;
283
284                 if (poll(&pfd, 1, -1) < 0) {
285                         syslog(LOG_ERR, "poll failed; error:%d %s", errno, strerror(errno));
286                         if (errno == EINVAL) {
287                                 close(vss_fd);
288                                 exit(EXIT_FAILURE);
289                         }
290                         else
291                                 continue;
292                 }
293
294                 len = read(vss_fd, vss_msg, sizeof(struct hv_vss_msg));
295
296                 if (in_handshake) {
297                         if (len != sizeof(kernel_modver)) {
298                                 syslog(LOG_ERR, "invalid version negotiation");
299                                 exit(EXIT_FAILURE);
300                         }
301                         kernel_modver = *(__u32 *)vss_msg;
302                         in_handshake = 0;
303                         syslog(LOG_INFO, "VSS: kernel module version: %d",
304                                kernel_modver);
305                         continue;
306                 }
307
308                 if (len != sizeof(struct hv_vss_msg)) {
309                         syslog(LOG_ERR, "read failed; error:%d %s",
310                                errno, strerror(errno));
311                         goto reopen_vss_fd;
312                 }
313
314                 op = vss_msg->vss_hdr.operation;
315                 error =  HV_S_OK;
316
317                 switch (op) {
318                 case VSS_OP_FREEZE:
319                 case VSS_OP_THAW:
320                         error = vss_operate(op);
321                         syslog(LOG_INFO, "VSS: op=%s: %s\n",
322                                 op == VSS_OP_FREEZE ? "FREEZE" : "THAW",
323                                 error ? "failed" : "succeeded");
324
325                         if (error) {
326                                 error = HV_E_FAIL;
327                                 syslog(LOG_ERR, "op=%d failed!", op);
328                                 syslog(LOG_ERR, "report it with these files:");
329                                 syslog(LOG_ERR, "/etc/fstab and /proc/mounts");
330                         }
331                         break;
332                 case VSS_OP_HOT_BACKUP:
333                         syslog(LOG_INFO, "VSS: op=CHECK HOT BACKUP\n");
334                         break;
335                 default:
336                         syslog(LOG_ERR, "Illegal op:%d\n", op);
337                 }
338
339                 /*
340                  * The write() may return an error due to the faked VSS_OP_THAW
341                  * message upon hibernation. Ignore the error by resetting the
342                  * dev file, i.e. closing and re-opening it.
343                  */
344                 vss_msg->error = error;
345                 len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg));
346                 if (len != sizeof(struct hv_vss_msg)) {
347                         syslog(LOG_ERR, "write failed; error: %d %s", errno,
348                                strerror(errno));
349                         goto reopen_vss_fd;
350                 }
351         }
352
353         close(vss_fd);
354         exit(0);
355 }