Line data    Source code

       1              : #include <stdlib.h>
       2              : #include <string.h>
       3              : #include <stdio.h>
       4              : #include <unistd.h>
       5              : #include <sys/file.h>
       6              : #include <sys/types.h>
       7              : #include <sys/stat.h>
       8              : #include <sys/mount.h>
       9              : #include <fcntl.h>
      10              : #include <errno.h>
      11              : #include <signal.h>
      12              : #include <mntent.h>
      13              : #include <libintl.h>
      14              : #include <locale.h>
      15              : #define _(String) gettext(String)
      16              : 
      17              : #include "metafs.h"
      18              : 
      19              : int metafs_interrupted;
      20              : 
      21            0 : static int lock_for_admin(struct metafs *mfs, int debug)
      22              : {
      23              :         int error;
      24              : 
      25            0 :         if (debug)
      26            0 :                 printf(_("Trying to get admin lock..."));
      27              : 
      28            0 :         mfs->fd = open(mfs->path, O_RDONLY | O_NOFOLLOW);
      29            0 :         if (mfs->fd < 0)
      30            0 :                 return -1;
      31              : 
      32            0 :         error = flock(mfs->fd, LOCK_EX);
      33            0 :         if (error) {
      34            0 :                 close(mfs->fd);
      35            0 :                 return -1;
      36              :         }
      37            0 :         if (debug)
      38            0 :                 printf(_("locked.\n"));
      39            0 :         return 0;
      40              : }
      41              : 
      42            0 : static void sighandler(int error)
      43              : {
      44            0 :         metafs_interrupted = 1;
      45            0 : }
      46              : 
      47            0 : static void setsigs(void (*handler)(int))
      48              : {
      49            0 :         struct sigaction sa = { .sa_handler = handler };
      50              : 
      51            0 :         sigaction(SIGINT, &sa, NULL);
      52            0 :         sigaction(SIGILL, &sa, NULL);
      53            0 :         sigaction(SIGTERM, &sa, NULL);
      54            0 :         sigaction(SIGHUP, &sa, NULL);
      55            0 :         sigaction(SIGABRT, &sa, NULL);
      56            0 :         sigaction(SIGCONT, &sa, NULL);
      57            0 :         sigaction(SIGUSR1, &sa, NULL);
      58            0 :         sigaction(SIGUSR2, &sa, NULL);
      59            0 : }
      60              : 
      61            0 : int mount_gfs2_meta(struct metafs *mfs, const char *path, int debug)
      62              : {
      63              :         int ret;
      64              : 
      65            0 :         mfs->path = strdup("/tmp/.gfs2meta.XXXXXX");
      66            0 :         if (mfs->path == NULL)
      67            0 :                 return -1;
      68              : 
      69            0 :         if(!mkdtemp(mfs->path))
      70            0 :                 goto err_free;
      71              : 
      72            0 :         setsigs(sighandler);
      73              : 
      74            0 :         ret = mount(path, mfs->path, "gfs2meta", 0, mfs->context);
      75            0 :         if (ret)
      76            0 :                 goto err_rmdir;
      77              : 
      78            0 :         if (lock_for_admin(mfs, debug))
      79            0 :                 goto err_umount;
      80              : 
      81            0 :         return 0;
      82              : 
      83            0 : err_umount:
      84            0 :         if (umount(mfs->path))
      85              :                 /* Translators: the first %s here is a path, the second is an error message */
      86            0 :                 fprintf(stderr, _("Could not unmount %s: %s\n"),
      87            0 :                                     mfs->path, strerror(errno));
      88            0 :         setsigs(SIG_DFL);
      89            0 : err_rmdir:
      90            0 :         rmdir(mfs->path);
      91            0 : err_free:
      92            0 :         free(mfs->path);
      93            0 :         mfs->path = NULL;
      94            0 :         return -1;
      95              : }
      96              : 
      97            0 : void cleanup_metafs(struct metafs *mfs)
      98              : {
      99              :         int ret;
     100              : 
     101            0 :         if (mfs->fd <= 0)
     102            0 :                 return;
     103              : 
     104            0 :         fsync(mfs->fd);
     105            0 :         close(mfs->fd);
     106            0 :         ret = umount(mfs->path);
     107            0 :         if (ret)
     108              :                 /* Translators: the first %s here is a path, the second is an error message */
     109            0 :                 fprintf(stderr, "Could not unmount %s : %s\n",
     110            0 :                         mfs->path, strerror(errno));
     111              :         else
     112            0 :                 rmdir(mfs->path);
     113              : 
     114            0 :         setsigs(SIG_DFL);
     115            0 :         metafs_interrupted = 0;
     116              : 
     117            0 :         free(mfs->path);
     118            0 :         mfs->path = NULL;
     119            0 :         free(mfs->context);
     120            0 :         mfs->context = NULL;
     121              : }
     122              : 
     123              : /**
     124              :  * Returns a duplicate of the 'context' mount option, or NULL if not found.
     125              :  */
     126            0 : char *copy_context_opt(struct mntent *mnt)
     127              : {
     128              :         char *ctx, *end;
     129              : 
     130            0 :         ctx = hasmntopt(mnt, "context");
     131            0 :         if (ctx == NULL)
     132            0 :                 return NULL;
     133              : 
     134            0 :         end = strchr(ctx, ',');
     135            0 :         if (end == NULL)
     136            0 :                 return NULL;
     137              : 
     138            0 :         return strndup(ctx, end - ctx);
     139              : }