Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

7 files changed, 203 insertions, 50 deletions

diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 90ebab753d30..050d29c0a5b5 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -62,8 +62,10 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
                 if ((HFSPLUS_SB(sb).flags & HFSPLUS_SB_HFSX) &&
                     (head->key_type == HFSPLUS_KEY_BINARY))
                         tree->keycmp = hfsplus_cat_bin_cmp_key;
-                else
+                else {
                         tree->keycmp = hfsplus_cat_case_cmp_key;
+                        HFSPLUS_SB(sb).flags |= HFSPLUS_SB_CASEFOLD;
+                }
         } else {
                 printk(KERN_ERR "hfs: unknown B*Tree requested\n");
                 goto fail_page;
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 80b5682a2273..1955ee61251c 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -36,6 +36,8 @@ static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
         u16 type;
 
         sb = dir->i_sb;
+
+        dentry->d_op = &hfsplus_dentry_operations;
         dentry->d_fsdata = NULL;
         hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd);
         hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 3915635b4470..d9f5eda6d039 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -150,6 +150,7 @@ struct hfsplus_sb_info {
 #define HFSPLUS_SB_NODECOMPOSE  0x0002
 #define HFSPLUS_SB_FORCE        0x0004
 #define HFSPLUS_SB_HFSX         0x0008
+#define HFSPLUS_SB_CASEFOLD     0x0010
 
 
 struct hfsplus_inode_info {
@@ -321,6 +322,7 @@ void hfsplus_file_truncate(struct inode *);
 /* inode.c */
 extern const struct address_space_operations hfsplus_aops;
 extern const struct address_space_operations hfsplus_btree_aops;
+extern struct dentry_operations hfsplus_dentry_operations;
 
 void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
 void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
@@ -353,6 +355,8 @@ int hfsplus_strcasecmp(const struct hfsplus_unistr *, const struct hfsplus_unist
 int hfsplus_strcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
 int hfsplus_uni2asc(struct super_block *, const struct hfsplus_unistr *, char *, int *);
 int hfsplus_asc2uni(struct super_block *, struct hfsplus_unistr *, const char *, int);
+int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str);
+int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2);
 
 /* wrapper.c */
 int hfsplus_read_wrapper(struct super_block *);
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 409ce5429c91..6f7c662174db 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -131,6 +131,11 @@ const struct address_space_operations hfsplus_aops = {
         .writepages     = hfsplus_writepages,
 };
 
+struct dentry_operations hfsplus_dentry_operations = {
+        .d_hash       = hfsplus_hash_dentry,
+        .d_compare    = hfsplus_compare_dentry,
+};
+
 static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry,
                                           struct nameidata *nd)
 {
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 79fd10402ea3..b60c0affbec5 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -38,7 +38,7 @@ int hfsplus_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                 if (IS_RDONLY(inode))
                         return -EROFS;
 
-                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                if (!is_owner_or_cap(inode))
                         return -EACCES;
 
                 if (get_user(flags, (int __user *)arg))
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index ebd1b380cbbc..7b0f2e5a44e2 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -283,11 +283,10 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         struct nls_table *nls = NULL;
         int err = -EINVAL;
 
-        sbi = kmalloc(sizeof(struct hfsplus_sb_info), GFP_KERNEL);
+        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
 
-        memset(sbi, 0, sizeof(HFSPLUS_SB(sb)));
         sb->s_fs_info = sbi;
         INIT_HLIST_HEAD(&sbi->rsrc_inodes);
         hfsplus_fill_defaults(sbi);
@@ -381,6 +380,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                 iput(root);
                 goto cleanup;
         }
+        sb->s_root->d_op = &hfsplus_dentry_operations;
 
         str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
         str.name = HFSP_HIDDENDIR_NAME;
@@ -479,7 +479,7 @@ static int __init init_hfsplus_fs(void)
 
         hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
                 HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN,
-                hfsplus_init_once, NULL);
+                hfsplus_init_once);
         if (!hfsplus_inode_cachep)
                 return -ENOMEM;
         err = register_filesystem(&hfsplus_fs_type);
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index 689c8bd721fb..9e10f9444b64 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -239,61 +239,201 @@ out:
         return res;
 }
 
