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 }