thr3ads.net - dovecot - [Dovecot] Filesystem Quota Enhancement Patch [Aug 2006]

If this information is useful, please help other people find it:
Share via:

Scott Alter

2006-Aug-21 23:59 UTC

[Dovecot] Filesystem Quota Enhancement Patch

I have just updated my patch that provides enhanced support for 
filesystem-based quotas in Dovecot.  I provides 2 main features:

* Support for group quotas
* Number of messages quota for users of maildir

If both user and group quotas are enabled on the filesystem, the plugin 
will report the quota that is closer to the maximum independently for 
both storage space and message count.  The message count quota comes from 
the filesystem inode quota.

This patch has been tested on Fedora Core only, but it should work on all 
other OSes.  The only exception is there is no group support on Solaris 
(I believe this is a limitation of Sun's implementation of 
filesystem-based quotas).

I believe this patch make Dovecot's filesystem-based quota support 
complete.  So, after a little bit of testing, it would be nice to have 
this merged with the main distribution.

Scott Alter
-------------- next part --------------
--- quota-fs.c.orig	2006-08-10 18:01:42.000000000 -0400
+++ quota-fs.c	2006-08-21 19:33:38.000000000 -0400
@@ -53,6 +53,7 @@
 	struct quota_root root;
 
 	uid_t uid;
+	gid_t gid;
 	struct fs_quota_mountpoint *mount;
 };
 
@@ -73,6 +74,7 @@
 	root->root.name = i_strdup(name);
 	root->root.v = quota_backend_fs.v;
 	root->uid = geteuid();
+	root->gid = getegid();
 
 	return &root->root;
 }
@@ -177,7 +179,16 @@
 static const char *const *
 fs_quota_root_get_resources(struct quota_root *root __attr_unused__)
 {
-	static const char *resources[] = { QUOTA_NAME_STORAGE, NULL };
+	const char *mail;
+	mail = getenv("MAIL");
+	static const char *resources[] = {
+		QUOTA_NAME_STORAGE,
+		NULL,
+		NULL
+	};
+	if (strstr(mail, "maildir") != NULL) {
+		resources[1] = QUOTA_NAME_MESSAGES;
+	}
 
 	return resources;
 }
@@ -192,82 +203,108 @@
 	struct quotctl ctl;
 #endif
 
+	int value_r_t, limit_r_t, value_r_c=0, limit_r_c=0;
+	char args[] = {USRQUOTA, GRPQUOTA};
+	int what[] = {root->uid, root->gid};
+	short i;
+	int quota_error=0;
+
 	*value_r = 0;
 	*limit_r = 0;
 
-	if (strcasecmp(name, QUOTA_NAME_STORAGE) != 0 || root->mount == NULL)
+	if (root->mount == NULL)
 		return 0;
 
