LU-1330 obdclass: splits server-side procfs handling

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

diff --git a/lustre/utils/mount_utils.c b/lustre/utils/mount_utils.c
index effa6c7..d754d49 100644 (file)
--- a/lustre/utils/mount_utils.c
+++ b/lustre/utils/mount_utils.c
@@ -26,7 +26,7 @@
 /*
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
- * Copyright (c) 2012 Whamcloud, Inc.
+ * Copyright (c) 2012, 2013, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -37,6 +37,7 @@
 #  include "config.h"
 #endif /* HAVE_CONFIG_H */
 
+#include "mount_utils.h"
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
@@ -45,7 +46,7 @@
 #include <lustre_ver.h>
 #include <sys/stat.h>
 #include <sys/utsname.h>
-#include "mount_utils.h"
+#include <linux/loop.h>
 
 extern char *progname;
 extern int verbose;
@@ -180,6 +181,20 @@ int check_mtab_entry(char *spec1, char *spec2, char *mtpt, char *type)
        return 0;
 }
 
+#define PROC_DIR       "/proc/"
+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)))
+               return 0;
+
+       return 1;
+}
+
 int update_mtab_entry(char *spec, char *mtpt, char *type, char *opts,
                int flags, int freq, int pass)
 {
@@ -187,6 +202,10 @@ int update_mtab_entry(char *spec, char *mtpt, char *type, char *opts,
        struct mntent mnt;
        int rc = 0;
 
+       /* Don't update mtab if it is linked to any file in /proc direcotry.*/
+       if (mtab_is_proc(MOUNTED))
+               return 0;
+
        mnt.mnt_fsname = spec;
        mnt.mnt_dir = mtpt;
        mnt.mnt_type = type;
@@ -289,7 +308,8 @@ int loop_setup(struct mkfs_opts *mop)
        int i, ret = 0;
 
        /* Figure out the loop device names */
-       if (!access("/dev/loop0", F_OK | R_OK)) {
+       if (!access("/dev/loop0", F_OK | R_OK) ||
+           !access("/dev/loop-control", F_OK | R_OK)) {
                strcpy(loop_base, "/dev/loop\0");
        } else if (!access("/dev/loop/0", F_OK | R_OK)) {
                strcpy(loop_base, "/dev/loop/\0");
@@ -303,9 +323,24 @@ int loop_setup(struct mkfs_opts *mop)
                char cmd[PATH_MAX];
                int cmdsz = sizeof(cmd);
 
+#ifdef LOOP_CTL_GET_FREE
+               ret = open("/dev/loop-control", O_RDWR);
+               if (ret < 0) {
+                       fprintf(stderr, "%s: can't access loop control\n", progname);
+                       return EACCES;
+               }
+               /* find or allocate a free loop device to use */
+               i = ioctl(ret, LOOP_CTL_GET_FREE);
+               if (i < 0) {
+                       fprintf(stderr, "%s: access loop control error\n", progname);
+                       return EACCES;
+               }
+               sprintf(l_device, "%s%d", loop_base, i);
+#else
                sprintf(l_device, "%s%d", loop_base, i);
                if (access(l_device, F_OK | R_OK))
                        break;
+#endif
                snprintf(cmd, cmdsz, "losetup %s > /dev/null 2>&1", l_device);
                ret = system(cmd);
 
@@ -321,7 +356,8 @@ int loop_setup(struct mkfs_opts *mop)
                                continue;
                        if (ret) {
                                fprintf(stderr, "%s: error %d on losetup: %s\n",
-                                       progname, ret, strerror(ret));
+                                       progname, ret,
+                                       ret >= 0 ? strerror(ret) : "");
                                return ret;
                        }
                        strscpy(mop->mo_loopdev, l_device,
@@ -337,11 +373,23 @@ int loop_setup(struct mkfs_opts *mop)
 int loop_cleanup(struct mkfs_opts *mop)
 {
        char cmd[150];
-       int ret = 1;
+       int ret = 0;
+
        if ((mop->mo_flags & MO_IS_LOOP) && *mop->mo_loopdev) {
+               int tries;
+
                sprintf(cmd, "losetup -d %s", mop->mo_loopdev);
-               ret = run_command(cmd, sizeof(cmd));
+               for (tries = 0; tries < 3; tries++) {
+                       ret = run_command(cmd, sizeof(cmd));
+                       if (ret == 0)
+                               break;
+                       sleep(1);
+               }
        }
+
+       if (ret != 0)
+               fprintf(stderr, "cannot cleanup %s: rc = %d\n",
+                       mop->mo_loopdev, ret);
        return ret;
 }
 
@@ -349,7 +397,7 @@ int loop_format(struct mkfs_opts *mop)
 {
        int fd;
 
-       if (mop->mo_device_sz == 0) {
+       if (mop->mo_device_kb == 0) {
                fatal();
                fprintf(stderr, "loop device requires a --device-size= "
                        "param\n");
@@ -364,7 +412,7 @@ int loop_format(struct mkfs_opts *mop)
                return errno;
        }
 
-       if (ftruncate(fd, mop->mo_device_sz * 1024) != 0) {
+       if (ftruncate(fd, mop->mo_device_kb * 1024) != 0) {
                close(fd);
                fatal();
                fprintf(stderr, "%s: Unable to truncate backing store: %s\n",
@@ -574,6 +622,37 @@ int osd_label_lustre(struct mount_opts *mop)
        return ret;
 }
 
+/* Enable quota accounting */
+int osd_enable_quota(struct mkfs_opts *mop)
+{
+       struct lustre_disk_data *ldd = &mop->mo_ldd;
+       int ret;
+
+       switch (ldd->ldd_mount_type) {
+#ifdef HAVE_LDISKFS_OSD
+       case LDD_MT_EXT3:
+       case LDD_MT_LDISKFS:
+       case LDD_MT_LDISKFS2:
+               ret = ldiskfs_enable_quota(mop);
+               break;
+#endif /* HAVE_LDISKFS_OSD */
+#ifdef HAVE_ZFS_OSD
+       case LDD_MT_ZFS:
+               fprintf(stderr, "this option is only valid for ldiskfs\n");
+               ret = EINVAL;
+               break;
+#endif /* HAVE_ZFS_OSD */
+       default:
+               fatal();
+               fprintf(stderr, "unknown fs type %d '%s'\n",
+                       ldd->ldd_mount_type, MT_STR(ldd));
+               ret = EINVAL;
+               break;
+       }
+
+       return ret;
+}
+
 int osd_init(void)
 {
        int ret = 0;
@@ -639,11 +718,23 @@ __u64 get_device_size(char* device)
        return size >> 10;
 }
 
-int file_create(char *path, int size)
+int file_create(char *path, __u64 size)
 {
+       __u64 size_max;
        int ret;
        int fd;
 
+       /*
+        * Since "size" is in KB, the file offset it represents could overflow
+        * off_t.
+        */
+       size_max = (off_t)1 << (_FILE_OFFSET_BITS - 1 - 10);
+       if (size >= size_max) {
+               fprintf(stderr, "%s: "LPU64" KB: Backing store size must be "
+                       "smaller than "LPU64" KB\n", progname, size, size_max);
+               return EFBIG;
+       }
+
        ret = access(path, F_OK);
        if (ret == 0) {
                ret = unlink(path);