cluster config: mark qdevice end point as protected
[pve-cluster.git] / data / src / pmxcfs.c
1 /*
2 Copyright (C) 2010 - 2020 Proxmox Server Solutions GmbH
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Affero General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Affero General Public License for more details.
13
14 You should have received a copy of the GNU Affero General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 Author: Dietmar Maurer <dietmar@proxmox.com>
18
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif /* HAVE_CONFIG_H */
24
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <glib.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <sys/mount.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <sys/file.h>
36 #include <sys/types.h>
37 #include <dirent.h>
38 #include <sys/utsname.h>
39 #include <grp.h>
40 #include <netdb.h>
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <arpa/inet.h>
44
45 #include <qb/qbdefs.h>
46 #include <qb/qbutil.h>
47 #include <qb/qblog.h>
48
49 #include "cfs-utils.h"
50 #include "cfs-plug.h"
51 #include "cfs-plug-memdb.h"
52 #include "status.h"
53 #include "dcdb.h"
54 #include "dfsm.h"
55 #include "quorum.h"
56 #include "confdb.h"
57 #include "server.h"
58
59 #define DBFILENAME VARLIBDIR "/config.db"
60 #define LOCKFILE VARLIBDIR "/.pmxcfs.lockfile"
61 #define RESTART_FLAG_FILE RUNDIR "/cfs-restart-flag"
62
63 #define CFSDIR "/etc/pve"
64
65 cfs_t cfs = {
66 .debug = 0,
67 };
68
69 static struct fuse *fuse = NULL;
70
71 static cfs_plug_t *root_plug;
72
73 static void glib_print_handler(const gchar *string)
74 {
75 printf("%s", string);
76 }
77
78 static void glib_log_handler(const gchar *log_domain,
79 GLogLevelFlags log_level,
80 const gchar *message,
81 gpointer user_data)
82 {
83
84 cfs_log(log_domain, log_level, NULL, 0, NULL, "%s", message);
85 }
86
87 static gboolean write_pidfile(pid_t pid)
88 {
89 char *strpid = g_strdup_printf("%d\n", pid);
90 gboolean res = atomic_write_file(CFS_PID_FN, strpid, strlen(strpid), 0644, getgid());
91 g_free(strpid);
92
93 return res;
94 }
95
96 static cfs_plug_t *find_plug(const char *path, char **sub)
97 {
98 g_return_val_if_fail(root_plug != NULL, NULL);
99 g_return_val_if_fail(path != NULL, NULL);
100
101 while(*path == '/') path++;
102
103 cfs_debug("find_plug start %s", path);
104
105 char *tmppath = g_strdup(path);
106 char *subpath = tmppath;
107
108 cfs_plug_t *plug = root_plug->lookup_plug(root_plug, &subpath);
109
110 cfs_debug("find_plug end %s = %p (%s)", path, (void *) plug, subpath);
111
112 if (subpath && subpath[0])
113 *sub = g_strdup(subpath);
114
115 g_free(tmppath);
116
117 return plug;
118 }
119
120 void *cfs_fuse_init(struct fuse_conn_info *conn)
121 {
122 return NULL;
123 }
124
125 static int cfs_fuse_getattr(const char *path, struct stat *stbuf)
126 {
127 cfs_debug("enter cfs_fuse_getattr %s", path);
128
129 int ret = -EACCES;
130
131 char *subpath = NULL;
132 cfs_plug_t *plug = find_plug(path, &subpath);
133
134 if (plug && plug->ops && plug->ops->getattr) {
135 ret = plug->ops->getattr(plug, subpath ? subpath : "", stbuf);
136
137 stbuf->st_gid = cfs.gid;
138
139 if (path_is_private(path)) {
140 stbuf->st_mode &= 0777700;
141 } else {
142 if (S_ISDIR(stbuf->st_mode) || S_ISLNK(stbuf->st_mode)) {
143 stbuf->st_mode &= 0777755; // access for other users
144 } else {
145 stbuf->st_mode &= 0777750; // no access for other users
146 }
147 }
148 }
149
150 cfs_debug("leave cfs_fuse_getattr %s (%d)", path, ret);
151
152 if (subpath)
153 g_free(subpath);
154
155 return ret;
156
157 }
158
159 static int cfs_fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
160 off_t offset, struct fuse_file_info *fi)
161 {
162 (void) offset;
163 (void) fi;
164
165 cfs_debug("enter cfs_fuse_readdir %s", path);
166
167 int ret = -EACCES;
168
169 char *subpath = NULL;
170 cfs_plug_t *plug = find_plug(path, &subpath);
171
172 if (!plug)
173 goto ret;
174
175 if (plug->ops && plug->ops->readdir)
176 ret = plug->ops->readdir(plug, subpath ? subpath : "", buf, filler, 0, fi);
177 ret:
178 cfs_debug("leave cfs_fuse_readdir %s (%d)", path, ret);
179
180 if (subpath)
181 g_free(subpath);
182
183 return ret;
184 }
185
186 static int cfs_fuse_chmod(const char *path, mode_t mode)
187 {
188 int ret = -EPERM;
189
190 cfs_debug("enter cfs_fuse_chmod %s", path);
191
192 mode_t allowed_mode = (S_IRUSR | S_IWUSR);
193 if (!path_is_private(path))
194 allowed_mode |= (S_IRGRP);
195
196 // allow only setting our supported modes (0600 for priv, 0640 for rest)
197 // mode has additional bits set, which we ignore; see stat(2)
198 if ((mode & ALLPERMS) == allowed_mode)
199 ret = 0;
200
201 cfs_debug("leave cfs_fuse_chmod %s (%d) mode: %o", path, ret, (int)mode);
202
203 return ret;
204 }
205
206 static int cfs_fuse_chown(const char *path, uid_t user, gid_t group)
207 {
208 int ret = -EPERM;
209
210 cfs_debug("enter cfs_fuse_chown %s", path);
211
212 // we get -1 if no change should be made
213 if ((user == 0 || user == -1) && (group == cfs.gid || group == -1))
214 ret = 0;
215
216 cfs_debug("leave cfs_fuse_chown %s (%d) (uid: %d; gid: %d)", path, ret, user, group);
217
218 return ret;
219 }
220
221 static int cfs_fuse_mkdir(const char *path, mode_t mode)
222 {
223 cfs_debug("enter cfs_fuse_mkdir %s", path);
224
225 int ret = -EACCES;
226
227 char *subpath = NULL;
228 cfs_plug_t *plug = find_plug(path, &subpath);
229
230 if (!plug)
231 goto ret;
232
233 if (subpath && plug->ops && plug->ops->mkdir)
234 ret = plug->ops->mkdir(plug, subpath, mode);
235
236 ret:
237 cfs_debug("leave cfs_fuse_mkdir %s (%d)", path, ret);
238
239 if (subpath)
240 g_free(subpath);
241
242 return ret;
243 }
244
245 static int cfs_fuse_rmdir(const char *path)
246 {
247 cfs_debug("enter cfs_fuse_rmdir %s", path);
248
249 int ret = -EACCES;
250
251 char *subpath = NULL;
252 cfs_plug_t *plug = find_plug(path, &subpath);
253
254 if (!plug)
255 goto ret;
256
257 if (subpath && plug->ops && plug->ops->rmdir)
258 ret = plug->ops->rmdir(plug, subpath);
259
260 ret:
261 cfs_debug("leave cfs_fuse_rmdir %s (%d)", path, ret);
262
263 if (subpath)
264 g_free(subpath);
265
266 return ret;
267 }
268
269 static int cfs_fuse_rename(const char *from, const char *to)
270 {
271 cfs_debug("enter cfs_fuse_rename from %s to %s", from, to);
272
273 int ret = -EACCES;
274
275 char *sub_from = NULL;
276 cfs_plug_t *plug_from = find_plug(from, &sub_from);
277
278 char *sub_to = NULL;
279 cfs_plug_t *plug_to = find_plug(to, &sub_to);
280
281 if (!plug_from || !plug_to || plug_from != plug_to)
282 goto ret;
283
284 if (plug_from->ops && plug_from->ops->rename && sub_from && sub_to)
285 ret = plug_from->ops->rename(plug_from, sub_from, sub_to);
286
287 ret:
288 cfs_debug("leave cfs_fuse_rename from %s to %s (%d)", from, to, ret);
289
290 if (sub_from)
291 g_free(sub_from);
292
293 if (sub_to)
294 g_free(sub_to);
295
296 return ret;
297 }
298
299 static int cfs_fuse_open(const char *path, struct fuse_file_info *fi)
300 {
301 cfs_debug("enter cfs_fuse_open %s", path);
302
303 fi->direct_io = 1;
304 fi->keep_cache = 0;
305
306 int ret = -EACCES;
307
308 char *subpath = NULL;
309 cfs_plug_t *plug = find_plug(path, &subpath);
310
311 if (plug && plug->ops) {
312 if ((subpath || !plug->ops->readdir) && plug->ops->open) {
313 ret = plug->ops->open(plug, subpath ? subpath : "", fi);
314 }
315 }
316
317 cfs_debug("leave cfs_fuse_open %s (%d)", path, ret);
318
319 if (subpath)
320 g_free(subpath);
321
322 return ret;
323 }
324
325 static int cfs_fuse_read(const char *path, char *buf, size_t size, off_t offset,
326 struct fuse_file_info *fi)
327 {
328 (void) fi;
329
330 cfs_debug("enter cfs_fuse_read %s %zu %jd", path, size, offset);
331
332 int ret = -EACCES;
333
334 char *subpath = NULL;
335 cfs_plug_t *plug = find_plug(path, &subpath);
336
337 if (plug && plug->ops) {
338 if ((subpath || !plug->ops->readdir) && plug->ops->read)
339 ret = plug->ops->read(plug, subpath ? subpath : "", buf, size, offset, fi);
340 }
341
342 cfs_debug("leave cfs_fuse_read %s (%d)", path, ret);
343
344 if (subpath)
345 g_free(subpath);
346
347 return ret;
348 }
349
350 static int cfs_fuse_write(const char *path, const char *buf, size_t size,
351 off_t offset, struct fuse_file_info *fi)
352 {
353 (void) fi;
354
355 cfs_debug("enter cfs_fuse_write %s %zu %jd", path, size, offset);
356
357 int ret = -EACCES;
358
359 char *subpath = NULL;
360 cfs_plug_t *plug = find_plug(path, &subpath);
361
362 if (plug && plug->ops) {
363 if ((subpath || !plug->ops->readdir) && plug->ops->write)
364 ret = plug->ops->write(plug, subpath ? subpath : "",
365 buf, size, offset, fi);
366 }
367
368 cfs_debug("leave cfs_fuse_write %s (%d)", path, ret);
369
370 if (subpath)
371 g_free(subpath);
372
373 return ret;
374 }
375
376 static int cfs_fuse_truncate(const char *path, off_t size)
377 {
378 cfs_debug("enter cfs_fuse_truncate %s %jd", path, size);
379
380 int ret = -EACCES;
381
382 char *subpath = NULL;
383 cfs_plug_t *plug = find_plug(path, &subpath);
384
385 if (plug && plug->ops) {
386 if ((subpath || !plug->ops->readdir) && plug->ops->truncate)
387 ret = plug->ops->truncate(plug, subpath ? subpath : "", size);
388 }
389
390 cfs_debug("leave cfs_fuse_truncate %s (%d)", path, ret);
391
392 if (subpath)
393 g_free(subpath);
394
395 return ret;
396 }
397
398 static int cfs_fuse_create(const char *path, mode_t mode, struct fuse_file_info *fi)
399 {
400 cfs_debug("enter cfs_fuse_create %s", path);
401
402 int ret = -EACCES;
403
404 char *subpath = NULL;
405 cfs_plug_t *plug = find_plug(path, &subpath);
406
407 if (!plug)
408 goto ret;
409
410 if (subpath && plug->ops && plug->ops->create)
411 ret = plug->ops->create(plug, subpath, mode, fi);
412
413 ret:
414 cfs_debug("leave cfs_fuse_create %s (%d)", path, ret);
415
416 if (subpath)
417 g_free(subpath);
418
419 return ret;
420 }
421
422 static int cfs_fuse_unlink(const char *path)
423 {
424 cfs_debug("enter cfs_fuse_unlink %s", path);
425
426 int ret = -EACCES;
427
428 char *subpath = NULL;
429 cfs_plug_t *plug = find_plug(path, &subpath);
430
431 if (!plug)
432 goto ret;
433
434 if (subpath && plug->ops && plug->ops->unlink)
435 ret = plug->ops->unlink(plug, subpath);
436
437 ret:
438 cfs_debug("leave cfs_fuse_unlink %s (%d)", path, ret);
439
440 if (subpath)
441 g_free(subpath);
442
443 return ret;
444 }
445
446 static int cfs_fuse_readlink(const char *path, char *buf, size_t max)
447 {
448 cfs_debug("enter cfs_fuse_readlink %s", path);
449
450 int ret = -EACCES;
451
452 char *subpath = NULL;
453 cfs_plug_t *plug = find_plug(path, &subpath);
454
455 if (!plug)
456 goto ret;
457
458 if (plug->ops && plug->ops->readlink)
459 ret = plug->ops->readlink(plug, subpath ? subpath : "", buf, max);
460
461 ret:
462 cfs_debug("leave cfs_fuse_readlink %s (%d)", path, ret);
463
464 if (subpath)
465 g_free(subpath);
466
467 return ret;
468 }
469
470 static int cfs_fuse_utimens(const char *path, const struct timespec tv[2])
471 {
472 cfs_debug("enter cfs_fuse_utimens %s", path);
473
474 int ret = -EACCES;
475
476 char *subpath = NULL;
477 cfs_plug_t *plug = find_plug(path, &subpath);
478
479 if (!plug)
480 goto ret;
481
482 if (plug->ops && plug->ops->utimens)
483 ret = plug->ops->utimens(plug, subpath ? subpath : "", tv);
484
485 ret:
486 cfs_debug("leave cfs_fuse_utimens %s (%d)", path, ret);
487
488 if (subpath)
489 g_free(subpath);
490
491 return ret;
492 }
493
494 static int cfs_fuse_statfs(const char *path, struct statvfs *stbuf)
495 {
496 g_return_val_if_fail(root_plug != NULL, PARAM_CHECK_ERRNO);
497
498 cfs_debug("enter cfs_fuse_statfs %s", path);
499
500 int ret = -EACCES;
501
502 if (root_plug && root_plug->ops && root_plug->ops->statfs)
503 ret = root_plug->ops->statfs(root_plug, "", stbuf);
504
505 return ret;
506 }
507
508 static struct fuse_operations fuse_ops = {
509 .getattr = cfs_fuse_getattr,
510 .readdir = cfs_fuse_readdir,
511 .mkdir = cfs_fuse_mkdir,
512 .rmdir = cfs_fuse_rmdir,
513 .rename = cfs_fuse_rename,
514 .open = cfs_fuse_open,
515 .read = cfs_fuse_read,
516 .write = cfs_fuse_write,
517 .truncate = cfs_fuse_truncate,
518 .create = cfs_fuse_create,
519 .unlink = cfs_fuse_unlink,
520 .readlink = cfs_fuse_readlink,
521 .utimens = cfs_fuse_utimens,
522 .statfs = cfs_fuse_statfs,
523 .init = cfs_fuse_init,
524 .chown = cfs_fuse_chown,
525 .chmod = cfs_fuse_chmod
526 };
527
528 static char *
529 create_dot_version_cb(cfs_plug_t *plug)
530 {
531 GString *outbuf = g_string_new(NULL);
532 char *data = NULL;
533
534 if (cfs_create_version_msg(outbuf) == 0) {
535 data = outbuf->str;
536 g_string_free(outbuf, FALSE);
537 } else {
538 g_string_free(outbuf, TRUE);
539 }
540
541 return data;
542 }
543
544 static char *
545 create_dot_members_cb(cfs_plug_t *plug)
546 {
547 GString *outbuf = g_string_new(NULL);
548 char *data = NULL;
549
550 if (cfs_create_memberlist_msg(outbuf) == 0) {
551 data = outbuf->str;
552 g_string_free(outbuf, FALSE);
553 } else {
554 g_string_free(outbuf, TRUE);
555 }
556
557 return data;
558 }
559
560 static char *
561 create_dot_vmlist_cb(cfs_plug_t *plug)
562 {
563 GString *outbuf = g_string_new(NULL);
564 char *data = NULL;
565
566 if (cfs_create_vmlist_msg(outbuf) == 0) {
567 data = outbuf->str;
568 g_string_free(outbuf, FALSE);
569 } else {
570 g_string_free(outbuf, TRUE);
571 }
572
573 return data;
574 }
575
576 static char *
577 create_dot_rrd_cb(cfs_plug_t *plug)
578 {
579 GString *outbuf = g_string_new(NULL);
580
581 cfs_rrd_dump(outbuf);
582 char *data = outbuf->str;
583 g_string_free(outbuf, FALSE);
584
585 return data;
586 }
587
588 static char *
589 create_dot_clusterlog_cb(cfs_plug_t *plug)
590 {
591 GString *outbuf = g_string_new(NULL);
592
593 cfs_cluster_log_dump(outbuf, NULL, 50);
594 char *data = outbuf->str;
595 g_string_free(outbuf, FALSE);
596
597 return data;
598 }
599
600 static char *
601 read_debug_setting_cb(cfs_plug_t *plug)
602 {
603 return g_strdup_printf("%d\n", !!cfs.debug);
604 }
605
606 static void
607 my_qb_log_filter(struct qb_log_callsite *cs)
608 {
609 int32_t priority = cfs.debug ? LOG_DEBUG : LOG_INFO;
610
611 if (qb_bit_is_set(cs->tags, QB_LOG_TAG_LIBQB_MSG_BIT)) {
612 if (cs->priority <= (cfs.debug ? priority : LOG_WARNING)) {
613 qb_bit_set(cs->targets, QB_LOG_SYSLOG);
614 } else {
615 qb_bit_clear(cs->targets, QB_LOG_SYSLOG);
616 }
617 if (cs->priority <= priority) {
618 qb_bit_set(cs->targets, QB_LOG_STDERR);
619 } else {
620 qb_bit_clear(cs->targets, QB_LOG_STDERR);
621 }
622 } else {
623 if (cs->priority <= priority) {
624 qb_bit_set(cs->targets, QB_LOG_SYSLOG);
625 qb_bit_set(cs->targets, QB_LOG_STDERR);
626 } else {
627 qb_bit_clear(cs->targets, QB_LOG_SYSLOG);
628 qb_bit_clear(cs->targets, QB_LOG_STDERR);
629 }
630 }
631 }
632
633 static void
634 update_qb_log_settings(void)
635 {
636 qb_log_filter_fn_set(my_qb_log_filter);
637
638 if (cfs.debug) {
639 qb_log_format_set(QB_LOG_SYSLOG, "[%g] %p: %b (%f:%l:%n)");
640 qb_log_format_set(QB_LOG_STDERR, "[%g] %p: %b (%f:%l:%n)");
641 } else {
642 qb_log_format_set(QB_LOG_SYSLOG, "[%g] %p: %b");
643 qb_log_format_set(QB_LOG_STDERR, "[%g] %p: %b");
644 }
645 }
646
647 static int
648 write_debug_setting_cb(
649 cfs_plug_t *plug,
650 const char *buf,
651 size_t size)
652 {
653 int res = -EIO;
654
655 if (size < 2)
656 return res;
657
658 if (strncmp(buf, "0\n", 2) == 0) {
659 if (cfs.debug) {
660 cfs_message("disable debug mode");
661 cfs.debug = 0;
662 update_qb_log_settings();
663 }
664 return 2;
665 } else if (strncmp(buf, "1\n", 2) == 0) {
666 if (!cfs.debug) {
667 cfs.debug = 1;
668 update_qb_log_settings();
669 cfs_message("enable debug mode");
670 }
671 return 2;
672 }
673
674 return res;
675 }
676
677 static void
678 create_symlinks(cfs_plug_base_t *bplug, const char *nodename)
679 {
680 g_return_if_fail(bplug != NULL);
681 g_return_if_fail(nodename != NULL);
682
683 char *lnktarget = g_strdup_printf("nodes/%s", nodename);
684 cfs_plug_link_t *lnk = cfs_plug_link_new("local", lnktarget);
685 g_free(lnktarget);
686 cfs_plug_base_insert(bplug, (cfs_plug_t*)lnk);
687
688 lnktarget = g_strdup_printf("nodes/%s/qemu-server", nodename);
689 lnk = cfs_plug_link_new("qemu-server", lnktarget);
690 g_free(lnktarget);
691 cfs_plug_base_insert(bplug, (cfs_plug_t*)lnk);
692
693 // FIXME: remove openvz stuff for 7.x
694 lnktarget = g_strdup_printf("nodes/%s/openvz", nodename);
695 lnk = cfs_plug_link_new("openvz", lnktarget);
696 g_free(lnktarget);
697 cfs_plug_base_insert(bplug, (cfs_plug_t*)lnk);
698
699 lnktarget = g_strdup_printf("nodes/%s/lxc", nodename);
700 lnk = cfs_plug_link_new("lxc", lnktarget);
701 g_free(lnktarget);
702 cfs_plug_base_insert(bplug, (cfs_plug_t*)lnk);
703
704 cfs_plug_func_t *fplug = cfs_plug_func_new(".version", 0440, create_dot_version_cb, NULL);
705 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
706
707 fplug = cfs_plug_func_new(".members", 0440, create_dot_members_cb, NULL);
708 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
709
710 fplug = cfs_plug_func_new(".vmlist", 0440, create_dot_vmlist_cb, NULL);
711 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
712
713 fplug = cfs_plug_func_new(".rrd", 0440, create_dot_rrd_cb, NULL);
714 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
715
716 fplug = cfs_plug_func_new(".clusterlog", 0440, create_dot_clusterlog_cb, NULL);
717 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
718
719 fplug = cfs_plug_func_new(".debug", 0640, read_debug_setting_cb, write_debug_setting_cb);
720 cfs_plug_base_insert(bplug, (cfs_plug_t*)fplug);
721
722
723 }
724
725 static char *
726 lookup_node_ip(const char *nodename)
727 {
728 char buf[INET6_ADDRSTRLEN];
729 struct addrinfo *ainfo;
730 struct addrinfo ahints;
731 char *res = NULL;
732 memset(&ahints, 0, sizeof(ahints));
733
734 if (getaddrinfo(nodename, NULL, &ahints, &ainfo))
735 return NULL;
736
737 if (ainfo->ai_family == AF_INET) {
738 struct sockaddr_in *sa = (struct sockaddr_in *)ainfo->ai_addr;
739 inet_ntop(ainfo->ai_family, &sa->sin_addr, buf, sizeof(buf));
740 if (strncmp(buf, "127.", 4) != 0) {
741 res = g_strdup(buf);
742 }
743 } else if (ainfo->ai_family == AF_INET6) {
744 struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ainfo->ai_addr;
745 inet_ntop(ainfo->ai_family, &sa->sin6_addr, buf, sizeof(buf));
746 if (strcmp(buf, "::1") != 0) {
747 res = g_strdup(buf);
748 }
749 }
750
751 freeaddrinfo(ainfo);
752
753 return res;
754 }
755
756 static const char*
757 log_tags_stringify(uint32_t tags) {
758 if (qb_bit_is_set(tags, QB_LOG_TAG_LIBQB_MSG_BIT)) {
759 return "libqb";
760 } else {
761 GQuark quark = tags;
762 const char *domain = g_quark_to_string(quark);
763 if (domain != NULL) {
764 return domain;
765 } else {
766 return "main";
767 }
768 }
769 }
770
771 int main(int argc, char *argv[])
772 {
773 int ret = -1;
774 int lockfd = -1;
775 int pipefd[2];
776
777 gboolean foreground = FALSE;
778 gboolean force_local_mode = FALSE;
779 gboolean wrote_pidfile = FALSE;
780 memdb_t *memdb = NULL;
781 dfsm_t *dcdb = NULL;
782 dfsm_t *status_fsm = NULL;
783
784 qb_log_init("pmxcfs", LOG_DAEMON, LOG_DEBUG);
785 /* remove default filter */
786 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_REMOVE,
787 QB_LOG_FILTER_FILE, "*", LOG_DEBUG);
788
789 qb_log_tags_stringify_fn_set(log_tags_stringify);
790
791 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
792
793 update_qb_log_settings();
794
795 g_set_print_handler(glib_print_handler);
796 g_set_printerr_handler(glib_print_handler);
797 g_log_set_default_handler(glib_log_handler, NULL);
798
799 GOptionContext *context;
800
801 GOptionEntry entries[] = {
802 { "debug", 'd', 0, G_OPTION_ARG_NONE, &cfs.debug, "Turn on debug messages", NULL },
803 { "foreground", 'f', 0, G_OPTION_ARG_NONE, &foreground, "Do not daemonize server", NULL },
804 { "local", 'l', 0, G_OPTION_ARG_NONE, &force_local_mode,
805 "Force local mode (ignore corosync.conf, force quorum)", NULL },
806 { NULL },
807 };
808
809 context = g_option_context_new ("");
810 g_option_context_add_main_entries (context, entries, NULL);
811
812 GError *err = NULL;
813 if (!g_option_context_parse (context, &argc, &argv, &err))
814 {
815 cfs_critical("option parsing failed: %s", err->message);
816 g_error_free (err);
817 qb_log_fini();
818 exit (1);
819 }
820 g_option_context_free(context);
821
822 if (optind < argc) {
823 cfs_critical("too many arguments");
824 qb_log_fini();
825 exit(-1);
826 }
827
828 if (cfs.debug) {
829 update_qb_log_settings();
830 }
831
832 struct utsname utsname;
833 if (uname(&utsname) != 0) {
834 cfs_critical("Unable to read local node name");
835 qb_log_fini();
836 exit (-1);
837 }
838
839 char *dot = strchr(utsname.nodename, '.');
840 if (dot)
841 *dot = 0;
842
843 cfs.nodename = g_strdup(utsname.nodename);
844
845 if (!(cfs.ip = lookup_node_ip(cfs.nodename))) {
846 cfs_critical("Unable to get local IP address");
847 qb_log_fini();
848 exit(-1);
849 }
850
851 struct group *www_data = getgrnam("www-data");
852 if (!www_data) {
853 cfs_critical("Unable to get www-data group ID");
854 qb_log_fini();
855 exit (-1);
856 }
857 cfs.gid = www_data->gr_gid;
858
859 umask(027);
860
861 mkdir(VARLIBDIR, 0755);
862 mkdir(RUNDIR, 0755);
863 chown(RUNDIR, 0, cfs.gid);
864
865 if ((lockfd = open(LOCKFILE, O_RDWR|O_CREAT|O_APPEND, 0600)) == -1) {
866 cfs_critical("unable to create lock '%s': %s", LOCKFILE, strerror (errno));
867 goto err;
868 }
869
870 for (int i = 10; i >= 0; i--) {
871 if (flock(lockfd, LOCK_EX|LOCK_NB) != 0) {
872 if (!i) {
873 cfs_critical("unable to acquire pmxcfs lock: %s", strerror (errno));
874 goto err;
875 }
876 if (i == 10)
877 cfs_message("unable to acquire pmxcfs lock - trying again");
878
879 sleep(1);
880 }
881 }
882
883 cfs_status_init();
884
885 gboolean create = !g_file_test(DBFILENAME, G_FILE_TEST_EXISTS);
886
887 if (!(memdb = memdb_open (DBFILENAME))) {
888 cfs_critical("memdb_open failed - unable to open database '%s'", DBFILENAME);
889 goto err;
890 }
891
892 // automatically import corosync.conf from host
893 if (create && !force_local_mode) {
894 char *cdata = NULL;
895 gsize clen = 0;
896 if (g_file_get_contents(HOST_CLUSTER_CONF_FN, &cdata, &clen, NULL)) {
897
898 guint32 mtime = time(NULL);
899
900 memdb_create(memdb, "/corosync.conf", 0, mtime);
901 if (memdb_write(memdb, "/corosync.conf", 0, mtime, cdata, clen, 0, 1) < 0) {
902 cfs_critical("memdb_write failed - unable to import corosync.conf");
903 goto err;
904 }
905 }
906 }
907
908 // does corosync.conf exist?
909 gpointer conf_data = NULL;
910 int len = memdb_read(memdb, "corosync.conf", &conf_data);
911 if (len >= 0) {
912 if (force_local_mode) {
913 cfs_message("forcing local mode (although corosync.conf exists)");
914 cfs_set_quorate(1, TRUE);
915 } else {
916 if (!(dcdb = dcdb_new(memdb)))
917 goto err;
918 dcdb_sync_corosync_conf(memdb, 1);
919 }
920 } else {
921 cfs_debug("using local mode (corosync.conf does not exist)");
922 cfs_set_quorate(1, TRUE);
923 }
924 if (conf_data) g_free(conf_data);
925
926 cfs_plug_memdb_t *config = cfs_plug_memdb_new("memdb", memdb, dcdb);
927
928 cfs_plug_base_t *bplug = cfs_plug_base_new("", (cfs_plug_t *)config);
929
930 create_symlinks(bplug, cfs.nodename);
931
932 root_plug = (cfs_plug_t *)bplug;
933
934 umount2(CFSDIR, MNT_FORCE);
935
936 mkdir(CFSDIR, 0755);
937
938 char *fa[] = { "-f", "-odefault_permissions", "-oallow_other", NULL};
939
940 struct fuse_args fuse_args = FUSE_ARGS_INIT(sizeof (fa)/sizeof(gpointer) - 1, fa);
941
942 struct fuse_chan *fuse_chan = fuse_mount(CFSDIR, &fuse_args);
943 if (!fuse_chan) {
944 cfs_critical("fuse_mount error: %s", strerror(errno));
945 goto err;
946 }
947
948 if (!(fuse = fuse_new(fuse_chan, &fuse_args, &fuse_ops, sizeof(fuse_ops), NULL))) {
949 cfs_critical("fuse_new error: %s", strerror(errno));
950 goto err;
951 }
952
953 fuse_set_signal_handlers(fuse_get_session(fuse));
954
955 if (!foreground) {
956 if (pipe(pipefd) == -1) {
957 cfs_critical("pipe error: %s", strerror(errno));
958 goto err;
959 }
960
961 pid_t cpid = fork();
962
963 if (cpid == -1) {
964 cfs_critical("failed to daemonize program - %s", strerror (errno));
965 goto err;
966 } else if (cpid) {
967 int readbytes, errno_tmp;
968 char readbuffer;
969 close(pipefd[1]);
970 readbytes = read(pipefd[0], &readbuffer, sizeof(readbuffer));
971 errno_tmp = errno;
972 close(pipefd[0]);
973 if (readbytes == -1) {
974 cfs_critical("read error: %s", strerror(errno_tmp));
975 kill(cpid, SIGKILL);
976 goto err;
977 } else if (readbytes != 1 || readbuffer != '1') {
978 cfs_critical("child failed to send '1'");
979 kill(cpid, SIGKILL);
980 goto err;
981 }
982 /* child finished starting up */
983 write_pidfile(cpid);
984 qb_log_fini();
985 _exit (0);
986 } else {
987 int nullfd;
988 close(pipefd[0]);
989
990 chroot("/");
991
992 if ((nullfd = open("/dev/null", O_RDWR, 0)) != -1) {
993 dup2(nullfd, 0);
994 dup2(nullfd, 1);
995 dup2(nullfd, 2);
996 if (nullfd > 2)
997 close (nullfd);
998 }
999
1000 // do not print to the console after this point
1001 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
1002
1003 setsid();
1004 }
1005 } else {
1006 write_pidfile(getpid());
1007 }
1008
1009 wrote_pidfile = TRUE;
1010
1011 cfs_loop_t *corosync_loop = cfs_loop_new(fuse);
1012
1013 cfs_service_t *service_quorum = NULL;
1014 cfs_service_t *service_confdb = NULL;
1015 cfs_service_t *service_dcdb = NULL;
1016 cfs_service_t *service_status = NULL;
1017
1018 if (dcdb) {
1019
1020 service_quorum = service_quorum_new();
1021
1022 cfs_loop_add_service(corosync_loop, service_quorum, QB_LOOP_HIGH);
1023
1024 service_confdb = service_confdb_new();
1025
1026 cfs_loop_add_service(corosync_loop, service_confdb, QB_LOOP_MED);
1027
1028 service_dcdb = service_dfsm_new(dcdb);
1029 cfs_service_set_timer(service_dcdb, DCDB_VERIFY_TIME);
1030
1031 cfs_loop_add_service(corosync_loop, service_dcdb, QB_LOOP_MED);
1032
1033 status_fsm = cfs_status_dfsm_new();
1034 service_status = service_dfsm_new(status_fsm);
1035
1036 cfs_loop_add_service(corosync_loop, service_status, QB_LOOP_LOW);
1037
1038 }
1039
1040 cfs_loop_start_worker(corosync_loop);
1041
1042 server_start(memdb);
1043
1044 unlink(RESTART_FLAG_FILE);
1045
1046 if (!foreground) {
1047 /* finished starting up, signaling parent */
1048 write(pipefd[1], "1", 1);
1049 close(pipefd[1]);
1050 }
1051
1052 ret = fuse_loop_mt(fuse);
1053
1054 open(RESTART_FLAG_FILE, O_CREAT|O_NOCTTY|O_NONBLOCK, S_IRUSR | S_IRGRP);
1055 chown(RESTART_FLAG_FILE, 0, cfs.gid);
1056
1057 cfs_message("teardown filesystem");
1058
1059 server_stop();
1060
1061 fuse_unmount(CFSDIR, fuse_chan);
1062
1063 fuse_destroy(fuse);
1064
1065 cfs_debug("set stop event loop flag");
1066
1067 cfs_loop_stop_worker(corosync_loop);
1068
1069 cfs_loop_destroy(corosync_loop);
1070
1071 cfs_debug("worker finished");
1072
1073 if (service_dcdb)
1074 service_dfsm_destroy(service_dcdb);
1075
1076 if (service_confdb)
1077 service_confdb_destroy(service_confdb);
1078
1079 if (service_quorum)
1080 service_quorum_destroy(service_quorum);
1081
1082 if (service_status)
1083 service_dfsm_destroy(service_status);
1084
1085 ret:
1086
1087 if (status_fsm)
1088 dfsm_destroy(status_fsm);
1089
1090 if (dcdb)
1091 dfsm_destroy(dcdb);
1092
1093 if (memdb)
1094 memdb_close(memdb);
1095
1096 if (wrote_pidfile)
1097 unlink(CFS_PID_FN);
1098
1099 cfs_message("exit proxmox configuration filesystem (%d)", ret);
1100
1101 cfs_status_cleanup();
1102
1103 qb_log_fini();
1104
1105 exit(ret);
1106
1107 err:
1108 goto ret;
1109 }