Parents (Total: 24)

The searched file hash is included in 24 parent files which include package known and seen by metalookup. A sample is included below:

Key	Value
MD5	F87C624414155D9F62FF73507F3F9051
PackageArch	x86_64
PackageDescription	A daemon that handles the complexity of the LIO kernel target's userspace passthrough interface (TCMU). It presents a C plugin API for extension modules that handle SCSI requests in ways not possible or suitable to be handled by LIO's in-kernel backstores.
PackageMaintainer	Fedora Project
PackageName	tcmu-runner
PackageRelease	2.fc32
PackageVersion	1.5.2
SHA-1	00BA78A3D89B56AD4BFBF1450013E7F9F552DF5E
SHA-256	026763BDA4B85207C2426879615AF560D0D7F200A64F74CE82BE40BBED32F960

Key	Value
MD5	CA8F72009E08C00F31AE3DD18F3E4C5A
PackageArch	x86_64
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageMaintainer	https://www.suse.com/
PackageName	tcmu-runner
PackageRelease	150400.1.5
PackageVersion	1.5.4
SHA-1	128B028D6DF130F4CE761BDA601B45CD7DFCCF56
SHA-256	16AE496AE3BAE99572A6935370AF3E6DADD7490E3E8168EF0A85E9B2A44440E0

Key	Value
MD5	4969E8C85B7CB3C31F831E7057D28B68
PackageArch	x86_64
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageName	tcmu-runner
PackageRelease	39.18
PackageVersion	1.5.4
SHA-1	17AE41F0F53C8ADA6E218E0B46702A4E7E31E58D
SHA-256	2DE1A3868BB579548A6D556800C64ED0490FF3D4C3218CBC9A3CF486F98D489A

Key	Value
MD5	EFA4A3664CC2E2DC136BF84042A55FA3
PackageArch	aarch64
PackageDescription	A daemon that handles the complexity of the LIO kernel target's userspace passthrough interface (TCMU). It presents a C plugin API for extension modules that handle SCSI requests in ways not possible or suitable to be handled by LIO's in-kernel backstores.
PackageMaintainer	Fedora Project
PackageName	tcmu-runner
PackageRelease	8.fc34
PackageVersion	1.5.2
SHA-1	1A9EFDDA9F5630B6A3DEB06C41B4755E4B12F2BC
SHA-256	010463FFAD119A3C2E477511A598FDF9C0A671383A74BFBE110630B91EA1A5BC

Key	Value
MD5	528F6D208F83D38423DB820AED325E4F
PackageArch	riscv64
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageName	tcmu-runner
PackageRelease	39.18
PackageVersion	1.5.4
SHA-1	1BB155F321776B355AA5563697FC13F96DA58955
SHA-256	451517BE931D03BAF4DF4F5893ACBF54E81302827F1A621594634F589A2148AF

Key	Value
MD5	D3E2170F8A7F91C2452B94FD27874C1E
PackageArch	i586
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageMaintainer	https://bugs.opensuse.org
PackageName	tcmu-runner
PackageRelease	1.2
PackageVersion	1.5.4
SHA-1	1EE163138F2BC445C6CC5E587D2D10D934C07D73
SHA-256	F413EE1EF046D65DB9332058A760B60497430F590590D12668C7CED02B9E416B

Key	Value
MD5	9CF801849A9954F553CCB220D65BE805
PackageArch	s390x
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageMaintainer	https://www.suse.com/
PackageName	tcmu-runner
PackageRelease	150400.1.5
PackageVersion	1.5.4
SHA-1	24D50E5B09B937F2BC0B57468B86D78CC1A01451
SHA-256	7137B8C93D0956F0A84B92ED6B7969BCA296656801D9CB592E06AF31E3727474

Key	Value
MD5	E90C72B89EA0FB65AA8E18C33D722B49
PackageArch	aarch64
PackageDescription	A daemon that handles the complexity of the LIO kernel target's userspace passthrough interface (TCMU). It presents a C plugin API for extension modules that handle SCSI requests in ways not possible or suitable to be handled by LIO's in-kernel backstores.
PackageMaintainer	Fedora Project
PackageName	tcmu-runner
PackageRelease	2.fc32
PackageVersion	1.5.2
SHA-1	36B680A37957996E42A9A3E922505BB94EF8A1C7
SHA-256	9A93644C2597A225E6D2E9EE622945040B3DFFCF8D7A7CC8055AAEB5EDA03274

Key	Value
MD5	CF55A6210FADCCFBA71FE3755CD45E76
PackageArch	s390x
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageName	tcmu-runner
PackageRelease	39.18
PackageVersion	1.5.4
SHA-1	3DCDB2E53F50E6D7919B25C5F7702727EA5CB96F
SHA-256	986327C840971DDAF55690CA602FAF4789FB1784BC03F9F6C93CEA47DC3F4F71

Key	Value
MD5	647F15344273245DC383C338A2AE80E6
PackageArch	armv7hl
PackageDescription	LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and allows exported SCSI logical units (LUNs) to be backed by regular files or block devices. But, if we want to get fancier with the capabilities of the device we're emulating, the kernel is not necessarily the right place. While there are userspace libraries for compression, encryption, and clustered storage solutions like Ceph or Gluster, these are not accessible from the kernel. The TCMU userspace-passthrough backstore allows a userspace process to handle requests to a LUN. But since the kernel-user interface that TCMU provides must be fast and flexible, it is complex enough that we'd like to avoid each userspace handler having to write boilerplate code. tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink, pthreads, and DBus -- and exports a more friendly C plugin module API. Modules using this API are called "TCMU handlers". Handler authors can write code just to handle the SCSI commands as desired, and can also link with whatever userspace libraries they like.
PackageName	tcmu-runner
PackageRelease	39.18
PackageVersion	1.5.4
SHA-1	4FB6260FED79A4D4D100271AFB2005FFE92961F0
SHA-256	AEB58278F13DA10B97953C15806ED5D86A3BA68A33C7240CBD59ACF75138DEF7