[DLM] compat patch

Here's a patch which add 32/64 bit compat to the DLM IOs and tidies the
structures for alignment.

As it causes an ABI change I had few qualms about adding the extra flag for
"is64bit" as it simply uses a byte that would have been padding.

Cc: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

1 files changed, 156 insertions, 10 deletions

diff --git a/fs/dlm/device.c b/fs/dlm/device.c
index 49a20d549216..47798fe46d72 100644
--- a/fs/dlm/device.c
+++ b/fs/dlm/device.c
@@ -2,7 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+**  Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 **
 **  This copyrighted material is made available to anyone wishing to use,
 **  modify, copy, or redistribute it subject to the terms and conditions
@@ -59,6 +59,9 @@ static rwlock_t lockinfo_lock;
 #define LS_FLAG_DELETED   1
 #define LS_FLAG_AUTOFREE  2
 
+/* flags in ls_flags*/
+#define FI_FLAG_OPEN      1
+#define FI_FLAG_COMPAT    2
 
 #define LOCKINFO_MAGIC 0x53595324
 
@@ -117,9 +120,110 @@ struct file_info {
 	wait_queue_head_t   fi_wait;
 	struct user_ls     *fi_ls;
 	atomic_t            fi_refcnt;   /* Number of users */
-	unsigned long       fi_flags;    /* Bit 1 means the device is open */
+	unsigned long       fi_flags;
+};
+
+#ifdef CONFIG_COMPAT
+
+struct dlm_lock_params32 {
+	__u8 mode;
+	__u8 namelen;
+	__u16 flags;
+	__u32 lkid;
+	__u32 parent;
+
+	__u32 castparam;
+	__u32 castaddr;
+	__u32 bastparam;
+	__u32 bastaddr;
+	__u32 lksb;
+
+	char lvb[DLM_USER_LVB_LEN];
+	char name[0];
 };
 
+struct dlm_write_request32 {
+	__u32 version[3];
+	__u8 cmd;
+	__u8 is64bit;
+	__u8 unused[2];
+
+	union  {
+		struct dlm_lock_params32 lock;
+		struct dlm_lspace_params lspace;
+	} i;
+};
+
+struct dlm_lksb32 {
+	__u32 	 sb_status;
+	__u32    sb_lkid;
+	__u8 	 sb_flags;
+	__u32    sb_lvbptr;
+};
+
+struct dlm_lock_result32 {
+	__u32 length;
+	__u32 user_astaddr;
+	__u32 user_astparam;
+	__u32 user_lksb;
+	struct dlm_lksb32 lksb;
+	__u8 bast_mode;
+	__u8 unused[3];
+	/* Offsets may be zero if no data is present */
+	__u32 lvb_offset;
+};
+
+
+static void compat_input(struct dlm_write_request *kparams, struct dlm_write_request32 *k32params)
+{
+
+	kparams->version[0] = k32params->version[0];
+	kparams->version[1] = k32params->version[1];
+	kparams->version[2] = k32params->version[2];
+
+	kparams->cmd = k32params->cmd;
+	kparams->is64bit = k32params->is64bit;
+	if (kparams->cmd == DLM_USER_CREATE_LOCKSPACE ||
+	    kparams->cmd == DLM_USER_REMOVE_LOCKSPACE) {
+
+		kparams->i.lspace.flags = k32params->i.lspace.flags;
+		kparams->i.lspace.minor = k32params->i.lspace.minor;
+		strcpy(kparams->i.lspace.name, k32params->i.lspace.name);
+	}
+	else {
+		kparams->i.lock.mode = k32params->i.lock.mode;
+		kparams->i.lock.namelen = k32params->i.lock.namelen;
+		kparams->i.lock.flags = k32params->i.lock.flags;
+		kparams->i.lock.lkid = k32params->i.lock.lkid;
+		kparams->i.lock.parent = k32params->i.lock.parent;
+		kparams->i.lock.castparam = (void *)(long)k32params->i.lock.castparam;
+		kparams->i.lock.castaddr = (void *)(long)k32params->i.lock.castaddr;
+		kparams->i.lock.bastparam = (void *)(long)k32params->i.lock.bastparam;
+		kparams->i.lock.bastaddr = (void *)(long)k32params->i.lock.bastaddr;
+		kparams->i.lock.lksb = (void *)(long)k32params->i.lock.lksb;
+		memcpy(kparams->i.lock.lvb, k32params->i.lock.lvb, DLM_USER_LVB_LEN);
+		memcpy(kparams->i.lock.name, k32params->i.lock.name, kparams->i.lock.namelen);
+	}
+}
+
+void compat_output(struct dlm_lock_result *res, struct dlm_lock_result32 *res32)
+{
+	res32->length = res->length - (sizeof(struct dlm_lock_result) - sizeof(struct dlm_lock_result32));
+	res32->user_astaddr = (__u32)(long)res->user_astaddr;
+	res32->user_astparam = (__u32)(long)res->user_astparam;
+	res32->user_lksb = (__u32)(long)res->user_lksb;
+	res32->bast_mode = res->bast_mode;
+
+	res32->lvb_offset = res->lvb_offset;
+	res32->length = res->length;
+
+	res32->lksb.sb_status = res->lksb.sb_status;
+	res32->lksb.sb_flags = res->lksb.sb_flags;
+	res32->lksb.sb_lkid = res->lksb.sb_lkid;
+	res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
+}
+#endif
+
 
 /* get and put ops for file_info.
    Actually I don't really like "get" and "put", but everyone
@@ -364,7 +468,7 @@ static void ast_routine(void *param)
 			li->li_grmode = li->li_rqmode;
 
 		/* Only queue AST if the device is still open */
