Release 4.10 fs/hfsplus/catalog.c

Directory: fs/hfsplus
/*
 *  linux/fs/hfsplus/catalog.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * Handling of catalog records
 */


#include "hfsplus_fs.h"
#include "hfsplus_raw.h"



int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1,
			     const hfsplus_btree_key *k2)
{
	__be32 k1p, k2p;

	k1p = k1->cat.parent;
	k2p = k2->cat.parent;
	if (k1p != k2p)
		return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;

	return hfsplus_strcasecmp(&k1->cat.name, &k2->cat.name);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 54 71.05% 1 33.33%
david elliott david elliott 21 27.63% 1 33.33%
al viro al viro 1 1.32% 1 33.33%
Total 76 100.00% 3 100.00%



int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1,
			    const hfsplus_btree_key *k2)
{
	__be32 k1p, k2p;

	k1p = k1->cat.parent;
	k2p = k2->cat.parent;
	if (k1p != k2p)
		return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;

	return hfsplus_strcmp(&k1->cat.name, &k2->cat.name);
}

Contributors
Person Tokens Prop Commits CommitProp
david elliott david elliott 59 77.63% 1 50.00%
andrew morton andrew morton 17 22.37% 1 50.00%
Total 76 100.00% 2 100.00%

/* Generates key for catalog file/folders record. */


int hfsplus_cat_build_key(struct super_block *sb,
		hfsplus_btree_key *key, u32 parent, const struct qstr *str)
{
	int len, err;

	key->cat.parent = cpu_to_be32(parent);
	err = hfsplus_asc2uni(sb, &key->cat.name, HFSPLUS_MAX_STRLEN,
			str->name, str->len);
	if (unlikely(err < 0))
		return err;

	len = be16_to_cpu(key->cat.name.length);
	key->key_len = cpu_to_be16(6 + 2 * len);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 61 58.65% 1 20.00%
sougata santra sougata santra 33 31.73% 1 20.00%
roman zippel roman zippel 7 6.73% 1 20.00%
vyacheslav dubeyko vyacheslav dubeyko 2 1.92% 1 20.00%
al viro al viro 1 0.96% 1 20.00%
Total 104 100.00% 5 100.00%

/* Generates key for catalog thread record. */


void hfsplus_cat_build_key_with_cnid(struct super_block *sb,
			hfsplus_btree_key *key, u32 parent)
{
	key->cat.parent = cpu_to_be32(parent);
	key->cat.name.length = 0;
	key->key_len = cpu_to_be16(6);
}

Contributors
Person Tokens Prop Commits CommitProp
sougata santra sougata santra 26 55.32% 1 33.33%
andrew morton andrew morton 20 42.55% 1 33.33%
al viro al viro 1 2.13% 1 33.33%
Total 47 100.00% 3 100.00%



static void hfsplus_cat_build_key_uni(hfsplus_btree_key *key, u32 parent,
				      struct hfsplus_unistr *name)
{
	int ustrlen;

	ustrlen = be16_to_cpu(name->length);
	key->cat.parent = cpu_to_be32(parent);
	key->cat.name.length = cpu_to_be16(ustrlen);
	ustrlen *= 2;
	memcpy(key->cat.name.unicode, name->unicode, ustrlen);
	key->key_len = cpu_to_be16(6 + ustrlen);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 86 100.00% 1 100.00%
Total 86 100.00% 1 100.00%



void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms)
{
	if (inode->i_flags & S_IMMUTABLE)
		perms->rootflags |= HFSPLUS_FLG_IMMUTABLE;
	else
		perms->rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
	if (inode->i_flags & S_APPEND)
		perms->rootflags |= HFSPLUS_FLG_APPEND;
	else
		perms->rootflags &= ~HFSPLUS_FLG_APPEND;

	perms->userflags = HFSPLUS_I(inode)->userflags;
	perms->mode = cpu_to_be16(inode->i_mode);
	perms->owner = cpu_to_be32(i_uid_read(inode));
	perms->group = cpu_to_be32(i_gid_read(inode));

	if (S_ISREG(inode->i_mode))
		perms->dev = cpu_to_be32(inode->i_nlink);
	else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode))
		perms->dev = cpu_to_be32(inode->i_rdev);
	else
		perms->dev = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 93 58.12% 1 25.00%
christoph hellwig christoph hellwig 61 38.12% 2 50.00%
eric w. biederman eric w. biederman 6 3.75% 1 25.00%
Total 160 100.00% 4 100.00%



static int hfsplus_cat_build_record(hfsplus_cat_entry *entry,
		u32 cnid, struct inode *inode)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);

	if (S_ISDIR(inode->i_mode)) {
		struct hfsplus_cat_folder *folder;

		folder = &entry->folder;
		memset(folder, 0, sizeof(*folder));
		folder->type = cpu_to_be16(HFSPLUS_FOLDER);
		if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags))
			folder->flags |= cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT);
		folder->id = cpu_to_be32(inode->i_ino);
		HFSPLUS_I(inode)->create_date =
			folder->create_date =
			folder->content_mod_date =
			folder->attribute_mod_date =
			folder->access_date = hfsp_now2mt();
		hfsplus_cat_set_perms(inode, &folder->permissions);
		if (inode == sbi->hidden_dir)
			/* invisible and namelocked */
			folder->user_info.frFlags = cpu_to_be16(0x5000);
		return sizeof(*folder);
	} else {
		struct hfsplus_cat_file *file;

		file = &entry->file;
		memset(file, 0, sizeof(*file));
		file->type = cpu_to_be16(HFSPLUS_FILE);
		file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS);
		file->id = cpu_to_be32(cnid);
		HFSPLUS_I(inode)->create_date =
			file->create_date =
			file->content_mod_date =
			file->attribute_mod_date =
			file->access_date = hfsp_now2mt();
		if (cnid == inode->i_ino) {
			hfsplus_cat_set_perms(inode, &file->permissions);
			if (S_ISLNK(inode->i_mode)) {
				file->user_info.fdType =
					cpu_to_be32(HFSP_SYMLINK_TYPE);
				file->user_info.fdCreator =
					cpu_to_be32(HFSP_SYMLINK_CREATOR);
			} else {
				file->user_info.fdType =
					cpu_to_be32(sbi->type);
				file->user_info.fdCreator =
					cpu_to_be32(sbi->creator);
			}
			if (HFSPLUS_FLG_IMMUTABLE &
					(file->permissions.rootflags |
					file->permissions.userflags))
				file->flags |=
					cpu_to_be16(HFSPLUS_FILE_LOCKED);
		} else {
			file->user_info.fdType =
				cpu_to_be32(HFSP_HARDLINK_TYPE);
			file->user_info.fdCreator =
				cpu_to_be32(HFSP_HFSPLUS_CREATOR);
			file->user_info.fdFlags =
				cpu_to_be16(0x100);
			file->create_date =
				HFSPLUS_I(sbi->hidden_dir)->create_date;
			file->permissions.dev =
				cpu_to_be32(HFSPLUS_I(inode)->linkid);
		}
		return sizeof(*file);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 327 75.69% 1 10.00%
roman zippel roman zippel 59 13.66% 3 30.00%
christoph hellwig christoph hellwig 23 5.32% 4 40.00%
sergei antonov sergei antonov 21 4.86% 1 10.00%
anton salikhmetov anton salikhmetov 2 0.46% 1 10.00%
Total 432 100.00% 10 100.00%



static int hfsplus_fill_cat_thread(struct super_block *sb,
				   hfsplus_cat_entry *entry, int type,
				   u32 parentid, const struct qstr *str)
{
	int err;

	entry->type = cpu_to_be16(type);
	entry->thread.reserved = 0;
	entry->thread.parentID = cpu_to_be32(parentid);
	err = hfsplus_asc2uni(sb, &entry->thread.nodeName, HFSPLUS_MAX_STRLEN,
				str->name, str->len);
	if (unlikely(err < 0))
		return err;

	return 10 + be16_to_cpu(entry->thread.nodeName.length) * 2;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 83 75.45% 1 20.00%
sougata santra sougata santra 17 15.45% 1 20.00%
roman zippel roman zippel 7 6.36% 1 20.00%
vyacheslav dubeyko vyacheslav dubeyko 2 1.82% 1 20.00%
al viro al viro 1 0.91% 1 20.00%
Total 110 100.00% 5 100.00%

/* Try to get a catalog entry for given catalog id */


int hfsplus_find_cat(struct super_block *sb, u32 cnid,
		     struct hfs_find_data *fd)
{
	hfsplus_cat_entry tmp;
	int err;
	u16 type;

	hfsplus_cat_build_key_with_cnid(sb, fd->search_key, cnid);
	err = hfs_brec_read(fd, &tmp, sizeof(hfsplus_cat_entry));
	if (err)
		return err;

	type = be16_to_cpu(tmp.type);
	if (type != HFSPLUS_FOLDER_THREAD && type != HFSPLUS_FILE_THREAD) {
		pr_err("found bad thread record in catalog\n");
		return -EIO;
	}

	if (be16_to_cpu(tmp.thread.nodeName.length) > 255) {
		pr_err("catalog name length corrupted\n");
		return -EIO;
	}

	hfsplus_cat_build_key_uni(fd->search_key,
		be32_to_cpu(tmp.thread.parentID),
		&tmp.thread.nodeName);
	return hfs_brec_find(fd, hfs_find_rec_by_key);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 114 77.55% 1 16.67%
eric sesterhenn eric sesterhenn 24 16.33% 1 16.67%
joe perches joe perches 4 2.72% 1 16.67%
vyacheslav dubeyko vyacheslav dubeyko 2 1.36% 1 16.67%
roman zippel roman zippel 2 1.36% 1 16.67%
sougata santra sougata santra 1 0.68% 1 16.67%
Total 147 100.00% 6 100.00%



static void hfsplus_subfolders_inc(struct inode *dir)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);

	if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) {
		/*
                 * Increment subfolder count. Note, the value is only meaningful
                 * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set.
                 */
		HFSPLUS_I(dir)->subfolders++;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
sergei antonov sergei antonov 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%



static void hfsplus_subfolders_dec(struct inode *dir)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);

	if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) {
		/*
                 * Decrement subfolder count. Note, the value is only meaningful
                 * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set.
                 *
                 * Check for zero. Some subfolders may have been created
                 * by an implementation ignorant of this counter.
                 */
		if (HFSPLUS_I(dir)->subfolders)
			HFSPLUS_I(dir)->subfolders--;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
sergei antonov sergei antonov 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%



int hfsplus_create_cat(u32 cnid, struct inode *dir,
		const struct qstr *str, struct inode *inode)
{
	struct super_block *sb = dir->i_sb;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;
	int entry_size;
	int err;

	hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n",
		str->name, cnid, inode->i_nlink);
	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	if (err)
		return err;

	hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
	entry_size = hfsplus_fill_cat_thread(sb, &entry,
		S_ISDIR(inode->i_mode) ?
			HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD,
		dir->i_ino, str);
	if (unlikely(entry_size < 0)) {
		err = entry_size;
		goto err2;
	}

	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err != -ENOENT) {
		if (!err)
			err = -EEXIST;
		goto err2;
	}
	err = hfs_brec_insert(&fd, &entry, entry_size);
	if (err)
		goto err2;

	err = hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
	if (unlikely(err))
		goto err1;

	entry_size = hfsplus_cat_build_record(&entry, cnid, inode);
	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err != -ENOENT) {
		/* panic? */
		if (!err)
			err = -EEXIST;
		goto err1;
	}
	err = hfs_brec_insert(&fd, &entry, entry_size);
	if (err)
		goto err1;

	dir->i_size++;
	if (S_ISDIR(inode->i_mode))
		hfsplus_subfolders_inc(dir);
	dir->i_mtime = dir->i_ctime = current_time(dir);
	hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);

	hfs_find_exit(&fd);
	return 0;

err1:
	hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
	if (!hfs_brec_find(&fd, hfs_find_rec_by_key))
		hfs_brec_remove(&fd);
err2:
	hfs_find_exit(&fd);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 286 76.47% 3 23.08%
sougata santra sougata santra 32 8.56% 1 7.69%
sergei antonov sergei antonov 14 3.74% 1 7.69%
christoph hellwig christoph hellwig 12 3.21% 2 15.38%
alexey khoroshilov alexey khoroshilov 9 2.41% 1 7.69%
roman zippel roman zippel 8 2.14% 1 7.69%
vyacheslav dubeyko vyacheslav dubeyko 6 1.60% 1 7.69%
deepa dinamani deepa dinamani 4 1.07% 1 7.69%
joe perches joe perches 2 0.53% 1 7.69%
al viro al viro 1 0.27% 1 7.69%
Total 374 100.00% 13 100.00%



