LU-7433 ldlm: xattr locks are lost on mdt

[fs/lustre-release.git] / lustre / utils / mount_utils.c

diff --git a/lustre/utils/mount_utils.c b/lustre/utils/mount_utils.c
index 7411577..3de6f2a 100644 (file)
--- a/lustre/utils/mount_utils.c
+++ b/lustre/utils/mount_utils.c
@@ -52,8 +52,15 @@
 #include <sys/stat.h>
 #include <sys/utsname.h>
 #include <linux/loop.h>
+#include <sys/types.h>
+#include <dirent.h>
 #include <dlfcn.h>
 
+#ifdef HAVE_GSS
+#include <keyutils.h>
+#include <lustre/utils/gss/sk_utils.h>
+#endif
+
 #include "mount_utils.h"
 
 extern char *progname;
@@ -228,18 +235,16 @@ int check_mtab_entry(char *spec1, char *spec2, char *mtpt, char *type)
        return 0;
 }
 
-#define PROC_DIR       "/proc/"
+#include <sys/vfs.h>
+#include <linux/magic.h>
+
 static int mtab_is_proc(const char *mtab)
 {
-       char path[16];
-
-       if (readlink(mtab, path, sizeof(path)) < 0)
-               return 0;
-
-       if (strncmp(path, PROC_DIR, strlen(PROC_DIR)))
+       struct statfs s;
+       if (statfs(mtab, &s) < 0)
                return 0;
 
-       return 1;
+       return (s.f_type == PROC_SUPER_MAGIC);
 }
 
 #ifdef HAVE_LIBMOUNT
@@ -308,12 +313,12 @@ int update_mtab_entry(char *spec, char *mtpt, char *type, char *opts,
 
        fp = setmntent(MOUNTED, "a+");
        if (fp == NULL) {
-               fprintf(stderr, "%s: setmntent(%s): %s:",
+               fprintf(stderr, "%s: setmntent(%s): %s\n",
                        progname, MOUNTED, strerror (errno));
                rc = 16;
        } else {
                if ((addmntent(fp, &mnt)) == 1) {
-                       fprintf(stderr, "%s: addmntent: %s:",
+                       fprintf(stderr, "%s: addmntent: %s\n",
                                progname, strerror (errno));
                        rc = 16;
                }
@@ -640,7 +645,6 @@ int osd_write_ldd(struct mkfs_opts *mop)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->write_ldd(mop);
-
        else
                ret = EINVAL;
 
@@ -654,7 +658,6 @@ int osd_read_ldd(char *dev, struct lustre_disk_data *ldd)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->read_ldd(dev, ldd);
-
        else
                ret = EINVAL;
 
@@ -688,7 +691,6 @@ int osd_make_lustre(struct mkfs_opts *mop)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->make_lustre(mop);
-
        else
                ret = EINVAL;
 
@@ -704,7 +706,6 @@ int osd_prepare_lustre(struct mkfs_opts *mop,
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->prepare_lustre(mop,
                                                        wanted_mountopts, len);
-
        else
                ret = EINVAL;
 
@@ -732,7 +733,6 @@ int osd_tune_lustre(char *dev, struct mount_opts *mop)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->tune_lustre(dev, mop);
-
        else
                ret = EINVAL;
 
@@ -746,7 +746,6 @@ int osd_label_lustre(struct mount_opts *mop)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->label_lustre(mop);
-
        else
                ret = EINVAL;
 
@@ -761,7 +760,6 @@ int osd_enable_quota(struct mkfs_opts *mop)
 
        if (backfs_mount_type_okay(ldd->ldd_mount_type))
                ret = backfs_ops[ldd->ldd_mount_type]->enable_quota(mop);
-
        else
                ret = EINVAL;
 
@@ -880,3 +878,89 @@ int file_create(char *path, __u64 size)
 
        return 0;
 }
+
+#ifdef HAVE_GSS
+int load_shared_keys(struct mount_opts *mop)
+{
+       DIR *dir;
+       struct dirent *dentry;
+       struct stat sbuf;
+       char fullpath[PATH_MAX];
+       char *path = mop->mo_skpath;
+       int type = 0;
+       int rc;
+
+       if (IS_SERVER(&mop->mo_ldd)) {
+               if (IS_MGS(&mop->mo_ldd))
+                       type |= SK_TYPE_MGS;
+               if (IS_MDT(&mop->mo_ldd) || IS_OST(&mop->mo_ldd))
+                       type |= SK_TYPE_SERVER | SK_TYPE_CLIENT;
+       } else {
+               type |= SK_TYPE_CLIENT;
+       }
+
+       /* init logging */
+       sk_init_logging(NULL, 1, 1);
+
+       rc = stat(path, &sbuf);
+       if (rc < 0) {
+               fprintf(stderr, "stat() failed for key %s: %s\n", path,
+                       strerror(errno));
+               return -errno;
+       }
+
+       /* Load individual keys or a directory of them */
+       if (S_ISREG(sbuf.st_mode)) {
+               return sk_load_keyfile(path, type);
+       } else if (!S_ISDIR(sbuf.st_mode)) {
+               fprintf(stderr, "Invalid shared key path: %s\n", path);
+               return -ENOKEY;
+       }
+
+       dir = opendir(path);
+       if (dir == NULL) {
+               fprintf(stderr, "Unable to open shared key directory: %s\n",
+                       path);
+               return -ENOENT;
+       }
+
+       /* Loop through the files in the directory attempting to load them.
+        * Any issue with loading the keyfile is treated as an error although
+        * the loop continues until all files have been attempted.  This will
+        * allow all errors be reported at once rather then requiring
+        * incremental corrections to fix each one and try again. */
+       while ((dentry = readdir(dir)) != NULL) {
+               if (strcmp(".", dentry->d_name) == 0 ||
+                   strcmp("..", dentry->d_name) == 0)
+                       continue;
+
+               rc = snprintf(fullpath, PATH_MAX, "%s/%s", path,
+                             dentry->d_name);
+               if (rc >= PATH_MAX) {
+                       fprintf(stderr, "Path too long for %s/%s\n",
+                               path, dentry->d_name);
+                       rc = -ENAMETOOLONG;
+                       continue;
+               }
+
+               rc = stat(fullpath, &sbuf);
+               if (rc < 0) {
+                       fprintf(stderr, "Unable to stat %s: %s\n", fullpath,
+                               strerror(errno));
+                       rc = -errno;
+                       continue;
+               }
+
+               if (!S_ISREG(sbuf.st_mode))
+                       continue;
+
+               rc = sk_load_keyfile(fullpath, type);
+               if (rc) {
+                       fprintf(stderr, "Failed to load key %s\n", fullpath);
+               }
+       }
+       closedir(dir);
+
+       return rc;
+}
+#endif