From patchwork Fri Apr 14 05:08:34 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 13210932 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0F612C77B73 for ; Fri, 14 Apr 2023 05:08:57 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 378CF900005; Fri, 14 Apr 2023 01:08:54 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 3118F900004; Fri, 14 Apr 2023 01:08:54 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1798C900004; Fri, 14 Apr 2023 01:08:54 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 06B41900003 for ; Fri, 14 Apr 2023 01:08:54 -0400 (EDT) Received: from smtpin11.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id B696CA0115 for ; Fri, 14 Apr 2023 05:08:53 +0000 (UTC) X-FDA: 80678816946.11.6FF7FD2 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) by imf23.hostedemail.com (Postfix) with ESMTP id 9D98C140002 for ; Fri, 14 Apr 2023 05:08:50 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=infradead.org header.s=bombadil.20210309 header.b=EyOGTA5x; spf=none (imf23.hostedemail.com: domain of mcgrof@infradead.org has no SPF policy when checking 198.137.202.133) smtp.mailfrom=mcgrof@infradead.org; dmarc=fail reason="No valid SPF, DKIM not aligned (relaxed)" header.from=kernel.org (policy=none) ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1681448931; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=TU8tmoj4+nC9iaV5IMo+u+NGjzkEv9TSC0uMqT3ZueI=; b=LBPIljtEMbA3pSXburBuL3j3NfuvENTpAKUUiZaFElMcXQaodAnbFhNB3ny6FzKpK3rwJv exIkb7g9VtWEYzoWM7JhQhAUmU+wcqC1x+poIO8/klfvu3aFHIujH0e/Rc2jFmb0NpUzaL dGmsWxyUXl6NviLPmzMFcbaaNN+tXpk= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=infradead.org header.s=bombadil.20210309 header.b=EyOGTA5x; spf=none (imf23.hostedemail.com: domain of mcgrof@infradead.org has no SPF policy when checking 198.137.202.133) smtp.mailfrom=mcgrof@infradead.org; dmarc=fail reason="No valid SPF, DKIM not aligned (relaxed)" header.from=kernel.org (policy=none) ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1681448931; a=rsa-sha256; cv=none; b=hEe+VtnNYDtfVOykdg6PA96aIhS9nfWriMMc+HwSYyIJ5lwVuQrNDa8j0mE5xvowz/kEYP RMTGUn2uITbL5BmXV199x3pd6LvNrmrSQGirVuHqyjECHhjbcqjc4EsrarrCwnm6P9qMz1 kZHasLR75CH1X529DPUA2KXVW1eAneA= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=TU8tmoj4+nC9iaV5IMo+u+NGjzkEv9TSC0uMqT3ZueI=; b=EyOGTA5xTDzDcGr8GSBjkFLAN8 nGjkRQkjVZyZ1K+MuXZXYknzkVx1pGnFe94XPuHo4pX/P+jISL8mSC74ra5XSjl1AhLiUBcKp5fHv HTH3BHIqG/QCcwQsDxY47l8GSa8CI27vezXz4S8W5/UNxP1wlFF10VEDXPBlEczhj4nWzdiZLjwjX 7y3fYrCRccB7AfukcLW8wj8KzNE4sFjwAO8RmmNXBw3hKI83KBPOegRJadxHY8gH3WWgOCCElc0zS AVLGLYqIZAsNBXE0Lnh18BuIo2GpcXFQIA723+MLHAFr/MYvdVp4KTBPRmb7fTKZtEPos+zmyZheG vngAaacw==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.96 #2 (Red Hat Linux)) id 1pnBfp-008KKL-23; Fri, 14 Apr 2023 05:08:37 +0000 From: Luis Chamberlain To: david@redhat.com, patches@lists.linux.dev, linux-modules@vger.kernel.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, pmladek@suse.com, petr.pavlu@suse.com, prarit@redhat.com, torvalds@linux-foundation.org, gregkh@linuxfoundation.org, rafael@kernel.org Cc: christophe.leroy@csgroup.eu, tglx@linutronix.de, peterz@infradead.org, song@kernel.org, rppt@kernel.org, dave@stgolabs.net, willy@infradead.org, vbabka@suse.cz, mhocko@suse.com, dave.hansen@linux.intel.com, colin.i.king@gmail.com, jim.cromie@gmail.com, catalin.marinas@arm.com, jbaron@akamai.com, rick.p.edgecombe@intel.com, mcgrof@kernel.org Subject: [PATCH v3 2/4] module: extract patient module check into helper Date: Thu, 13 Apr 2023 22:08:34 -0700 Message-Id: <20230414050836.1984746-3-mcgrof@kernel.org> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20230414050836.1984746-1-mcgrof@kernel.org> References: <20230414050836.1984746-1-mcgrof@kernel.org> MIME-Version: 1.0 X-Rspamd-Queue-Id: 9D98C140002 X-Stat-Signature: mf81i6zo5t7qa3ggixtaser1487sebxp X-Rspam-User: X-Rspamd-Server: rspam08 X-HE-Tag: 1681448930-991637 X-HE-Meta: U2FsdGVkX19L7/vqmqUQD1Dud7sv2OsnR+L8qEEG/j1n+AkBuc9UVD+H3vYHURskXAt3tA5k920hef+zyaBXCYGg09YGm4q8AfyjXlGtC0/EJULOtA2Fsb2r0CK9cuf8irplZq/Tv33ZluX4gQIee+ZRHLrPsLJ0p6y6k1Tnv3A1oCT6Ka1xOg2sUScTC0hZrmddq72gQpmwL4IdDrCUfkREGecxlbTJxQtIvdo4Z29UetS4x1mPDEDptZdoevPQ24B3zaj6vgAitXSrBh4IP6wPRFNp9rhH4VcRo0Py1OzOH2e26v0HUT6PPI7SOzhHWU3RiCsPds9MoCgktIc+ufrrvRwDHP1SPqh6Yg/W5JydZktYZXmuHQfl4VDTCyp1FCOkzhNwuPfupnVqjudP/L81EKpkucS22UHcUnYoW5ilwjDfNxONKRs9YSvaSYVH6Bybs3Cbd53aRMFT6tBaAXXOLgnpn0q0KftNjmczXATXDYLKrPQrsWMgrQLfF1j5CO5NX9hlVzQKnQkcWGk/9dBuOKuMb1e8mvcJRIaYrI7mgap7UYN5FotrNOpe6/9DP1q7GAn0KgFgKuCSzmLcSYt+CWffYjAVW3SuElvtS1zwiUGZkUuVAVbKuZWebkNuVkQIpJGzlslLIo+FX88EdpQCc7O4rstGu0LDLPMyHrvjvSrvXgX8mu61AdYi5Mo166+GLnZvLbIiT/oZqqw2gFcxU1Yh9og+PqxXxJJ8emYWKExDpaeE42SKy3k/3eU2dIGf+qkFx9Cl4R9ra48gBvATtpF3FiUX22Qa3Mgjs0Y69uTX1i7+uOxdnPRaZSTpU+l//dLZguz1Zb+DhlOzFcSaLiPkFbcn5zESe1GOfuSNTC7nWnV2YR3JqPzwwTfvEeFn68A1xaeM3t8X9Tl/WAXCa3D+dwwh9B+L2NYKdOF94LP4PeMw3l+g7oQaEW8xeQaUNaF+UdAkOjSkvs0 R3o7P9mP 4NFdWqryir3k+Em2hFgRwbjIWRFiZsiIC9j8mO8Ama+NgENlk2p+CydJsTRvG5mIqd6d0jtFQ4Pz6ko/RcbhV423E4kRZHuN3KNNV6HLcNqrvrOJ0wMablsMuTR6Wt5iOb2ln2WaTDHxaZj/w9qOqoc0dyAuhmVpMiZw46ngTRwGI9vS/gzjrU9CA4jeHucQN0h2HSLMYxQ5USF25HSs72kQ0MPyb6aD5OqA+PcUE++xQDGkuyUL2wwJzT14OV3XROG4e1dDCKNCuyvlaphBOJEXsGo3RKRrC3uR/b7odllmwuNJGd4FAuQpC4DC1QQUpHB1twnQnTYqw5KmJRhuxrlWX3d0PbCFiDMul/LOhBfPxtfggaNKdxP2BsW+g01PPxoSjnqicF4WslMNlO1u8m/EONOKAu3bsEOZ5/aqv/8f8OsCifFgxfXC15XL8D0HBaLSGnGWCe3VNkeuKKeYGlOc7v1ckdSuK+/9KrKLQyT/tkywZiPdj2CdM1kRKDyNPYnRq X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: The patient module check inside add_unformed_module() is large enough as we need it. It is a bit hard to read too, so just move it to a helper and do the inverse checks first to help shift the code and make it easier to read. The new helper then is module_patient_check_exists(). To make this work we need to mvoe the finished_loading() up, we do that without making any functional changes to that routine. Reviewed-by: David Hildenbrand Signed-off-by: Luis Chamberlain --- kernel/module/main.c | 112 +++++++++++++++++++++++-------------------- 1 file changed, 60 insertions(+), 52 deletions(-) diff --git a/kernel/module/main.c b/kernel/module/main.c index 32554d8a5791..75b23257128d 100644 --- a/kernel/module/main.c +++ b/kernel/module/main.c @@ -2447,27 +2447,6 @@ static int post_relocation(struct module *mod, const struct load_info *info) return module_finalize(info->hdr, info->sechdrs, mod); } -/* Is this module of this name done loading? No locks held. */ -static bool finished_loading(const char *name) -{ - struct module *mod; - bool ret; - - /* - * The module_mutex should not be a heavily contended lock; - * if we get the occasional sleep here, we'll go an extra iteration - * in the wait_event_interruptible(), which is harmless. - */ - sched_annotate_sleep(); - mutex_lock(&module_mutex); - mod = find_module_all(name, strlen(name), true); - ret = !mod || mod->state == MODULE_STATE_LIVE - || mod->state == MODULE_STATE_GOING; - mutex_unlock(&module_mutex); - - return ret; -} - /* Call module constructors. */ static void do_mod_ctors(struct module *mod) { @@ -2631,6 +2610,63 @@ static int may_init_module(void) return 0; } +/* Is this module of this name done loading? No locks held. */ +static bool finished_loading(const char *name) +{ + struct module *mod; + bool ret; + + /* + * The module_mutex should not be a heavily contended lock; + * if we get the occasional sleep here, we'll go an extra iteration + * in the wait_event_interruptible(), which is harmless. + */ + sched_annotate_sleep(); + mutex_lock(&module_mutex); + mod = find_module_all(name, strlen(name), true); + ret = !mod || mod->state == MODULE_STATE_LIVE + || mod->state == MODULE_STATE_GOING; + mutex_unlock(&module_mutex); + + return ret; +} + +/* Must be called with module_mutex held */ +static int module_patient_check_exists(const char *name) +{ + struct module *old; + int err = 0; + + old = find_module_all(name, strlen(name), true); + if (old == NULL) + return 0; + + if (old->state == MODULE_STATE_COMING || + old->state == MODULE_STATE_UNFORMED) { + /* Wait in case it fails to load. */ + mutex_unlock(&module_mutex); + err = wait_event_interruptible(module_wq, + finished_loading(name)); + mutex_lock(&module_mutex); + if (err) + return err; + + /* The module might have gone in the meantime. */ + old = find_module_all(name, strlen(name), true); + } + + /* + * We are here only when the same module was being loaded. Do + * not try to load it again right now. It prevents long delays + * caused by serialized module load failures. It might happen + * when more devices of the same type trigger load of + * a particular module. + */ + if (old && old->state == MODULE_STATE_LIVE) + return -EEXIST; + return -EBUSY; +} + /* * We try to place it in the list now to make sure it's unique before * we dedicate too many resources. In particular, temporary percpu @@ -2639,41 +2675,14 @@ static int may_init_module(void) static int add_unformed_module(struct module *mod) { int err; - struct module *old; mod->state = MODULE_STATE_UNFORMED; mutex_lock(&module_mutex); - old = find_module_all(mod->name, strlen(mod->name), true); - if (old != NULL) { - if (old->state == MODULE_STATE_COMING - || old->state == MODULE_STATE_UNFORMED) { - /* Wait in case it fails to load. */ - mutex_unlock(&module_mutex); - err = wait_event_interruptible(module_wq, - finished_loading(mod->name)); - if (err) - goto out_unlocked; - - /* The module might have gone in the meantime. */ - mutex_lock(&module_mutex); - old = find_module_all(mod->name, strlen(mod->name), - true); - } - - /* - * We are here only when the same module was being loaded. Do - * not try to load it again right now. It prevents long delays - * caused by serialized module load failures. It might happen - * when more devices of the same type trigger load of - * a particular module. - */ - if (old && old->state == MODULE_STATE_LIVE) - err = -EEXIST; - else - err = -EBUSY; + err = module_patient_check_exists(mod->name); + if (err) goto out; - } + mod_update_bounds(mod); list_add_rcu(&mod->list, &modules); mod_tree_insert(mod); @@ -2681,7 +2690,6 @@ static int add_unformed_module(struct module *mod) out: mutex_unlock(&module_mutex); -out_unlocked: return err; }