Release 4.12 drivers/mmc/core/queue.c

Directory: drivers/mmc/core
/*
 *  Copyright (C) 2003 Russell King, All Rights Reserved.
 *  Copyright 2006-2007 Pierre Ossman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/freezer.h>
#include <linux/kthread.h>
#include <linux/scatterlist.h>
#include <linux/dma-mapping.h>

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>

#include "queue.h"
#include "block.h"
#include "core.h"
#include "card.h"


#define MMC_QUEUE_BOUNCESZ	65536

/*
 * Prepare a MMC request. This just filters out odd stuff.
 */


static int mmc_prep_request(struct request_queue *q, struct request *req)
{
	struct mmc_queue *mq = q->queuedata;

	if (mq && (mmc_card_removed(mq->card) || mmc_access_rpmb(mq)))
		return BLKPREP_KILL;

	req->rq_flags |= RQF_DONTPREP;

	return BLKPREP_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
Sujit Reddy Thumma 23 41.82% 1 20.00%
Russell King 22 40.00% 1 20.00%
Chuanxiao Dong 7 12.73% 1 20.00%
Christoph Hellwig 2 3.64% 1 20.00%
Pierre Ossman 1 1.82% 1 20.00%
Total 55 100.00% 5 100.00%



struct mmc_queue_req *mmc_queue_req_find(struct mmc_queue *mq,
					 struct request *req)
{
	struct mmc_queue_req *mqrq;
	int i = ffz(mq->qslots);

	if (i >= mq->qdepth)
		return NULL;

	mqrq = &mq->mqrq[i];
	WARN_ON(mqrq->req || mq->qcnt >= mq->qdepth ||
		test_bit(mqrq->task_id, &mq->qslots));
	mqrq->req = req;
	mq->qcnt += 1;
	__set_bit(mqrq->task_id, &mq->qslots);

	return mqrq;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 107 100.00% 1 100.00%
Total 107 100.00% 1 100.00%



void mmc_queue_req_free(struct mmc_queue *mq,
			struct mmc_queue_req *mqrq)
{
	WARN_ON(!mqrq->req || mq->qcnt < 1 ||
		!test_bit(mqrq->task_id, &mq->qslots));
	mqrq->req = NULL;
	mq->qcnt -= 1;
	__clear_bit(mqrq->task_id, &mq->qslots);
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 66 100.00% 1 100.00%
Total 66 100.00% 1 100.00%



static int mmc_queue_thread(void *d)
{
	struct mmc_queue *mq = d;
	struct request_queue *q = mq->queue;
	struct mmc_context_info *cntx = &mq->card->host->context_info;

	current->flags |= PF_MEMALLOC;

	down(&mq->thread_sem);
	do {
		struct request *req;

		spin_lock_irq(q->queue_lock);
		set_current_state(TASK_INTERRUPTIBLE);
		req = blk_fetch_request(q);
		mq->asleep = false;
		cntx->is_waiting_last_req = false;
		cntx->is_new_req = false;
		if (!req) {
			/*
                         * Dispatch queue is empty so set flags for
                         * mmc_request_fn() to wake us up.
                         */
			if (mq->qcnt)
				cntx->is_waiting_last_req = true;
			else
				mq->asleep = true;
		}
		spin_unlock_irq(q->queue_lock);

		if (req || mq->qcnt) {
			set_current_state(TASK_RUNNING);
			mmc_blk_issue_rq(mq, req);
			cond_resched();
		} else {
			if (kthread_should_stop()) {
				set_current_state(TASK_RUNNING);
				break;
			}
			up(&mq->thread_sem);
			schedule();
			down(&mq->thread_sem);
		}
	} while (1);
	up(&mq->thread_sem);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Russell King 93 44.50% 4 33.33%
Adrian Hunter 58 27.75% 2 16.67%
Seungwon Jeon 36 17.22% 1 8.33%
Per Forlin 15 7.18% 1 8.33%
Rabin Vincent 3 1.44% 1 8.33%
Juha Yrjölä 2 0.96% 1 8.33%
Linus Walleij 1 0.48% 1 8.33%
Tejun Heo 1 0.48% 1 8.33%
Total 209 100.00% 12 100.00%

/*
 * Generic MMC request handler.  This is called for any queue on a
 * particular host.  When the host is not busy, we look for a request
 * on any queue on this host, and attempt to issue it.  This may
 * not be the queue we were asked to process.
 */


static void mmc_request_fn(struct request_queue *q)
{
	struct mmc_queue *mq = q->queuedata;
	struct request *req;
	struct mmc_context_info *cntx;

	if (!mq) {
		while ((req = blk_fetch_request(q)) != NULL) {
			req->rq_flags |= RQF_QUIET;
			__blk_end_request_all(req, -EIO);
		}
		return;
	}

	cntx = &mq->card->host->context_info;

	if (cntx->is_waiting_last_req) {
		cntx->is_new_req = true;
		wake_up_interruptible(&cntx->wait);
	}

	if (mq->asleep)
		wake_up_process(mq->thread);
}

Contributors
Person Tokens Prop Commits CommitProp
Konstantin Dorfman 38 33.63% 1 7.69%
Pierre Ossman 30 26.55% 1 7.69%
Russell King 25 22.12% 1 7.69%
Adrian Hunter 7 6.19% 2 15.38%
Christoph Hellwig 4 3.54% 2 15.38%
Kiyoshi Ueda 2 1.77% 1 7.69%
Jens Axboe 2 1.77% 1 7.69%
Per Forlin 2 1.77% 1 7.69%
Tejun Heo 2 1.77% 2 15.38%
Venkatraman Sathiyamoorthy 1 0.88% 1 7.69%
Total 113 100.00% 13 100.00%



static struct scatterlist *mmc_alloc_sg(int sg_len)
{
	struct scatterlist *sg;

	sg = kmalloc_array(sg_len, sizeof(*sg), GFP_KERNEL);
	if (sg)
		sg_init_table(sg, sg_len);

	return sg;
}

Contributors
Person Tokens Prop Commits CommitProp
Per Forlin 39 86.67% 1 33.33%
SF Markus Elfring 5 11.11% 1 33.33%
Venkatraman Sathiyamoorthy 1 2.22% 1 33.33%
Total 45 100.00% 3 100.00%



static void mmc_queue_setup_discard(struct request_queue *q,
				    struct mmc_card *card)
{
	unsigned max_discard;

	max_discard = mmc_calc_max_discard(card);
	if (!max_discard)
		return;

	queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
	blk_queue_max_discard_sectors(q, max_discard);
	q->limits.discard_granularity = card->pref_erase << 9;
	/* granularity must not be greater than max. discard */
	if (card->pref_erase > max_discard)
		q->limits.discard_granularity = 0;
	if (mmc_can_secure_erase_trim(card))
		queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 84 94.38% 1 33.33%
Jens Axboe 4 4.49% 1 33.33%
Christoph Hellwig 1 1.12% 1 33.33%
Total 89 100.00% 3 100.00%



static void mmc_queue_req_free_bufs(struct mmc_queue_req *mqrq)
{
	kfree(mqrq->bounce_sg);
	mqrq->bounce_sg = NULL;

	kfree(mqrq->sg);
	mqrq->sg = NULL;

	kfree(mqrq->bounce_buf);
	mqrq->bounce_buf = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 50 100.00% 2 100.00%
Total 50 100.00% 2 100.00%



static void mmc_queue_reqs_free_bufs(struct mmc_queue_req *mqrq, int qdepth)
{
	int i;

	for (i = 0; i < qdepth; i++)
		mmc_queue_req_free_bufs(&mqrq[i]);
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 39 100.00% 3 100.00%
Total 39 100.00% 3 100.00%



static void mmc_queue_free_mqrqs(struct mmc_queue_req *mqrq, int qdepth)
{
	mmc_queue_reqs_free_bufs(mqrq, qdepth);
	kfree(mqrq);
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static struct mmc_queue_req *mmc_queue_alloc_mqrqs(int qdepth)
{
	struct mmc_queue_req *mqrq;
	int i;

	mqrq = kcalloc(qdepth, sizeof(*mqrq), GFP_KERNEL);
	if (mqrq) {
		for (i = 0; i < qdepth; i++)
			mqrq[i].task_id = i;
	}

	return mqrq;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 65 100.00% 3 100.00%
Total 65 100.00% 3 100.00%

#ifdef CONFIG_MMC_BLOCK_BOUNCE


static int mmc_queue_alloc_bounce_bufs(struct mmc_queue_req *mqrq, int qdepth,
				       unsigned int bouncesz)
{
	int i;

	for (i = 0; i < qdepth; i++) {
		mqrq[i].bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
		if (!mqrq[i].bounce_buf)
			return -ENOMEM;

		mqrq[i].sg = mmc_alloc_sg(1);
		if (!mqrq[i].sg)
			return -ENOMEM;

		mqrq[i].bounce_sg = mmc_alloc_sg(bouncesz / 512);
		if (!mqrq[i].bounce_sg)
			return -ENOMEM;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 121 100.00% 4 100.00%
Total 121 100.00% 4 100.00%



static bool mmc_queue_alloc_bounce(struct mmc_queue_req *mqrq, int qdepth,
				   unsigned int bouncesz)
{
	int ret;

	ret = mmc_queue_alloc_bounce_bufs(mqrq, qdepth, bouncesz);
	if (ret)
		mmc_queue_reqs_free_bufs(mqrq, qdepth);

	return !ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 47 100.00% 3 100.00%
Total 47 100.00% 3 100.00%



static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
{
	unsigned int bouncesz = MMC_QUEUE_BOUNCESZ;

	if (host->max_segs != 1)
		return 0;

	if (bouncesz > host->max_req_size)
		bouncesz = host->max_req_size;
	if (bouncesz > host->max_seg_size)
		bouncesz = host->max_seg_size;
	if (bouncesz > host->max_blk_count * 512)
		bouncesz = host->max_blk_count * 512;

	if (bouncesz <= 512)
		return 0;

	return bouncesz;
}
Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 87 100.00% 2 100.00%
Total 87 100.00% 2 100.00%

#else


static inline bool mmc_queue_alloc_bounce(struct mmc_queue_req *mqrq,
					  int qdepth, unsigned int bouncesz)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 22 100.00% 3 100.00%
Total 22 100.00% 3 100.00%



static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 15 100.00% 3 100.00%
Total 15 100.00% 3 100.00%

#endif



static int mmc_queue_alloc_sgs(struct mmc_queue_req *mqrq, int qdepth,
			       int max_segs)
{
	int i;

	for (i = 0; i < qdepth; i++) {
		mqrq[i].sg = mmc_alloc_sg(max_segs);
		if (!mqrq[i].sg)
			return -ENOMEM;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 64 100.00% 3 100.00%
Total 64 100.00% 3 100.00%



void mmc_queue_free_shared_queue(struct mmc_card *card)
{
	if (card->mqrq) {
		mmc_queue_free_mqrqs(card->mqrq, card->qdepth);
		card->mqrq = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 35 100.00% 3 100.00%
Total 35 100.00% 3 100.00%



static int __mmc_queue_alloc_shared_queue(struct mmc_card *card, int qdepth)
{
	struct mmc_host *host = card->host;
	struct mmc_queue_req *mqrq;
	unsigned int bouncesz;
	int ret = 0;

	if (card->mqrq)
		return -EINVAL;

	mqrq = mmc_queue_alloc_mqrqs(qdepth);
	if (!mqrq)
		return -ENOMEM;

	card->mqrq = mqrq;
	card->qdepth = qdepth;

	bouncesz = mmc_queue_calc_bouncesz(host);

	if (bouncesz && !mmc_queue_alloc_bounce(mqrq, qdepth, bouncesz)) {
		bouncesz = 0;
		pr_warn("%s: unable to allocate bounce buffers\n",
			mmc_card_name(card));
	}

	card->bouncesz = bouncesz;

	if (!bouncesz) {
		ret = mmc_queue_alloc_sgs(mqrq, qdepth, host->max_segs);
		if (ret)
			goto out_err;
	}

	return ret;

out_err:
	mmc_queue_free_shared_queue(card);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 158 100.00% 3 100.00%
Total 158 100.00% 3 100.00%



int mmc_queue_alloc_shared_queue(struct mmc_card *card)
{
	return __mmc_queue_alloc_shared_queue(card, 2);
}

Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 18 100.00% 3 100.00%
Total 18 100.00% 3 100.00%

/**
 * mmc_init_queue - initialise a queue structure.
 * @mq: mmc queue
 * @card: mmc card to attach this queue
 * @lock: queue lock
 * @subname: partition subname
 *
 * Initialise a MMC card request queue.
 */


int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
		   spinlock_t *lock, const char *subname)
{
	struct mmc_host *host = card->host;
	u64 limit = BLK_BOUNCE_HIGH;
	int ret = -ENOMEM;

	if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
		limit = (u64)dma_max_pfn(mmc_dev(host)) << PAGE_SHIFT;

	mq->card = card;
	mq->queue = blk_init_queue(mmc_request_fn, lock);
	if (!mq->queue)
		return -ENOMEM;

	mq->mqrq = card->mqrq;
	mq->qdepth = card->qdepth;
	mq->queue->queuedata = mq;

	blk_queue_prep_rq(mq->queue, mmc_prep_request);
	queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
	queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, mq->queue);
	if (mmc_can_erase(card))
		mmc_queue_setup_discard(mq->queue, card);

	if (card->bouncesz) {
		blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
		blk_queue_max_hw_sectors(mq->queue, card->bouncesz / 512);
		blk_queue_max_segments(mq->queue, card->bouncesz / 512);
		blk_queue_max_segment_size(mq->queue, card->bouncesz);
	} else {
		blk_queue_bounce_limit(mq->queue, limit);
		blk_queue_max_hw_sectors(mq->queue,
			min(host->max_blk_count, host->max_req_size / 512));
		blk_queue_max_segments(mq->queue, host->max_segs);
		blk_queue_max_segment_size(mq->queue, host->max_seg_size);
	}

	sema_init(&mq->thread_sem, 1);

	mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd/%d%s",
		host->index, subname ? subname : "");

	if (IS_ERR(mq->thread)) {
		ret = PTR_ERR(mq->thread);
		goto cleanup_queue;
	}

	return 0;

cleanup_queue:
	mq->mqrq = NULL;
	blk_cleanup_queue(mq->queue);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Russell King 169 47.47% 6 19.35%
Pierre Ossman 71 19.94% 6 19.35%
Adrian Hunter 55 15.45% 7 22.58%
Christoph Hellwig 15 4.21% 1 3.23%
Per Forlin 10 2.81% 2 6.45%
Greg Kroah-Hartman 9 2.53% 1 3.23%
Mike Snitzer 9 2.53% 1 3.23%
Santosh Shilimkar 5 1.40% 1 3.23%
Martin K. Petersen 5 1.40% 3 9.68%
Ethan Du 4 1.12% 1 3.23%
Thomas Gleixner 3 0.84% 1 3.23%
Venkatraman Sathiyamoorthy 1 0.28% 1 3.23%
Total 356 100.00% 31 100.00%



void mmc_cleanup_queue(struct mmc_queue *mq)
{
	struct request_queue *q = mq->queue;
	unsigned long flags;

	/* Make sure the queue isn't suspended, as that will deadlock */
	mmc_queue_resume(mq);

	/* Then terminate our worker thread */
	kthread_stop(mq->thread);

	/* Empty the queue */
	spin_lock_irqsave(q->queue_lock, flags);
	q->queuedata = NULL;
	blk_start_queue(q);
	spin_unlock_irqrestore(q->queue_lock, flags);

	mq->mqrq = NULL;
	mq->card = NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Pierre Ossman 27 34.18% 1 16.67%
Adrian Hunter 26 32.91% 2 33.33%
Russell King 24 30.38% 2 33.33%
Jens Axboe 2 2.53% 1 16.67%
Total 79 100.00% 6 100.00%


EXPORT_SYMBOL(mmc_cleanup_queue);

/**
 * mmc_queue_suspend - suspend a MMC request queue
 * @mq: MMC queue to suspend
 *
 * Stop the block request queue, and wait for our thread to
 * complete any outstanding requests.  This ensures that we
 * won't suspend while a request is being processed.
 */


void mmc_queue_suspend(struct mmc_queue *mq)
{
	struct request_queue *q = mq->queue;
	unsigned long flags;

	if (!mq->suspended) {
		mq->suspended |= true;

		spin_lock_irqsave(q->queue_lock, flags);
		blk_stop_queue(q);
		spin_unlock_irqrestore(q->queue_lock, flags);

		down(&mq->thread_sem);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Russell King 64 92.75% 1 33.33%
Linus Walleij 3 4.35% 1 33.33%
Jens Axboe 2 2.90% 1 33.33%
Total 69 100.00% 3 100.00%

/**
 * mmc_queue_resume - resume a previously suspended MMC request queue
 * @mq: MMC queue to resume
 */


void mmc_queue_resume(struct mmc_queue *mq)
{
	struct request_queue *q = mq->queue;
	unsigned long flags;

	if (mq->suspended) {
		mq->suspended = false;

		up(&mq->thread_sem);

		spin_lock_irqsave(q->queue_lock, flags);
		blk_start_queue(q);
		spin_unlock_irqrestore(q->queue_lock, flags);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Russell King 62 91.18% 1 33.33%
Linus Walleij 4 5.88% 1 33.33%
Jens Axboe 2 2.94% 1 33.33%
Total 68 100.00% 3 100.00%

/*
 * Prepare the sg list(s) to be handed of to the host driver
 */


unsigned int mmc_queue_map_sg(struct mmc_queue *mq, struct mmc_queue_req *mqrq)
{
	unsigned int sg_len;
	size_t buflen;
	struct scatterlist *sg;
	int i;

	if (!mqrq->bounce_buf)
		return blk_rq_map_sg(mq->queue, mqrq->req, mqrq->sg);

	sg_len = blk_rq_map_sg(mq->queue, mqrq->req, mqrq->bounce_sg);

	mqrq->bounce_sg_len = sg_len;

	buflen = 0;
	for_each_sg(mqrq->bounce_sg, sg, sg_len, i)
		buflen += sg->length;

	sg_init_one(mqrq->sg, mqrq->bounce_buf, buflen);

	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Pierre Ossman 95 84.07% 2 50.00%
Per Forlin 14 12.39% 1 25.00%
Jens Axboe 4 3.54% 1 25.00%
Total 113 100.00% 4 100.00%

/*
 * If writing, bounce the data to the buffer before the request
 * is sent to the host driver
 */


void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
{
	if (!mqrq->bounce_buf)
		return;

	if (rq_data_dir(mqrq->req) != WRITE)
		return;

	sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
		mqrq->bounce_buf, mqrq->sg[0].length);
}

Contributors
Person Tokens Prop Commits CommitProp
Pierre Ossman 46 85.19% 2 66.67%
Per Forlin 8 14.81% 1 33.33%
Total 54 100.00% 3 100.00%

/*
 * If reading, bounce the data from the buffer after the request
 * has been handled by the host driver
 */


void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
{
	if (!mqrq->bounce_buf)
		return;

	if (rq_data_dir(mqrq->req) != READ)
		return;

	sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
		mqrq->bounce_buf, mqrq->sg[0].length);
}
Contributors
Person Tokens Prop Commits CommitProp
Pierre Ossman 46 85.19% 2 66.67%
Per Forlin 8 14.81% 1 33.33%
Total 54 100.00% 3 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Adrian Hunter 1158 50.61% 13 19.40%
Russell King 481 21.02% 9 13.43%
Pierre Ossman 325 14.20% 9 13.43%
Per Forlin 96 4.20% 3 4.48%
Konstantin Dorfman 38 1.66% 1 1.49%
Seungwon Jeon 36 1.57% 1 1.49%
Christoph Hellwig 25 1.09% 3 4.48%
Sujit Reddy Thumma 23 1.01% 1 1.49%
Jens Axboe 19 0.83% 3 4.48%
Linus Walleij 11 0.48% 2 2.99%
Greg Kroah-Hartman 9 0.39% 1 1.49%
Mike Snitzer 9 0.39% 1 1.49%
Santosh Shilimkar 8 0.35% 1 1.49%
Ulf Hansson 7 0.31% 3 4.48%
Chuanxiao Dong 7 0.31% 1 1.49%
Tejun Heo 6 0.26% 3 4.48%
SF Markus Elfring 5 0.22% 1 1.49%
Martin K. Petersen 5 0.22% 3 4.48%
Ethan Du 4 0.17% 1 1.49%
Rabin Vincent 3 0.13% 1 1.49%
Thomas Gleixner 3 0.13% 1 1.49%
Venkatraman Sathiyamoorthy 3 0.13% 2 2.99%
Rafael J. Wysocki 3 0.13% 1 1.49%
Kiyoshi Ueda 2 0.09% 1 1.49%
Juha Yrjölä 2 0.09% 1 1.49%
Total 2288 100.00% 67 100.00%
Directory: drivers/mmc/core

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Sujit Reddy Thumma	23	41.82%	1	20.00%
Russell King	22	40.00%	1	20.00%
Chuanxiao Dong	7	12.73%	1	20.00%
Christoph Hellwig	2	3.64%	1	20.00%
Pierre Ossman	1	1.82%	1	20.00%
Total	55	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.12 drivers/mmc/core/queue.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
