~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/hv/hv_vss_daemon.c

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
356 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp