Release 4.11 drivers/mtd/mtdpart.c
/*
* Simple MTD partitioning layer
*
* Copyright © 2000 Nicolas Pitre <nico@fluxnic.net>
* Copyright © 2002 Thomas Gleixner <gleixner@linutronix.de>
* Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/kmod.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/err.h>
#include "mtdcore.h"
/* Our partition linked list */
static LIST_HEAD(mtd_partitions);
static DEFINE_MUTEX(mtd_partitions_mutex);
/* Our partition node structure */
struct mtd_part {
struct mtd_info mtd;
struct mtd_info *master;
uint64_t offset;
struct list_head list;
};
/*
* Given a pointer to the MTD object in the mtd_part structure, we can retrieve
* the pointer to that structure.
*/
static inline struct mtd_part *mtd_to_part(const struct mtd_info *mtd)
{
return container_of(mtd, struct mtd_part, mtd);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Brian Norris | 24 | 92.31% | 1 | 50.00% |
| Linus Torvalds (pre-git) | 2 | 7.69% | 1 | 50.00% |
| Total | 26 | 100.00% | 2 | 100.00% |
/*
* MTD methods which simply translate the effective address and pass through
* to the _real_ device.
*/
static int part_read(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
struct mtd_ecc_stats stats;
int res;
stats = part->master->ecc_stats;
res = part->master->_read(part->master, from + part->offset, len,
retlen, buf);
if (unlikely(mtd_is_eccerr(res)))
mtd->ecc_stats.failed +=
part->master->ecc_stats.failed - stats.failed;
else
mtd->ecc_stats.corrected +=
part->master->ecc_stats.corrected - stats.corrected;
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 52 | 41.60% | 1 | 14.29% |
| Yauhen Kharuzhy | 32 | 25.60% | 1 | 14.29% |
| Thomas Gleixner | 24 | 19.20% | 1 | 14.29% |
| Mike Dunn | 14 | 11.20% | 2 | 28.57% |
| Brian Norris | 3 | 2.40% | 2 | 28.57% |
| Total | 125 | 100.00% | 7 | 100.00% |
static int part_point(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, void **virt, resource_size_t *phys)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_point(part->master, from + part->offset, len,
retlen, virt, phys);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 47 | 71.21% | 1 | 20.00% |
| Jared Hulbert | 9 | 13.64% | 1 | 20.00% |
| Mike Dunn | 5 | 7.58% | 1 | 20.00% |
| David Woodhouse | 4 | 6.06% | 1 | 20.00% |
| Brian Norris | 1 | 1.52% | 1 | 20.00% |
| Total | 66 | 100.00% | 5 | 100.00% |
static int part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_unpoint(part->master, from + part->offset, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 33 | 70.21% | 1 | 20.00% |
| Mike Dunn | 5 | 10.64% | 1 | 20.00% |
| David Woodhouse | 5 | 10.64% | 1 | 20.00% |
| Artem B. Bityutskiy | 3 | 6.38% | 1 | 20.00% |
| Brian Norris | 1 | 2.13% | 1 | 20.00% |
| Total | 47 | 100.00% | 5 | 100.00% |
static unsigned long part_get_unmapped_area(struct mtd_info *mtd,
unsigned long len,
unsigned long offset,
unsigned long flags)
{
struct mtd_part *part = mtd_to_part(mtd);
offset += part->offset;
return part->master->_get_unmapped_area(part->master, len, offset,
flags);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Howells | 52 | 89.66% | 1 | 33.33% |
| Mike Dunn | 5 | 8.62% | 1 | 33.33% |
| Brian Norris | 1 | 1.72% | 1 | 33.33% |
| Total | 58 | 100.00% | 3 | 100.00% |
static int part_read_oob(struct mtd_info *mtd, loff_t from,
struct mtd_oob_ops *ops)
{
struct mtd_part *part = mtd_to_part(mtd);
int res;
if (from >= mtd->size)
return -EINVAL;
if (ops->datbuf && from + ops->len > mtd->size)
return -EINVAL;
/*
* If OOB is also requested, make sure that we do not read past the end
* of this partition.
*/
if (ops->oobbuf) {
size_t len, pages;
len = mtd_oobavail(mtd, ops);
pages = mtd_div_by_ws(mtd->size, mtd);
pages -= mtd_div_by_ws(from, mtd);
if (ops->ooboffs + ops->ooblen > pages * len)
return -EINVAL;
}
res = part->master->_read_oob(part->master, from + part->offset, ops);
if (unlikely(res)) {
if (mtd_is_bitflip(res))
mtd->ecc_stats.corrected++;
if (mtd_is_eccerr(res))
mtd->ecc_stats.failed++;
}
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Artem B. Bityutskiy | 56 | 30.11% | 1 | 10.00% |
| Thomas Gleixner | 52 | 27.96% | 2 | 20.00% |
| Linus Torvalds (pre-git) | 38 | 20.43% | 1 | 10.00% |
| David Woodhouse | 19 | 10.22% | 1 | 10.00% |
| Brian Norris | 7 | 3.76% | 2 | 20.00% |
| Mike Dunn | 5 | 2.69% | 1 | 10.00% |
| Boris Brezillon | 5 | 2.69% | 1 | 10.00% |
| Vitaly Wool | 4 | 2.15% | 1 | 10.00% |
| Total | 186 | 100.00% | 10 | 100.00% |
static int part_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_read_user_prot_reg(part->master, from, len,
retlen, buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 34 | 61.82% | 1 | 25.00% |
| David Woodhouse | 15 | 27.27% | 1 | 25.00% |
| Mike Dunn | 5 | 9.09% | 1 | 25.00% |
| Brian Norris | 1 | 1.82% | 1 | 25.00% |
| Total | 55 | 100.00% | 4 | 100.00% |
static int part_get_user_prot_info(struct mtd_info *mtd, size_t len,
size_t *retlen, struct otp_info *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_get_user_prot_info(part->master, len, retlen,
buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Nico Pitre | 34 | 66.67% | 1 | 25.00% |
| Christian Riesch | 11 | 21.57% | 1 | 25.00% |
| Mike Dunn | 5 | 9.80% | 1 | 25.00% |
| Brian Norris | 1 | 1.96% | 1 | 25.00% |
| Total | 51 | 100.00% | 4 | 100.00% |
static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_read_fact_prot_reg(part->master, from, len,
retlen, buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 34 | 61.82% | 1 | 25.00% |
| David Woodhouse | 15 | 27.27% | 1 | 25.00% |
| Mike Dunn | 5 | 9.09% | 1 | 25.00% |
| Brian Norris | 1 | 1.82% | 1 | 25.00% |
| Total | 55 | 100.00% | 4 | 100.00% |
static int part_get_fact_prot_info(struct mtd_info *mtd, size_t len,
size_t *retlen, struct otp_info *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_get_fact_prot_info(part->master, len, retlen,
buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Nico Pitre | 34 | 66.67% | 1 | 25.00% |
| Christian Riesch | 11 | 21.57% | 1 | 25.00% |
| Mike Dunn | 5 | 9.80% | 1 | 25.00% |
| Brian Norris | 1 | 1.96% | 1 | 25.00% |
| Total | 51 | 100.00% | 4 | 100.00% |
static int part_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_write(part->master, to + part->offset, len,
retlen, buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 31 | 51.67% | 1 | 25.00% |
| Linus Torvalds | 23 | 38.33% | 1 | 25.00% |
| Mike Dunn | 5 | 8.33% | 1 | 25.00% |
| Brian Norris | 1 | 1.67% | 1 | 25.00% |
| Total | 60 | 100.00% | 4 | 100.00% |
static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_panic_write(part->master, to + part->offset, len,
retlen, buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Richard Purdie | 54 | 90.00% | 1 | 33.33% |
| Mike Dunn | 5 | 8.33% | 1 | 33.33% |
| Brian Norris | 1 | 1.67% | 1 | 33.33% |
| Total | 60 | 100.00% | 3 | 100.00% |
static int part_write_oob(struct mtd_info *mtd, loff_t to,
struct mtd_oob_ops *ops)
{
struct mtd_part *part = mtd_to_part(mtd);
if (to >= mtd->size)
return -EINVAL;
if (ops->datbuf && to + ops->len > mtd->size)
return -EINVAL;
return part->master->_write_oob(part->master, to + part->offset, ops);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 58 | 71.60% | 1 | 20.00% |
| Thomas Gleixner | 13 | 16.05% | 1 | 20.00% |
| Mike Dunn | 5 | 6.17% | 1 | 20.00% |
| Vitaly Wool | 4 | 4.94% | 1 | 20.00% |
| Brian Norris | 1 | 1.23% | 1 | 20.00% |
| Total | 81 | 100.00% | 5 | 100.00% |
static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_write_user_prot_reg(part->master, from, len,
retlen, buf);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 49 | 89.09% | 1 | 33.33% |
| Mike Dunn | 5 | 9.09% | 1 | 33.33% |
| Brian Norris | 1 | 1.82% | 1 | 33.33% |
| Total | 55 | 100.00% | 3 | 100.00% |
static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_lock_user_prot_reg(part->master, from, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Nico Pitre | 37 | 86.05% | 1 | 33.33% |
| Mike Dunn | 5 | 11.63% | 1 | 33.33% |
| Brian Norris | 1 | 2.33% | 1 | 33.33% |
| Total | 43 | 100.00% | 3 | 100.00% |
static int part_writev(struct mtd_info *mtd, const struct kvec *vecs,
unsigned long count, loff_t to, size_t *retlen)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_writev(part->master, vecs, count,
to + part->offset, retlen);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 55 | 88.71% | 1 | 25.00% |
| Mike Dunn | 5 | 8.06% | 1 | 25.00% |
| Brian Norris | 1 | 1.61% | 1 | 25.00% |
| Al Viro | 1 | 1.61% | 1 | 25.00% |
| Total | 62 | 100.00% | 4 | 100.00% |
static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
{
struct mtd_part *part = mtd_to_part(mtd);
int ret;
instr->addr += part->offset;
ret = part->master->_erase(part->master, instr);
if (ret) {
if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
instr->fail_addr -= part->offset;
instr->addr -= part->offset;
}
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 49 | 57.65% | 3 | 42.86% |
| Adrian Hunter | 30 | 35.29% | 2 | 28.57% |
| Mike Dunn | 5 | 5.88% | 1 | 14.29% |
| Brian Norris | 1 | 1.18% | 1 | 14.29% |
| Total | 85 | 100.00% | 7 | 100.00% |
void mtd_erase_callback(struct erase_info *instr)
{
if (instr->mtd->_erase == part_erase) {
struct mtd_part *part = mtd_to_part(instr->mtd);
if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
instr->fail_addr -= part->offset;
instr->addr -= part->offset;
}
if (instr->callback)
instr->callback(instr);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 68 | 95.77% | 3 | 50.00% |
| Brian Norris | 1 | 1.41% | 1 | 16.67% |
| Adrian Hunter | 1 | 1.41% | 1 | 16.67% |
| Artem B. Bityutskiy | 1 | 1.41% | 1 | 16.67% |
| Total | 71 | 100.00% | 6 | 100.00% |
EXPORT_SYMBOL_GPL(mtd_erase_callback);
static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_lock(part->master, ofs + part->offset, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 40 | 85.11% | 1 | 25.00% |
| Mike Dunn | 5 | 10.64% | 1 | 25.00% |
| Brian Norris | 1 | 2.13% | 1 | 25.00% |
| Adrian Hunter | 1 | 2.13% | 1 | 25.00% |
| Total | 47 | 100.00% | 4 | 100.00% |
static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_unlock(part->master, ofs + part->offset, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 40 | 85.11% | 1 | 25.00% |
| Mike Dunn | 5 | 10.64% | 1 | 25.00% |
| Adrian Hunter | 1 | 2.13% | 1 | 25.00% |
| Brian Norris | 1 | 2.13% | 1 | 25.00% |
| Total | 47 | 100.00% | 4 | 100.00% |
static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_is_locked(part->master, ofs + part->offset, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Richard Cochran | 41 | 87.23% | 1 | 33.33% |
| Mike Dunn | 5 | 10.64% | 1 | 33.33% |
| Brian Norris | 1 | 2.13% | 1 | 33.33% |
| Total | 47 | 100.00% | 3 | 100.00% |
static void part_sync(struct mtd_info *mtd)
{
struct mtd_part *part = mtd_to_part(mtd);
part->master->_sync(part->master);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 26 | 81.25% | 1 | 33.33% |
| Mike Dunn | 5 | 15.62% | 1 | 33.33% |
| Brian Norris | 1 | 3.12% | 1 | 33.33% |
| Total | 32 | 100.00% | 3 | 100.00% |
static int part_suspend(struct mtd_info *mtd)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_suspend(part->master);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 27 | 81.82% | 1 | 33.33% |
| Mike Dunn | 5 | 15.15% | 1 | 33.33% |
| Brian Norris | 1 | 3.03% | 1 | 33.33% |
| Total | 33 | 100.00% | 3 | 100.00% |
static void part_resume(struct mtd_info *mtd)
{
struct mtd_part *part = mtd_to_part(mtd);
part->master->_resume(part->master);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 19 | 59.38% | 1 | 25.00% |
| Linus Torvalds | 7 | 21.88% | 1 | 25.00% |
| Mike Dunn | 5 | 15.62% | 1 | 25.00% |
| Brian Norris | 1 | 3.12% | 1 | 25.00% |
| Total | 32 | 100.00% | 4 | 100.00% |
static int part_block_isreserved(struct mtd_info *mtd, loff_t ofs)
{
struct mtd_part *part = mtd_to_part(mtd);
ofs += part->offset;
return part->master->_block_isreserved(part->master, ofs);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ezequiel García | 43 | 97.73% | 1 | 50.00% |
| Brian Norris | 1 | 2.27% | 1 | 50.00% |
| Total | 44 | 100.00% | 2 | 100.00% |
static int part_block_isbad(struct mtd_info *mtd, loff_t ofs)
{
struct mtd_part *part = mtd_to_part(mtd);
ofs += part->offset;
return part->master->_block_isbad(part->master, ofs);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 38 | 86.36% | 1 | 33.33% |
| Mike Dunn | 5 | 11.36% | 1 | 33.33% |
| Brian Norris | 1 | 2.27% | 1 | 33.33% |
| Total | 44 | 100.00% | 3 | 100.00% |
static int part_block_markbad(struct mtd_info *mtd, loff_t ofs)
{
struct mtd_part *part = mtd_to_part(mtd);
int res;
ofs += part->offset;
res = part->master->_block_markbad(part->master, ofs);
if (!res)
mtd->ecc_stats.badblocks++;
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 37 | 58.73% | 1 | 25.00% |
| Thomas Gleixner | 20 | 31.75% | 1 | 25.00% |
| Mike Dunn | 5 | 7.94% | 1 | 25.00% |
| Brian Norris | 1 | 1.59% | 1 | 25.00% |
| Total | 63 | 100.00% | 4 | 100.00% |
static int part_get_device(struct mtd_info *mtd)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_get_device(part->master);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Richard Weinberger | 33 | 100.00% | 1 | 100.00% |
| Total | 33 | 100.00% | 1 | 100.00% |
static void part_put_device(struct mtd_info *mtd)
{
struct mtd_part *part = mtd_to_part(mtd);
part->master->_put_device(part->master);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Richard Weinberger | 32 | 100.00% | 1 | 100.00% |
| Total | 32 | 100.00% | 1 | 100.00% |
static int part_ooblayout_ecc(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion)
{
struct mtd_part *part = mtd_to_part(mtd);
return mtd_ooblayout_ecc(part->master, section, oobregion);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Boris Brezillon | 41 | 100.00% | 1 | 100.00% |
| Total | 41 | 100.00% | 1 | 100.00% |
static int part_ooblayout_free(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion)
{
struct mtd_part *part = mtd_to_part(mtd);
return mtd_ooblayout_free(part->master, section, oobregion);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Boris Brezillon | 41 | 100.00% | 1 | 100.00% |
| Total | 41 | 100.00% | 1 | 100.00% |
static const struct mtd_ooblayout_ops part_ooblayout_ops = {
.ecc = part_ooblayout_ecc,
.free = part_ooblayout_free,
};
static int part_max_bad_blocks(struct mtd_info *mtd, loff_t ofs, size_t len)
{
struct mtd_part *part = mtd_to_part(mtd);
return part->master->_max_bad_blocks(part->master,
ofs + part->offset, len);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jeff Westfahl | 47 | 100.00% | 1 | 100.00% |
| Total | 47 | 100.00% | 1 | 100.00% |
static inline void free_partition(struct mtd_part *p)
{
kfree(p->mtd.name);
kfree(p);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Roman Tereshonkov | 26 | 100.00% | 1 | 100.00% |
| Total | 26 | 100.00% | 1 | 100.00% |
/*
* This function unregisters and destroy all slave MTD objects which are
* attached to the given master MTD object.
*/
int del_mtd_partitions(struct mtd_info *master)
{
struct mtd_part *slave, *next;
int ret, err = 0;
mutex_lock(&mtd_partitions_mutex);
list_for_each_entry_safe(slave, next, &mtd_partitions, list)
if (slave->master == master) {
ret = del_mtd_device(&slave->mtd);
if (ret < 0) {
err = ret;
continue;
}
list_del(&slave->list);
free_partition(slave);
}
mutex_unlock(&mtd_partitions_mutex);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 45 | 46.88% | 1 | 33.33% |
| Roman Tereshonkov | 40 | 41.67% | 1 | 33.33% |
| Chris Malley | 11 | 11.46% | 1 | 33.33% |
| Total | 96 | 100.00% | 3 | 100.00% |
static struct mtd_part *allocate_partition(struct mtd_info *master,
const struct mtd_partition *part, int partno,
uint64_t cur_offset)
{
struct mtd_part *slave;
char *name;
/* allocate the partition structure */
slave = kzalloc(sizeof(*slave), GFP_KERNEL);
name = kstrdup(part->name, GFP_KERNEL);
if (!name || !slave) {
printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n",
master->name);
kfree(name);
kfree(slave);
return ERR_PTR(-ENOMEM);
}
/* set up the MTD object for this partition */
slave->mtd.type = master->type;
slave->mtd.flags = master->flags & ~part->mask_flags;
slave->mtd.size = part->size;
slave->mtd.writesize = master->writesize;
slave->mtd.writebufsize = master->writebufsize;
slave->mtd.oobsize = master->oobsize;
slave->mtd.oobavail = master->oobavail;
slave->mtd.subpage_sft = master->subpage_sft;
slave->mtd.pairing = master->pairing;
slave->mtd.name = name;
slave->mtd.owner = master->owner;
/* NOTE: Historically, we didn't arrange MTDs as a tree out of
* concern for showing the same data in multiple partitions.
* However, it is very useful to have the master node present,
* so the MTD_PARTITIONED_MASTER option allows that. The master
* will have device nodes etc only if this is set, so make the
* parent conditional on that option. Note, this is a way to
* distinguish between the master and the partition in sysfs.
*/
slave->mtd.dev.parent = IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER) ?
&master->dev :
master->dev.parent;
slave->mtd.dev.of_node = part->of_node;
slave->mtd._read = part_read;
slave->mtd._write = part_write;
if (master->_panic_write)
slave->mtd._panic_write = part_panic_write;
if (master->_point && master->_unpoint) {
slave->mtd._point = part_point;
slave->mtd._unpoint = part_unpoint;
}
if (master->_get_unmapped_area)
slave->mtd._get_unmapped_area = part_get_unmapped_area;
if (master->_read_oob)
slave->mtd._read_oob = part_read_oob;
if (master->_write_oob)
slave->mtd._write_oob = part_write_oob;
if (master->_read_user_prot_reg)
slave->mtd._read_user_prot_reg = part_read_user_prot_reg;
if (master->_read_fact_prot_reg)
slave->mtd._read_fact_prot_reg = part_read_fact_prot_reg;
if (master->_write_user_prot_reg)
slave->mtd._write_user_prot_reg = part_write_user_prot_reg;
if (master->_lock_user_prot_reg)
slave->mtd._lock_user_prot_reg = part_lock_user_prot_reg;
if (master->_get_user_prot_info)
slave->mtd._get_user_prot_info = part_get_user_prot_info;
if (master->_get_fact_prot_info)
slave->mtd._get_fact_prot_info = part_get_fact_prot_info;
if (master->_sync)
slave->mtd._sync = part_sync;
if (!partno && !master->dev.class && master->_suspend &&
master->_resume) {
slave->mtd._suspend = part_suspend;
slave->mtd._resume = part_resume;
}
if (master->_writev)
slave->mtd._writev = part_writev;
if (master->_lock)
slave->mtd._lock = part_lock;
if (master->_unlock)
slave->mtd._unlock = part_unlock;
if (master->_is_locked)
slave->mtd._is_locked = part_is_locked;
if (master->_block_isreserved)
slave->mtd._block_isreserved = part_block_isreserved;
if (master->_block_isbad)
slave->mtd._block_isbad = part_block_isbad;
if (master->_block_markbad)
slave->mtd._block_markbad = part_block_markbad;
if (master->_max_bad_blocks)
slave->mtd._max_bad_blocks = part_max_bad_blocks;
if (master->_get_device)
slave->mtd._get_device = part_get_device;
if (master->_put_device)
slave->mtd._put_device = part_put_device;
slave->mtd._erase = part_erase;
slave->master = master;
slave->offset = part->offset;
if (slave->offset == MTDPART_OFS_APPEND)
slave->offset = cur_offset;
if (slave->offset == MTDPART_OFS_NXTBLK) {
slave->offset = cur_offset;
if (mtd_mod_by_eb(cur_offset, master) != 0) {
/* Round up to next erasesize */
slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
printk(KERN_NOTICE "Moving partition %d: "
"0x%012llx -> 0x%012llx\n", partno,
(unsigned long long)cur_offset, (unsigned long long)slave->offset);
}
}
if (slave->offset == MTDPART_OFS_RETAIN) {
slave->offset = cur_offset;
if (master->size - slave->offset >= slave->mtd.size) {
slave->mtd.size = master->size - slave->offset
- slave->mtd.size;
} else {
printk(KERN_ERR "mtd partition \"%s\" doesn't have enough space: %#llx < %#llx, disabled\n",
part->name, master->size - slave->offset,
slave->mtd.size);
/* register to preserve ordering */
goto out_register;
}
}
if (slave->mtd.size == MTDPART_SIZ_FULL)
slave->mtd.size = master->size - slave->offset;
printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset,
(unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name);
/* let's do some sanity checks */
if (slave->offset >= master->size) {
/* let's register it anyway to preserve ordering */
slave->offset = 0;
slave->mtd.size = 0;
printk(KERN_ERR"mtd: partition \"%s\" is out of reach -- disabled\n",
part->name);
goto out_register;
}
if (slave->offset + slave->mtd.size > master->size) {
slave->mtd.size = master->size - slave->offset;
printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n",
part->name, master->name, (unsigned long long)slave->mtd.size);
}
if (master->numeraseregions > 1) {
/* Deal with variable erase size stuff */
int i, max = master->numeraseregions;
u64 end = slave->offset + slave->mtd.size;
struct mtd_erase_region_info *regions = master->eraseregions;
/* Find the first erase regions which is part of this
* partition. */
for (i = 0; i < max && regions[i].offset <= slave->offset; i++)
;
/* The loop searched for the region _behind_ the first one */
if (i > 0)
i--;
/* Pick biggest erasesize */
for (; i < max && regions[i].offset < end; i++) {
if (slave->mtd.erasesize < regions[i].erasesize) {
slave->mtd.erasesize = regions[i].erasesize;
}
}
BUG_ON(slave->mtd.erasesize == 0);
} else {
/* Single erase size */
slave->mtd.erasesize = master->erasesize;
}
if ((slave->mtd.flags & MTD_WRITEABLE) &&
mtd_mod_by_eb(slave->offset, &slave->mtd)) {
/* Doesn't start on a boundary of major erase size */
/* FIXME: Let it be writable if it is on a boundary of
* _minor_ erase size though */
slave->mtd.flags &= ~MTD_WRITEABLE;
printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
part->name);
}
if ((slave->mtd.flags & MTD_WRITEABLE) &&
mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
slave->mtd.flags &= ~MTD_WRITEABLE;
printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
part->name);
}
mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops);
slave->mtd.ecc_step_size = master->ecc_step_size;
slave->mtd.ecc_strength = master->ecc_strength;
slave->mtd.bitflip_threshold = master->bitflip_threshold;
if (master->_block_isbad) {
uint64_t offs = 0;
while (offs < slave->mtd.size) {
if (mtd_block_isreserved(master, offs + slave->offset))
slave->mtd.ecc_stats.bbtblocks++;
else if (mtd_block_isbad(master, offs + slave->offset))
slave->mtd.ecc_stats.badblocks++;
offs += slave->mtd.erasesize;
}
}
out_register:
return slave;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 458 | 33.90% | 3 | 7.69% |
| Linus Torvalds (pre-git) | 174 | 12.88% | 1 | 2.56% |
| Atsushi Nemoto | 88 | 6.51% | 4 | 10.26% |
| Dmitry Baryshkov | 85 | 6.29% | 1 | 2.56% |
| Linus Torvalds | 71 | 5.26% | 1 | 2.56% |
| Artem B. Bityutskiy | 66 | 4.89% | 3 | 7.69% |
| Thomas Gleixner | 60 | 4.44% | 2 | 5.13% |
| Adrian Hunter | 51 | 3.77% | 1 | 2.56% |
| Ezequiel García | 37 | 2.74% | 2 | 5.13% |
| Nico Pitre | 36 | 2.66% | 1 | 2.56% |
| Roman Tereshonkov | 30 | 2.22% | 1 | 2.56% |
| Richard Weinberger | 28 | 2.07% | 1 | 2.56% |
| Mike Dunn | 20 | 1.48% | 2 | 5.13% |
| Boris Brezillon | 17 | 1.26% | 3 | 7.69% |
| David Howells | 16 | 1.18% | 1 | 2.56% |
| Jeff Westfahl | 14 | 1.04% | 1 | 2.56% |
| David Brownell | 14 | 1.04% | 1 | 2.56% |
| Richard Purdie | 12 | 0.89% | 1 | 2.56% |
| Sascha Hauer | 12 | 0.89% | 1 | 2.56% |
| Richard Cochran | 12 | 0.89% | 1 | 2.56% |
| Dan Ehrenberg | 11 | 0.81% | 1 | 2.56% |
| Anatolij Gustschin | 10 | 0.74% | 1 | 2.56% |
| Huang Shijie | 10 | 0.74% | 1 | 2.56% |
| Vitaly Wool | 10 | 0.74% | 1 | 2.56% |
| Roel Kluin | 6 | 0.44% | 1 | 2.56% |
| Jörn Engel | 2 | 0.15% | 1 | 2.56% |
| Burman Yan | 1 | 0.07% | 1 | 2.56% |
| Total | 1351 | 100.00% | 39 | 100.00% |
static ssize_t mtd_partition_offset_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mtd_info *mtd = dev_get_drvdata(dev);
struct mtd_part *part = mtd_to_part(mtd);
return snprintf(buf, PAGE_SIZE, "%lld\n", part->offset);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dan Ehrenberg | 53 | 98.15% | 1 | 50.00% |
| Brian Norris | 1 | 1.85% | 1 | 50.00% |
| Total | 54 | 100.00% | 2 | 100.00% |
static DEVICE_ATTR(offset, S_IRUGO, mtd_partition_offset_show, NULL);
static const struct attribute *mtd_partition_attrs[] = {
&dev_attr_offset.attr,
NULL
};
static int mtd_add_partition_attrs(struct mtd_part *new)
{
int ret = sysfs_create_files(&new->mtd.dev.kobj, mtd_partition_attrs);
if (ret)
printk(KERN_WARNING
"mtd: failed to create partition attrs, err=%d\n", ret);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dan Ehrenberg | 43 | 100.00% | 1 | 100.00% |
| Total | 43 | 100.00% | 1 | 100.00% |
int mtd_add_partition(struct mtd_info *master, const char *name,
long long offset, long long length)
{
struct mtd_partition part;
struct mtd_part *new;
int ret = 0;
/* the direct offset is expected */
if (offset == MTDPART_OFS_APPEND ||
offset == MTDPART_OFS_NXTBLK)
return -EINVAL;
if (length == MTDPART_SIZ_FULL)
length = master->size - offset;
if (length <= 0)
return -EINVAL;
memset(&part, 0, sizeof(part));
part.name = name;
part.size = length;
part.offset = offset;
new = allocate_partition(master, &part, -1, offset);
if (IS_ERR(new))
return PTR_ERR(new);
mutex_lock(&mtd_partitions_mutex);
list_add(&new->list, &mtd_partitions);
mutex_unlock(&mtd_partitions_mutex);
add_mtd_device(&new->mtd);
mtd_add_partition_attrs(new);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Roman Tereshonkov | 121 | 69.54% | 1 | 20.00% |
| Atsushi Nemoto | 34 | 19.54% | 1 | 20.00% |
| Brian Norris | 13 | 7.47% | 1 | 20.00% |
| Dan Ehrenberg | 5 | 2.87% | 1 | 20.00% |
| Geert Uytterhoeven | 1 | 0.57% | 1 | 20.00% |
| Total | 174 | 100.00% | 5 | 100.00% |
EXPORT_SYMBOL_GPL(mtd_add_partition);
int mtd_del_partition(struct mtd_info *master, int partno)
{
struct mtd_part *slave, *next;
int ret = -EINVAL;
mutex_lock(&mtd_partitions_mutex);
list_for_each_entry_safe(slave, next, &mtd_partitions, list)
if ((slave->master == master) &&
(slave->mtd.index == partno)) {
sysfs_remove_files(&slave->mtd.dev.kobj,
mtd_partition_attrs);
ret = del_mtd_device(&slave->mtd);
if (ret < 0)
break;
list_del(&slave->list);
free_partition(slave);
break;
}
mutex_unlock(&mtd_partitions_mutex);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Roman Tereshonkov | 105 | 88.24% | 1 | 50.00% |
| Dan Ehrenberg | 14 | 11.76% | 1 | 50.00% |
| Total | 119 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL_GPL(mtd_del_partition);
/*
* This function, given a master MTD object and a partition table, creates
* and registers slave MTD objects which are bound to the master according to
* the partition definitions.
*
* For historical reasons, this function's caller only registers the master
* if the MTD_PARTITIONED_MASTER config option is set.
*/
int add_mtd_partitions(struct mtd_info *master,
const struct mtd_partition *parts,
int nbparts)
{
struct mtd_part *slave;
uint64_t cur_offset = 0;
int i;
printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
for (i = 0; i < nbparts; i++) {
slave = allocate_partition(master, parts + i, i, cur_offset);
if (IS_ERR(slave)) {
del_mtd_partitions(master);
return PTR_ERR(slave);
}
mutex_lock(&mtd_partitions_mutex);
list_add(&slave->list, &mtd_partitions);
mutex_unlock(&mtd_partitions_mutex);
add_mtd_device(&slave->mtd);
mtd_add_partition_attrs(slave);
cur_offset = slave->offset + slave->mtd.size;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Roman Tereshonkov | 117 | 80.69% | 1 | 16.67% |
| Atsushi Nemoto | 11 | 7.59% | 1 | 16.67% |
| Boris Brezillon | 7 | 4.83% | 1 | 16.67% |
| Dan Ehrenberg | 5 | 3.45% | 1 | 16.67% |
| David Woodhouse | 4 | 2.76% | 1 | 16.67% |
| Linus Torvalds (pre-git) | 1 | 0.69% | 1 | 16.67% |
| Total | 145 | 100.00% | 6 | 100.00% |
static DEFINE_SPINLOCK(part_parser_lock);
static LIST_HEAD(part_parsers);
static struct mtd_part_parser *mtd_part_parser_get(const char *name)
{
struct mtd_part_parser *p, *ret = NULL;
spin_lock(&part_parser_lock);
list_for_each_entry(p, &part_parsers, list)
if (!strcmp(p->name, name) && try_module_get(p->owner)) {
ret = p;
break;
}
spin_unlock(&part_parser_lock);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 60 | 83.33% | 2 | 33.33% |
| Chris Malley | 6 | 8.33% | 1 | 16.67% |
| Linus Torvalds | 3 | 4.17% | 1 | 16.67% |
| Linus Torvalds (pre-git) | 2 | 2.78% | 1 | 16.67% |
| Brian Norris | 1 | 1.39% | 1 | 16.67% |
| Total | 72 | 100.00% | 6 | 100.00% |
static inline void mtd_part_parser_put(const struct mtd_part_parser *p)
{
module_put(p->owner);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Brian Norris | 17 | 85.00% | 1 | 50.00% |
| Dmitry Baryshkov | 3 | 15.00% | 1 | 50.00% |
| Total | 20 | 100.00% | 2 | 100.00% |
/*
* Many partition parsers just expected the core to kfree() all their data in
* one chunk. Do that by default.
*/
static void mtd_part_parser_cleanup_default(const struct mtd_partition *pparts,
int nr_parts)
{
kfree(pparts);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Brian Norris | 20 | 100.00% | 1 | 100.00% |
| Total | 20 | 100.00% | 1 | 100.00% |
int __register_mtd_parser(struct mtd_part_parser *p, struct module *owner)
{
p->owner = owner;
if (!p->cleanup)
p->cleanup = &mtd_part_parser_cleanup_default;
spin_lock(&part_parser_lock);
list_add(&p->list, &part_parsers);
spin_unlock(&part_parser_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 31 | 50.82% | 1 | 33.33% |
| Brian Norris | 30 | 49.18% | 2 | 66.67% |
| Total | 61 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL_GPL(__register_mtd_parser);
void deregister_mtd_parser(struct mtd_part_parser *p)
{
spin_lock(&part_parser_lock);
list_del(&p->list);
spin_unlock(&part_parser_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 29 | 96.67% | 1 | 50.00% |
| Axel Lin | 1 | 3.33% | 1 | 50.00% |
| Total | 30 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL_GPL(deregister_mtd_parser);
/*
* Do not forget to update 'parse_mtd_partitions()' kerneldoc comment if you
* are changing this array!
*/
static const char * const default_mtd_part_types[] = {
"cmdlinepart",
"ofpart",
NULL
};
/**
* parse_mtd_partitions - parse MTD partitions
* @master: the master partition (describes whole MTD device)
* @types: names of partition parsers to try or %NULL
* @pparts: info about partitions found is returned here
* @data: MTD partition parser-specific data
*
* This function tries to find partition on MTD device @master. It uses MTD
* partition parsers, specified in @types. However, if @types is %NULL, then
* the default list of parsers is used. The default list contains only the
* "cmdlinepart" and "ofpart" parsers ATM.
* Note: If there are more then one parser in @types, the kernel only takes the
* partitions parsed out by the first parser.
*
* This function may return:
* o a negative error code in case of failure
* o zero otherwise, and @pparts will describe the partitions, number of
* partitions, and the parser which parsed them. Caller must release
* resources with mtd_part_parser_cleanup() when finished with the returned
* data.
*/
int parse_mtd_partitions(struct mtd_info *master, const char *const *types,
struct mtd_partitions *pparts,
struct mtd_part_parser_data *data)
{
struct mtd_part_parser *parser;
int ret, err = 0;
if (!types)
types = default_mtd_part_types;
for ( ; *types; types++) {
pr_debug("%s: parsing partitions %s\n", master->name, *types);
parser = mtd_part_parser_get(*types);
if (!parser && !request_module("%s", *types))
parser = mtd_part_parser_get(*types);
pr_debug("%s: got parser %s\n", master->name,
parser ? parser->name : NULL);
if (!parser)
continue;
ret = (*parser->parse_fn)(master, &pparts->parts, data);
pr_debug("%s: parser %s: %i\n",
master->name, parser->name, ret);
if (ret > 0) {
printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
ret, parser->name, master->name);
pparts->nr_parts = ret;
pparts->parser = parser;
return 0;
}
mtd_part_parser_put(parser);
/*
* Stash the first error we see; only report it if no parser
* succeeds
*/
if (ret < 0 && !err)
err = ret;
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 81 | 36.99% | 1 | 9.09% |
| Michal Suchanek | 44 | 20.09% | 1 | 9.09% |
| Brian Norris | 43 | 19.63% | 4 | 36.36% |
| Linus Torvalds | 26 | 11.87% | 1 | 9.09% |
| Dmitry Baryshkov | 14 | 6.39% | 2 | 18.18% |
| Linus Torvalds (pre-git) | 10 | 4.57% | 1 | 9.09% |
| Artem B. Bityutskiy | 1 | 0.46% | 1 | 9.09% |
| Total | 219 | 100.00% | 11 | 100.00% |
void mtd_part_parser_cleanup(struct mtd_partitions *parts)
{
const struct mtd_part_parser *parser;
if (!parts)
return;
parser = parts->parser;
if (parser) {
if (parser->cleanup)
parser->cleanup(parts->parts, parts->nr_parts);
mtd_part_parser_put(parser);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Brian Norris | 58 | 100.00% | 1 | 100.00% |
| Total | 58 | 100.00% | 1 | 100.00% |
int mtd_is_partition(const struct mtd_info *mtd)
{
struct mtd_part *part;
int ispart = 0;
mutex_lock(&mtd_partitions_mutex);
list_for_each_entry(part, &mtd_partitions, list)
if (&part->mtd == mtd) {
ispart = 1;
break;
}
mutex_unlock(&mtd_partitions_mutex);
return ispart;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Roman Tereshonkov | 59 | 98.33% | 2 | 66.67% |
| Richard Genoud | 1 | 1.67% | 1 | 33.33% |
| Total | 60 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL_GPL(mtd_is_partition);
/* Returns the size of the entire flash chip */
uint64_t mtd_get_device_size(const struct mtd_info *mtd)
{
if (!mtd_is_partition(mtd))
return mtd->size;
return mtd_to_part(mtd)->master->size;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Richard Genoud | 33 | 97.06% | 1 | 50.00% |
| Brian Norris | 1 | 2.94% | 1 | 50.00% |
| Total | 34 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL_GPL(mtd_get_device_size);
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Woodhouse | 1275 | 27.80% | 7 | 8.33% |
| Roman Tereshonkov | 522 | 11.38% | 2 | 2.38% |
| Linus Torvalds (pre-git) | 520 | 11.34% | 1 | 1.19% |
| Brian Norris | 246 | 5.36% | 8 | 9.52% |
| Thomas Gleixner | 175 | 3.82% | 5 | 5.95% |
| Dan Ehrenberg | 161 | 3.51% | 2 | 2.38% |
| Mike Dunn | 149 | 3.25% | 4 | 4.76% |
| Atsushi Nemoto | 142 | 3.10% | 4 | 4.76% |
| Nico Pitre | 141 | 3.07% | 1 | 1.19% |
| Linus Torvalds | 131 | 2.86% | 2 | 2.38% |
| Artem B. Bityutskiy | 129 | 2.81% | 8 | 9.52% |
| Boris Brezillon | 129 | 2.81% | 5 | 5.95% |
| Dmitry Baryshkov | 117 | 2.55% | 5 | 5.95% |
| Richard Weinberger | 93 | 2.03% | 1 | 1.19% |
| Adrian Hunter | 85 | 1.85% | 3 | 3.57% |
| Ezequiel García | 80 | 1.74% | 2 | 2.38% |
| David Howells | 68 | 1.48% | 1 | 1.19% |
| Richard Purdie | 66 | 1.44% | 1 | 1.19% |
| Jeff Westfahl | 61 | 1.33% | 1 | 1.19% |
| Richard Cochran | 53 | 1.16% | 1 | 1.19% |
| Michal Suchanek | 44 | 0.96% | 1 | 1.19% |
| Richard Genoud | 40 | 0.87% | 2 | 2.38% |
| Yauhen Kharuzhy | 32 | 0.70% | 1 | 1.19% |
| Christian Riesch | 22 | 0.48% | 1 | 1.19% |
| Vitaly Wool | 18 | 0.39% | 2 | 2.38% |
| Chris Malley | 17 | 0.37% | 1 | 1.19% |
| David Brownell | 14 | 0.31% | 1 | 1.19% |
| Sascha Hauer | 12 | 0.26% | 1 | 1.19% |
| Anatolij Gustschin | 10 | 0.22% | 1 | 1.19% |
| Huang Shijie | 10 | 0.22% | 1 | 1.19% |
| Jared Hulbert | 9 | 0.20% | 1 | 1.19% |
| Roel Kluin | 6 | 0.13% | 1 | 1.19% |
| Jamie Iles | 3 | 0.07% | 1 | 1.19% |
| Jörn Engel | 2 | 0.04% | 1 | 1.19% |
| Geert Uytterhoeven | 1 | 0.02% | 1 | 1.19% |
| Al Viro | 1 | 0.02% | 1 | 1.19% |
| Axel Lin | 1 | 0.02% | 1 | 1.19% |
| Burman Yan | 1 | 0.02% | 1 | 1.19% |
| Total | 4586 | 100.00% | 84 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.