+	for (i = 0; i < 2; i++) {
+
 #if defined (HAVE_QUOTACTL) && defined(HAVE_SYS_QUOTA_H)
-	/* Linux */
+		/* Linux */
 #ifdef HAVE_XFS_QUOTA
-	if (strcmp(root->mount->type, "xfs") == 0) {
-		/* XFS */
-		struct fs_disk_quota xdqblk;
+		if (strcmp(root->mount->type, "xfs") == 0) {
+			/* XFS */
+			struct fs_disk_quota xdqblk;
 
-		if (quotactl(QCMD(Q_XGETQUOTA, USRQUOTA),
-			     root->mount->device_path,
-			     root->uid, (caddr_t)&xdqblk) < 0) {
-			i_error("quotactl(Q_XGETQUOTA, %s) failed: %m",
-				root->mount->device_path);
-			quota_set_error(_root->setup->quota,
-					"Internal quota error");
-			return -1;
-		}
+			if (quotactl(QCMD(Q_XGETQUOTA, args[i]),
+				     root->mount->device_path,
+				     what[i], (caddr_t)&xdqblk) < 0) {
+				quota_error = quota_error + 1;
+			}
 
-		/* values always returned in 512 byte blocks */
-		*value_r = xdqblk.d_bcount >> 1;
-		*limit_r = xdqblk.d_blk_softlimit >> 1;
-	} else
+			/* values always returned in 512 byte blocks */
+			value_r_t = xdqblk.d_bcount >> 1;
+			limit_r_t = xdqblk.d_blk_softlimit >> 1;
+
+			dqblk.dqb_curinodes = xdqblk.d_icount;
+			dqblk.dqb_isoftlimit = xdqblk.d_ino_softlimit;
+		} else
 #endif
-	{
-		/* ext2, ext3 */
-		if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA),
-			     root->mount->device_path,
-			     root->uid, (caddr_t)&dqblk) < 0) {
-			i_error("quotactl(Q_GETQUOTA, %s) failed: %m",
-				root->mount->device_path);
-			if (errno == EINVAL) {
+		{
+			/* ext2, ext3 */
+			if (quotactl(QCMD(Q_GETQUOTA, args[i]),
+				     root->mount->device_path,
+				     what[i], (caddr_t)&dqblk) < 0) {
+				if (errno == EINVAL) {
 				i_error("Dovecot was compiled with Linux quota "
 					"v%d support, try changing it "
 					"(--with-linux-quota configure option)",
 					_LINUX_QUOTA_VERSION);
+					quota_error = quota_error + 1;
+				}
 			}
-			quota_set_error(_root->setup->quota,
-					"Internal quota error");
+
+			value_r_t = dqblk.dqb_curblocks / 1024;
+			limit_r_t = dqblk.dqb_bsoftlimit;
+		}
+#elif defined(HAVE_QUOTACTL)
+		/* BSD, AIX */
+		if (quotactl(root->mount->mount_path, QCMD(Q_GETQUOTA, args[i]),
+			     what[i], (void *)&dqblk) < 0) {
+			quota_error = quota_error + 1;
+		}
+		value_r_t = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
+		limit_r_t = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
+#else
+		/* Solaris */
+		if (root->mount->fd == -1)
+			return 0;
+
+		ctl.op = Q_GETQUOTA;
+		ctl.uid = root->uid;
+		ctl.addr = (caddr_t)&dqblk;
+		if (ioctl(root->mount->fd, Q_QUOTACTL, &ctl) < 0) {
+			i_error("ioctl(%s, Q_QUOTACTL) failed: %m",
root->mount->path);
+			quota_set_error(_root->setup->quota, "Internal quota
error");
 			return -1;
 		}
+		value_r_t = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
+		limit_r_t = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
+#endif
+
+		if (strcmp(name, QUOTA_NAME_MESSAGES) == 0) {
+			value_r_t = (uint64_t)dqblk.dqb_curinodes;
+			limit_r_t = (uint64_t)dqblk.dqb_isoftlimit;
+		}
 
-		*value_r = dqblk.dqb_curblocks / 1024;
-		*limit_r = dqblk.dqb_bsoftlimit;
+		if ((value_r_c == 0) ||         // first time in loop
+		    (limit_r_c == 0  && limit_r_t >= 0) ||      // first quota
+		    (limit_r_c > 0 && limit_r_t > 0 &&
+		    (limit_r_t - value_r_t) < (limit_r_c - value_r_c)) ||     // another
quota, closer
+		    (limit_r_c == 0 && limit_r_t == 0 && value_r_t >
value_r_c)) {      // no quotas, higher usage
+			limit_r_c = limit_r_t;
+			value_r_c = value_r_t;
+		}
 	}
-#elif defined(HAVE_QUOTACTL)
-	/* BSD, AIX */
-	if (quotactl(root->mount->mount_path, QCMD(Q_GETQUOTA, USRQUOTA),
-		     root->uid, (void *)&dqblk) < 0) {
+
+	if (quota_error == 2) {
 		i_error("quotactl(Q_GETQUOTA, %s) failed: %m",
-			root->mount->mount_path);
+		         root->mount->mount_path);
 		quota_set_error(_root->setup->quota, "Internal quota error");
 		return -1;
 	}
-	*value_r = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
-	*limit_r = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
-#else
-	/* Solaris */
-	if (root->mount->fd == -1)
-		return 0;
 
-	ctl.op = Q_GETQUOTA;
-	ctl.uid = root->uid;
-	ctl.addr = (caddr_t)&dqblk;
-	if (ioctl(root->mount->fd, Q_QUOTACTL, &ctl) < 0) {
-		i_error("ioctl(%s, Q_QUOTACTL) failed: %m",
root->mount->path);
-		quota_set_error(_root->setup->quota, "Internal quota error");
-		return -1;
-	}
-	*value_r = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
-	*limit_r = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
-#endif
+	*limit_r = limit_r_c;
+	*value_r = value_r_c;
+
 	return 1;
 }
 
-------------- next part --------------
/* Copyright (C) 2005-2006 Timo Sirainen */

/* Only for reporting filesystem quota */

#include "lib.h"
#include "array.h"
#include "str.h"
#include "mountpoint.h"
#include "quota-private.h"
#include "quota-fs.h"

#ifdef HAVE_FS_QUOTA

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#ifdef HAVE_LINUX_DQBLK_XFS_H
#  include <linux/dqblk_xfs.h>
#  define HAVE_XFS_QUOTA
#elif defined (HAVE_XFS_XQM_H)
#  include <xfs/xqm.h> /* CentOS 4.x at least uses this */
#  define HAVE_XFS_QUOTA
#endif

#ifndef DEV_BSIZE
#  define DEV_BSIZE 512
#endif

#ifdef HAVE_STRUCT_DQBLK_CURSPACE
#  define dqb_curblocks dqb_curspace
#endif

/* Older sys/quota.h doesn't define _LINUX_QUOTA_VERSION at all, which means
   it supports only v1 quota */
#ifndef _LINUX_QUOTA_VERSION
#  define _LINUX_QUOTA_VERSION 1
#endif

struct fs_quota_mountpoint {
	char *mount_path;
	char *device_path;
	char *type;

#ifdef HAVE_Q_QUOTACTL
	int fd;
	char *path;
#endif
};

struct fs_quota_root {
	struct quota_root root;

	uid_t uid;
	gid_t gid;
	struct fs_quota_mountpoint *mount;
};

struct fs_quota_root_iter {
	struct quota_root_iter iter;

	bool sent;
};

extern struct quota_backend quota_backend_fs;

static struct quota_root *
fs_quota_init(struct quota_setup *setup __attr_unused__, const char *name)
{
	struct fs_quota_root *root;

	root = i_new(struct fs_quota_root, 1);
	root->root.name = i_strdup(name);
	root->root.v = quota_backend_fs.v;
	root->uid = geteuid();
	root->gid = getegid();

	return &root->root;
}

static void fs_quota_mountpoint_free(struct fs_quota_mountpoint *mount)
{
#ifdef HAVE_Q_QUOTACTL
	if (mount->fd != -1) {
		if (close(mount->fd) < 0)
			i_error("close(%s) failed: %m", mount->path);
	}
	i_free(mount->path);
#endif

	i_free(mount->device_path);
	i_free(mount->mount_path);
	i_free(mount->type);
	i_free(mount);
}

static void fs_quota_deinit(struct quota_root *_root)
{
	struct fs_quota_root *root = (struct fs_quota_root *)_root;

	if (root->mount != NULL)
		fs_quota_mountpoint_free(root->mount);
	i_free(root->root.name);
	i_free(root);
}

static struct fs_quota_mountpoint *fs_quota_mountpoint_get(const char *dir)
{
	struct fs_quota_mountpoint *mount;
	struct mountpoint point;
	int ret;

	ret = mountpoint_get(dir, default_pool, &point);
	if (ret <= 0)
		return NULL;

	mount = i_new(struct fs_quota_mountpoint, 1);
	mount->device_path = point.device_path;
	mount->mount_path = point.mount_path;
	mount->type = point.type;
	return mount;
}

static bool fs_quota_add_storage(struct quota_root *_root,
				 struct mail_storage *storage)
{
	struct fs_quota_root *root = (struct fs_quota_root *)_root;
	struct fs_quota_mountpoint *mount;
	const char *dir;
	bool is_file;

	dir = mail_storage_get_mailbox_path(storage, "", &is_file);

	if (getenv("DEBUG") != NULL)
		i_info("fs quota add storage dir = %s", dir);

	mount = fs_quota_mountpoint_get(dir);
	if (root->mount == NULL) {
		if (mount == NULL) {
			/* Not found */
			return TRUE;
		}
		root->mount = mount;
	} else {
		bool match = strcmp(root->mount->mount_path,
				    mount->mount_path) == 0;

		fs_quota_mountpoint_free(mount);
		if (!match) {
			/* different mountpoints, can't use this */
			return FALSE;
		}
		mount = root->mount;
	}

	if (getenv("DEBUG") != NULL) {
		i_info("fs quota block device = %s", mount->device_path);
		i_info("fs quota mount point = %s", mount->mount_path);
	}

#ifdef HAVE_Q_QUOTACTL
	if (mount->path == NULL) {
		mount->path = i_strconcat(mount->mount_path, "/quotas", NULL);
		mount->fd = open(mount->path, O_RDONLY);
		if (mount->fd == -1 && errno != ENOENT)
			i_error("open(%s) failed: %m", mount->path);
	}
#endif
	return TRUE;
}

static void
fs_quota_remove_storage(struct quota_root *root __attr_unused__,
			struct mail_storage *storage __attr_unused__)
{
}

static const char *const *
fs_quota_root_get_resources(struct quota_root *root __attr_unused__)
{
	const char *mail;
	mail = getenv("MAIL");
	static const char *resources[] = {
		QUOTA_NAME_STORAGE,
		NULL,
		NULL
	};
	if (strstr(mail, "maildir") != NULL) {
		resources[1] = QUOTA_NAME_MESSAGES;
	}

	return resources;
}

static int
fs_quota_get_resource(struct quota_root *_root, const char *name,
		      uint64_t *value_r, uint64_t *limit_r)
{
	struct fs_quota_root *root = (struct fs_quota_root *)_root;
	struct dqblk dqblk;
#ifdef HAVE_Q_QUOTACTL
	struct quotctl ctl;
#endif

	int value_r_t, limit_r_t, value_r_c=0, limit_r_c=0;
	char args[] = {USRQUOTA, GRPQUOTA};
	int what[] = {root->uid, root->gid};
	short i;
	int quota_error=0;

	*value_r = 0;
	*limit_r = 0;

	if (root->mount == NULL)
		return 0;

	for (i = 0; i < 2; i++) {

#if defined (HAVE_QUOTACTL) && defined(HAVE_SYS_QUOTA_H)
		/* Linux */
#ifdef HAVE_XFS_QUOTA
		if (strcmp(root->mount->type, "xfs") == 0) {
			/* XFS */
			struct fs_disk_quota xdqblk;

			if (quotactl(QCMD(Q_XGETQUOTA, args[i]),
				     root->mount->device_path,
				     what[i], (caddr_t)&xdqblk) < 0) {
				quota_error = quota_error + 1;
			}

			/* values always returned in 512 byte blocks */
			value_r_t = xdqblk.d_bcount >> 1;
			limit_r_t = xdqblk.d_blk_softlimit >> 1;

			dqblk.dqb_curinodes = xdqblk.d_icount;
			dqblk.dqb_isoftlimit = xdqblk.d_ino_softlimit;
		} else
#endif
		{
			/* ext2, ext3 */
			if (quotactl(QCMD(Q_GETQUOTA, args[i]),
				     root->mount->device_path,
				     what[i], (caddr_t)&dqblk) < 0) {
				if (errno == EINVAL) {
				i_error("Dovecot was compiled with Linux quota "
					"v%d support, try changing it "
					"(--with-linux-quota configure option)",
					_LINUX_QUOTA_VERSION);
					quota_error = quota_error + 1;
				}
			}

			value_r_t = dqblk.dqb_curblocks / 1024;
			limit_r_t = dqblk.dqb_bsoftlimit;
		}
#elif defined(HAVE_QUOTACTL)
		/* BSD, AIX */
		if (quotactl(root->mount->mount_path, QCMD(Q_GETQUOTA, args[i]),
			     what[i], (void *)&dqblk) < 0) {
			quota_error = quota_error + 1;
		}
		value_r_t = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
		limit_r_t = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
#else
		/* Solaris */
		if (root->mount->fd == -1)
			return 0;

		ctl.op = Q_GETQUOTA;
		ctl.uid = root->uid;
		ctl.addr = (caddr_t)&dqblk;
		if (ioctl(root->mount->fd, Q_QUOTACTL, &ctl) < 0) {
			i_error("ioctl(%s, Q_QUOTACTL) failed: %m",
root->mount->path);
			quota_set_error(_root->setup->quota, "Internal quota error");
			return -1;
		}
		value_r_t = (uint64_t)dqblk.dqb_curblocks * 1024 / DEV_BSIZE;
		limit_r_t = (uint64_t)dqblk.dqb_bsoftlimit * 1024 / DEV_BSIZE;
#endif

		if (strcmp(name, QUOTA_NAME_MESSAGES) == 0) {
			value_r_t = (uint64_t)dqblk.dqb_curinodes;
			limit_r_t = (uint64_t)dqblk.dqb_isoftlimit;
		}

		if ((value_r_c == 0) ||         // first time in loop
		    (limit_r_c == 0  && limit_r_t >= 0) ||      // first quota
		    (limit_r_c > 0 && limit_r_t > 0 &&
		    (limit_r_t - value_r_t) < (limit_r_c - value_r_c)) ||     // another
quota, closer
		    (limit_r_c == 0 && limit_r_t == 0 && value_r_t >
value_r_c)) {      // no quotas, higher usage
			limit_r_c = limit_r_t;
			value_r_c = value_r_t;
		}
	}

	if (quota_error == 2) {
		i_error("quotactl(Q_GETQUOTA, %s) failed: %m",
		         root->mount->mount_path);
		quota_set_error(_root->setup->quota, "Internal quota error");
		return -1;
	}

	*limit_r = limit_r_c;
	*value_r = value_r_c;

	return 1;
}

static int
fs_quota_set_resource(struct quota_root *root,
		      const char *name __attr_unused__,
		      uint64_t value __attr_unused__)
{
	quota_set_error(root->setup->quota, MAIL_STORAGE_ERR_NO_PERMISSION);
	return -1;
}

static struct quota_root_transaction_context *
fs_quota_transaction_begin(struct quota_root *root,
			   struct quota_transaction_context *ctx)
{
	struct quota_root_transaction_context *root_ctx;

	root_ctx = i_new(struct quota_root_transaction_context, 1);
	root_ctx->root = root;
	root_ctx->ctx = ctx;
	root_ctx->disabled = TRUE;
	return root_ctx;
}

static int
fs_quota_transaction_commit(struct quota_root_transaction_context *ctx)
{
	i_free(ctx);
	return 0;
}

struct quota_backend quota_backend_fs = {
	"fs",

	{
		fs_quota_init,
		fs_quota_deinit,

		fs_quota_add_storage,
		fs_quota_remove_storage,

		fs_quota_root_get_resources,

		fs_quota_get_resource,
		fs_quota_set_resource,

		fs_quota_transaction_begin,
		fs_quota_transaction_commit,
		quota_default_transaction_rollback,

		quota_default_try_alloc,
		quota_default_try_alloc_bytes,
		quota_default_test_alloc_bytes,
		quota_default_alloc,
		quota_default_free
	}
};

#endif

Timo Sirainen

2006-Aug-22 02:30 UTC

head link

[Dovecot] Filesystem Quota Enhancement Patch

On Mon, 2006-08-21 at 19:59 -0400, Scott Alter wrote:> I have just updated my patch that provides enhanced support for 
> filesystem-based quotas in Dovecot.  I provides 2 main features:
> 
> * Support for group quotas
> * Number of messages quota for users of maildir
> 
> If both user and group quotas are enabled on the filesystem, the plugin 
> will report the quota that is closer to the maximum independently for 
> both storage space and message count.  
I guess for v1.0 that's fine, but do you think for CVS HEAD this could
be done using two quotaroots? Do clients even understand more than one
quota root?
> I believe this patch make Dovecot's filesystem-based quota support 
> complete.  So, after a little bit of testing, it would be nice to have 
> this merged with the main distribution.
I think I'll add this and some other stuff to 1.0rc8.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part
URL:
<http://dovecot.org/pipermail/dovecot/attachments/20060822/5e88e155/attachment.bin>

Scott Alter

2006-Aug-22 05:15 UTC

head link

[Dovecot] Filesystem Quota Enhancement Patch

> I guess for v1.0 that's fine, but do you think for CVS HEAD this could
> be done using two quotaroots? Do clients even understand more than one
> quota root?
>   There are a few considerations that need to be made regarding support 
for multiple quotaroots.  I believe that this will require the 
modification of the imap_quota plugin first in order to accommodate a 
mapping between namespaces and quotaroots (more below).  I've been 
reading over RFC 2087 (IMAP4 QUOTA extension), and have a few 
considerations and possibilities.  I do not know if there are any 
clients that support multiple quotaroots, but that doesn't mean Dovecot 
shouldn't be standards compliant.  If I have time, I will attempt to 
hack Dovecot to return multiple quotaroots and see how Thunderbird responds.

I first want to call to your attention the presence of a draft of a new 
RFC which has long expired - 
http://www.melnikov.ca/mel/Drafts/draft-cridland-imap-quota-00.txt.  It 
would have addressed all of these issues, but I guess it never caught 
on.  Since we're stuck with RFC 2087, here are my thoughts.

The first possibility is to have only one quotaroot for each namespace 
and return multiple of the same resources for the quota.  Since both the 
user and group quotas apply to the same quotaroot, they theoretically 
could both be returned.  From the RFC (5.1 QUOTA
Response):> The [quota root] is followed by a S-expression format list of the 
> resource usage and limits of the quota root. The list contains zero or 
> more triplets. Each triplet conatins a resource name, the current 
> usage of the resource, and the resource limit.If I interpreted this RFC correctly, there could theoretically be 
multiple storage and message resource limits for each quotaroot.  So, 
there could be a response like: "* QUOTA "" (STORAGE 10 512
STORAGE 123
6000 STORAGE 45 50 MESSAGE 5 20)".  This could be used to show both user 
and group quotas in 1 quotaroot, plus additional quota information 
coming from different sources (fs, dict, maildir, dirsize) all in one 
quotaroot.  The downside is that there is no differentiation between 
which quota comes from where (user vs. group & fs vs dict vs maildir vs 
dirsize).  Also, this might not be what the author of the RFC had in 
mind, and it may never be supported by any clients.

Assuming that we cannot proceed with multiple of the same resources, we 
need to define what exactly a quotaroot is.  The RFC (3 Introduction and 
Overview) says:> Each mailbox has zero or more implementation-defined named "quota 
> roots". Each quota root has zero or more resource limits. All 
> mailboxes that share the same named quota root share the resource 
> limits of the quota root.This is pretty ambiguous.  A problem with the current specifications is 
that there is no mapping between mailboxes and quotaroots.  I assume 
that currently, it works by equating one quotaroot to each namespace 
with the quotaroot named for the namespace.  I know that Dovecot does 
not yet fully support this even, but if this is the case, to support 
multiple quotaroots in a namespace, we would need to define the 
quotaroots for each namespace in the Dovecot config file.  Otherwise, 
there is no way to support multiple quotaroots for any namespace.

Once quotaroots are named, it is then necessary to define the limits of 
the quotaroot and where to get the quota from (fs, maildir, dict, 
dirsize).  This could be done also in each namespace section, or it 
could be kept in the plugin section.  This can get complicated because 
ideally, you would be able to specify the name of the quotaroot, the 
backend, and which resource to use.  This is also true of filesystem 
quotas, since we want the user and group quotas to be in different 
quotaroots.  Also, some quotaroots may be used in multiple namespaces 
(such as multiple namespaces on a single filesystem).  For example:

namespace private {
    prefix     location = maildir:~/Maildir
    quotaroots = userroot grouproot
}
namespace private {
    prefix = "#moremail/"   
    location = maildir:~/mail
    quotaroot = moremailroot userroot grouproot
}
plugin {
    quota = userroot:fs:storage=user:messages=user 
grouproot:fs:storage=group:messages=group moremailroot:maildir:storage=10240
}

I do not think it would be possible to have a maildir or dirsize 
backends span multiple namespaces.  For filesystem-based quotas, 
assuming that a namespace is only on one filesystem (does not span 
across multiple partitions),  it could span partitions.


To begin to tackle this big change, I would recommend first adding a 
quotaroots variable to the config file.  Then, use this quotaroot to 
look up where to get the quota from rather than just taking it blindly 
from the plugins section regardless of the namespace.  After this, the 
dirsize, dict, and maildir quota plugins should with with little 
modification.  The fs quota plugin will require a little modification, 
as the resources are not currently passed from the conf file to the plugin.

On the other hand for the filesystem quotas, you could make the 
configuration like "quota = quotaroot:fs:source=user" or "quota =
quotaroot:fs:source=group", and just pass the source to the plugin.  The 
storage and messages would both always be returned, because if they are 
present on the filesystem, they exist and do not need to be hidden.

Another (possibly more difficult) option for filesystem-based quotas is 
to leave the config file like "quota = quotaroot:fs" and have the 
quota-fs backend return 2 quotaroots automatically if there are both 
user and group quotas (and rename the quotaroot to quotaroot-user and 
quotaroot-group).

These are my suggestions.  I'm not sure what the major changes are to 
the CVS HEAD branch, but I think there needs to be a way to map 
quotaroots to namespaces.  To answer your question, the filesystem quota 
backend probably could return 2 quotaroots without too much 
modification, but it would be a hack...and I wouldn't want the next 
version of Dovecot to start off with some hacks to get the job done!

-Scott

Maybe Matching Threads

Search for more seemingly similar threads

dovecot - Aug 2006 - Filesystem Quota Enhancement Patch

[Dovecot] Filesystem Quota Enhancement Patch

[Dovecot] Filesystem Quota Enhancement Patch

[Dovecot] Filesystem Quota Enhancement Patch

Maybe Matching Threads