From patchwork Mon Dec 3 23:34:58 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Jerome Glisse X-Patchwork-Id: 10710893 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 1232B13BF for ; Mon, 3 Dec 2018 23:35:56 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id F3E9629267 for ; Mon, 3 Dec 2018 23:35:55 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id E571B2B212; Mon, 3 Dec 2018 23:35:55 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.1 Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id D27C92B1EF for ; Mon, 3 Dec 2018 23:35:54 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id DA6766B6BAC; Mon, 3 Dec 2018 18:35:53 -0500 (EST) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id D2E686B6BAD; Mon, 3 Dec 2018 18:35:53 -0500 (EST) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id BCF3F6B6BAE; Mon, 3 Dec 2018 18:35:53 -0500 (EST) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from mail-qk1-f200.google.com (mail-qk1-f200.google.com [209.85.222.200]) by kanga.kvack.org (Postfix) with ESMTP id 8FF6C6B6BAC for ; Mon, 3 Dec 2018 18:35:53 -0500 (EST) Received: by mail-qk1-f200.google.com with SMTP id s70so14942144qks.4 for ; Mon, 03 Dec 2018 15:35:53 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-original-authentication-results:x-gm-message-state:from:to:cc :subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=qEWzPDikBrPZIZ8YPALgUwtKNGrdoB4MANJ8TJxUGCg=; b=coxVJ5Hwsk/Hi3ffkud2OIKNpp/QO93az+1GHMXMGy2bkOVMDvPqxMPfwnup5J8/v2 Rxm+y/eLZNu+uj3mtK4I8Erur66TdkC9ni/VullL83gsvvmsTF/8pM6nRiig7X+bqiKd UgiLjOK7tINthzZ5Im9Cab83daeRzxveAKq5ut6Gq/penL3/2ogPyHkGaKYbI1PuHE6h RTZ+aBRaMKdxUKYtBHMYESfyDzBEksidUc6uC7XnEhre1vLlwSzLwODkevBMfD+AlfBj 3NXwS97VEsXJOFxU4JRX/FTeIZyHsi008xbUjHhmC4Le3YlqIQwcu+EW65B995g9R6oj Y96Q== X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com X-Gm-Message-State: AA+aEWa2WOHF0zDBZZ5DSebxYXBetmYvrFjH0rV9ie31a5UCSQaQghmY oGQwtGMrBrolHzvJfIslv7WWP5vYEiAN7ChctfzVlxZwMuRvZq0LaHXM1+Be3DvFqlgQpoAGi0p FLnu0+yu5+b/J/1uHxQ2Q+OBdwszJY9J7UPDDvNjresFOkCvAC9NzKCS08GaIGHXEXQ== X-Received: by 2002:a37:611:: with SMTP id 17mr16748141qkg.123.1543880153307; Mon, 03 Dec 2018 15:35:53 -0800 (PST) X-Google-Smtp-Source: AFSGD/W2AGFXTmjrLWVF98vQInGkn4jDCxT2810oR/yGH49Bl3C2bmtNCArzmm3J3GnWTFR92Euj X-Received: by 2002:a37:611:: with SMTP id 17mr16748119qkg.123.1543880152612; Mon, 03 Dec 2018 15:35:52 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1543880152; cv=none; d=google.com; s=arc-20160816; b=pJ/It14ei8sKJbeaDiPsg18T8RG22Vcr+3yTutdLxcIVZU2PkB9G6Z+pvkr+IXNBw5 W9A5Vl+YfqQiEQwhdaFRIQgrhIpEiDkOOFYHfMOIa7GIBX61O5FBtaVlS/aBIe/+kZjv Gn0Q4/1yaWICGgSW3ijdIkEKd8pDPRJXJMKvezr/wI2Uc42f3iHlANhstGE7MR6ihbm2 N3HYInL/2lg/tnw35mUrWQfoDy6S6ODXnogj0LiAsRbkrgCNO+5YAUbixpv3rxdeorzu QG9iezAovOBopLx28BR15GfFemtkMvuZwJzJSySYYqhHgXUvWMGma7Z3AHAnOuEu26az 6NGQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from; bh=qEWzPDikBrPZIZ8YPALgUwtKNGrdoB4MANJ8TJxUGCg=; b=QbGMzARXj0APmcALMtW7PFYlDpnkL7TdloYGy8iUfylOV6kO1fT7h3eyA68vQO7KJL VHFCb+5yrUm4wrrLoQaxUzGR5gjhgGO8ozlXDu/cmN4uefwEoLGqtvstazSwr6onKSzs cRmtBTeNjkeEeKmhEUOBngm5WFOK2Pn/+fPzNOlXyOUfEUhMF38XrA0x67uo975dNwh0 cEB79Y0nIuMsiZVqzt/kT+8O9ktdJZfKKZe/SlSmDrECVI7hE/D/CB6G/srkjPj2epR4 1i2l5ICPVLjstCA2DZmTZPB3SpnZNOlMFtu9rJmFxiTTsseQLAz0Vkxv+PqQtL4b7v2I mhXQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from mx1.redhat.com (mx1.redhat.com. [209.132.183.28]) by mx.google.com with ESMTPS id o3si6521099qvr.36.2018.12.03.15.35.52 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 03 Dec 2018 15:35:52 -0800 (PST) Received-SPF: pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; Authentication-Results: mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 8D28530024C8; Mon, 3 Dec 2018 23:35:51 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-120-188.rdu2.redhat.com [10.10.120.188]) by smtp.corp.redhat.com (Postfix) with ESMTP id 49B55600C1; Mon, 3 Dec 2018 23:35:45 +0000 (UTC) From: jglisse@redhat.com To: linux-mm@kvack.org Cc: Andrew Morton , linux-kernel@vger.kernel.org, =?utf-8?b?SsOpcsO0bWUgR2xpc3Nl?= , "Rafael J . Wysocki" , Ross Zwisler , Dan Williams , Dave Hansen , Haggai Eran , Balbir Singh , "Aneesh Kumar K . V" , Benjamin Herrenschmidt , Felix Kuehling , Philip Yang , =?utf-8?q?Christian_K=C3=B6nig?= , Paul Blinzer , Logan Gunthorpe , John Hubbard , Ralph Campbell , Michal Hocko , Jonathan Cameron , Mark Hairgrove , Vivek Kini , Mel Gorman , Dave Airlie , Ben Skeggs , Andrea Arcangeli Subject: [RFC PATCH 03/14] mm/hms: add target memory to heterogeneous memory system infrastructure Date: Mon, 3 Dec 2018 18:34:58 -0500 Message-Id: <20181203233509.20671-4-jglisse@redhat.com> In-Reply-To: <20181203233509.20671-1-jglisse@redhat.com> References: <20181203233509.20671-1-jglisse@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.40]); Mon, 03 Dec 2018 23:35:51 +0000 (UTC) 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: X-Virus-Scanned: ClamAV using ClamSMTP From: Jérôme Glisse A target is some kind of memory, it can be regular main memory or some more specialize memory like CPU's HBM (High Bandwidth Memory) or some device's memory. Some target memory might not be accessible by all initiators (anything that can trigger memory access). For instance some device memory might not be accessible by CPU. This is truely heterogeneous systems at its heart. Signed-off-by: Jérôme Glisse Cc: Rafael J. Wysocki Cc: Ross Zwisler Cc: Dan Williams Cc: Dave Hansen Cc: Haggai Eran Cc: Balbir Singh Cc: Aneesh Kumar K.V Cc: Benjamin Herrenschmidt Cc: Felix Kuehling Cc: Philip Yang Cc: Christian König Cc: Paul Blinzer Cc: Logan Gunthorpe Cc: John Hubbard Cc: Ralph Campbell Cc: Michal Hocko Cc: Jonathan Cameron Cc: Mark Hairgrove Cc: Vivek Kini Cc: Mel Gorman Cc: Dave Airlie Cc: Ben Skeggs Cc: Andrea Arcangeli --- drivers/base/Makefile | 2 +- drivers/base/hms-target.c | 193 ++++++++++++++++++++++++++++++++++++++ include/linux/hms.h | 43 ++++++++- 3 files changed, 235 insertions(+), 3 deletions(-) create mode 100644 drivers/base/hms-target.c diff --git a/drivers/base/Makefile b/drivers/base/Makefile index 92ebfacbf0dc..8e8092145f18 100644 --- a/drivers/base/Makefile +++ b/drivers/base/Makefile @@ -12,7 +12,7 @@ obj-y += power/ obj-$(CONFIG_ISA_BUS_API) += isa.o obj-y += firmware_loader/ obj-$(CONFIG_NUMA) += node.o -obj-$(CONFIG_HMS) += hms.o +obj-$(CONFIG_HMS) += hms.o hms-target.o obj-$(CONFIG_MEMORY_HOTPLUG_SPARSE) += memory.o ifeq ($(CONFIG_SYSFS),y) obj-$(CONFIG_MODULES) += module.o diff --git a/drivers/base/hms-target.c b/drivers/base/hms-target.c new file mode 100644 index 000000000000..ce28dfe089a3 --- /dev/null +++ b/drivers/base/hms-target.c @@ -0,0 +1,193 @@ +/* + * Copyright 2018 Red Hat Inc. + * + * 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. + * + * Authors: + * Jérôme Glisse + */ +/* Heterogeneous memory system (HMS) see Documentation/vm/hms.rst */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +static DEFINE_MUTEX(hms_target_mutex); + + +static inline struct hms_target *hms_object_to_target(struct hms_object *object) +{ + if (object == NULL) + return NULL; + + if (object->type != HMS_TARGET) + return NULL; + return container_of(object, struct hms_target, object); +} + +static inline struct hms_target *device_to_hms_target(struct device *device) +{ + if (device == NULL) + return NULL; + + return hms_object_to_target(to_hms_object(device)); +} + +struct hms_target *hms_target_find_locked(unsigned uid) +{ + struct hms_object *object = hms_object_find_locked(uid); + struct hms_target *target; + + target = hms_object_to_target(object); + if (target) + return target; + hms_object_put(object); + return NULL; +} + +struct hms_target *hms_target_find(unsigned uid) +{ + struct hms_object *object = hms_object_find(uid); + struct hms_target *target; + + target = hms_object_to_target(object); + if (target) + return target; + hms_object_put(object); + return NULL; +} + +static void hms_target_release(struct device *device) +{ + struct hms_target *target = device_to_hms_target(device); + + hms_object_release(&target->object); + kfree(target); +} + +static ssize_t hms_target_show_size(struct device *device, + struct device_attribute *attr, + char *buf) +{ + struct hms_target *target = device_to_hms_target(device); + + if (target == NULL) + return -EINVAL; + + return sprintf(buf, "%ld\n", target->size); +} + +static ssize_t hms_target_show_nid(struct device *device, + struct device_attribute *attr, + char *buf) +{ + struct hms_target *target = device_to_hms_target(device); + + if (target == NULL) + return -EINVAL; + + return sprintf(buf, "%d\n", target->nid); +} + +static ssize_t hms_target_show_uid(struct device *device, + struct device_attribute *attr, + char *buf) +{ + struct hms_target *target = device_to_hms_target(device); + + if (target == NULL) + return -EINVAL; + + return sprintf(buf, "%d\n", target->object.uid); +} + +static DEVICE_ATTR(size, 0444, hms_target_show_size, NULL); +static DEVICE_ATTR(nid, 0444, hms_target_show_nid, NULL); +static DEVICE_ATTR(uid, 0444, hms_target_show_uid, NULL); + +static struct attribute *hms_target_attrs[] = { + &dev_attr_size.attr, + &dev_attr_nid.attr, + &dev_attr_uid.attr, + NULL +}; + +static struct attribute_group hms_target_attr_group = { + .attrs = hms_target_attrs, +}; + +static const struct attribute_group *hms_target_attr_groups[] = { + &hms_target_attr_group, + NULL, +}; + +void hms_target_register(struct hms_target **targetp, struct device *parent, + int nid, const struct hms_target_hbind *hbind, + unsigned long size, unsigned version) +{ + struct hms_target *target; + + *targetp = NULL; + target = kzalloc(sizeof(*target), GFP_KERNEL); + if (target == NULL) + return; + + target->nid = nid; + target->size = size; + target->hbind = hbind; + + if (hms_object_init(&target->object, parent, HMS_TARGET, version, + hms_target_release, hms_target_attr_groups)) { + kfree(target); + target = NULL; + } + + *targetp = target; +} +EXPORT_SYMBOL(hms_target_register); + +void hms_target_add_memory(struct hms_target *target, unsigned long size) +{ + if (target) { + mutex_lock(&hms_target_mutex); + target->size += size; + mutex_unlock(&hms_target_mutex); + } +} +EXPORT_SYMBOL(hms_target_add_memory); + +void hms_target_remove_memory(struct hms_target *target, unsigned long size) +{ + if (target) { + mutex_lock(&hms_target_mutex); + target->size = size < target->size ? target->size - size : 0; + mutex_unlock(&hms_target_mutex); + } +} +EXPORT_SYMBOL(hms_target_remove_memory); + +void hms_target_unregister(struct hms_target **targetp) +{ + struct hms_target *target = *targetp; + + *targetp = NULL; + if (target == NULL) + return; + + hms_object_unregister(&target->object); +} +EXPORT_SYMBOL(hms_target_unregister); diff --git a/include/linux/hms.h b/include/linux/hms.h index 1ab288df0158..0568fdf6d479 100644 --- a/include/linux/hms.h +++ b/include/linux/hms.h @@ -17,10 +17,21 @@ /* Heterogeneous memory system (HMS) see Documentation/vm/hms.rst */ #ifndef HMS_H #define HMS_H -#if IS_ENABLED(CONFIG_HMS) - #include +#include + + +struct hms_target; + +struct hms_target_hbind { + int (*migrate)(struct hms_target *target, struct mm_struct *mm, + unsigned long start, unsigned long end, + unsigned natoms, uint32_t *atoms); +}; + + +#if IS_ENABLED(CONFIG_HMS) #define to_hms_object(device) container_of(device, struct hms_object, device) @@ -56,12 +67,40 @@ struct hms_object *hms_object_find_locked(unsigned uid); struct hms_object *hms_object_find(unsigned uid); +struct hms_target { + const struct hms_target_hbind *hbind; + struct hms_object object; + unsigned long size; + void *private; + int nid; +}; + +void hms_target_add_memory(struct hms_target *target, unsigned long size); +void hms_target_remove_memory(struct hms_target *target, unsigned long size); +void hms_target_register(struct hms_target **targetp, struct device *parent, + int nid, const struct hms_target_hbind *hbind, + unsigned long size, unsigned version); +void hms_target_unregister(struct hms_target **targetp); +struct hms_target *hms_target_find(unsigned uid); + +static inline void hms_target_put(struct hms_target *target) +{ + hms_object_put(&target->object); +} + + int hms_init(void); #else /* IS_ENABLED(CONFIG_HMS) */ +#define hms_target_add_memory(target, size) +#define hms_target_remove_memory(target, size) +#define hms_target_register(targetp, nid, size) +#define hms_target_unregister(targetp) + + static inline int hms_init(void) { return 0;