From: Dan Williams The first attempt at an ABI for this failed to account for naming collisions across host bridges: Commit a4438f06b1db ("PCI/TSM: Report active IDE streams") Revive this ABI with a per host bridge link that appears at first stream creation for a given host bridge and disappears after the last stream is removed. For systems with many host bridge objects it allows: ls /sys/class/tsm/tsmN/pci*/stream* ...to find all the host bridges with active streams without first iterating over all host bridges. Yilun notes that is handy to have this short cut [1] and from an administrator perspective it helps with inventory for constrained stream resources. Link: http://lore.kernel.org/aXLtILY85oMU5qlb@yilunxu-OptiPlex-7050 [1] Signed-off-by: Dan Williams --- Documentation/ABI/testing/sysfs-class-tsm | 13 +++ include/linux/pci-ide.h | 2 + include/linux/tsm.h | 3 + drivers/pci/ide.c | 4 + drivers/virt/coco/tsm-core.c | 97 +++++++++++++++++++++++ 5 files changed, 119 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-class-tsm b/Documentation/ABI/testing/sysfs-class-tsm index 2949468deaf7..1ddb8f357961 100644 --- a/Documentation/ABI/testing/sysfs-class-tsm +++ b/Documentation/ABI/testing/sysfs-class-tsm @@ -7,3 +7,16 @@ Description: signals when the PCI layer is able to support establishment of link encryption and other device-security features coordinated through a platform tsm. + +What: /sys/class/tsm/tsmN/pciDDDD:BB +Contact: linux-pci@vger.kernel.org +Description: + (RO) When a PCIe host bridge has established a secure connection + via a TSM to an endpoint, this symlink appears. It facilitates a + TSM instance scoped view of PCIe Link Encryption and Secure + Session resource consumption across host bridges. The symlink + appears when a host bridge has 1 or more IDE streams established + with this TSM, and disappears when that number returns to 0. See + Documentation/ABI/testing/sysfs-devices-pci-host-bridge for the + description of the pciDDDD:BB/streamH.R.E symlink and the + pciDDDD:BB/available_secure_streams attribute. diff --git a/include/linux/pci-ide.h b/include/linux/pci-ide.h index ae07d9f699c0..381a1bf22a95 100644 --- a/include/linux/pci-ide.h +++ b/include/linux/pci-ide.h @@ -82,6 +82,7 @@ struct pci_ide_regs { * @host_bridge_stream: allocated from host bridge @ide_stream_ida pool * @stream_id: unique Stream ID (within Partner Port pairing) * @name: name of the established Selective IDE Stream in sysfs + * @tsm_dev: For TSM established IDE, the TSM device context * * Negative @stream_id values indicate "uninitialized" on the * expectation that with TSM established IDE the TSM owns the stream_id @@ -93,6 +94,7 @@ struct pci_ide { u8 host_bridge_stream; int stream_id; const char *name; + struct tsm_dev *tsm_dev; }; /* diff --git a/include/linux/tsm.h b/include/linux/tsm.h index 381c53244c83..7f72a154b6b2 100644 --- a/include/linux/tsm.h +++ b/include/linux/tsm.h @@ -123,4 +123,7 @@ int tsm_report_unregister(const struct tsm_report_ops *ops); struct tsm_dev *tsm_register(struct device *parent, struct pci_tsm_ops *ops); void tsm_unregister(struct tsm_dev *tsm_dev); struct tsm_dev *find_tsm_dev(int id); +struct pci_ide; +int tsm_ide_stream_register(struct pci_ide *ide); +void tsm_ide_stream_unregister(struct pci_ide *ide); #endif /* __TSM_H */ diff --git a/drivers/pci/ide.c b/drivers/pci/ide.c index be74e8f0ae21..b35e8aba7ecb 100644 --- a/drivers/pci/ide.c +++ b/drivers/pci/ide.c @@ -11,6 +11,7 @@ #include #include #include +#include #include "pci.h" @@ -372,6 +373,9 @@ void pci_ide_stream_release(struct pci_ide *ide) if (ide->partner[PCI_IDE_EP].enable) pci_ide_stream_disable(pdev, ide); + if (ide->tsm_dev) + tsm_ide_stream_unregister(ide); + if (ide->partner[PCI_IDE_RP].setup) pci_ide_stream_teardown(rp, ide); diff --git a/drivers/virt/coco/tsm-core.c b/drivers/virt/coco/tsm-core.c index 98dcf7d836df..ece7cd7ea9d8 100644 --- a/drivers/virt/coco/tsm-core.c +++ b/drivers/virt/coco/tsm-core.c @@ -4,10 +4,12 @@ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include +#include #include #include #include #include +#include static struct class *tsm_class; static DEFINE_IDA(tsm_ida); @@ -104,6 +106,100 @@ void tsm_unregister(struct tsm_dev *tsm_dev) } EXPORT_SYMBOL_GPL(tsm_unregister); +static DEFINE_XARRAY(tsm_ide_streams); +static DEFINE_MUTEX(tsm_ide_streams_lock); + +/* tracker for the bridge symlink when the bridge has any streams */ +struct tsm_ide_stream { + struct tsm_dev *tsm_dev; + struct pci_host_bridge *bridge; + struct kref kref; +}; + +static struct tsm_ide_stream *create_streams(struct tsm_dev *tsm_dev, + struct pci_host_bridge *bridge) +{ + int rc; + + struct tsm_ide_stream *streams __free(kfree) = + kzalloc(sizeof(*streams), GFP_KERNEL); + if (!streams) + return NULL; + + streams->tsm_dev = tsm_dev; + streams->bridge = bridge; + kref_init(&streams->kref); + rc = xa_insert(&tsm_ide_streams, (unsigned long)bridge, streams, + GFP_KERNEL); + if (rc) + return NULL; + + rc = sysfs_create_link(&tsm_dev->dev.kobj, &bridge->dev.kobj, + dev_name(&bridge->dev)); + if (rc) { + xa_erase(&tsm_ide_streams, (unsigned long)bridge); + return NULL; + } + + return no_free_ptr(streams); +} + +int tsm_ide_stream_register(struct pci_ide *ide) +{ + struct tsm_ide_stream *streams; + struct pci_dev *pdev = ide->pdev; + struct pci_tsm *tsm = pdev->tsm; + struct tsm_dev *tsm_dev = tsm->tsm_dev; + struct pci_host_bridge *bridge = pci_find_host_bridge(pdev->bus); + + guard(mutex)(&tsm_ide_streams_lock); + streams = xa_load(&tsm_ide_streams, (unsigned long)bridge); + if (streams) + kref_get(&streams->kref); + else + streams = create_streams(tsm_dev, bridge); + + if (!streams) + return -ENOMEM; + ide->tsm_dev = tsm_dev; + + return 0; +} +EXPORT_SYMBOL_GPL(tsm_ide_stream_register); + +static void destroy_streams(struct kref *kref) +{ + struct tsm_ide_stream *streams = + container_of(kref, struct tsm_ide_stream, kref); + struct tsm_dev *tsm_dev = streams->tsm_dev; + struct pci_host_bridge *bridge = streams->bridge; + + lockdep_assert_held(&tsm_ide_streams_lock); + sysfs_remove_link(&tsm_dev->dev.kobj, dev_name(&bridge->dev)); + xa_erase(&tsm_ide_streams, (unsigned long)bridge); + kfree(streams); +} + +void tsm_ide_stream_unregister(struct pci_ide *ide) +{ + struct tsm_ide_stream *streams; + struct tsm_dev *tsm_dev = ide->tsm_dev; + struct pci_dev *pdev = ide->pdev; + struct pci_host_bridge *bridge = pci_find_host_bridge(pdev->bus); + + guard(mutex)(&tsm_ide_streams_lock); + streams = xa_load(&tsm_ide_streams, (unsigned long)bridge); + /* catch API abuse */ + if (dev_WARN_ONCE(&tsm_dev->dev, + !streams || streams->tsm_dev != tsm_dev, + "no IDE streams associated with %s\n", + dev_name(&bridge->dev))) + return; + kref_put(&streams->kref, destroy_streams); + ide->tsm_dev = NULL; +} +EXPORT_SYMBOL_GPL(tsm_ide_stream_unregister); + static void tsm_release(struct device *dev) { struct tsm_dev *tsm_dev = container_of(dev, typeof(*tsm_dev), dev); @@ -126,6 +222,7 @@ module_init(tsm_init) static void __exit tsm_exit(void) { class_destroy(tsm_class); + xa_destroy(&tsm_ide_streams); } module_exit(tsm_exit) -- 2.25.1