From patchwork Fri Dec 17 03:56:21 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cho KyongHo X-Patchwork-Id: 5111 Return-path: Envelope-to: mchehab@gaivota Delivery-date: Fri, 17 Dec 2010 02:24:24 -0200 Received: from mchehab by gaivota with local (Exim 4.72) (envelope-from ) id 1PTRrj-00037d-SV for mchehab@gaivota; Fri, 17 Dec 2010 02:24:24 -0200 Received: from casper.infradead.org [85.118.1.10] by gaivota with IMAP (fetchmail-6.3.17) for (single-drop); Fri, 17 Dec 2010 02:24:23 -0200 (BRST) Received: from vger.kernel.org ([209.132.180.67]) by casper.infradead.org with esmtp (Exim 4.72 #1 (Red Hat Linux)) id 1PTRmQ-0007hB-UW; Fri, 17 Dec 2010 04:18:55 +0000 Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753117Ab0LQESG (ORCPT + 1 other); Thu, 16 Dec 2010 23:18:06 -0500 Received: from ganesha.gnumonks.org ([213.95.27.120]:37658 "EHLO ganesha.gnumonks.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752676Ab0LQEQi (ORCPT ); Thu, 16 Dec 2010 23:16:38 -0500 Received: from uucp by ganesha.gnumonks.org with local-bsmtp (Exim 4.69) (envelope-from ) id 1PTRk8-0000tN-N3; Fri, 17 Dec 2010 05:16:32 +0100 Received: from [12.23.102.153] (helo=localhost.localdomain) by jackpot.kr.gnumonks.org with esmtp (Exim 4.69) (envelope-from ) id 1PTQkN-0000sX-PF; Fri, 17 Dec 2010 12:12:43 +0900 From: KyongHo Cho To: KyongHo Cho Cc: Kyungmin Park , Kukjin Kim , Inho Lee , Inki Dae , Andrew Morton , Ankita Garg , Daniel Walker , Johan MOSSBERG , KAMEZAWA Hiroyuki , Marek Szyprowski , Mel Gorman , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, linux-mm@kvack.org, linux-samsung-soc@vger.kernel.org, KyongHo Cho Subject: [RFCv2,2/8] mm: vcm: reference counting on a reservation added Date: Fri, 17 Dec 2010 12:56:21 +0900 Message-Id: <1292558187-17348-3-git-send-email-pullip.cho@samsung.com> X-Mailer: git-send-email 1.6.2.5 In-Reply-To: <1292558187-17348-2-git-send-email-pullip.cho@samsung.com> References: <1292558187-17348-1-git-send-email-pullip.cho@samsung.com> <1292558187-17348-2-git-send-email-pullip.cho@samsung.com> Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Sender: Mauro Carvalho Chehab This commits adds vcm_ref_reserve() and refcnt member into vcm_res structure. This feature is enabled by turnning on CONFIG_VCM_RES_REFCNT. This enables the users of the vcm framework not to care about the sequence of reserving and unreserving in complex scenarios. Signed-off-by: KyongHo Cho --- Documentation/virtual-contiguous-memory.txt | 47 +++++++++++++++++++++++++++ include/linux/vcm.h | 23 +++++++++++++ mm/Kconfig | 7 ++++ mm/vcm.c | 17 ++++++++++ 4 files changed, 94 insertions(+), 0 deletions(-) diff --git a/Documentation/virtual-contiguous-memory.txt b/Documentation/virtual-contiguous-memory.txt index 9793a86..2008465 100644 --- a/Documentation/virtual-contiguous-memory.txt +++ b/Documentation/virtual-contiguous-memory.txt @@ -275,6 +275,34 @@ To deactivate the VCM context vcm_deactivate() function is used: Both of those functions can be called several times if all calls to vcm_activate() are paired with a later call to vcm_deactivate(). +** Aquiring and releasing ownership of a reservation + +Once a device driver reserve a reservation, it may want to pass other device +drivers or attach the reservation in a data structre. Since the reservation +may be shared among many device drivers, the VCM context is needed to provide +a simple way to unreserve a reservation. + +Below 2 functions gives the ownership of a reservation to the caller: + + struct vcm_res *__must_check + vcm_reserve(struct vcm *vcm, resource_size_t size, unsigned flags); + + int __must_check vcm_ref_reserve(struct vcm_res *res); + +vcm_reserve() creates a new reservation, thus the first owner of the +reservation is set to the caller of vcm_reservation(). It then passes to a +function the reservation. The function that received the reservation calls +vcm_ref_reserve() to acquire the ownership of the given reservation. If the +function decides that it does not need the reservation any more, it calls +vcm_release() to release the ownership of the reservation. + + void vcm_unreserve(struct vcm_res *res); + +It is not required to determine if other functions and drivers still need to +access the reservation because this function just release the ownership of the +reservation. If vcm_unreserve() finds no one has the ownership of the given +reservation, only then does it unreserve (remove) the given reservation. + ** Device driver example The following is a simple, untested example of how platform and @@ -706,6 +734,25 @@ automatically reflect new mappings on the hardware MMU. Neither of the operations are required and if missing, VCM will assume they are a no-operation and no warning will be generated. +*** Ownership of a reservation + +When to aquire the ownership of a reservation: + - When creating a new reservation (having the ownership automatically) + - When assigning a reservation to a member of data structure + - When a reservation is passed from the caller function + - When requiring to access a reservation (that is a global variable) + at first in its context. +The first one is done with vcm_reserve() and others with vcm_ref_reserve(). + +When to release the ownership of a reservation: + - When a reservation is no longer needed in its context. + - When returning from a function and the function received a reservation + from its caller and acquired the ownership of the reservation. + - When removing a reservation from a data structure that includes a pointer + to the reservation +It is not required as well unable to remove the reservation explicitly. The +last call to vcm_unreserve() will cause the reservation to be removed. + * Epilogue The initial version of the VCM framework was written by Zach Pfeffer diff --git a/include/linux/vcm.h b/include/linux/vcm.h index 965dc9b..3d54f18 100644 --- a/include/linux/vcm.h +++ b/include/linux/vcm.h @@ -52,6 +52,9 @@ struct vcm { * @bound_size: number of bytes actually bound to the virtual address; * read only. * @res_size: size of the reserved address space in bytes; read only. + * @refcnt: reference count of a reservation to pass ownership of + * a reservation in a safe way; internal. + * Implemented only when CONFIG_VCM_RES_REFCNT is enabled. * @vcm: VCM context; internal, read only for MMU drivers. * @phys: pointer to physical memory bound to this reservation; NULL * if no physical memory is bound; read only. @@ -65,6 +68,9 @@ struct vcm_res { dma_addr_t start; resource_size_t bound_size; resource_size_t res_size; +#ifdef CONFIG_VCM_RES_REFCNT + atomic_t refcnt; +#endif struct vcm *vcm; struct vcm_phys *phys; @@ -180,6 +186,23 @@ struct vcm_res *__must_check vcm_reserve(struct vcm *vcm, resource_size_t size, unsigned flags); /** + * vcm_ref_reserve() - acquires the ownership of a reservation. + * @res: a valid reservation to access + * + * On success returns 0 and leads the same effect as vcm_reserve() in the + * context of the caller of this function. In other words, once a function + * acquire the ownership of a reservation with vcm_ref_reserve(), it must + * release the ownership with vcm_release() as soon as it does not need + * the reservation. + * + * On error returns -EINVAL. The only reason of the error is passing an invalid + * reservation like NULL or an unreserved reservation. + */ +#ifdef CONFIG_VCM_RES_REFCNT +int __must_check vcm_ref_reserve(struct vcm_res *res); +#endif + +/** * vcm_unreserve() - destroyers a virtual address space reservation * @res: reservation to destroy. * diff --git a/mm/Kconfig b/mm/Kconfig index 7f0e4b1..b937f32 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -353,6 +353,13 @@ config VCM . If unsure, say "n". +config VCM_RES_REFCNT + bool "Reference counting on reservations" + depends on VCM + help + This enables reference counting on a reservation to make sharing + and migrating the ownership of the reservation easier. + # # UP and nommu archs use km based percpu allocator # diff --git a/mm/vcm.c b/mm/vcm.c index 1389ee6..5819f0f 100644 --- a/mm/vcm.c +++ b/mm/vcm.c @@ -156,10 +156,23 @@ vcm_reserve(struct vcm *vcm, resource_size_t size, unsigned flags) __vcm_alloc_and_reserve(vcm, size, NULL, 0, &res, flags); +#ifdef CONFIG_VCM_RES_REFCNT + if (!IS_ERR(res)) + atomic_inc(&res->refcnt); +#endif + return res; } EXPORT_SYMBOL_GPL(vcm_reserve); +int __must_check vcm_ref_reserve(struct vcm_res *res) +{ + if (WARN_ON(!res) || (atomic_inc_return(&res->refcnt) < 2)) + return -EINVAL; + return 0; +} +EXPORT_SYMBOL_GPL(vcm_ref_reserve); + struct vcm_res *__must_check vcm_map(struct vcm *vcm, struct vcm_phys *phys, unsigned flags) { @@ -196,6 +209,10 @@ EXPORT_SYMBOL_GPL(vcm_map); void vcm_unreserve(struct vcm_res *res) { if (!WARN_ON(!res)) { +#ifdef CONFIG_VCM_RES_REFCNT + if (!atomic_dec_and_test(&res->refcnt)) + return; +#endif if (WARN_ON(res->phys)) vcm_unbind(res); if (!WARN_ON_ONCE(!res->vcm->driver->unreserve))