From patchwork Wed Aug 9 14:35:47 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Takashi Iwai X-Patchwork-Id: 133321 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:c44e:0:b0:3f2:4152:657d with SMTP id w14csp2903139vqr; Wed, 9 Aug 2023 09:10:46 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG+fG+rOgH5pxCFy2Z2jq5RCGI+XX0SoTGfI61PcqpowdA6ymounpTTBgiRrACgvFLqzudQ X-Received: by 2002:a17:902:8307:b0:1b9:c205:a876 with SMTP id bd7-20020a170902830700b001b9c205a876mr3295080plb.29.1691597446175; Wed, 09 Aug 2023 09:10:46 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691597446; cv=none; d=google.com; s=arc-20160816; b=FF/V5rX5WHhkYxrAjvAadEoTJPP1I/11Mpa9n6e5yNPa2hKS/dJ1ggxdWGgywh8Sti EtYg0W6NkOi3h4tGqIX52kJ3seOn4yK5GQf4jv+Iv0tNT89NctfvceSBJGYtJevCHtPP wABmrCZnCuEgcIKDKgg6iOasL2aFBFyvNDI44qfy71RGAz6o2k2c1hGMZdGadcpCXt7V TrffXeZkGfjvc95FnnhL8FSSO5dHfCGjZ6PwtLd7YcP2vPvIuOvlYlnpGHueRSjQnPE0 dHpZSxxBJFyqs5jGFhbYqy2zLL98AOVBsJe5z9IYwiz1qFQtVD6XqVOYspC1PDCWXnV/ mrGg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:user-agent:subject:cc:to:from :message-id:date:dkim-signature:dkim-signature; bh=0yqLkSRXZ8f3zN1k6eS9Dsh1bWA3RF5pe3YHi1TbXrU=; fh=bG6eZQcJKMHFFrmI1EN8K7epiU4KFugrBTj8pevkXQE=; b=WoFcucbP+F/1BsK0DmB5qmqvUI5ASq+ifq/n2Aiu+P4ADiIQ9aLCizC2EcN08do3ez uM83D4oDZC6UNOapqBI3B6s4MbAKORAm9Xe0ypckzinpiR98kuAlqgnslUHS+bDLZHJF mXi99uH3dfHvpednpXO5qdVz3nfkq02cbfa8gKAeyCzq2YDfQiWFtP70cJBaLg6t0d5Y haF2NBB/vbUfbUiXPEJLxKxYTY6B3fVMPCdm0lbnaj27Uhn74U7rTCVDhZbl8pk/6x7e QzHil2XTi/yS/zrY2pTnlXQyPieSsWKDMfh2A4FwxECpa4R+5ihf/z8pQ6A8JWt6zUhd LWLQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@suse.de header.s=susede2_rsa header.b=Y0EPY0Z5; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=suse.de Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id n4-20020a170902d2c400b001b8987f4004si10201381plc.541.2023.08.09.09.10.31; Wed, 09 Aug 2023 09:10:46 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@suse.de header.s=susede2_rsa header.b=Y0EPY0Z5; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=suse.de Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232265AbjHIOfv (ORCPT + 99 others); Wed, 9 Aug 2023 10:35:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36466 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229967AbjHIOfu (ORCPT ); Wed, 9 Aug 2023 10:35:50 -0400 Received: from smtp-out2.suse.de (smtp-out2.suse.de [IPv6:2001:67c:2178:6::1d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CD86BEE; Wed, 9 Aug 2023 07:35:49 -0700 (PDT) Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 89D3F1F38C; Wed, 9 Aug 2023 14:35:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_rsa; t=1691591748; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type; bh=0yqLkSRXZ8f3zN1k6eS9Dsh1bWA3RF5pe3YHi1TbXrU=; b=Y0EPY0Z55IgKRJqb9qpumcoLr0RyBq8JjsZFu8NQ9OrOKeKY23A2D58fbowxX+ORnb0jRr Jkqljx1vafZqpX7L0f9dwH0fcbCI5kLL2ugXWQnX4LjJkK78XyJV1UPb+Z34JtuC0fzww+ WBgfS/2GsYSBVRj0OZFXuBNnWxF98WQ= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_ed25519; t=1691591748; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type; bh=0yqLkSRXZ8f3zN1k6eS9Dsh1bWA3RF5pe3YHi1TbXrU=; b=1+XcZ0e8l0cXa6QMh5n2/GXE+vT70b2c9LDv93ahnmZ8uhsKna2SqpxtgBPkn5/rHs1kf/ vWVvkNGpNyLInEAg== Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by imap2.suse-dmz.suse.de (Postfix) with ESMTPS id 531ED133B5; Wed, 9 Aug 2023 14:35:48 +0000 (UTC) Received: from dovecot-director2.suse.de ([192.168.254.65]) by imap2.suse-dmz.suse.de with ESMTPSA id T98SE0Sk02RTMAAAMHmgww (envelope-from ); Wed, 09 Aug 2023 14:35:48 +0000 Date: Wed, 09 Aug 2023 16:35:47 +0200 Message-ID: <87edkce118.wl-tiwai@suse.de> From: Takashi Iwai To: linux-kernel@vger.kernel.org Cc: Andy Shevchenko , Mark Brown , Christoph Hellwig , netdev@vger.kernel.org Subject: [PATCH RFC] Introduce uniptr_t as a generic "universal" pointer User-Agent: Wanderlust/2.15.9 (Almost Unreal) Emacs/27.2 Mule/6.0 MIME-Version: 1.0 (generated by SEMI-EPG 1.14.7 - "Harue") X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773763128778817792 X-GMAIL-MSGID: 1773768484198829426 Although sockptr_t is used already in several places as a "universal" pointer, it's still too confusing to use it in other subsystems, since people see it always as if it were a network-related stuff. This patch defines a more generic type, uniptr_t, that does exactly as same as sockptr_t for a wider use. As of now, it's almost 1:1 copy with renames (just with comprehensive header file inclusions). Signed-off-by: Takashi Iwai --- This is a RFC patch, or rather a material for bikeshedding. Initially the discussion started from the use of sockptr_t for the sound driver in Andy's patch: https://lore.kernel.org/r/20230721100146.67293-1-andriy.shevchenko@linux.intel.com followed by a bigger series of patches by me: https://lore.kernel.org/r/20230731154718.31048-1-tiwai@suse.de The first reaction to the patches (including my own) were "why sockptr_t?" Yes, it's just confusing. So, here it is, a proposal of defining the new type for the very purpose as sockptr_t. The name of uniptr_t is nothing but my random pick up, and we can endlessly discuss for a better name (genptr_t or whatever). I'm totally open for the name. After this introduction, sockptr_t can be alias of uniptr_t, e.g. simply override with "#define sockptr_t uniptr_t" or such. How can it be is another open question. Also, we can clean up the macro implementation along with it; there seem a few (rather minor) issues as suggested by Andy: https://lore.kernel.org/r/ZMlGKy7ibjkQ6ii7@smile.fi.intel.com Honestly speaking, I don't mind to keep using sockptr_t generically despite of the name, if people agree. The rename might make sense, though, if it's more widely used in other subsystems in future. Takashi === include/linux/uniptr.h | 121 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 include/linux/uniptr.h diff --git a/include/linux/uniptr.h b/include/linux/uniptr.h new file mode 100644 index 000000000000..f7994d3a45eb --- /dev/null +++ b/include/linux/uniptr.h @@ -0,0 +1,121 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Support for "universal" pointers that can point to either kernel or userspace + * memory. + * + * Original code from sockptr.h + * Copyright (c) 2020 Christoph Hellwig + */ +#ifndef _LINUX_UNIPTR_H +#define _LINUX_UNIPTR_H + +#include +#include +#include +#include +#include + +typedef struct { + union { + void *kernel; + void __user *user; + }; + bool is_kernel : 1; +} uniptr_t; + +static inline bool uniptr_is_kernel(uniptr_t uniptr) +{ + return uniptr.is_kernel; +} + +static inline uniptr_t KERNEL_UNIPTR(void *p) +{ + return (uniptr_t) { .kernel = p, .is_kernel = true }; +} + +static inline uniptr_t USER_UNIPTR(void __user *p) +{ + return (uniptr_t) { .user = p }; +} + +static inline bool uniptr_is_null(uniptr_t uniptr) +{ + if (uniptr_is_kernel(uniptr)) + return !uniptr.kernel; + return !uniptr.user; +} + +static inline int copy_from_uniptr_offset(void *dst, uniptr_t src, + size_t offset, size_t size) +{ + if (!uniptr_is_kernel(src)) + return copy_from_user(dst, src.user + offset, size); + memcpy(dst, src.kernel + offset, size); + return 0; +} + +static inline int copy_from_uniptr(void *dst, uniptr_t src, size_t size) +{ + return copy_from_uniptr_offset(dst, src, 0, size); +} + +static inline int copy_to_uniptr_offset(uniptr_t dst, size_t offset, + const void *src, size_t size) +{ + if (!uniptr_is_kernel(dst)) + return copy_to_user(dst.user + offset, src, size); + memcpy(dst.kernel + offset, src, size); + return 0; +} + +static inline int copy_to_uniptr(uniptr_t dst, const void *src, size_t size) +{ + return copy_to_uniptr_offset(dst, 0, src, size); +} + +static inline void *memdup_uniptr(uniptr_t src, size_t len) +{ + void *p = kmalloc_track_caller(len, GFP_USER | __GFP_NOWARN); + + if (!p) + return ERR_PTR(-ENOMEM); + if (copy_from_uniptr(p, src, len)) { + kfree(p); + return ERR_PTR(-EFAULT); + } + return p; +} + +static inline void *memdup_uniptr_nul(uniptr_t src, size_t len) +{ + char *p = kmalloc_track_caller(len + 1, GFP_KERNEL); + + if (!p) + return ERR_PTR(-ENOMEM); + if (copy_from_uniptr(p, src, len)) { + kfree(p); + return ERR_PTR(-EFAULT); + } + p[len] = '\0'; + return p; +} + +static inline long strncpy_from_uniptr(char *dst, uniptr_t src, size_t count) +{ + if (uniptr_is_kernel(src)) { + size_t len = min(strnlen(src.kernel, count - 1) + 1, count); + + memcpy(dst, src.kernel, len); + return len; + } + return strncpy_from_user(dst, src.user, count); +} + +static inline int check_zeroed_uniptr(uniptr_t src, size_t offset, size_t size) +{ + if (!uniptr_is_kernel(src)) + return check_zeroed_user(src.user + offset, size); + return memchr_inv(src.kernel + offset, 0, size) == NULL; +} + +#endif /* _LINUX_UNIPTR_H */