int hfsplus_delete_cat(u32 cnid, struct inode *dir, const struct qstr *str)
{
	struct super_block *sb = dir->i_sb;
	struct hfs_find_data fd;
	struct hfsplus_fork_raw fork;
	struct list_head *pos;
	int err, off;
	u16 type;

	hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	if (err)
		return err;

	if (!str) {
		int len;

		hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
		err = hfs_brec_find(&fd, hfs_find_rec_by_key);
		if (err)
			goto out;

		off = fd.entryoffset +
			offsetof(struct hfsplus_cat_thread, nodeName);
		fd.search_key->cat.parent = cpu_to_be32(dir->i_ino);
		hfs_bnode_read(fd.bnode,
			&fd.search_key->cat.name.length, off, 2);
		len = be16_to_cpu(fd.search_key->cat.name.length) * 2;
		hfs_bnode_read(fd.bnode,
			&fd.search_key->cat.name.unicode,
			off + 2, len);
		fd.search_key->key_len = cpu_to_be16(6 + len);
	} else {
		err = hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
		if (unlikely(err))
			goto out;
	}

	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err)
		goto out;

	type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
	if (type == HFSPLUS_FILE) {
#if 0
		off = fd.entryoffset + offsetof(hfsplus_cat_file, data_fork);
                hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork));
                hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA);
#endif

		off = fd.entryoffset +
			offsetof(struct hfsplus_cat_file, rsrc_fork);
		hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork));
		hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC);
	}

	/* we only need to take spinlock for exclusion with ->release() */
	spin_lock(&HFSPLUS_I(dir)->open_dir_lock);
	list_for_each(pos, &HFSPLUS_I(dir)->open_dir_list) {
		struct hfsplus_readdir_data *rd =
			list_entry(pos, struct hfsplus_readdir_data, list);
		if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0)
			rd->file->f_pos--;
	}
	spin_unlock(&HFSPLUS_I(dir)->open_dir_lock);

	err = hfs_brec_remove(&fd);
	if (err)
		goto out;

	hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err)
		goto out;

	err = hfs_brec_remove(&fd);
	if (err)
		goto out;

	dir->i_size--;
	if (type == HFSPLUS_FOLDER)
		hfsplus_subfolders_dec(dir);
	dir->i_mtime = dir->i_ctime = current_time(dir);
	hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);

	if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) {
		if (HFSPLUS_SB(sb)->attr_tree)
			hfsplus_delete_all_attrs(dir, cnid);
	}

out:
	hfs_find_exit(&fd);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 443 79.39% 2 13.33%
vyacheslav dubeyko vyacheslav dubeyko 34 6.09% 1 6.67%
al viro al viro 24 4.30% 2 13.33%
sougata santra sougata santra 14 2.51% 1 6.67%
sergei antonov sergei antonov 11 1.97% 1 6.67%
alexey khoroshilov alexey khoroshilov 9 1.61% 1 6.67%
christoph hellwig christoph hellwig 9 1.61% 3 20.00%
roman zippel roman zippel 6 1.08% 1 6.67%
deepa dinamani deepa dinamani 4 0.72% 1 6.67%
dan carpenter dan carpenter 2 0.36% 1 6.67%
joe perches joe perches 2 0.36% 1 6.67%
Total 558 100.00% 15 100.00%



int hfsplus_rename_cat(u32 cnid,
		       struct inode *src_dir, const struct qstr *src_name,
		       struct inode *dst_dir, const struct qstr *dst_name)
{
	struct super_block *sb = src_dir->i_sb;
	struct hfs_find_data src_fd, dst_fd;
	hfsplus_cat_entry entry;
	int entry_size, type;
	int err;

	hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
		cnid, src_dir->i_ino, src_name->name,
		dst_dir->i_ino, dst_name->name);
	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
	if (err)
		return err;
	dst_fd = src_fd;

	/* find the old dir entry and read the data */
	err = hfsplus_cat_build_key(sb, src_fd.search_key,
			src_dir->i_ino, src_name);
	if (unlikely(err))
		goto out;

	err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
	if (err)
		goto out;
	if (src_fd.entrylength > sizeof(entry) || src_fd.entrylength < 0) {
		err = -EIO;
		goto out;
	}

	hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
				src_fd.entrylength);
	type = be16_to_cpu(entry.type);

	/* create new dir entry with the data from the old entry */
	err = hfsplus_cat_build_key(sb, dst_fd.search_key,
			dst_dir->i_ino, dst_name);
	if (unlikely(err))
		goto out;

	err = hfs_brec_find(&dst_fd, hfs_find_rec_by_key);
	if (err != -ENOENT) {
		if (!err)
			err = -EEXIST;
		goto out;
	}

	err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
	if (err)
		goto out;
	dst_dir->i_size++;
	if (type == HFSPLUS_FOLDER)
		hfsplus_subfolders_inc(dst_dir);
	dst_dir->i_mtime = dst_dir->i_ctime = current_time(dst_dir);

	/* finally remove the old entry */
	err = hfsplus_cat_build_key(sb, src_fd.search_key,
			src_dir->i_ino, src_name);
	if (unlikely(err))
		goto out;

	err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
	if (err)
		goto out;
	err = hfs_brec_remove(&src_fd);
	if (err)
		goto out;
	src_dir->i_size--;
	if (type == HFSPLUS_FOLDER)
		hfsplus_subfolders_dec(src_dir);
	src_dir->i_mtime = src_dir->i_ctime = current_time(src_dir);

	/* remove old thread entry */
	hfsplus_cat_build_key_with_cnid(sb, src_fd.search_key, cnid);
	err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
	if (err)
		goto out;
	type = hfs_bnode_read_u16(src_fd.bnode, src_fd.entryoffset);
	err = hfs_brec_remove(&src_fd);
	if (err)
		goto out;

	/* create new thread entry */
	hfsplus_cat_build_key_with_cnid(sb, dst_fd.search_key, cnid);
	entry_size = hfsplus_fill_cat_thread(sb, &entry, type,
		dst_dir->i_ino, dst_name);
	if (unlikely(entry_size < 0)) {
		err = entry_size;
		goto out;
	}

	err = hfs_brec_find(&dst_fd, hfs_find_rec_by_key);
	if (err != -ENOENT) {
		if (!err)
			err = -EEXIST;
		goto out;
	}
	err = hfs_brec_insert(&dst_fd, &entry, entry_size);

	hfsplus_mark_inode_dirty(dst_dir, HFSPLUS_I_CAT_DIRTY);
	hfsplus_mark_inode_dirty(src_dir, HFSPLUS_I_CAT_DIRTY);
out:
	hfs_bnode_put(dst_fd.bnode);
	hfs_find_exit(&src_fd);
	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 412 70.07% 2 15.38%
sougata santra sougata santra 56 9.52% 1 7.69%
sergei antonov sergei antonov 31 5.27% 1 7.69%
greg kroah-hartman greg kroah-hartman 27 4.59% 1 7.69%
christoph hellwig christoph hellwig 19 3.23% 2 15.38%
roman zippel roman zippel 12 2.04% 1 7.69%
vyacheslav dubeyko vyacheslav dubeyko 10 1.70% 1 7.69%
alexey khoroshilov alexey khoroshilov 9 1.53% 1 7.69%
deepa dinamani deepa dinamani 8 1.36% 1 7.69%
joe perches joe perches 2 0.34% 1 7.69%
al viro al viro 2 0.34% 1 7.69%
Total 588 100.00% 13 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 2004 69.85% 3 10.71%
sougata santra sougata santra 181 6.31% 1 3.57%
sergei antonov sergei antonov 178 6.20% 1 3.57%
christoph hellwig christoph hellwig 124 4.32% 5 17.86%
roman zippel roman zippel 101 3.52% 4 14.29%
david elliott david elliott 80 2.79% 1 3.57%
vyacheslav dubeyko vyacheslav dubeyko 56 1.95% 1 3.57%
al viro al viro 31 1.08% 3 10.71%
greg kroah-hartman greg kroah-hartman 27 0.94% 1 3.57%
alexey khoroshilov alexey khoroshilov 27 0.94% 1 3.57%
eric sesterhenn eric sesterhenn 24 0.84% 1 3.57%
deepa dinamani deepa dinamani 16 0.56% 1 3.57%
joe perches joe perches 10 0.35% 2 7.14%
eric w. biederman eric w. biederman 6 0.21% 1 3.57%
dan carpenter dan carpenter 2 0.07% 1 3.57%
anton salikhmetov anton salikhmetov 2 0.07% 1 3.57%
Total 2869 100.00% 28 100.00%
Directory: fs/hfsplus

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
andrew morton	andrew morton	54	71.05%	1	33.33%
david elliott	david elliott	21	27.63%	1	33.33%
al viro	al viro	1	1.32%	1	33.33%
	Total	76	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/hfsplus/catalog.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
