From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 81850C07E85 for ; Mon, 3 Dec 2018 23:36:05 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3E8F820864 for ; Mon, 3 Dec 2018 23:36:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3E8F820864 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726200AbeLCXgD (ORCPT ); Mon, 3 Dec 2018 18:36:03 -0500 Received: from mx1.redhat.com ([209.132.183.28]:46462 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726182AbeLCXgC (ORCPT ); Mon, 3 Dec 2018 18:36:02 -0500 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 163EA2D7FB; Mon, 3 Dec 2018 23:36:02 +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 B9873600C1; Mon, 3 Dec 2018 23:35:58 +0000 (UTC) From: jglisse@redhat.com To: linux-mm@kvack.org Cc: Andrew Morton , linux-kernel@vger.kernel.org, =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , "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=20K=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 06/14] mm/hms: add bridge to heterogeneous memory system infrastructure Date: Mon, 3 Dec 2018 18:35:01 -0500 Message-Id: <20181203233509.20671-7-jglisse@redhat.com> In-Reply-To: <20181203233509.20671-1-jglisse@redhat.com> References: <20181203233509.20671-1-jglisse@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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.30]); Mon, 03 Dec 2018 23:36:02 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Jérôme Glisse A bridge connect two links with each others and apply only to listed initiators. With links, this allows to describe any kind of system topology ie any kind of directed graph. Moreover with bridges the userspace can choose to use different bridges to load balance bandwidth usage accross multiple paths between targets memory and initiators. Note that explicit path selection is not always under the control of user space, some system might do load balancing in hardware. See HMS Documentation/vm/hms.txt for detail. 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-bridge.c | 197 ++++++++++++++++++++++++++++++++++++++ include/linux/hms.h | 24 +++++ 3 files changed, 222 insertions(+), 1 deletion(-) create mode 100644 drivers/base/hms-bridge.c diff --git a/drivers/base/Makefile b/drivers/base/Makefile index b8ff678fdae9..62695fdcd32f 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 hms-target.o hms-initiator.o hms-link.o +obj-$(CONFIG_HMS) += hms.o hms-target.o hms-initiator.o hms-link.o hms-bridge.o obj-$(CONFIG_MEMORY_HOTPLUG_SPARSE) += memory.o ifeq ($(CONFIG_SYSFS),y) obj-$(CONFIG_MODULES) += module.o diff --git a/drivers/base/hms-bridge.c b/drivers/base/hms-bridge.c new file mode 100644 index 000000000000..64732e923fba --- /dev/null +++ b/drivers/base/hms-bridge.c @@ -0,0 +1,197 @@ +/* + * 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 inline struct hms_bridge *hms_object_to_bridge(struct hms_object *object) +{ + if (object == NULL) + return NULL; + + if (object->type != HMS_BRIDGE) + return NULL; + return container_of(object, struct hms_bridge, object); +} + +static inline struct hms_bridge *device_to_hms_bridge(struct device *device) +{ + if (device == NULL) + return NULL; + + return hms_object_to_bridge(to_hms_object(device)); +} + +struct hms_bridge *hms_bridge_find_locked(unsigned uid) +{ + struct hms_object *object = hms_object_find_locked(uid); + struct hms_bridge *bridge; + + bridge = hms_object_to_bridge(object); + if (bridge) + return bridge; + hms_object_put(object); + return NULL; +} + +struct hms_bridge *hms_bridge_find(unsigned uid) +{ + struct hms_object *object = hms_object_find(uid); + struct hms_bridge *bridge; + + bridge = hms_object_to_bridge(object); + if (bridge) + return bridge; + hms_object_put(object); + return NULL; +} + +static void hms_bridge_release(struct device *device) +{ + struct hms_bridge *bridge = device_to_hms_bridge(device); + + hms_object_put(&bridge->linka->object); + hms_object_put(&bridge->linkb->object); + hms_object_release(&bridge->object); + kfree(bridge); +} + +static ssize_t hms_bridge_show_uid(struct device *device, + struct device_attribute *attr, + char *buf) +{ + struct hms_bridge *bridge = device_to_hms_bridge(device); + + if (bridge == NULL) + return -EINVAL; + + return sprintf(buf, "%d\n", bridge->object.uid); +} + +static DEVICE_ATTR(uid, 0444, hms_bridge_show_uid, NULL); + +static struct attribute *hms_bridge_attrs[] = { + &dev_attr_uid.attr, + NULL +}; + +static struct attribute_group hms_bridge_attr_group = { + .attrs = hms_bridge_attrs, +}; + +static const struct attribute_group *hms_bridge_attr_groups[] = { + &hms_bridge_attr_group, + NULL, +}; + +void hms_bridge_register(struct hms_bridge **bridgep, + struct device *parent, + struct hms_link *linka, + struct hms_link *linkb, + unsigned version) +{ + struct hms_bridge *bridge; + int ret; + + *bridgep = NULL; + + if (linka == NULL || linkb == NULL) + return; + linka = hms_object_to_link(hms_object_get(&linka->object)); + linkb = hms_object_to_link(hms_object_get(&linkb->object)); + if (linka == NULL || linkb == NULL) + goto error; + + bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); + if (bridge == NULL) + goto error; + + if (hms_object_init(&bridge->object, parent, HMS_BRIDGE, version, + hms_bridge_release, hms_bridge_attr_groups)) { + kfree(bridge); + goto error; + } + + bridge->linka = linka; + bridge->linkb = linkb; + + ret = hms_object_link(&bridge->object, &linka->object); + if (ret) { + hms_bridge_unregister(&bridge); + return; + } + + ret = hms_object_link(&bridge->object, &linkb->object); + if (ret) { + hms_bridge_unregister(&bridge); + return; + } + + *bridgep = bridge; + return; + +error: + hms_object_put(&linka->object); + hms_object_put(&linkb->object); +} +EXPORT_SYMBOL(hms_bridge_register); + +void hms_unbridge_initiator(struct hms_bridge *bridge, + struct hms_initiator *initiator) +{ + if (bridge == NULL || initiator == NULL) + return; + if (bridge->object.type != HMS_BRIDGE) + return; + if (initiator->object.type != HMS_INITIATOR) + return; + hms_object_unlink(&bridge->object, &initiator->object); +} +EXPORT_SYMBOL(hms_unbridge_initiator); + +int hms_bridge_initiator(struct hms_bridge *bridge, + struct hms_initiator *initiator) +{ + if (bridge == NULL || initiator == NULL) + return -EINVAL; + if (bridge->object.type != HMS_BRIDGE) + return -EINVAL; + if (initiator->object.type != HMS_INITIATOR) + return -EINVAL; + return hms_object_link(&bridge->object, &initiator->object); +} +EXPORT_SYMBOL(hms_bridge_initiator); + +void hms_bridge_unregister(struct hms_bridge **bridgep) +{ + struct hms_bridge *bridge = *bridgep; + + *bridgep = NULL; + if (bridge == NULL) + return; + + hms_object_unregister(&bridge->object); +} +EXPORT_SYMBOL(hms_bridge_unregister); diff --git a/include/linux/hms.h b/include/linux/hms.h index 2a9e49a2d771..511b5363d8f2 100644 --- a/include/linux/hms.h +++ b/include/linux/hms.h @@ -115,6 +115,24 @@ void hms_link_register(struct hms_link **linkp, struct device *parent, void hms_link_unregister(struct hms_link **linkp); +struct hms_bridge { + struct hms_object object; + struct hms_link *linka; + struct hms_link *linkb; +}; + +void hms_unbridge_initiator(struct hms_bridge *bridge, + struct hms_initiator *initiator); +int hms_bridge_initiator(struct hms_bridge *bridge, + struct hms_initiator *initiator); +void hms_bridge_register(struct hms_bridge **bridgep, + struct device *parent, + struct hms_link *linka, + struct hms_link *linkb, + unsigned version); +void hms_bridge_unregister(struct hms_bridge **bridgep); + + int hms_init(void); @@ -139,6 +157,12 @@ int hms_init(void); #define hms_link_unregister(linkp) +#define hms_unbridge_initiator(bridge, initiator) +#define hms_bridge_initiator(bridge, initiator) +#define hms_bridge_register(bridgep) +#define hms_bridge_unregister(bridgep) + + static inline int hms_init(void) { return 0; -- 2.17.2