-int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr, const char *astr, int len)
+/*
+ * Convert one or more ASCII characters into a single unicode character.
+ * Returns the number of ASCII characters corresponding to the unicode char.
+ */
+static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
+                              wchar_t *uc)
 {
-        struct nls_table *nls = HFSPLUS_SB(sb).nls;
-        int size, off, decompose;
+        int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc);
+        if (size <= 0) {
+                *uc = '?';
+                size = 1;
+        }
+        switch (*uc) {
+        case 0x2400:
+                *uc = 0;
+                break;
+        case ':':
+                *uc = '/';
+                break;
+        }
+        return size;
+}
+
+/* Decomposes a single unicode character. */
+static inline u16 *decompose_unichar(wchar_t uc, int *size)
+{
+        int off;
+
+        off = hfsplus_decompose_table[(uc >> 12) & 0xf];
+        if (off == 0 || off == 0xffff)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
+        if (!off)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
+        if (!off)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + (uc & 0xf)];
+        *size = off & 3;
+        if (*size == 0)
+                return NULL;
+        return hfsplus_decompose_table + (off / 4);
+}
+
+int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
+                    const char *astr, int len)
+{
+        int size, dsize, decompose;
+        u16 *dstr, outlen = 0;
         wchar_t c;
-        u16 outlen = 0;
 
         decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
-
         while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
-                size = nls->char2uni(astr, len, &c);
-                if (size <= 0) {
-                        c = '?';
-                        size = 1;
-                }
-                astr += size;
-                len -= size;
-                switch (c) {
-                case 0x2400:
-                        c = 0;
-                        break;
-                case ':':
-                        c = '/';
-                        break;
-                }
-                if (c >= 0xc0 && decompose) {
-                        off = hfsplus_decompose_table[(c >> 12) & 0xf];
-                        if (!off)
-                                goto done;
-                        if (off == 0xffff) {
-                                goto done;
-                        }
-                        off = hfsplus_decompose_table[off + ((c >> 8) & 0xf)];
-                        if (!off)
-                                goto done;
-                        off = hfsplus_decompose_table[off + ((c >> 4) & 0xf)];
-                        if (!off)
-                                goto done;
-                        off = hfsplus_decompose_table[off + (c & 0xf)];
-                        size = off & 3;
-                        if (!size)
-                                goto done;
-                        off /= 4;
-                        if (outlen + size > HFSPLUS_MAX_STRLEN)
+                size = asc2unichar(sb, astr, len, &c);
+
+                if (decompose && (dstr = decompose_unichar(c, &dsize))) {
+                        if (outlen + dsize > HFSPLUS_MAX_STRLEN)
                                 break;
                         do {
-                                ustr->unicode[outlen++] = cpu_to_be16(hfsplus_decompose_table[off++]);
-                        } while (--size > 0);
-                        continue;
-                }
-        done:
-                ustr->unicode[outlen++] = cpu_to_be16(c);
+                                ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
+                        } while (--dsize > 0);
+                } else
+                        ustr->unicode[outlen++] = cpu_to_be16(c);
+
+                astr += size;
+                len -= size;
         }
         ustr->length = cpu_to_be16(outlen);
         if (len > 0)
                 return -ENAMETOOLONG;
         return 0;
 }
+
+/*
+ * Hash a string to an integer as appropriate for the HFS+ filesystem.
+ * Composed unicode characters are decomposed and case-folding is performed
+ * if the appropriate bits are (un)set on the superblock.
+ */
+int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
+{
+        struct super_block *sb = dentry->d_sb;
+        const char *astr;
+        const u16 *dstr;
+        int casefold, decompose, size, dsize, len;
+        unsigned long hash;
+        wchar_t c;
+        u16 c2;
+
+        casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
+        decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
+        hash = init_name_hash();
+        astr = str->name;
+        len = str->len;
+        while (len > 0) {
+                size = asc2unichar(sb, astr, len, &c);
+                astr += size;
+                len -= size;
+
+                if (decompose && (dstr = decompose_unichar(c, &dsize))) {
+                        do {
+                                c2 = *dstr++;
+                                if (!casefold || (c2 = case_fold(c2)))
+                                        hash = partial_name_hash(c2, hash);
+                        } while (--dsize > 0);
+                } else {
+                        c2 = c;
+                        if (!casefold || (c2 = case_fold(c2)))
+                                hash = partial_name_hash(c2, hash);
+                }
+        }
+        str->hash = end_name_hash(hash);
+
+        return 0;
+}
+
+/*
+ * Compare strings with HFS+ filename ordering.
+ * Composed unicode characters are decomposed and case-folding is performed
+ * if the appropriate bits are (un)set on the superblock.
+ */
+int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2)
+{
+        struct super_block *sb = dentry->d_sb;
+        int casefold, decompose, size;
+        int dsize1, dsize2, len1, len2;
+        const u16 *dstr1, *dstr2;
+        const char *astr1, *astr2;
+        u16 c1, c2;
+        wchar_t c;
+
+        casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
+        decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
+        astr1 = s1->name;
+        len1 = s1->len;
+        astr2 = s2->name;
+        len2 = s2->len;
+        dsize1 = dsize2 = 0;
+        dstr1 = dstr2 = NULL;
+
+        while (len1 > 0 && len2 > 0) {
+                if (!dsize1) {
+                        size = asc2unichar(sb, astr1, len1, &c);
+                        astr1 += size;
+                        len1 -= size;
+
+                        if (!decompose || !(dstr1 = decompose_unichar(c, &dsize1))) {
+                                c1 = c;
+                                dstr1 = &c1;
+                                dsize1 = 1;
+                        }
+                }
+
+                if (!dsize2) {
+                        size = asc2unichar(sb, astr2, len2, &c);
+                        astr2 += size;
+                        len2 -= size;
+
+                        if (!decompose || !(dstr2 = decompose_unichar(c, &dsize2))) {
+                                c2 = c;
+                                dstr2 = &c2;
+                                dsize2 = 1;
+                        }
+                }
+
+                c1 = *dstr1;
+                c2 = *dstr2;
+                if (casefold) {
+                        if  (!(c1 = case_fold(c1))) {
+                                dstr1++;
+                                dsize1--;
+                                continue;
+                        }
+                        if (!(c2 = case_fold(c2))) {
+                                dstr2++;
+                                dsize2--;
+                                continue;
+                        }
+                }
+                if (c1 < c2)
+                        return -1;
+                else if (c1 > c2)
+                        return 1;
+
+                dstr1++;
+                dsize1--;
+                dstr2++;
+                dsize2--;
+        }
+
+        if (len1 < len2)
+                return -1;
+        if (len1 > len2)
+                return 1;
+        return 0;
+}