-		if (test_bit(1, &li->li_file->fi_flags))
+		if (test_bit(FI_FLAG_OPEN, &li->li_file->fi_flags))
 			add_to_astqueue(li, li->li_castaddr, li->li_castparam,
 					lvb_updated);
 
@@ -449,7 +553,7 @@ static int dlm_open(struct inode *inode, struct file *file)
 	f->fi_ls = lsinfo;
 	f->fi_flags = 0;
 	get_file_info(f);
-	set_bit(1, &f->fi_flags);
+	set_bit(FI_FLAG_OPEN, &f->fi_flags);
 
 	file->private_data = f;
 
@@ -494,7 +598,7 @@ static int dlm_close(struct inode *inode, struct file *file)
 		return -ENOENT;
 
 	/* Mark this closed so that ASTs will not be delivered any more */
-	clear_bit(1, &f->fi_flags);
+	clear_bit(FI_FLAG_OPEN, &f->fi_flags);
 
 	/* Block signals while we are doing this */
 	sigfillset(&allsigs);
@@ -643,11 +747,18 @@ static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count,
 {
 	struct file_info *fi = file->private_data;
 	struct ast_info *ast;
+	void *data;
 	int data_size;
+	int struct_size;
 	int offset;
 	DECLARE_WAITQUEUE(wait, current);
+#ifdef CONFIG_COMPAT
+	struct dlm_lock_result32 result32;
 
+	if (count < sizeof(struct dlm_lock_result32))
+#else
 	if (count < sizeof(struct dlm_lock_result))
+#endif
 		return -EINVAL;
 
 	spin_lock(&fi->fi_ast_lock);
@@ -691,11 +802,21 @@ static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count,
 	spin_unlock(&fi->fi_ast_lock);
 
 	/* Work out the size of the returned data */
-	data_size = sizeof(struct dlm_lock_result);
+#ifdef CONFIG_COMPAT
+	if (test_bit(FI_FLAG_COMPAT, &fi->fi_flags)) {
+		data_size = struct_size = sizeof(struct dlm_lock_result32);
+		data = &result32;
+	}
+	else
+#endif
+	{
+		data_size = struct_size = sizeof(struct dlm_lock_result);
+		data = &ast->result;
+	}
 	if (ast->lvb_updated && ast->result.lksb.sb_lvbptr)
 		data_size += DLM_USER_LVB_LEN;
 
-	offset = sizeof(struct dlm_lock_result);
+	offset = struct_size;
 
 	/* Room for the extended data ? */
 	if (count >= data_size) {
@@ -711,8 +832,13 @@ static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count,
 	}
 
 	ast->result.length = data_size;
+
+#ifdef CONFIG_COMPAT
+	compat_output(&ast->result, &result32);
+#endif
+
 	/* Copy the header now it has all the offsets in it */
-	if (copy_to_user(buffer, &ast->result, sizeof(struct dlm_lock_result)))
+	if (copy_to_user(buffer, data, struct_size))
 		offset = -EFAULT;
 
 	/* If we only returned a header and there's more to come then put it
@@ -970,8 +1096,14 @@ static ssize_t dlm_write(struct file *file, const char __user *buffer,
 	sigset_t allsigs;
 	int status;
 
-	/* -1 because lock name is optional */
-	if (count < sizeof(struct dlm_write_request)-1)
+#ifdef CONFIG_COMPAT
+	if (count < sizeof(struct dlm_write_request32))
+#else
+	if (count < sizeof(struct dlm_write_request))
+#endif
+		return -EINVAL;
+
+	if (count > sizeof(struct dlm_write_request) + DLM_RESNAME_MAXLEN)
 		return -EINVAL;
 
 	/* Has the lockspace been deleted */
@@ -991,6 +1123,20 @@ static ssize_t dlm_write(struct file *file, const char __user *buffer,
 	if (check_version(kparams))
 		goto out_free;
 
+#ifdef CONFIG_COMPAT
+	if (!kparams->is64bit) {
+		struct dlm_write_request32 *k32params = (struct dlm_write_request32 *)kparams;
+		kparams = kmalloc(count + (sizeof(struct dlm_write_request) - sizeof(struct dlm_write_request32)), GFP_KERNEL);
+		if (!kparams)
+			return -ENOMEM;
+
+		if (fi)
+			set_bit(FI_FLAG_COMPAT, &fi->fi_flags);
+		compat_input(kparams, k32params);
+		kfree(k32params);
+	}
+#endif
+
 	/* Block signals while we are doing this */
 	sigfillset(&allsigs);
 	sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);