Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 99 insertions, 0 deletions

diff --git a/fs/xattr_acl.c b/fs/xattr_acl.c
new file mode 100644
index 000000000000..789a2559bd54
--- /dev/null
+++ b/fs/xattr_acl.c
@@ -0,0 +1,99 @@
+/*
+ * linux/fs/xattr_acl.c
+ *
+ * Almost all from linux/fs/ext2/acl.c:
+ * Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
+ */
+
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/posix_acl_xattr.h>
+
+
+/*
+ * Convert from extended attribute to in-memory representation.
+ */
+struct posix_acl *
+posix_acl_from_xattr(const void *value, size_t size)
+{
+        posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
+        posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
+        int count;
+        struct posix_acl *acl;
+        struct posix_acl_entry *acl_e;
+
+        if (!value)
+                return NULL;
+        if (size < sizeof(posix_acl_xattr_header))
+                 return ERR_PTR(-EINVAL);
+        if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
+                return ERR_PTR(-EOPNOTSUPP);
+
+        count = posix_acl_xattr_count(size);
+        if (count < 0)
+                return ERR_PTR(-EINVAL);
+        if (count == 0)
+                return NULL;
+        
+        acl = posix_acl_alloc(count, GFP_KERNEL);
+        if (!acl)
+                return ERR_PTR(-ENOMEM);
+        acl_e = acl->a_entries;
+        
+        for (end = entry + count; entry != end; acl_e++, entry++) {
+                acl_e->e_tag  = le16_to_cpu(entry->e_tag);
+                acl_e->e_perm = le16_to_cpu(entry->e_perm);
+
+                switch(acl_e->e_tag) {
+                        case ACL_USER_OBJ:
+                        case ACL_GROUP_OBJ:
+                        case ACL_MASK:
+                        case ACL_OTHER:
+                                acl_e->e_id = ACL_UNDEFINED_ID;
+                                break;
+
+                        case ACL_USER:
+                        case ACL_GROUP:
+                                acl_e->e_id = le32_to_cpu(entry->e_id);
+                                break;
+
+                        default:
+                                goto fail;
+                }
+        }
+        return acl;
+
+fail:
+        posix_acl_release(acl);
+        return ERR_PTR(-EINVAL);
+}
+EXPORT_SYMBOL (posix_acl_from_xattr);
+
+/*
+ * Convert from in-memory to extended attribute representation.
+ */
+int
+posix_acl_to_xattr(const struct posix_acl *acl, void *buffer, size_t size)
+{
+        posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
+        posix_acl_xattr_entry *ext_entry = ext_acl->a_entries;
+        int real_size, n;
+
+        real_size = posix_acl_xattr_size(acl->a_count);
+        if (!buffer)
+                return real_size;
+        if (real_size > size)
+                return -ERANGE;
+        
+        ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
+
+        for (n=0; n < acl->a_count; n++, ext_entry++) {
+                ext_entry->e_tag  = cpu_to_le16(acl->a_entries[n].e_tag);
+                ext_entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
+                ext_entry->e_id   = cpu_to_le32(acl->a_entries[n].e_id);
+        }
+        return real_size;
+}
+EXPORT_SYMBOL (posix_acl_to_xattr);