Add hypervisor sysfs-like support
v7 cover Add hypervisor sysfs-like support
On the 2019 Xen developer summit there was agreement that the Xen hypervisor should gain support for a hierarchical name-value store similar to the Linux kernel's sysfs.
This is a first implementation of that idea adding the basic functionality to hypervisor and tools side. The interface to any user program making use of that "xen-hypfs" is a new library "libxenhypfs" with a stable interface.
The series adds read-only nodes with buildinfo data and writable nodes with runtime parameters. xl is switched to use the new file system for modifying the runtime parameters and the old sysctl interface for that purpose is dropped.
Changes in V7:
- old patch 1 already applied
- add new patch 1 (carved out and modified from patch 9)
- addressed review comments
- modified public interface to have a max write size instead of a writable flag only
Changes in V6:
- added new patches 1, 10, 11, 12
- addressed review comments
- modified interface for creating nodes for runtime parameters
Changes in V5:
- switched to xsm for privilege check
Changes in V4:
- former patch 2 removed as already committed
- addressed review comments
Changes in V3:
- major rework, especially by supporting binary contents of entries
- added several new patches (1, 2, 7)
- full support of all runtime parameters
- support of writing entries (especially runtime parameters)
Changes in V2:
- all comments to V1 addressed
- added man-page for xenhypfs tool
- added runtime parameter read access for string parameters
Changes in V1:
- renamed xenfs ->xenhypfs
- added writable entries support at the interface level and in the xenhypfs tool
- added runtime parameter read access (integer type only for now)
- added docs/misc/hypfs-paths.pandoc for path descriptions
Juergen Gross (12):
xen/vmx: let opt_ept_ad always reflect the current setting
xen: add a generic way to include binary files as variables
docs: add feature document for Xen hypervisor sysfs-like support
xen: add basic hypervisor filesystem support
libs: add libxenhypfs
tools: add xenfs tool
xen: provide version information in hypfs
xen: add /buildinfo/config entry to hypervisor filesystem
xen: add runtime parameter access support to hypfs tools/libxl: use libxenhypfs for setting xen runtime parameters tools/libxc: remove xc_set_parameters()
xen: remove XEN_SYSCTL_set_parameter support
.gitignore | 6 + docs/features/hypervisorfs.pandoc | 92 +++++++ docs/man/xenhypfs.1.pod | 61 ++++ docs/misc/hypfs-paths.pandoc | 163 +++++++++++ tools/Rules.mk | 8 +- tools/flask/policy/modules/dom0.te | 4 +- tools/libs/Makefile | 1 + tools/libs/hypfs/Makefile | 16 ++ tools/libs/hypfs/core.c | 536 ++++++++++++++++++++++++++++++++++++ tools/libs/hypfs/include/xenhypfs.h | 75 +++++ tools/libs/hypfs/libxenhypfs.map | 10 + tools/libs/hypfs/xenhypfs.pc.in | 10 + tools/libxc/include/xenctrl.h | 1 - tools/libxc/xc_misc.c | 21 -- tools/libxl/Makefile | 3 +- tools/libxl/libxl.c | 53 +++- tools/libxl/libxl_internal.h | 1 + tools/libxl/xenlight.pc.in | 2 +- tools/misc/Makefile | 6 + tools/misc/xenhypfs.c | 192 +++++++++++++ tools/xl/xl_misc.c | 1 - xen/arch/arm/traps.c | 1 + xen/arch/arm/xen.lds.S | 10 +- xen/arch/x86/hvm/hypercall.c | 1 + xen/arch/x86/hvm/vmx/vmcs.c | 54 +++- xen/arch/x86/hvm/vmx/vmx.c | 4 +- xen/arch/x86/hypercall.c | 1 + xen/arch/x86/pv/domain.c | 21 +- xen/arch/x86/pv/hypercall.c | 1 + xen/arch/x86/xen.lds.S | 10 +- xen/common/Kconfig | 10 + xen/common/Makefile | 13 + xen/common/grant_table.c | 49 +++- xen/common/hypfs.c | 381 +++++++++++++++++++++++++ xen/common/kernel.c | 84 +++++- xen/common/sysctl.c | 36 --- xen/drivers/char/console.c | 61 +++- xen/include/Makefile | 1 + xen/include/asm-x86/hvm/vmx/vmcs.h | 3 +- xen/include/public/hypfs.h | 127 +++++++++ xen/include/public/sysctl.h | 19 +- xen/include/public/xen.h | 1 + xen/include/xen/hypercall.h | 8 + xen/include/xen/hypfs.h | 118 ++++++++ xen/include/xen/kernel.h | 3 + xen/include/xen/lib.h | 1 - xen/include/xen/param.h | 101 ++++--- xen/include/xlat.lst | 2 + xen/include/xsm/dummy.h | 6 + xen/include/xsm/xsm.h | 6 + xen/tools/binfile | 41 +++ xen/xsm/dummy.c | 1 + xen/xsm/flask/Makefile | 5 +- xen/xsm/flask/flask-policy.S | 16 -- xen/xsm/flask/hooks.c | 9 +- xen/xsm/flask/policy/access_vectors | 4 +- 56 files changed, 2284 insertions(+), 187 deletions(-) create mode 100644 docs/features/hypervisorfs.pandoc create mode 100644 docs/man/xenhypfs.1.pod create mode 100644 docs/misc/hypfs-paths.pandoc create mode 100644 tools/libs/hypfs/Makefile create mode 100644 tools/libs/hypfs/core.c create mode 100644 tools/libs/hypfs/include/xenhypfs.h create mode 100644 tools/libs/hypfs/libxenhypfs.map create mode 100644 tools/libs/hypfs/xenhypfs.pc.in create mode 100644 tools/misc/xenhypfs.c create mode 100644 xen/common/hypfs.c create mode 100644 xen/include/public/hypfs.h create mode 100644 xen/include/xen/hypfs.h create mode 100755 xen/tools/binfile delete mode 100644 xen/xsm/flask/flask-policy.S
Signature · 1 line
2.16.4
PATCH v7 1/12 xen/vmx: let opt_ept_ad always reflect the current setting
In case opt_ept_ad has not been set explicitly by the user via command line or runtime parameter, it is treated as "no" on Avoton cpus.
Change that handling by setting opt_ept_ad to 0 for this cpu type explicitly if no user value has been set.
By putting this into the (renamed) boot time initialization of vmcs.c _vmx_cpu_up() can be made static.
--- xen/arch/x86/hvm/vmx/vmcs.c | 22 +++++++++++++++------- xen/arch/x86/hvm/vmx/vmx.c | 4 +--- xen/include/asm-x86/hvm/vmx/vmcs.h | 3 +-- 3 files changed, 17 insertions(+), 12 deletions(-)
xen/arch/x86/hvm/vmx/vmcs.c +15 -7
@@ -315,10 +315,6 @@ static int vmx_init_vmcs_config(void)if ( !opt_ept_ad ) _vmx_ept_vpid_cap &= ~VMX_EPT_AD_BIT ; -else if (/* Work around Erratum AVR41 on Avoton processors. */ - boot_cpu_data.x86 ==6 && boot_cpu_data.x86_model ==0x4d && - opt_ept_ad <0 ) - _vmx_ept_vpid_cap &= ~VMX_EPT_AD_BIT ;/* * Additional sanity checking before using EPT:
@@ -652,7 +648,7 @@ void vmx_cpu_dead(unsigned int cpu)vmx_pi_desc_fixup (cpu); } -int _vmx_cpu_up (bool bsp) +static int _vmx_cpu_up (bool bsp) {u32 eax, edx;int rc, bios_locked, cpu =smp_processor_id ();
@@ -2108,9 +2104,21 @@ static void vmcs_dump(unsigned char ch)printk ("**************************************\n" ); } -void __init setup_vmcs_dump (void ) +int __init vmx_vmcs_init (void ) { -register_keyhandler ('v' , vmcs_dump,"dump VT-x VMCSs" ,1 ); +int ret; + +if ( opt_ept_ad <0 ) +/* Work around Erratum AVR41 on Avoton processors. */ + opt_ept_ad = (boot_cpu_data.x86 ==6 && + boot_cpu_data.x86_model ==0x4d ) ?0 :1 ; + + ret =_vmx_cpu_up (true); + +if ( !ret ) +register_keyhandler ('v' , vmcs_dump,"dump VT-x VMCSs" ,1 ); + +return ret; }static void __init __maybe_unused build_assertions (void )
xen/arch/x86/hvm/vmx/vmx.c +1 -3
@@ -2478,7 +2478,7 @@ const struct hvm_function_table * __init start_vmx(void) {set_in_cr4 (X86_CR4_VMXE ); -if (_vmx_cpu_up (true) ) +if (vmx_vmcs_init () ) {printk ("VMX: failed to initialise.\n" );return NULL ;
@@ -2549,8 +2549,6 @@ const struct hvm_function_table * __init start_vmx(void) vmx_function_table.get_guest_bndcfgs = vmx_get_guest_bndcfgs; } -setup_vmcs_dump (); -lbr_tsx_fixup_check ();bdf93_fixup_check ();
xen/include/asm-x86/hvm/vmx/vmcs.h +1 -2
@@ -21,11 +21,10 @@#include <xen/mm.h> extern void vmcs_dump_vcpu (struct vcpu *v); -extern void setup_vmcs_dump (void ); +extern int vmx_vmcs_init (void );extern int vmx_cpu_up_prepare (unsigned int cpu);extern void vmx_cpu_dead (unsigned int cpu);extern int vmx_cpu_up (void ); -extern int _vmx_cpu_up (bool bsp);extern void vmx_cpu_down (void );struct vmcs_struct {
Signature · 1 line
2.16.4
Re: [PATCH v7 01/12] xen/vmx: let opt_ept_ad always reflect the current setting
Quoted 10 lines · Juergen Gross
In case
opt_ept_adhas not been set explicitly by the user via command line or runtime parameter, it is treated as "no" on Avoton cpus.Change that handling by setting
opt_ept_adto 0 for this cpu type explicitly if no user value has been set.By putting this into the (renamed) boot time initialization of
vmcs.c_vmx_cpu_up()can be made static.Signed-off-by Juergen Gross <[email protected]>
albeit preferably with ...
Quoted 4 lines
xen/arch/x86/hvm/vmx/vmcs.c +0
-0@@ -2108,9 +2104,21 @@ static void vmcs_dump(unsigned char ch)printk ("**************************************\n" ); }
xen/arch/x86/hvm/vmx/vmcs.c static void vmcs_dump(unsigned char ch) · line 2114
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c +7
-2-void __init setup_vmcs_dump (void ) +int __init vmx_vmcs_init (void ) { -register_keyhandler ('v' , vmcs_dump,"dump VT-x VMCSs" ,1 ); +int ret; + +if ( opt_ept_ad <0 ) +/* Work around Erratum AVR41 on Avoton processors. */ + opt_ept_ad = (boot_cpu_data.x86 ==6 && + boot_cpu_data.x86_model ==0x4d ) ?0 :1 ;
... no use of the conditional operator here - the result of the && (or its logical inversion to be precise) would be quite fine to use directly here.
Jan
Re: [PATCH v7 01/12] xen/vmx: let opt_ept_ad always reflect the current setting
Quoted 19 lines · Jan Beulich
Quoted 10 lines · Juergen Gross
In case
opt_ept_adhas not been set explicitly by the user via command line or runtime parameter, it is treated as "no" on Avoton cpus.Change that handling by setting
opt_ept_adto 0 for this cpu type explicitly if no user value has been set.By putting this into the (renamed) boot time initialization of
vmcs.c_vmx_cpu_up()can be made static.Signed-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>albeit preferably with ...
Quoted 4 lines
xen/arch/x86/hvm/vmx/vmcs.c +0
-0@@ -2108,9 +2104,21 @@ static void vmcs_dump(unsigned char ch)printk ("**************************************\n" ); }
Quoted 14 lines
xen/arch/x86/hvm/vmx/vmcs.c static void vmcs_dump(unsigned char ch) · line 2114
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c +7
-2-void __init setup_vmcs_dump (void ) +int __init vmx_vmcs_init (void ) { -register_keyhandler ('v' , vmcs_dump,"dump VT-x VMCSs" ,1 ); +int ret; + +if ( opt_ept_ad <0 ) +/* Work around Erratum AVR41 on Avoton processors. */ + opt_ept_ad = (boot_cpu_data.x86 ==6 && + boot_cpu_data.x86_model ==0x4d ) ?0 :1 ;... no use of the conditional operator here - the result of the && (or its logical inversion to be precise) would be quite fine to use directly here.
Okay.
Juergen
PATCH v7 2/12 xen: add a generic way to include binary files as variables
In reply to Juergen GrossAdd a new script xen/tools/binfile for including a binary file at build time being usable via a pointer and a size variable in the hypervisor.
Make use of that generic tool in xsm.
---
V3:
- new patch
V4:
- add alignment parameter (Jan Beulich)
- use .Lend instead of . (Jan Beulich)
--- .gitignore | 1 + xen/tools/binfile | 41 +++++++++++++++++++++++++++++++++++++++++ xen/xsm/flask/Makefile | 5 ++++- xen/xsm/flask/flask-policy.S | 16 ---------------- 4 files changed, 46 insertions(+), 17 deletions(-) create mode 100755 xen/tools/binfile delete mode 100644 xen/xsm/flask/flask-policy.S
.gitignore +1 -0
@@ -313,6 +313,7 @@ xen/test/livepatch/*.livepatch xen/tools/kconfig/.tmp_gtkcheck xen/tools/kconfig/.tmp_qtcheck xen/tools/symbols +xen/xsm/flask/flask-policy.S xen/xsm/flask/include/av_perm_to_string.h xen/xsm/flask/include/av_permissions.h xen/xsm/flask/include/class_to_string.h
xen/tools/binfile new file +41 -0
41 lines not on this page · raw message
xen/xsm/flask/Makefile +4 -1
@@ -30,6 +30,9 @@ $(AV_H_FILES): $(AV_H_DEPEND) obj-bin-$(CONFIG_XSM_FLASK_POLICY) += flask-policy.o flask-policy.o: policy.bin +flask-policy.S: $(XEN_ROOT)/xen/tools/binfile + $(XEN_ROOT)/xen/tools/binfile -i $@ policy.bin xsm_flask_init_policy + FLASK_BUILD_DIR := $(CURDIR) POLICY_SRC := $(FLASK_BUILD_DIR)/xenpolicy-$(XEN_FULLVERSION)
@@ -39,4 +42,4 @@ policy.bin: FORCE .PHONY: clean clean:: - rm -f $(ALL_H_FILES) *.o $(DEPS_RM) policy.* $(POLICY_SRC) + rm -f $(ALL_H_FILES) *.o $(DEPS_RM) policy.* $(POLICY_SRC) flask-policy.S
xen/xsm/flask/flask-policy.S deleted +0 -16
@@ -1,16 +0,0 @@ -#include <asm/asm_defns.h> - - .section .init.rodata, "a", %progbits - -/* const unsigned char xsm_flask_init_policy[] __initconst */ - .global xsm_flask_init_policy -xsm_flask_init_policy: - .incbin "policy.bin" -.Lend: - - .type xsm_flask_init_policy, %object - .size xsm_flask_init_policy, . - xsm_flask_init_policy - -/* const unsigned int __initconst xsm_flask_init_policy_size */ - .global xsm_flask_init_policy_size - ASM_INT(xsm_flask_init_policy_size, .Lend - xsm_flask_init_policy)
Signature · 1 line
2.16.4
PATCH v7 3/12 docs: add feature document for Xen hypervisor sysfs-like support
In reply to Juergen GrossOn the 2019 Xen developer summit there was agreement that the Xen hypervisor should gain support for a hierarchical name-value store similar to the Linux kernel's sysfs.
In the beginning there should only be basic support: entries can be added from the hypervisor itself only, there is a simple hypercall interface to read the data.
Add a feature document for setting the base of a discussion regarding the desired functionality and the entries to add.
---
V1:
- remove the "--" prefixes of the sub-commands of the user tool (Jan Beulich)
- rename xenfs to xenhypfs (Jan Beulich)
- add "tree" and "write" options to user tool
V2:
- move example tree to the paths description (Ian Jackson)
- specify allowed characters for keys and values (Ian Jackson)
V3:
- correct introduction (writable entries)
V4:
- add list specification
- add entry example (Julien Grall)
- correct date and Xen version (Julien Grall)
- add ARM64 as possible architecture (Julien Grall)
- add version description to the feature doc (Jan Beulich)
--- docs/features/hypervisorfs.pandoc | 92 +++++++++++++++++++++++++++++++++ docs/misc/hypfs-paths.pandoc | 105 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 docs/features/hypervisorfs.pandoc create mode 100644 docs/misc/hypfs-paths.pandoc
docs/features/hypervisorfs.pandoc new file +92 -0
@@ -0,0 +1,92 @@ +% Hypervisor FS +% Revision 1 + +\clearpage + +# Basics +---------------- --------------------- + Status: **Supported** + + Architectures: all + + Components: Hypervisor, toolstack +---------------- --------------------- + +# Overview + +The Hypervisor FS is a hierarchical name-value store for reporting +information to guests, especially dom0. It is similar to the Linux +kernel's sysfs. Entries and directories are created by the hypervisor, +while the toolstack is able to use a hypercall to query the entry +values or (if allowed by the hypervisor) to modify them. + +# User details + +With: + + xenhypfs ls <path> + +the user can list the entries of a specific path of the FS. Using: + + xenhypfs cat <path> + +the content of an entry can be retrieved. Using: + + xenhypfs write <path> <string> + +a writable entry can be modified. With: + + xenhypfs tree + +the complete Hypervisor FS entry tree can be printed. + +The FS paths are documented in `docs/misc/hypfs-paths.pandoc`. + +# Technical details + +Access to the hypervisor filesystem is done via the stable new hypercall +__HYPERVISOR_filesystem_op. This hypercall supports a sub-command +XEN_HYPFS_OP_get_version which will return the highest version of the +interface supported by the hypervisor. Additions to the interface need +to bump the interface version. The hypervisor is required to support the +previous interface versions, too (this implies that additions will always +require new sub-commands in order to allow the hypervisor to decide which +version of the interface to use). + +* hypercall interface specification + * `xen/include/public/hypfs.h` +* hypervisor internal files + * `xen/include/xen/hypfs.h` + * `xen/common/hypfs.c` +* `libxenhypfs` + * `tools/libs/libxenhypfs/*` +* `xenhypfs` + * `tools/misc/xenhypfs.c` +* path documentation + * `docs/misc/hypfs-paths.pandoc` + +# Testing + +Any new parameters or hardware mitigations should be verified to show up +correctly in the filesystem. + +# Areas for improvement + +* More detailed access rights +* Entries per domain and/or per cpupool + +# Known issues + +* None + +# References + +* None + +# History + +------------------------------------------------------------------------ +Date Revision Version Notes +---------- -------- -------- ------------------------------------------- +2020-01-23 1 Xen 4.14 Document written +---------- -------- -------- -------------------------------------------
docs/misc/hypfs-paths.pandoc new file +105 -0
105 lines not on this page · raw message
Signature · 1 line
2.16.4
Re: [PATCH v7 03/12] docs: add feature document for Xen hypervisor sysfs-like support
Quoted 2 lines · Juergen Gross
[snip]
Quoted 2 lines
docs/misc/hypfs-paths.pandoc new file +2
-0+* {VALUE, VALUE, ... } -- a list of possible values separated by "," and + enclosed in "{" and "}".
[snip]
docs/misc/hypfs-paths.pandoc line 61
Quoted 5 lines
docs/misc/hypfs-paths.pandoc new file +5
-0+So an entry could look like this: + + /cpu-bugs/active-pv/xpti = ("No"|{"dom0", "domU", "PCID on"}) [w,X86,PV] + +Possible values would be "No" or a list of "dom0", "domU", and "PCID on".
One thing that wasn’t clear to me here: Does the “list” look like
“dom0", “domU", “PCID on”
or
{dom0, domU, PCID on}or
{“dom0”, “domU”, “PCID on”}?
Another question that occurs to me from asking this question: in a case like this, are we generally expecting to have options with spaces in them (like “PCID on”)? And/or, are we expecting the strings themselves to have quotes in them? If so, commands to manipulate these will start to look a little gnarly:
xenhypfs write <path> “{\”dom0\”, \”PCID on\”}”
It seems like it would be nicer to be able to write:
xenhypfs write <path> "{dom0, PCID-on}”
(Maybe this will be made more clear later in the series, just thought I’d share my thoughts / confusion here.)
-George
Re: [PATCH v7 03/12] docs: add feature document for Xen hypervisor sysfs-like support
Quoted 18 lines · George Dunlap
Quoted 2 lines · Juergen Gross
[snip]
Quoted 2 lines
docs/misc/hypfs-paths.pandoc new file +2
-0+* {VALUE, VALUE, ... } -- a list of possible values separated by "," and + enclosed in "{" and "}".[snip]
docs/misc/hypfs-paths.pandoc line 61
Quoted 5 lines
docs/misc/hypfs-paths.pandoc new file +5
-0+So an entry could look like this: + + /cpu-bugs/active-pv/xpti = ("No"|{"dom0", "domU", "PCID on"}) [w,X86,PV] + +Possible values would be "No" or a list of "dom0", "domU", and "PCID on".One thing that wasn’t clear to me here: Does the “list” look like
“dom0", “domU", “PCID on”
or
Quoted 7 lines
{dom0, domU, PCID on}or
{“dom0”, “domU”, “PCID on”}?
This is only the notation used.
The entry could then be e.g.
dom0 domU
Quoted 4 lines
Another question that occurs to me from asking this question: in a case like this, are we generally expecting to have options with spaces in them (like “PCID on”)? And/or, are we expecting the strings themselves to have quotes in them? If so, commands to manipulate these will start to look a little gnarly:
xenhypfs write <path> “{\”dom0\”, \”PCID on\”}”
You've got a point here. Spaces in single items seem to be a bad idea, especially in lists.
And as said above: the '{', ',' and the quotes are notation only, they are not part of the entry content.
Quoted 4 lines
It seems like it would be nicer to be able to write:
xenhypfs write <path> "{dom0, PCID-on}”
This would be then:
xenhypfs write <path> "dom0 PCID-on"
Quoted 2 lines
(Maybe this will be made more clear later in the series, just thought I’d share my thoughts / confusion here.)
I'll make this clearer.
Juergen
PATCH v7 4/12 xen: add basic hypervisor filesystem support
In reply to Juergen GrossAdd the infrastructure for the hypervisor filesystem.
This includes the hypercall interface and the base functions for entry creation, deletion and modification.
In order not to have to repeat the same pattern multiple times in case adding a new node should BUG_ON() failure, the helpers for adding a node (hypfs_add_dir() and hypfs_add_leaf()) get a nofault parameter causing the BUG() in case of a failure.
When supporting writable leafs the entry's write pointer will need to be set to the function performing the write to the variable holding the content. In case there are no special constraints this will be hypfs_write_bool() for type XEN_HYPFS_TYPE_BOOL and hypfs_write_leaf() for the other entry types.
---
V1:
- rename files from filesystem.* to hypfs.*
- add dummy write entry support
- rename hypercall filesystem_op to hypfs_op
- add support for unsigned integer entries
V2:
- test new entry name to be valid
V3:
- major rework, especially by supporting binary contents of entries
- addressed all comments
V4:
- sort #includes alphabetically (Wei Liu)
- add public interface structures to xlat.lst (Jan Beulich)
- let DIRENTRY_SIZE() add 1 for trailing nul byte (Jan Beulich)
- remove hypfs_add_entry() (Jan Beulich)
- len -> ulen (Jan Beulich)
- switch sequence of tests in hypfs_get_entry_rel() (Jan Beulich)
- add const qualifier (Jan Beulich)
- return -ENOBUFS if only direntry but no entry contents are returned (Jan Beulich)
- use xmalloc() instead of xzalloc() (Jan Beulich)
- better error handling in hypfs_write_leaf() (Jan Beulich)
- return -EOPNOTSUPP for unknown sub-command (Jan Beulich)
- use plain integers for enum-like constants in public interface (Jan Beulich)
- rename XEN_HYPFS_OP_read_contents to XEN_HYPFS_OP_read (Jan Beulich)
- add some comments in include/public/hypfs.h (Jan Beulich)
- use const_char for user parameter path (Jan Beulich)
- add helpers for XEN_HYPFS_TYPE_BOOL and XEN_HYPFS_TYPE_INT entry definitions (Jan Beulich)
- make statically defined entries __read_mostly (Jan Beulich)
V5:
- switch to xsm for privilege check
V6:
- use memchr() for testing correct string length (Jan Beulich)
- reject writing to non-string leafs with wrong length (Jan Beulich)
- only support bools of natural size (Julien Grall)
- adjust blank padding in header (Jan Beulich)
- adjust comments in public header (Jan Beulich)
- rename hypfs_string_set() and add comment (Jan Beulich)
- add common HYPFS_INIT helper macro (Jan Beulich)
- really check structures added to xlat.lst (Jan Beulich)
- add missing xsm parts (Jan Beulich)
V7:
- simplify compat check (Jan Beulich)
- add max write size (Jan Beulich)
- better length testing of written string (Jan Beulich)
--- tools/flask/policy/modules/dom0.te | 2 +- xen/arch/arm/traps.c | 1 + xen/arch/x86/hvm/hypercall.c | 1 + xen/arch/x86/hypercall.c | 1 + xen/arch/x86/pv/hypercall.c | 1 + xen/common/Makefile | 1 + xen/common/hypfs.c | 350 ++++++++++++++++++++++++++++++++++++ xen/include/Makefile | 1 + xen/include/public/hypfs.h | 127 +++++++++++++ xen/include/public/xen.h | 1 + xen/include/xen/hypercall.h | 8 + xen/include/xen/hypfs.h | 116 ++++++++++++ xen/include/xlat.lst | 2 + xen/include/xsm/dummy.h | 6 + xen/include/xsm/xsm.h | 6 + xen/xsm/dummy.c | 1 + xen/xsm/flask/hooks.c | 6 + xen/xsm/flask/policy/access_vectors | 2 + 18 files changed, 632 insertions(+), 1 deletion(-) create mode 100644 xen/common/hypfs.c create mode 100644 xen/include/public/hypfs.h create mode 100644 xen/include/xen/hypfs.h
tools/flask/policy/modules/dom0.te +1 -1
@@ -11,7 +11,7 @@ allow dom0_t xen_t:xen { mtrr_del mtrr_read microcode physinfo quirk writeconsole readapic writeapic privprofile nonprivprofile kexec firmware sleep frequency getidle debug getcpuinfo heap pm_op mca_op lockprof cpupool_op - getscheduler setscheduler + getscheduler setscheduler hypfs_op }; allow dom0_t xen_t:xen2 { resource_op psr_cmt_op psr_alloc pmu_ctrl get_symbol
xen/arch/arm/traps.c +1 -0
@@ -1381,6 +1381,7 @@ static arm_hypercall_t arm_hypercall_table[] = {#ifdef CONFIG_ARGO HYPERCALL (argo_op,5 ), #endif + HYPERCALL(hypfs_op, 5), };#ifndef NDEBUG
xen/arch/x86/hvm/hypercall.c +1 -0
@@ -148,6 +148,7 @@ static const hypercall_table_t hvm_hypercall_table[] = {#endif HYPERCALL (xenpmu_op),COMPAT_CALL (dm_op), +HYPERCALL (hypfs_op), HYPERCALL(arch_1) };
xen/arch/x86/hypercall.c +1 -0
@@ -73,6 +73,7 @@ const hypercall_args_t hypercall_args_table[NR_hypercalls] =ARGS (hvm_op,2 ),ARGS (dm_op,3 ), #endif +ARGS (hypfs_op,5 ),ARGS (mca,1 ), ARGS(arch_1, 1), };
xen/arch/x86/pv/hypercall.c +1 -0
@@ -85,6 +85,7 @@ const hypercall_table_t pv_hypercall_table[] = {HYPERCALL (hvm_op),COMPAT_CALL (dm_op), #endif +HYPERCALL (hypfs_op),HYPERCALL (mca), HYPERCALL(arch_1), };
xen/common/Makefile +1 -0
@@ -10,6 +10,7 @@ obj-y += domain.o obj-y += event_2l.o obj-y += event_channel.o obj-y += event_fifo.o +obj-y += hypfs.o obj-$(CONFIG_CRASH_DEBUG) += gdbstub.o obj-$(CONFIG_GRANT_TABLE) += grant_table.o obj-y += guestcopy.o
xen/common/hypfs.c new file +350 -0
350 lines not on this page · raw message
xen/include/Makefile +1 -0
@@ -9,6 +9,7 @@ headers-y := \ compat/event_channel.h \ compat/features.h \ compat/grant_table.h \ + compat/hypfs.h \ compat/kexec.h \ compat/memory.h \ compat/nmi.h \
xen/include/public/hypfs.h new file +127 -0
127 lines not on this page · raw message
xen/include/public/xen.h +1 -0
@@ -130,6 +130,7 @@ DEFINE_XEN_GUEST_HANDLE(xen_ulong_t);#define __HYPERVISOR_argo_op 39#define __HYPERVISOR_xenpmu_op 40#define __HYPERVISOR_dm_op 41 +#define __HYPERVISOR_hypfs_op 42/* Architecture-specific hypercall definitions. */ #define __HYPERVISOR_arch_0 48
xen/include/xen/hypercall.h +8 -0
@@ -150,6 +150,14 @@ do_dm_op( unsigned int nr_bufs, XEN_GUEST_HANDLE_PARAM(xen_dm_op_buf_t) bufs); +extern long +do_hypfs_op ( +unsigned int cmd, +XEN_GUEST_HANDLE_PARAM (const_char) arg1, +unsigned long arg2, +XEN_GUEST_HANDLE_PARAM (void ) arg3, +unsigned long arg4); +#ifdef CONFIG_COMPAT extern int
xen/include/xen/hypfs.h new file +116 -0
116 lines not on this page · raw message
xen/include/xlat.lst +2 -0
@@ -86,6 +86,8 @@ ? vcpu_hvm_context hvm/hvm_vcpu.h ? vcpu_hvm_x86_32 hvm/hvm_vcpu.h ? vcpu_hvm_x86_64 hvm/hvm_vcpu.h +? hypfs_direntry hypfs.h +? hypfs_dirlistentry hypfs.h ? kexec_exec kexec.h ! kexec_image kexec.h ! kexec_range kexec.h
xen/include/xsm/dummy.h +6 -0
@@ -434,6 +434,12 @@ static XSM_INLINE int xsm_page_offline(XSM_DEFAULT_ARG uint32_t cmd)return xsm_default_action (action, current->domain,NULL ); } +static XSM_INLINE int xsm_hypfs_op(XSM_DEFAULT_VOID) +{ +XSM_ASSERT_ACTION (XSM_PRIV ); +return xsm_default_action (action, current->domain,NULL ); +} +static XSM_INLINE long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM (xsm_op_t) op) {return -ENOSYS ;
xen/include/xsm/xsm.h +6 -0
@@ -127,6 +127,7 @@ struct xsm_operations {int (*resource_setup_misc) (void );int (*page_offline)(uint32_t cmd); +int (*hypfs_op)(void );long (*do_xsm_op) (XEN_GUEST_HANDLE_PARAM (xsm_op_t) op);#ifdef CONFIG_COMPAT
@@ -536,6 +537,11 @@ static inline int xsm_page_offline(xsm_default_t def, uint32_t cmd)return xsm_ops->page_offline (cmd); } +static inline int xsm_hypfs_op (xsm_default_t def) +{ +return xsm_ops->hypfs_op (); +} +static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM (xsm_op_t) op) {return xsm_ops->do_xsm_op (op);
xen/xsm/dummy.c +1 -0
@@ -103,6 +103,7 @@ void __init xsm_fixup_ops (struct xsm_operations *ops)set_to_dummy_if_null (ops, resource_setup_misc);set_to_dummy_if_null (ops, page_offline); +set_to_dummy_if_null (ops, hypfs_op);set_to_dummy_if_null (ops, hvm_param);set_to_dummy_if_null (ops, hvm_control);set_to_dummy_if_null (ops, hvm_param_nested);
xen/xsm/flask/hooks.c +6 -0
@@ -1172,6 +1172,11 @@ static inline int flask_page_offline(uint32_t cmd) } } +static inline int flask_hypfs_op (void ) +{ +return domain_has_xen (current->domain,XEN__HYPFS_OP ); +} +static int flask_add_to_physmap (struct domain *d1,struct domain *d2) {return domain_has_perm (d1, d2,SECCLASS_MMU ,MMU__PHYSMAP );
@@ -1811,6 +1816,7 @@ static struct xsm_operations flask_ops = { .resource_setup_misc = flask_resource_setup_misc, .page_offline = flask_page_offline, + .hypfs_op = flask_hypfs_op, .hvm_param = flask_hvm_param, .hvm_control = flask_hvm_param, .hvm_param_nested = flask_hvm_param_nested,
xen/xsm/flask/policy/access_vectors +2 -0
@@ -67,6 +67,8 @@ class xen lockprof # XEN_SYSCTL_cpupool_op cpupool_op +# hypfs hypercall + hypfs_op # XEN_SYSCTL_scheduler_op with XEN_DOMCTL_SCHEDOP_getinfo, XEN_SYSCTL_sched_id, XEN_DOMCTL_SCHEDOP_getvcpuinfo getscheduler # XEN_SYSCTL_scheduler_op with XEN_DOMCTL_SCHEDOP_putinfo, XEN_DOMCTL_SCHEDOP_putvcpuinfo
Signature · 1 line
2.16.4
Re: [PATCH v7 04/12] xen: add basic hypervisor filesystem support
Quoted 10 lines · Juergen Gross
Add the infrastructure for the hypervisor filesystem.
This includes the hypercall interface and the base functions for entry creation, deletion and modification.
In order not to have to repeat the same pattern multiple times in case adding a new node should
BUG_ON()failure, the helpers for adding a node (hypfs_add_dir()andhypfs_add_leaf()) get a nofault parameter causing theBUG()in case of a failure.
Quoted 5 lines
When supporting writable leafs the entry's write pointer will need to be set to the function performing the write to the variable holding the content. In case there are no special constraints this will be
hypfs_write_bool()for typeXEN_HYPFS_TYPE_BOOLandhypfs_write_leaf()for the other entry types.
Seeing your HYPFS_*_INIT_WRITABLE() macros I find this a pretty strange requirement. Why can't the macros set the write hook right away?
Quoted 30 lines
xen/common/hypfs.c new file +30
-0+int hypfs_write_leaf (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +char *buf; +int ret; + +if ( leaf->e.type !=XEN_HYPFS_TYPE_STRING && + leaf->e.type !=XEN_HYPFS_TYPE_BLOB && ulen != leaf->e.size ) +return -EDOM ; + + buf =xmalloc_array (char, ulen); +if ( !buf ) +return -ENOMEM ; + + ret = -EFAULT ; +if (copy_from_guest (buf, uaddr, ulen) ) + goto out; + + ret = -EINVAL ; +if ( leaf->e.type ==XEN_HYPFS_TYPE_STRING && +memchr (buf,0 , ulen) != (buf + ulen -1 ) ) + goto out; + + ret =0 ; +memcpy (leaf->write_ptr, buf, ulen); + leaf->e.size = ulen; + + out: +xfree (buf); +return ret;
xen/common/hypfs.c line 271
Quoted 10 lines
xen/common/hypfs.c new file +10
-0+} + +int hypfs_write_bool (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +bool buf; + +ASSERT (leaf->e.type ==XEN_HYPFS_TYPE_BOOL && leaf->e.size ==sizeof (bool )); + +if ( ulen != leaf->e.max_size )
Why max_size here when the ASSERT() checks size?
xen/common/hypfs.c line 291
Quoted 10 lines
xen/common/hypfs.c new file +10
-0+static int hypfs_write (struct hypfs_entry *entry, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +struct hypfs_entry_leaf *l; + +if ( !entry->write ) +return -EACCES ; + +if ( ulen > entry->max_size ) +return -ENOSPC ;
max_size being zero for non-writable entries, perhaps use -EACCES also for this special case? Together with the other comment above, maybe the ->write check wants replacing this way?
Jan
Re: [PATCH v7 04/12] xen: add basic hypervisor filesystem support
Quoted 17 lines · Jan Beulich
Quoted 10 lines · Juergen Gross
Add the infrastructure for the hypervisor filesystem.
This includes the hypercall interface and the base functions for entry creation, deletion and modification.
In order not to have to repeat the same pattern multiple times in case adding a new node should
BUG_ON()failure, the helpers for adding a node (hypfs_add_dir()andhypfs_add_leaf()) get a nofault parameter causing theBUG()in case of a failure.Quoted 5 lines
When supporting writable leafs the entry's write pointer will need to be set to the function performing the write to the variable holding the content. In case there are no special constraints this will be
hypfs_write_bool()for typeXEN_HYPFS_TYPE_BOOLandhypfs_write_leaf()for the other entry types.
Quoted 3 lines
Seeing your HYPFS_*_INIT_WRITABLE() macros I find this a pretty strange requirement. Why can't the macros set the write hook right away?
Okay, will expand the macros.
Quoted 35 lines
Quoted 35 lines
xen/common/hypfs.c new file +34
-0+int hypfs_write_leaf (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +char *buf; +int ret; + +if ( leaf->e.type !=XEN_HYPFS_TYPE_STRING && + leaf->e.type !=XEN_HYPFS_TYPE_BLOB && ulen != leaf->e.size ) +return -EDOM ; + + buf =xmalloc_array (char, ulen); +if ( !buf ) +return -ENOMEM ; + + ret = -EFAULT ; +if (copy_from_guest (buf, uaddr, ulen) ) + goto out; + + ret = -EINVAL ; +if ( leaf->e.type ==XEN_HYPFS_TYPE_STRING && +memchr (buf,0 , ulen) != (buf + ulen -1 ) ) + goto out; + + ret =0 ; +memcpy (leaf->write_ptr, buf, ulen); + leaf->e.size = ulen; + + out: +xfree (buf); +return ret; +} + +int hypfs_write_bool (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen)
Quoted 8 lines
xen/common/hypfs.c line 271
Quoted 6 lines
xen/common/hypfs.c new file +6
-0+{ +bool buf; + +ASSERT (leaf->e.type ==XEN_HYPFS_TYPE_BOOL && leaf->e.size ==sizeof (bool )); + +if ( ulen != leaf->e.max_size )Why
max_sizehere when theASSERT()checks size?
Just for consistency with the other write functions.
Quoted 15 lines
xen/common/hypfs.c line 291
Quoted 11 lines
xen/common/hypfs.c new file +10
-0+static int hypfs_write (struct hypfs_entry *entry, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +struct hypfs_entry_leaf *l; + +if ( !entry->write ) +return -EACCES ; + +if ( ulen > entry->max_size ) +return -ENOSPC ;
max_sizebeing zero for non-writable entries, perhaps use-EACCESalso for this special case? Together with the other comment above, maybe the ->write check wants replacing this way?
Checking the write function being not NULL is a nice security addon, as I avoid to call into a non existing function. Basically both tests would be equivalent, but this one is IMO better to avoid crashes.
Juergen
Re: [PATCH v7 04/12] xen: add basic hypervisor filesystem support
Quoted 45 lines · Jürgen Groß
Quoted 35 lines · Jan Beulich
Quoted 34 lines · Juergen Gross
xen/common/hypfs.c new file +34
-0+int hypfs_write_leaf (struct hypfs_entry_leaf *leaf, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen) +{ + char *buf; + int ret; + + if ( leaf->e.type != XEN_HYPFS_TYPE_STRING && + leaf->e.type != XEN_HYPFS_TYPE_BLOB && ulen != leaf->e.size ) + return -EDOM; + + buf = xmalloc_array(char, ulen); + if ( !buf ) + return -ENOMEM; + + ret = -EFAULT; + if ( copy_from_guest(buf, uaddr, ulen) ) + goto out; + + ret = -EINVAL; + if ( leaf->e.type == XEN_HYPFS_TYPE_STRING && + memchr(buf, 0, ulen) != (buf + ulen - 1) ) + goto out; + + ret = 0; + memcpy(leaf->write_ptr, buf, ulen); + leaf->e.size = ulen; + + out: + xfree(buf); + return ret; +} + +int hypfs_write_bool (struct hypfs_entry_leaf *leaf, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen)Quoted 8 lines
xen/common/hypfs.c line 271
Quoted 6 lines
xen/common/hypfs.c new file +6
-0+{ + bool buf; + + ASSERT(leaf->e.type == XEN_HYPFS_TYPE_BOOL && leaf->e.size == sizeof(bool)); + + if ( ulen != leaf->e.max_size )Why
max_sizehere when theASSERT()checks size?
Quoted 1 line
Just for consistency with the other write functions.
In which case perhaps extend the ASSERT() to also check max_size?
Quoted 15 lines
Quoted 6 lines
Quoted 6 lines
xen/common/hypfs.c new file +6
-0+static int hypfs_write (struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen) +{ + struct hypfs_entry_leaf *l; + + if ( !entry->write )Quoted 8 lines
Quoted 4 lines
+ return
-EACCES;
+
+ if ( ulen >entry->max_size)
+ return-ENOSPC;
max_sizebeing zero for non-writable entries, perhaps use-EACCESalso for this special case? Together with the other comment above, maybe the ->write check wants replacing this way?
Quoted 3 lines
Checking the write function being not NULL is a nice security addon, as I avoid to call into a non existing function. Basically both tests would be equivalent, but this one is IMO better to avoid crashes.
In which case perhaps ASSERT(entry->max_size) between the two if()s?
Jan
Re: [PATCH v7 04/12] xen: add basic hypervisor filesystem support
Quoted 46 lines · Jan Beulich
Quoted 45 lines · Jürgen Groß
Quoted 43 lines · Jan Beulich
Quoted 30 lines · Juergen Gross
xen/common/hypfs.c new file +30
-0+int hypfs_write_leaf (struct hypfs_entry_leaf *leaf, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen) +{ + char *buf; + int ret; + + if ( leaf->e.type != XEN_HYPFS_TYPE_STRING && + leaf->e.type != XEN_HYPFS_TYPE_BLOB && ulen != leaf->e.size ) + return -EDOM; + + buf = xmalloc_array(char, ulen); + if ( !buf ) + return -ENOMEM; + + ret = -EFAULT; + if ( copy_from_guest(buf, uaddr, ulen) ) + goto out; + + ret = -EINVAL; + if ( leaf->e.type == XEN_HYPFS_TYPE_STRING && + memchr(buf, 0, ulen) != (buf + ulen - 1) ) + goto out; + + ret = 0; + memcpy(leaf->write_ptr, buf, ulen); + leaf->e.size = ulen; + + out: + xfree(buf); + return ret;xen/common/hypfs.c line 271
Quoted 10 lines
xen/common/hypfs.c new file +10
-0+} + +int hypfs_write_bool (struct hypfs_entry_leaf *leaf, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen) +{ + bool buf; + + ASSERT(leaf->e.type == XEN_HYPFS_TYPE_BOOL && leaf->e.size == sizeof(bool)); + + if ( ulen != leaf->e.max_size )Why
max_sizehere when theASSERT()checks size?
Quoted 3 lines
Quoted 1 line
Just for consistency with the other write functions.
In which case perhaps extend the
ASSERT()to also checkmax_size?
Okay.
Quoted 16 lines
Quoted 16 lines
Quoted 15 lines
xen/common/hypfs.c line 291
Quoted 11 lines
xen/common/hypfs.c new file +10
-0+static int hypfs_write (struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen) +{ + struct hypfs_entry_leaf *l; + + if ( !entry->write ) + return -EACCES; + + if ( ulen > entry->max_size ) + return -ENOSPC;
max_sizebeing zero for non-writable entries, perhaps use-EACCESalso for this special case? Together with the other comment above, maybe the ->write check wants replacing this way?
Quoted 5 lines
Quoted 3 lines
Checking the write function being not NULL is a nice security addon, as I avoid to call into a non existing function. Basically both tests would be equivalent, but this one is IMO better to avoid crashes.
In which case perhaps
ASSERT(entry->max_size)between the two if()s?
Okay.
Juergen
PATCH v7 5/12 libs: add libxenhypfs
In reply to Juergen GrossAdd the new library libxenhypfs for access to the hypervisor filesystem.
---
V1:
- rename to libxenhypfs
- add xenhypfs_write()
V3:
- major rework due to new hypervisor interface
- add decompression capability
V4:
- add dependency to libz in pkgconfig file (Wei Liu)
V7:
- don't assume hypervisor's sizeof(bool) is same as in user land
--- .gitignore | 2 + tools/Rules.mk | 6 + tools/libs/Makefile | 1 + tools/libs/hypfs/Makefile | 16 ++ tools/libs/hypfs/core.c | 536 ++++++++++++++++++++++++++++++++++++ tools/libs/hypfs/include/xenhypfs.h | 75 +++++ tools/libs/hypfs/libxenhypfs.map | 10 + tools/libs/hypfs/xenhypfs.pc.in | 10 + 8 files changed, 656 insertions(+) create mode 100644 tools/libs/hypfs/Makefile create mode 100644 tools/libs/hypfs/core.c create mode 100644 tools/libs/hypfs/include/xenhypfs.h create mode 100644 tools/libs/hypfs/libxenhypfs.map create mode 100644 tools/libs/hypfs/xenhypfs.pc.in
.gitignore +2 -0
@@ -109,6 +109,8 @@ tools/libs/evtchn/headers.chk tools/libs/evtchn/xenevtchn.pc tools/libs/gnttab/headers.chk tools/libs/gnttab/xengnttab.pc +tools/libs/hypfs/headers.chk +tools/libs/hypfs/xenhypfs.pc tools/libs/call/headers.chk tools/libs/call/xencall.pc tools/libs/foreignmemory/headers.chk
tools/Rules.mk +6 -0
@@ -19,6 +19,7 @@ XEN_LIBXENGNTTAB = $(XEN_ROOT)/tools/libs/gnttab XEN_LIBXENCALL = $(XEN_ROOT)/tools/libs/call XEN_LIBXENFOREIGNMEMORY = $(XEN_ROOT)/tools/libs/foreignmemory XEN_LIBXENDEVICEMODEL = $(XEN_ROOT)/tools/libs/devicemodel +XEN_LIBXENHYPFS = $(XEN_ROOT)/tools/libs/hypfs XEN_LIBXC = $(XEN_ROOT)/tools/libxc XEN_XENLIGHT = $(XEN_ROOT)/tools/libxl # Currently libxlutil lives in the same directory as libxenlight
@@ -134,6 +135,11 @@ SHDEPS_libxendevicemodel = $(SHLIB_libxentoollog) $(SHLIB_libxentoolcore) $(SHLI LDLIBS_libxendevicemodel = $(SHDEPS_libxendevicemodel) $(XEN_LIBXENDEVICEMODEL)/libxendevicemodel$(libextension) SHLIB_libxendevicemodel = $(SHDEPS_libxendevicemodel) -Wl,-rpath-link=$(XEN_LIBXENDEVICEMODEL) +CFLAGS_libxenhypfs = -I$(XEN_LIBXENHYPFS)/include $(CFLAGS_xeninclude) +SHDEPS_libxenhypfs = $(SHLIB_libxentoollog) $(SHLIB_libxentoolcore) $(SHLIB_xencall) +LDLIBS_libxenhypfs = $(SHDEPS_libxenhypfs) $(XEN_LIBXENHYPFS)/libxenhypfs$(libextension) +SHLIB_libxenhypfs = $(SHDEPS_libxenhypfs) -Wl,-rpath-link=$(XEN_LIBXENHYPFS) + # code which compiles against libxenctrl get __XEN_TOOLS__ and # therefore sees the unstable hypercall interfaces. CFLAGS_libxenctrl = -I$(XEN_LIBXC)/include $(CFLAGS_libxentoollog) $(CFLAGS_libxenforeignmemory) $(CFLAGS_libxendevicemodel) $(CFLAGS_xeninclude) -D__XEN_TOOLS__
tools/libs/Makefile +1 -0
@@ -9,6 +9,7 @@ SUBDIRS-y += gnttab SUBDIRS-y += call SUBDIRS-y += foreignmemory SUBDIRS-y += devicemodel +SUBDIRS-y += hypfs ifeq ($(CONFIG_RUMP),y) SUBDIRS-y := toolcore
tools/libs/hypfs/Makefile new file +16 -0
@@ -0,0 +1,16 @@ +XEN_ROOT = $(CURDIR)/../../.. +include $(XEN_ROOT)/tools/Rules.mk + +MAJOR = 1 +MINOR = 0 +LIBNAME := hypfs +USELIBS := toollog toolcore call + +APPEND_LDFLAGS += -lz + +SRCS-y += core.c + +include ../libs.mk + +$(PKG_CONFIG_LOCAL): PKG_CONFIG_INCDIR = $(XEN_LIBXENHYPFS)/include +$(PKG_CONFIG_LOCAL): PKG_CONFIG_CFLAGS_LOCAL = $(CFLAGS_xeninclude)
tools/libs/hypfs/core.c new file +536 -0
536 lines not on this page · raw message
tools/libs/hypfs/include/xenhypfs.h new file +75 -0
75 lines not on this page · raw message
tools/libs/hypfs/libxenhypfs.map new file +10 -0
@@ -0,0 +1,10 @@ +VERS_1.0 { + global: + xenhypfs_open; + xenhypfs_close; + xenhypfs_read_raw; + xenhypfs_read; + xenhypfs_readdir; + xenhypfs_write; + local: *; /* Do not expose anything by default */ +};
tools/libs/hypfs/xenhypfs.pc.in new file +10 -0
@@ -0,0 +1,10 @@ +prefix=@@prefix@@ +includedir=@@incdir@@ +libdir=@@libdir@@ + +Name: Xenhypfs +Description: The Xenhypfs library for Xen hypervisor +Version: @@version@@ +Cflags: -I${includedir} @@cflagslocal@@ +Libs: @@libsflag@@${libdir} -lxenhypfs +Requires.private: xentoolcore,xentoollog,xencall,z
Signature · 1 line
2.16.4
Re: [PATCH v7 05/12] libs: add libxenhypfs
Quoted 8 lines · Juergen Gross
Add the new library libxenhypfs for access to the hypervisor filesystem.
Signed-off-by Juergen Gross <[email protected]>Acked-by Wei Liu <[email protected]>
Just a few questions...
tools/libs/hypfs/include/xenhypfs.h line 56
Quoted 6 lines
tools/libs/hypfs/include/xenhypfs.h new file +6
-0+/* Returned buffer and dirent should be freed via free(). */ +void *xenhypfs_read_raw (xenhypfs_handle *fshdl,const char *path, +struct xenhypfs_dirent **dirent); + +/* Returned buffer should be freed via free(). */ +char *xenhypfs_read (xenhypfs_handle *fshdl,const char *path);
What’s the difference between these two? And what’s the dirent argument to xenhypfs_read_raw() for?
-George
Re: [PATCH v7 05/12] libs: add libxenhypfs
Quoted 11 lines · George Dunlap
Quoted 8 lines · Juergen Gross
Add the new library libxenhypfs for access to the hypervisor filesystem.
Signed-off-by Juergen Gross <[email protected]>Acked-by Wei Liu <[email protected]>Just a few questions...
Quoted 8 lines
tools/libs/hypfs/include/xenhypfs.h line 56
Quoted 6 lines
tools/libs/hypfs/include/xenhypfs.h new file +6
-0+/* Returned buffer and dirent should be freed via free(). */ +void *xenhypfs_read_raw (xenhypfs_handle *fshdl,const char *path, +struct xenhypfs_dirent **dirent); + +/* Returned buffer should be freed via free(). */ +char *xenhypfs_read (xenhypfs_handle *fshdl,const char *path);What’s the difference between these two? And what’s the
direntargument toxenhypfs_read_raw()for?
xenhypfs_read() is returning the printable content (if possible), e.g. "1" for an entry of type integer containing 0x00000001
xenhypfs_read_raw() returns the raw content (e.g. the binary value 0x00000001 in above example) and the entry format data in dirent (type, size and enconding of entry).
Juergen
PATCH v7 6/12 tools: add xenfs tool
In reply to Juergen GrossAdd the xenfs tool for accessing the hypervisor filesystem.
---
V1:
- rename to xenhypfs
- don't use "--" for subcommands
- add write support
V2:
- escape non-printable characters per default with cat subcommand (Ian Jackson)
- add -b option to cat subcommand (Ian Jackson)
- add man page
V3:
- adapt to new hypfs interface
V7:
- added missing bool for ls output
--- .gitignore | 1 + docs/man/xenhypfs.1.pod | 61 +++++++++++++++ tools/misc/Makefile | 6 ++ tools/misc/xenhypfs.c | 192 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 260 insertions(+) create mode 100644 docs/man/xenhypfs.1.pod create mode 100644 tools/misc/xenhypfs.c
.gitignore +1 -0
@@ -367,6 +367,7 @@ tools/libxl/test_timedereg tools/libxl/test_fdderegrace tools/firmware/etherboot/eb-roms.h tools/firmware/etherboot/gpxe-git-snapshot.tar.gz +tools/misc/xenhypfs tools/misc/xenwatchdogd tools/misc/xen-hvmcrash tools/misc/xen-lowmemd
docs/man/xenhypfs.1.pod new file +61 -0
61 lines not on this page · raw message
tools/misc/Makefile +6 -0
@@ -24,6 +24,7 @@ INSTALL_SBIN-$(CONFIG_X86) += xen-lowmemd INSTALL_SBIN-$(CONFIG_X86) += xen-mfndump INSTALL_SBIN-$(CONFIG_X86) += xen-ucode INSTALL_SBIN += xencov +INSTALL_SBIN += xenhypfs INSTALL_SBIN += xenlockprof INSTALL_SBIN += xenperf INSTALL_SBIN += xenpm
@@ -86,6 +87,9 @@ xenperf: xenperf.o xenpm: xenpm.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenctrl) $(APPEND_LDFLAGS) +xenhypfs: xenhypfs.o + $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenhypfs) $(APPEND_LDFLAGS) + xenlockprof: xenlockprof.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenctrl) $(APPEND_LDFLAGS)
@@ -94,6 +98,8 @@ xen-hptool.o: CFLAGS += -I$(XEN_ROOT)/tools/libxc $(CFLAGS_libxencall) xen-hptool: xen-hptool.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenevtchn) $(LDLIBS_libxenctrl) $(LDLIBS_libxenguest) $(LDLIBS_libxenstore) $(APPEND_LDFLAGS) +xenhypfs.o: CFLAGS += $(CFLAGS_libxenhypfs) + # xen-mfndump incorrectly uses libxc internals xen-mfndump.o: CFLAGS += -I$(XEN_ROOT)/tools/libxc $(CFLAGS_libxencall) xen-mfndump: xen-mfndump.o
tools/misc/xenhypfs.c new file +192 -0
192 lines not on this page · raw message
Signature · 1 line
2.16.4
PATCH v7 7/12 xen: provide version information in hypfs
In reply to Juergen GrossProvide version and compile information in /buildinfo/ node of the Xen hypervisor file system. As this information is accessible by dom0 only no additional security problem arises.
---
V3:
- new patch
V4:
- add __read_mostly annotations (Jan Beulich)
--- docs/misc/hypfs-paths.pandoc | 45 ++++++++++++++++++++++++++++++++++++++++++++ xen/common/kernel.c | 45 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+)
docs/misc/hypfs-paths.pandoc +45 -0
@@ -103,3 +103,48 @@ A populated Xen hypervisor file system might look like the following example: #### / The root of the hypervisor file system. + +#### /buildinfo/ + +A directory containing static information generated while building the +hypervisor. + +#### /buildinfo/changeset = STRING + +Git commit of the hypervisor. + +#### /buildinfo/compileinfo/ + +A directory containing information about compilation of Xen. + +#### /buildinfo/compileinfo/compile_by = STRING + +Information who compiled the hypervisor. + +#### /buildinfo/compileinfo/compile_date = STRING + +Date of the hypervisor compilation. + +#### /buildinfo/compileinfo/compile_domain = STRING + +Information about the compile domain. + +#### /buildinfo/compileinfo/compiler = STRING + +The compiler used to build Xen. + +#### /buildinfo/version/ + +A directory containing version information of the hypervisor. + +#### /buildinfo/version/extra = STRING + +Extra version information. + +#### /buildinfo/version/major = INTEGER + +The major version of Xen. + +#### /buildinfo/version/minor = INTEGER + +The minor version of Xen.
xen/common/kernel.c +45 -0
57 lines not on this page · raw message
Signature · 1 line
2.16.4
PATCH v7 8/12 xen: add /buildinfo/config entry to hypervisor filesystem
In reply to Juergen GrossAdd the /buildinfo/config entry to the hypervisor filesystem. This entry contains the .config file used to build the hypervisor.
---
V3:
- store data in gzip format
- use binfile mechanism to create data file
- move code to kernel.c
V6:
- add config item for the /buildinfo/config (Jan Beulich)
- make config related variables const in kernel.h (Jan Beulich)
V7:
- update doc (Jan Beulich)
- use "rm -f" in Makefile (Jan Beulich)
--- .gitignore | 2 ++ docs/misc/hypfs-paths.pandoc | 4 ++++ xen/common/Kconfig | 10 ++++++++++ xen/common/Makefile | 12 ++++++++++++ xen/common/kernel.c | 15 +++++++++++++++ xen/include/xen/kernel.h | 3 +++ 6 files changed, 46 insertions(+)
.gitignore +2 -0
@@ -297,6 +297,8 @@ xen/arch/*/efi/boot.c xen/arch/*/efi/compat.c xen/arch/*/efi/efi.h xen/arch/*/efi/runtime.c +xen/common/config_data.S +xen/common/config.gz xen/include/headers*.chk xen/include/asm xen/include/asm-*/asm-offsets.h
docs/misc/hypfs-paths.pandoc +4 -0
@@ -133,6 +133,10 @@ Information about the compile domain. The compiler used to build Xen. +#### /buildinfo/config = STRING [CONFIG_HYPFS_CONFIG] + +The contents of the `xen/.config` file at the time of the hypervisor build. + #### /buildinfo/version/ A directory containing version information of the hypervisor.
xen/common/Kconfig +10 -0
@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default y + ---help--- + When enabled the contents of the .config file used to build the + hypervisor are provided via the hypfs entry /buildinfo/config. + + Disable this option in case you want to spare some memory or you + want to hide the .config contents from dom0. + config TRACEBUFFER bool "Enable tracing infrastructure" if EXPERT = "y" default y
xen/common/Makefile +12 -0
@@ -1,6 +1,7 @@ obj-$(CONFIG_ARGO) += argo.o obj-y += bitmap.o obj-y += bsearch.o +obj-$(CONFIG_HYPFS_CONFIG) += config_data.o obj-$(CONFIG_CORE_PARKING) += core_parking.o obj-y += cpu.o obj-$(CONFIG_DEBUG_TRACE) += debugtrace.o
@@ -73,3 +74,14 @@ obj-$(CONFIG_UBSAN) += ubsan/ obj-$(CONFIG_NEEDS_LIBELF) += libelf/ obj-$(CONFIG_HAS_DEVICE_TREE) += libfdt/ + +config.gz: ../.config + gzip -c $< >$@ + +config_data.o: config.gz + +config_data.S: $(XEN_ROOT)/xen/tools/binfile + $(XEN_ROOT)/xen/tools/binfile $@ config.gz xen_config_data + +clean:: + rm -f config_data.S config.gz 2>/dev/null
xen/common/kernel.c +15 -0
@@ -389,6 +389,16 @@ static HYPFS_STRING_INIT(compile_date, "compile_date"); static HYPFS_STRING_INIT(compile_domain, "compile_domain"); static HYPFS_STRING_INIT(extra, "extra"); +#ifdef CONFIG_HYPFS_CONFIG +static struct hypfs_entry_leaf config = { + .e.type =XEN_HYPFS_TYPE_STRING , + .e.encoding =XEN_HYPFS_ENC_GZIP , + .e.name ="config" , + .e.read = hypfs_read_leaf, + .content = &xen_config_data +}; +#endif +static int __init buildinfo_init (void ) {hypfs_add_dir (&hypfs_root, &buildinfo, true);
@@ -414,6 +424,11 @@ static int __init buildinfo_init(void)hypfs_add_leaf (&version, &major, true);hypfs_add_leaf (&version, &minor, true); +#ifdef CONFIG_HYPFS_CONFIG + config.e.size = xen_config_data_size; +hypfs_add_leaf (&buildinfo, &config, true); +#endif +return 0 ; }__initcall (buildinfo_init);
xen/include/xen/kernel.h +3 -0
@@ -100,5 +100,8 @@ extern enum system_state {bool_t is_active_kernel_text (unsigned long addr); +extern const char xen_config_data; +extern const unsigned int xen_config_data_size; +#endif /* _LINUX_KERNEL_H */
Signature · 1 line
2.16.4
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
xen/common/Kconfig config DOM0_MEM · line 358
Quoted 9 lines · Juergen Gross
xen/common/Kconfig +3
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default y
My initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
Quoted 5 lines
xen/common/kernel.c +0
-0@@ -389,6 +389,16 @@ static HYPFS_STRING_INIT(compile_date, "compile_date"); static HYPFS_STRING_INIT(compile_domain, "compile_domain"); static HYPFS_STRING_INIT(extra, "extra");
xen/common/kernel.c static HYPFS_STRING_INIT(compile_date, "compile_date"); · line 400
Quoted 10 lines
xen/common/kernel.c +9
-0+#ifdef CONFIG_HYPFS_CONFIG +static struct hypfs_entry_leaf config = { + .e.type =XEN_HYPFS_TYPE_STRING , + .e.encoding =XEN_HYPFS_ENC_GZIP , + .e.name ="config" , + .e.read = hypfs_read_leaf, + .content = &xen_config_data +}; +#endif
Would be really good if no open-coded instantiations like this one would ever have to appear, i.e. if suitable macros were available. What's preventing use of one of the available ones here?
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 7 lines · Jan Beulich
Quoted 6 lines · Juergen Gross
xen/common/Kconfig +0
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify.
Quoted 8 lines
xen/common/Kconfig config DOM0_MEM · line 358
Quoted 3 lines
xen/common/Kconfig +3
-0+config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
No, I don't remember that agreement.
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to CONFIG_HYPFS.
Quoted 7 lines
Quoted 7 lines
xen/common/kernel.c +0
-0@@ -389,6 +389,16 @@ static HYPFS_STRING_INIT(compile_date, "compile_date"); static HYPFS_STRING_INIT(compile_domain, "compile_domain"); static HYPFS_STRING_INIT(extra, "extra");
Quoted 14 lines
xen/common/kernel.c static HYPFS_STRING_INIT(compile_date, "compile_date"); · line 400
Quoted 9 lines
xen/common/kernel.c +9
-0+#ifdef CONFIG_HYPFS_CONFIG +static struct hypfs_entry_leaf config = { + .e.type =XEN_HYPFS_TYPE_STRING , + .e.encoding =XEN_HYPFS_ENC_GZIP , + .e.name ="config" , + .e.read = hypfs_read_leaf, + .content = &xen_config_data +}; +#endif Would be really good if no open-coded instantiations like this one would ever have to appear, i.e. if suitable macros were available. What's preventing use of one of the available ones here?
Right now it is the only case for a non plain encoding. The alternative would have been to either specify the encoding explicitly at all other node definitions, or to have a macro for this single instance.
Juergen
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 15 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
Quoted 7 lines · Juergen Gross
xen/common/Kconfig +0
-0@@ -353,6 +353,16 @@ config DOM0_MEMLeave empty if you are not sure what to specify. +config
HYPFS_CONFIG
+ bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
Quoted 6 lines
No, I don't remember that agreement.
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to
CONFIG_HYPFS.
I think that would be fine - that's what config setting are for. Someone caring about space may not care about runtime setting of parameters.
Quoted 20 lines
Quoted 11 lines
Quoted 11 lines
xen/common/kernel.c +0
-0@@ -389,6 +389,16 @@ static HYPFS_STRING_INIT(compile_date, "compile_date"); static HYPFS_STRING_INIT(compile_domain, "compile_domain"); static HYPFS_STRING_INIT(extra, "extra");+#ifdef
CONFIG_HYPFS_CONFIG
+static structhypfs_entry_leafconfig = {
+ .e.type =XEN_HYPFS_TYPE_STRING,
+ .e.encoding =XEN_HYPFS_ENC_GZIP,
+ .e.name = "config",
+ .e.read =hypfs_read_leaf,Quoted 8 lines
xen/common/kernel.c static HYPFS_STRING_INIT(compile_date, "compile_date"); · line 400
Quoted 3 lines
+ .content =
&xen_config_dataxen/common/kernel.c +2
-0+}; +#endif Would be really good if no open-coded instantiations like this one would ever have to appear, i.e. if suitable macros were available. What's preventing use of one of the available ones here?
Quoted 3 lines
Right now it is the only case for a non plain encoding. The alternative would have been to either specify the encoding explicitly at all other node definitions, or to have a macro for this single instance.
Or set the encoding alongside e.size in the init function?
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 18 lines · Jan Beulich
Quoted 17 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
xen/common/Kconfig config DOM0_MEM · line 356
Quoted 7 lines · Juergen Gross
xen/common/Kconfig +2
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
No, I don't remember that agreement.
Quoted 8 lines
Quoted 4 lines
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to
CONFIG_HYPFS.I think that would be fine - that's what config setting are for. Someone caring about space may not care about runtime setting of parameters.
So right now it would start with a plain hypfs available or not.
The next step would be in patch 12 to tell the user he will lose the capability of setting runtime parameters.
Another planned extension would be to control per-cpupool settings, which would the go away (possibly functionality being unconditionally available today).
Next would be the lack of being able to control per-domain mitigations like XPTI or L1TF, which I'd like to add.
Another thing I wanted to add is some debugging stuff (e.g. to switch lock profiling using hypfs).
And the list will go on.
Does it really make sense to make a central control and information interface conditional?
I'd like at least a second opinion on that topic.
Quoted 21 lines
Quoted 21 lines
Quoted 20 lines
Quoted 5 lines
xen/common/kernel.c +0
-0@@ -389,6 +389,16 @@ static HYPFS_STRING_INIT(compile_date, "compile_date"); static HYPFS_STRING_INIT(compile_domain, "compile_domain");xen/common/kernel.c static HYPFS_STRING_INIT(compile_date, "compile_date"); · line 399
Quoted 10 lines
xen/common/kernel.c +8
-0static HYPFS_STRING_INIT(extra, "extra"); +#ifdef CONFIG_HYPFS_CONFIG +static struct hypfs_entry_leaf config = { + .e.type = XEN_HYPFS_TYPE_STRING, + .e.encoding = XEN_HYPFS_ENC_GZIP, + .e.name = "config", + .e.read = hypfs_read_leaf, + .content = &xen_config_data +}; +#endif Would be really good if no open-coded instantiations like this one would ever have to appear, i.e. if suitable macros were available. What's preventing use of one of the available ones here?
Quoted 5 lines
Quoted 3 lines
Right now it is the only case for a non plain encoding. The alternative would have been to either specify the encoding explicitly at all other node definitions, or to have a macro for this single instance.
Or set the encoding alongside e.size in the init function?
Hmm, that's an option, yes.
Juergen
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 37 lines · Jürgen Groß
Quoted 18 lines · Jan Beulich
Quoted 17 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
xen/common/Kconfig config DOM0_MEM · line 356
Quoted 7 lines · Juergen Gross
xen/common/Kconfig +2
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
No, I don't remember that agreement.
Quoted 8 lines
Quoted 4 lines
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to
CONFIG_HYPFS.I think that would be fine - that's what config setting are for. Someone caring about space may not care about runtime setting of parameters.
So right now it would start with a plain hypfs available or not.
The next step would be in patch 12 to tell the user he will lose the capability of setting runtime parameters.
Another planned extension would be to control per-cpupool settings, which would the go away (possibly functionality being unconditionally available today).
Quoted 7 lines
Next would be the lack of being able to control per-domain mitigations like XPTI or L1TF, which I'd like to add.
Another thing I wanted to add is some debugging stuff (e.g. to switch lock profiling using hypfs).
And the list will go on.
Understood.
Quoted 2 lines
Does it really make sense to make a central control and information interface conditional?
None of the above may be of interest to e.g. embedded use cases.
Quoted 1 line
I'd like at least a second opinion on that topic.
Yes, further opinions would surely help.
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Stefano,
Quoted 48 lines · Jan Beulich
Quoted 37 lines · Jürgen Groß
Quoted 18 lines · Jan Beulich
Quoted 17 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
xen/common/Kconfig config DOM0_MEM · line 356
Quoted 7 lines · Juergen Gross
xen/common/Kconfig +2
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
No, I don't remember that agreement.
Quoted 8 lines
Quoted 4 lines
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to
CONFIG_HYPFS.I think that would be fine - that's what config setting are for. Someone caring about space may not care about runtime setting of parameters.
So right now it would start with a plain hypfs available or not.
The next step would be in patch 12 to tell the user he will lose the capability of setting runtime parameters.
Another planned extension would be to control per-cpupool settings, which would the go away (possibly functionality being unconditionally available today).
Quoted 7 lines
Next would be the lack of being able to control per-domain mitigations like XPTI or L1TF, which I'd like to add.
Another thing I wanted to add is some debugging stuff (e.g. to switch lock profiling using hypfs).
And the list will go on.
Understood.
Quoted 8 lines
Quoted 2 lines
Does it really make sense to make a central control and information interface conditional?
None of the above may be of interest to e.g. embedded use cases.
Quoted 1 line
I'd like at least a second opinion on that topic.
Yes, further opinions would surely help.
Any opinion on making hypfs configurable?
It would be quite some code churn and I want to avoid it in case you see no benefit in configuring it out for embedded.
Juergen
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 55 lines · Jürgen Groß
Stefano,
Quoted 48 lines · Jan Beulich
Quoted 37 lines · Jürgen Groß
Quoted 18 lines · Jan Beulich
Quoted 17 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
xen/common/Kconfig config DOM0_MEM · line 356
Quoted 7 lines · Juergen Gross
xen/common/Kconfig +2
-0@@ -353,6 +353,16 @@ config DOM0_MEM Leave empty if you are not sure what to specify. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default yMy initial reaction was to ask for "depends on HYPFS", but then I noticed the earlier patch doesn't introduce such. Am I mis-remembering that it was agreed to make the whole thing possible to disable at least in EXPERT mode?
No, I don't remember that agreement.
Quoted 8 lines
Quoted 4 lines
And TBH I'm not sure this is a good idea, as that would at once make the plan to replace at least some sysctl and/or domctl interfaces impossible (like e.g. the last 3 patches of the series are doing already), or at least would tie the related functionality to
CONFIG_HYPFS.I think that would be fine - that's what config setting are for. Someone caring about space may not care about runtime setting of parameters.
So right now it would start with a plain hypfs available or not.
The next step would be in patch 12 to tell the user he will lose the capability of setting runtime parameters.
Another planned extension would be to control per-cpupool settings, which would the go away (possibly functionality being unconditionally available today).
Quoted 7 lines
Next would be the lack of being able to control per-domain mitigations like XPTI or L1TF, which I'd like to add.
Another thing I wanted to add is some debugging stuff (e.g. to switch lock profiling using hypfs).
And the list will go on.
Understood.
Quoted 2 lines
Does it really make sense to make a central control and information interface conditional?
Quoted 8 lines
Quoted 3 lines
None of the above may be of interest to e.g. embedded use cases.
Quoted 1 line
I'd like at least a second opinion on that topic.
Yes, further opinions would surely help.
Any opinion on making hypfs configurable?
It would be quite some code churn and I want to avoid it in case you see no benefit in configuring it out for embedded.
Just to reply with what I said on IRC:
First of all, if it were free, I think that having CONFIG_HYPFS would be valuable. Sub-options should be made available on a case-by-case basis; I think CONFIG_HYPFS_CONFIG would be valuable, but I don’t see any point in having CONFIG_HYPFS_RUNTIME_PARAMETER.
However, Juergen seems to think it would require a lot of churn to the current series. I don’t quite understand why; but supposing that’s so: In general, the people who want a feature should be the ones who do the work to make it. I think it would be perfectly reasonable for Juergen to say, “This is a lot of work that I don’t have time to do before the 4.14 release; if people want to be able to disable this feature, they can post their own patches.” (It’s also perfectly reasonable for him to do the work himself just to be helpful.)
The discussion about CONFIG_EXPERT is sort of the same. If we have CONFIG_HYPFS, it would obviously be more valuable if it were *not* in CONFIG_EXPERT, so that people could change it while still being security supported.
If Jan is OK with it simply being outside CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside of CONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.
Hope that makes sense. :-)
-George
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.
I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 7 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.
Quoted 12 lines
I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding CONFIG_HYPFS outside of CONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing for CONFIG_HYPFS=n.”
I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (CONFIG_HYPFS=n security supported), there is extra work that needs to be done (getting CONFIG_HYPFS=n tested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implements CONFIG_HYPFS=n testing (since he doesn’t personally have a stake in that feature).
Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement CONFIG_HYPFS. I wanted to make it clear that even though I see value in having CONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted that CONFIG_HYPFS=n had to be tested before being security supported.
Hope that makes sense. :-)
-George
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement
CONFIG_HYPFS. I wanted to make it clear that even though I see value in havingCONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
In particular, seeing which patch we're discussing, I find it far less helpful to have CONFIG_HYPFS_CONFIG when there's no CONFIG_HYPFS, at least as long as our .config-s are still tiny compared to Linux'es.
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Hi Jan,
Quoted 32 lines · Jan Beulich
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement
CONFIG_HYPFS. I wanted to make it clear that even though I see value in havingCONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Quoted 9 lines
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have
Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
I like the idea to have a more configurable Xen but this also comes at the expense of the testing/support.
At the moment, we are getting around the problem by gating the new config options with CONFIG_EXPERT. I have stoppped counting the number of time I sweared because my config got rewritten when using 'make clean' or explain to someone else how to use it.
As it stands, CONFIG_EXPERT is unusable and most likely anything behind it will rot quite quickly. So if we want to add more stuff behind it, then I would suggest to make it more accessible so any developper can experiment with it.
Going forward, I would expect the embedded folks to want more part of Xen configurable. Requesting them to use CONFIG_EXPERT may be an issue as this means we would not security support them. At the same time, I understand that exposing a CONFIG increase the testing matrix. How about declaring we are supporting/testing a given set of .config? On Arm it would be defconfig and tiny.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 45 lines · Julien Grall
Hi Jan,
Quoted 32 lines · Jan Beulich
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement CONFIG_HYPFS. I wanted to make it clear that even though I see value in having
CONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Quoted 9 lines
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have
Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
Quoted 5 lines
I like the idea to have a more configurable Xen but this also comes at the expense of the testing/support.
At the moment, we are getting around the problem by gating the new config options with
CONFIG_EXPERT. I have stoppped counting the number of time I sweared because my config got rewritten when using 'make clean' or explain to someone else how to use it.As it stands,
CONFIG_EXPERTis unusable and most likely anything behind it will rot quite quickly. So if we want to add more stuff behind it, then I would suggest to make it more accessible so any developper can experiment with it.
This complaint is not new; what I'm missing are concrete suggestions on how to improve the situation.
Quoted 1 line
Going forward, I would expect the embedded folks to want more part of Xen configurable. Requesting them to use
CONFIG_EXPERTmay be an issue as this means we would not security support them. At the same time, I understand that exposing a CONFIG increase the testing matrix. How about declaring we are supporting/testing a given set of .config? On Arm it would be defconfig and tiny.
We could do this, sure, but it would end up being rather limiting at least on the x86 side.
Considering how frequently this is coming up, perhaps instead we should drop use of EXPERT mostly or altogether, and declare that we're willing to live with the fallout? We could document options or option combinations we specifically exclude from being supported then ...
Jan
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Hi Jan,
Quoted 46 lines · Jan Beulich
Quoted 45 lines · Julien Grall
Hi Jan,
Quoted 41 lines · Jan Beulich
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement CONFIG_HYPFS. I wanted to make it clear that even though I see value in having
CONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have
Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
Quoted 8 lines
Quoted 5 lines
I like the idea to have a more configurable Xen but this also comes at the expense of the testing/support.
At the moment, we are getting around the problem by gating the new config options with
CONFIG_EXPERT. I have stoppped counting the number of time I sweared because my config got rewritten when using 'make clean' or explain to someone else how to use it.As it stands,
CONFIG_EXPERTis unusable and most likely anything behind it will rot quite quickly. So if we want to add more stuff behind it, then I would suggest to make it more accessible so any developper can experiment with it.This complaint is not new; what I'm missing are concrete suggestions on how to improve the situation.
It is quite easy to improve, rather than specifying on the command line we could introduce a new Kconfig option so the user can select it normally.
This would not be very different compare to what Linux does.
Quoted 5 lines
Quoted 2 lines
Going forward, I would expect the embedded folks to want more part of Xen configurable. Requesting them to use
CONFIG_EXPERTmay be an issue as this means we would not security support them. At the same time, I understand that exposing a CONFIG increase the testing matrix. How about declaring we are supporting/testing a given set of .config? On Arm it would be defconfig and tiny.We could do this, sure, but it would end up being rather limiting at least on the x86 side.
It would not be worse than where we are today, right?
Quoted 6 lines
Considering how frequently this is coming up, perhaps instead we should drop use of EXPERT mostly or altogether, and declare that we're willing to live with the fallout? We could document options or option combinations we specifically exclude from being supported then ...
I would not suggest to remove EXPERT so far, just to make easier to use of EXPERT.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
In reply to Jan BeulichQuoted 36 lines · Jan Beulich
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement
CONFIG_HYPFS. I wanted to make it clear that even though I see value in havingCONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Quoted 9 lines
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have
Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
I think that’s a reasonable position to take, but needs to be balanced on the amount of work that this would actually require. If it only requires adding a handful of #ifdef’s and maybe making a few stubs, then yes, asking the submitter to make the change makes sense. But if it requires three dozen #ifdef’s throughout the code and a fairly major architectural change, then I think it’s reasonable for a submitter to push back.
I don’t really understand why Juergen thinks adding CONFIG_HYPFS would cause a lot of code churn; my argumentation here is based on the assumption that his assessment is correct.
-George
Re: [PATCH v7 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 46 lines · George Dunlap
Quoted 36 lines · Jan Beulich
Quoted 23 lines · George Dunlap
Quoted 16 lines · Jan Beulich
Quoted 1 line · George Dunlap
If Jan is OK with it simply being outside
CONFIG_EXPERT, then great. But if he insists on some kind of testing for it to be outside ofCONFIG_EXPERT, then again, the people who want it to be security supported should be the ones who do the work to make it happen.I don't understand this part, I'm afraid: Without a config option, the code is going to be security supported as long as it doesn't get marked otherwise (experimental or what not). With an option depending on EXPERT, what would become security unsupported is the non-default (i.e. disabled) setting. There's not a whole lot to test there, it's merely a formal consequence of our general rules. (Of course, over time dependencies of other code may develop on the information being available e.g. to Dom0 userland. Just like there's Linux userland code assuming the kernel config is available in certain ways [I don't necessarily mean the equivalent of hypfs here], to then use it in what I'd call abusive ways in at least some cases.)
Here’s an argument you might make:
“As a member of the security team, I don’t want to be on the hook for issuing XSAs for code which isn’t at least smoke-tested. Therefore, I oppose any patch adding
CONFIG_HYPFSoutside ofCONFIG_EXPERT, *unless* there is a concrete plan for getting regular testing forCONFIG_HYPFS=n.”I’m not saying that’s an argument you *should* make. But personally I don’t have a strong argument against such an argument. So, it seems to me, if you did make it, you have a reasonable chance of carrying your point.
Quoted 7 lines
Now consider this hypothetical universe where you made that argument and nobody opposed it. In order to get a particular feature (
CONFIG_HYPFS=nsecurity supported), there is extra work that needs to be done (gettingCONFIG_HYPFS=ntested regularly). My point was, the expectation should be that the extra work will be done by the people who want or benefit from the feature; the series shouldn’t be blocked until Juergen implementsCONFIG_HYPFS=ntesting (since he doesn’t personally have a stake in that feature).Now obviously, doing work to help someone else out in the community is of course a good thing to do; it builds goodwill, uses our aggregate resources more efficiently, and makes our community more enjoyable to work with. But the goodwill primarily comes from the fact that it was done as a voluntary choice, not as a requirement.
Juergen was balking at having to do what he saw as extra work to implement
CONFIG_HYPFS. I wanted to make it clear that even though I see value in havingCONFIG_HYPFS, *he* doesn’t have to do the work if he doesn’t want to (although it would certainly be appreciated if he did). And this paragraph was extending the same principle into the hypothetical universe where someone insisted thatCONFIG_HYPFS=nhad to be tested before being security supported.Hope that makes sense. :-)
Quoted 9 lines
Yes, it does, thanks for the clarification. I can see what you describe as a valid perspective to take, but really in my request to Jürgen I took another: Now that we have
Kconfig, additions of larger bodies of code (possibly also just in terms of binary size) should imo generally be questioned whether they want/need to be built for everyone. I.e. it is not to be left to people being worried about binary sizes to arrange for things to not be built, but for people contributing new but not entirely essential code to consider making it option from the very beginning.
Quoted 3 lines
I think that’s a reasonable position to take, but needs to be balanced on the amount of work that this would actually require. If it only requires adding a handful of #ifdef’s and maybe making a few stubs, then yes, asking the submitter to make the change makes sense. But if it requires three dozen #ifdef’s throughout the code and a fairly major architectural change, then I think it’s reasonable for a submitter to push back.
I don’t really understand why Juergen thinks adding
CONFIG_HYPFSwould cause a lot of code churn; my argumentation here is based on the assumption that his assessment is correct.
The main problem I'm seeing is the setting of runtime parameters.
This will need a complete different set of macros for defining those parameters, split across multiple patches. And I'm fairly sure I'll need to touch each custom_runtime_param handling function, too, in order not to add dead code.
Juergen
PATCH v7 9/12 xen: add runtime parameter access support to hypfs
In reply to Juergen GrossAdd support to read and modify values of hypervisor runtime parameters via the hypervisor file system.
As runtime parameters can be modified via a sysctl, too, this path has to take the hypfs rw_lock as writer.
For custom runtime parameters the connection between the parameter value and the file system is done via an init function which will set the initial value (if needed) and the leaf properties.
---
V3:
- complete rework
- support custom parameters, too
- support parameter writing
V6:
- rewording in docs/misc/hypfs-paths.pandoc (Jan Beulich)
- use memchr() (Jan Beulich)
- use strlcat() (Jan Beulich)
- rework to use a custom parameter init function instead of a reference to a content variable, allowing to drop default strings
- style correction (Jan Beulich)
- dropping param_append_str() in favor of a custom function at its only use site
V7:
- fine tune some parameter initializations (Jan Beulich)
- call custom_runtime_set_var() after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)
--- docs/misc/hypfs-paths.pandoc | 9 +++++ xen/arch/arm/xen.lds.S | 5 +++ xen/arch/x86/hvm/vmx/vmcs.c | 32 +++++++++++++++- xen/arch/x86/pv/domain.c | 21 ++++++++++- xen/arch/x86/xen.lds.S | 5 +++ xen/common/grant_table.c | 49 ++++++++++++++++++++----- xen/common/hypfs.c | 41 +++++++++++++++++++++ xen/common/kernel.c | 27 +++++++++++++- xen/drivers/char/console.c | 61 ++++++++++++++++++++++++++++--- xen/include/xen/hypfs.h | 4 ++ xen/include/xen/param.h | 87 ++++++++++++++++++++++++++++++++++++++++---- 11 files changed, 314 insertions(+), 27 deletions(-)
docs/misc/hypfs-paths.pandoc +9 -0
@@ -152,3 +152,12 @@ The major version of Xen. #### /buildinfo/version/minor = INTEGER The minor version of Xen. + +#### /params/ + +A directory of runtime parameters. + +#### /params/* + +The individual parameters. The description of the different parameters can be +found in `docs/misc/xen-command-line.pandoc`.
xen/arch/arm/xen.lds.S +5 -0
@@ -89,6 +89,11 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .; + + . = ALIGN(4); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .; *(.data.rel) *(.data.rel.*) CONSTRUCTORS
xen/arch/x86/hvm/vmx/vmcs.c +31 -1
@@ -70,6 +70,30 @@ integer_param("ple_window", ple_window);static bool __read_mostly opt_ept_pml = true;static s8 __read_mostly opt_ept_ad =-1 ;int8_t __read_mostly opt_ept_exec_sp =-1 ; +static char opt_ept_setting[24 ]; + +static void update_ept_param_append (const char *str,int val) +{ +char *pos = opt_ept_setting +strlen (opt_ept_setting); + +snprintf (pos,sizeof (opt_ept_setting) - (pos - opt_ept_setting), +",%s=%d" , str, val); +} + +static void update_ept_param (void ) +{ +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"pml=%d" , opt_ept_pml); +if ( opt_ept_ad >=0 ) +update_ept_param_append ("ad" , opt_ept_ad); +if ( opt_ept_exec_sp >=0 ) +update_ept_param_append ("exec-sp" , opt_ept_exec_sp); +} + +static void __init init_ept_param (struct param_hypfs *par) +{ +update_ept_param (); +custom_runtime_set_var (par, opt_ept_setting); +}static int __init parse_ept_param (const char *s) {
@@ -97,6 +121,9 @@ static int __init parse_ept_param(const char *s) }custom_param ("ept" , parse_ept_param); +static int parse_ept_param_runtime (const char *s); +custom_runtime_only_param ("ept" , parse_ept_param_runtime, init_ept_param); +static int parse_ept_param_runtime (const char *s) {struct domain *d;
@@ -115,6 +142,10 @@ static int parse_ept_param_runtime(const char *s) opt_ept_exec_sp = val; +update_ept_param (); +custom_runtime_set_var (param_2_parfs (parse_ept_param_runtime), + opt_ept_setting); +rcu_read_lock (&domlist_read_lock);for_each_domain ( d ) {
@@ -144,7 +175,6 @@ static int parse_ept_param_runtime(const char *s)return 0 ; } -custom_runtime_only_param ("ept" , parse_ept_param_runtime);/* Dynamic (run-time adjusted) execution control flags. */ u32 vmx_pin_based_exec_control__read_mostly ;
xen/arch/x86/pv/domain.c +19 -2
@@ -20,8 +20,23 @@ static __read_mostly enum {PCID_OFF ,PCID_ALL ,PCID_XPTI , - PCID_NOXPTI +PCID_NOXPTI , + PCID_END } opt_pcid =PCID_XPTI ; +static const char opt_pcid_2_string[PCID_END ][7 ] = { + [PCID_OFF ] ="off" , + [PCID_ALL ] ="on" , + [PCID_XPTI ] ="xpti" , + [PCID_NOXPTI ] ="noxpti" +}; + +static void __init opt_pcid_init (struct param_hypfs *par) +{ +custom_runtime_set_var (par, opt_pcid_2_string[opt_pcid]); +} + +static int parse_pcid (const char *s); +custom_runtime_param ("pcid" , parse_pcid, opt_pcid_init);static int parse_pcid (const char *s) {
@@ -55,9 +70,11 @@ static int parse_pcid(const char *s)break ; } +custom_runtime_set_var (param_2_parfs (parse_pcid), + opt_pcid_2_string[opt_pcid]); +return rc; } -custom_runtime_param ("pcid" , parse_pcid);static void noreturncontinue_nonidle_domain (struct vcpu *v) {
xen/arch/x86/xen.lds.S +5 -0
@@ -279,6 +279,11 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .; + + . = ALIGN(8); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .; } :text DECL_SECTION(.data) {
xen/common/grant_table.c +40 -9
76 lines not on this page · raw message
xen/common/hypfs.c +41 -0
56 lines not on this page · raw message
xen/common/kernel.c +26 -1
@@ -198,7 +198,13 @@ static void __init _cmdline_parse(const char *cmdline)int runtime_parse (const char *line) { -return parse_params (line, __param_start, __param_end); +int ret; + +hypfs_write_lock (); + ret =parse_params (line, __param_start, __param_end); +hypfs_write_unlock (); + +return ret; }/**
@@ -433,6 +439,25 @@ static int __init buildinfo_init(void) }__initcall (buildinfo_init); +static HYPFS_DIR_INIT(params, "params"); + +static int __init param_init (void ) +{ +struct param_hypfs *param; + +hypfs_add_dir (&hypfs_root, ¶ms, true); + +for ( param = __paramhypfs_start; param < __paramhypfs_end; param++ ) + { +if ( param->init_leaf ) + param->init_leaf (param); +hypfs_add_leaf (¶ms, ¶m->hypfs, true); + } + +return 0 ; +} +__initcall (param_init); +# define DO (fn) long do_##fn#endif
xen/drivers/char/console.c +55 -6
135 lines not on this page · raw message
xen/include/xen/hypfs.h +4 -0
@@ -112,5 +112,9 @@ int hypfs_write_leaf(struct hypfs_entry_leaf *leaf, XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen);int hypfs_write_bool (struct hypfs_entry_leaf *leaf,XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen); +int hypfs_write_custom (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen); +void hypfs_write_lock (void ); +void hypfs_write_unlock (void );#endif /* __XEN_HYPFS_H__ */
xen/include/xen/param.h +79 -8
136 lines not on this page · raw message
Signature · 1 line
2.16.4
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)
I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
Quoted 5 lines
docs/misc/hypfs-paths.pandoc +0
-0@@ -152,3 +152,12 @@ The major version of Xen. #### /buildinfo/version/minor = INTEGER
docs/misc/hypfs-paths.pandoc The major version of Xen. · line 163
Quoted 10 lines
docs/misc/hypfs-paths.pandoc +9
-0The minor version of Xen. + +#### /params/ + +A directory of runtime parameters. + +#### /params/* + +The individual parameters. The description of the different parameters can be +found in `docs/misc/xen-command-line.pandoc`.
Is .pandoc a useful specification here, or do such extensions get converted when rendering into different formats?
Quoted 11 lines
xen/arch/x86/hvm/vmx/vmcs.c +5
-0@@ -70,6 +70,30 @@ integer_param("ple_window", ple_window);static bool __read_mostly opt_ept_pml = true;static s8 __read_mostly opt_ept_ad =-1 ;int8_t __read_mostly opt_ept_exec_sp =-1 ; +static char opt_ept_setting[24 ]; + +static void update_ept_param_append (const char *str,int val) +{ +char *pos = opt_ept_setting +strlen (opt_ept_setting);
xen/arch/x86/hvm/vmx/vmcs.c integer_param("ple_window", ple_window); · line 87
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c +10
-0+ +snprintf (pos,sizeof (opt_ept_setting) - (pos - opt_ept_setting), +",%s=%d" , str, val); +} + +static void update_ept_param (void ) +{ +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"pml=%d" , opt_ept_pml); +if ( opt_ept_ad >=0 ) +update_ept_param_append ("ad" , opt_ept_ad);
With the new patch 1, is the if() here really still needed? Then again, only "exec-sp" is a runtime sub-parameter anyway afaict, and hence I'd expect only that part of the option should be displayed (I'm sorry for not having paid attention to this earlier).
Jan
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
Oh, how silly of me. Should be POINTER_ALIGN, of course.
Quoted 6 lines
Quoted 6 lines
docs/misc/hypfs-paths.pandoc +0
-0@@ -152,3 +152,12 @@ The major version of Xen. #### /buildinfo/version/minor = INTEGER
Quoted 13 lines
docs/misc/hypfs-paths.pandoc The major version of Xen. · line 163
Quoted 10 lines
docs/misc/hypfs-paths.pandoc +9
-0The minor version of Xen. + +#### /params/ + +A directory of runtime parameters. + +#### /params/* + +The individual parameters. The description of the different parameters can be +found in `docs/misc/xen-command-line.pandoc`.Is .pandoc a useful specification here, or do such extensions get converted when rendering into different formats?
I looked into xenstore-paths.pandoc and found references to other docs like pvcalls.pandoc. So I assumed it is fine this way.
Quoted 20 lines
Quoted 20 lines
xen/arch/x86/hvm/vmx/vmcs.c +13
-0@@ -70,6 +70,30 @@ integer_param("ple_window", ple_window);static bool __read_mostly opt_ept_pml = true;static s8 __read_mostly opt_ept_ad =-1 ;int8_t __read_mostly opt_ept_exec_sp =-1 ; +static char opt_ept_setting[24 ]; + +static void update_ept_param_append (const char *str,int val) +{ +char *pos = opt_ept_setting +strlen (opt_ept_setting); + +snprintf (pos,sizeof (opt_ept_setting) - (pos - opt_ept_setting), +",%s=%d" , str, val); +} + +static void update_ept_param (void ) +{ +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"pml=%d" , opt_ept_pml);
Quoted 8 lines
xen/arch/x86/hvm/vmx/vmcs.c integer_param("ple_window", ple_window); · line 87
Quoted 2 lines
xen/arch/x86/hvm/vmx/vmcs.c +2
-0+if ( opt_ept_ad >=0 ) +update_ept_param_append ("ad" , opt_ept_ad);With the new patch 1, is the
if()here really still needed? Then again, only "exec-sp" is a runtime sub-parameter anyway afaict, and hence I'd expect only that part of the option should be displayed (I'm sorry for not having paid attention to this earlier).
Oh, you are right. Will change it.
Juergen
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 11 lines · Jürgen Groß
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
We don't allow unaligned access on Arm32, so if your structure happen to have a 64-bit value in it then you will get a crash at runtime.
For safety, it should neither be POINTER_ALIGN or 4, but 8. This is going to make your linker more robust.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 13 lines · Julien Grall
Quoted 11 lines · Jürgen Groß
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
Quoted 4 lines
We don't allow unaligned access on Arm32, so if your structure happen to have a 64-bit value in it then you will get a crash at runtime.
For safety, it should neither be
POINTER_ALIGNor 4, but 8. This is going to make your linker more robust.
Would you mind explaining to me why POINTER_ALIGN would be wrong when the most strictly aligned field in a structure is a pointer?
Jan
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 14 lines · Jan Beulich
Quoted 13 lines · Julien Grall
Quoted 11 lines · Jürgen Groß
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
Quoted 7 lines
Quoted 4 lines
We don't allow unaligned access on Arm32, so if your structure happen to have a 64-bit value in it then you will get a crash at runtime.
For safety, it should neither be
POINTER_ALIGNor 4, but 8. This is going to make your linker more robust.Would you mind explaining to me why
POINTER_ALIGNwould be wrong when the most strictly aligned field in a structure is a pointer?
Both are valid with one difference though. If tomorrow someone send a patch to add a 64-bit in the structure, what are the chance one won't notice the alignment change? It is quite high.
If you align the section to 8, then you make your code more robust at the expense of possibly adding an extra 4-bytes in your binary.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 19 lines · Julien Grall
Quoted 16 lines · Jan Beulich
Quoted 15 lines · Julien Grall
Quoted 11 lines · Jürgen Groß
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
We don't allow unaligned access on Arm32, so if your structure happen to have a 64-bit value in it then you will get a crash at runtime.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
For safety, it should neither be
POINTER_ALIGNor 4, but 8. This is going to make your linker more robust.Would you mind explaining to me why
POINTER_ALIGNwould be wrong when the most strictly aligned field in a structure is a pointer?Both are valid with one difference though. If tomorrow someone send a patch to add a 64-bit in the structure, what are the chance one won't notice the alignment change? It is quite high.
Hmm, adjustments altering structure alignment that affect linker script correctness should imo always be accompanied by checking what the linker scripts has for the specific structure.
Quoted 2 lines
If you align the section to 8, then you make your code more robust at the expense of possibly adding an extra 4-bytes in your binary.
Well, you're the maintainer for Arm, so you've got to judge. I'd view things the other way around. Yes, it's less likely for even larger alignment requirements to get introduced, but why not be careful about these too and, say, align everything to PAGE_SIZE? IOW - where do you draw the line in a non-arbitrary way?
Jan
Re: [PATCH v7 09/12] xen: add runtime parameter access support to hypfs
Quoted 25 lines · Jan Beulich
Quoted 24 lines · Julien Grall
Quoted 21 lines · Jan Beulich
Quoted 13 lines · Julien Grall
Quoted 11 lines · Jürgen Groß
Quoted 10 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
V7:
- fine tune some parameter initializations (Jan Beulich)
- callcustom_runtime_set_var()after updating the value
- modify alignment in Arm linker script to 4 (Jan Beulich)I didn't ask for this to be unilaterally 4 - I don't think this would work on Arm64, seeing that there are pointers inside the struct. This wants to be pointer size, i.e. 4 for Arm32 but 8 for Arm64.
Quoted 4 lines
We don't allow unaligned access on Arm32, so if your structure happen to have a 64-bit value in it then you will get a crash at runtime.
For safety, it should neither be
POINTER_ALIGNor 4, but 8. This is going to make your linker more robust.Would you mind explaining to me why
POINTER_ALIGNwould be wrong when the most strictly aligned field in a structure is a pointer?
Quoted 7 lines
Quoted 3 lines
Both are valid with one difference though. If tomorrow someone send a patch to add a 64-bit in the structure, what are the chance one won't notice the alignment change? It is quite high.
Hmm, adjustments altering structure alignment that affect linker script correctness should imo always be accompanied by checking what the linker scripts has for the specific structure.
I agree with this, however this is theory. In practice, a contributor may not have noticed it and the reviewer may have overlooked it. So I prefer to make my life easier if the trade off is limited.
Quoted 6 lines
Quoted 3 lines
If you align the section to 8, then you make your code more robust at the expense of possibly adding an extra 4-bytes in your binary.
Well, you're the maintainer for Arm, so you've got to judge. I'd view things the other way around.
For me, review and maintenance are burden that needs to be decreased and not increased.
Quoted 4 lines
Yes, it's less likely for even
larger alignment requirements to get introduced, but why not be careful about these too and, say, align everything toPAGE_SIZE? IOW - where do you draw the line in a non-arbitrary way?
Most of decisions are arbitrary, some are more than other (e.g style).
We are down to the cost of alignment vs cost of maintenance/review longer term.
ldr/str on arm32 will request the address to be aligned to the size accessed. This will at most be 8. So by switching to 8, you remove most of the common unalignment fault.
You could use an higher alignment (such as PAGE_SIZE), but such structures are pretty limited and mostly used by the hardware. So the chance is the alignment will be correct from scratch.
Cheers,
Signature · 1 line
Julien Grall
PATCH v7 10/12 tools/libxl: use libxenhypfs for setting xen runtime parameters
In reply to Juergen GrossInstead of xc_set_parameters() use xenhypfs_write() for setting parameters of the hypervisor.
---
V6:
- new patch
--- tools/Rules.mk | 2 +- tools/libxl/Makefile | 3 ++- tools/libxl/libxl.c | 53 +++++++++++++++++++++++++++++++++++++++----- tools/libxl/libxl_internal.h | 1 + tools/libxl/xenlight.pc.in | 2 +- tools/xl/xl_misc.c | 1 - 6 files changed, 52 insertions(+), 10 deletions(-)
tools/Rules.mk +1 -1
@@ -180,7 +180,7 @@ CFLAGS += -O2 -fomit-frame-pointer endif CFLAGS_libxenlight = -I$(XEN_XENLIGHT) $(CFLAGS_libxenctrl) $(CFLAGS_xeninclude) -SHDEPS_libxenlight = $(SHLIB_libxenctrl) $(SHLIB_libxenstore) +SHDEPS_libxenlight = $(SHLIB_libxenctrl) $(SHLIB_libxenstore) $(SHLIB_libxenhypfs) LDLIBS_libxenlight = $(SHDEPS_libxenlight) $(XEN_XENLIGHT)/libxenlight$(libextension) SHLIB_libxenlight = $(SHDEPS_libxenlight) -Wl,-rpath-link=$(XEN_XENLIGHT)
tools/libxl/Makefile +2 -1
@@ -20,7 +20,7 @@ LIBUUID_LIBS += -luuid endif LIBXL_LIBS = -LIBXL_LIBS = $(LDLIBS_libxentoollog) $(LDLIBS_libxenevtchn) $(LDLIBS_libxenctrl) $(LDLIBS_libxenguest) $(LDLIBS_libxenstore) $(LDLIBS_libxentoolcore) $(PTYFUNCS_LIBS) $(LIBUUID_LIBS) +LIBXL_LIBS = $(LDLIBS_libxentoollog) $(LDLIBS_libxenevtchn) $(LDLIBS_libxenctrl) $(LDLIBS_libxenguest) $(LDLIBS_libxenhypfs) $(LDLIBS_libxenstore) $(LDLIBS_libxentoolcore) $(PTYFUNCS_LIBS) $(LIBUUID_LIBS) ifeq ($(CONFIG_LIBNL),y) LIBXL_LIBS += $(LIBNL3_LIBS) endif
@@ -33,6 +33,7 @@ CFLAGS_LIBXL += $(CFLAGS_libxentoolcore) CFLAGS_LIBXL += $(CFLAGS_libxenevtchn) CFLAGS_LIBXL += $(CFLAGS_libxenctrl) CFLAGS_LIBXL += $(CFLAGS_libxenguest) +CFLAGS_LIBXL += $(CFLAGS_libxenhypfs) CFLAGS_LIBXL += $(CFLAGS_libxenstore) ifeq ($(CONFIG_LIBNL),y) CFLAGS_LIBXL += $(LIBNL3_CFLAGS)
tools/libxl/libxl.c +47 -6
62 lines not on this page · raw message
tools/libxl/libxl_internal.h +1 -0
@@ -56,6 +56,7 @@#define XC_WANT_COMPAT_MAP_FOREIGN_API #include <xenctrl.h> #include <xenguest.h> +#include <xenhypfs.h> #include <xc_dom.h> #include <xen-tools/libs.h>
tools/libxl/xenlight.pc.in +1 -1
@@ -9,4 +9,4 @@ Description: The Xenlight library for Xen hypervisor Version: @@version@@ Cflags: -I${includedir} Libs: @@libsflag@@${libdir} -lxenlight -Requires.private: xentoollog,xenevtchn,xencontrol,xenguest,xenstore +Requires.private: xentoollog,xenevtchn,xencontrol,xenguest,xenstore,xenhypfs
tools/xl/xl_misc.c +0 -1
@@ -168,7 +168,6 @@ int main_set_parameters(int argc, char **argv)if (libxl_set_parameters (ctx, params)) {fprintf (stderr,"cannot set parameters: %s\n" , params); -fprintf (stderr,"Use \"xl dmesg\" to look for possible reason.\n" );return EXIT_FAILURE ; }
Signature · 1 line
2.16.4
PATCH v7 11/12 tools/libxc: remove xc_set_parameters()
In reply to Juergen GrossThere is no user of xc_set_parameters() left, so remove it.
---
V6:
- new patch
--- tools/libxc/include/xenctrl.h | 1 - tools/libxc/xc_misc.c | 21 --------------------- 2 files changed, 22 deletions(-)
tools/libxc/include/xenctrl.h +0 -1
@@ -1226,7 +1226,6 @@ int xc_readconsolering(xc_interface *xch, int clear, int incremental, uint32_t *pindex);int xc_send_debug_keys (xc_interface *xch,const char *keys); -int xc_set_parameters (xc_interface *xch,const char *params);typedef struct xen_sysctl_physinfo xc_physinfo_t ;typedef struct xen_sysctl_cputopo xc_cputopo_t ;
tools/libxc/xc_misc.c +0 -21
@@ -187,27 +187,6 @@ int xc_send_debug_keys(xc_interface *xch, const char *keys)return ret; } -int xc_set_parameters (xc_interface *xch,const char *params) -{ -int ret, len =strlen (params); -DECLARE_SYSCTL ; -DECLARE_HYPERCALL_BOUNCE_IN (params, len); - -if (xc_hypercall_bounce_pre (xch, params) ) -return -1 ; - - sysctl.cmd = XEN_SYSCTL_set_parameter; -set_xen_guest_handle (sysctl.u.set_parameter.params, params); - sysctl.u.set_parameter.size = len; -memset (sysctl.u.set_parameter.pad,0 ,sizeof (sysctl.u.set_parameter.pad)); - - ret =do_sysctl (xch, &sysctl); - -xc_hypercall_bounce_post (xch, params); - -return ret; -} -int xc_physinfo (xc_interface *xch,xc_physinfo_t *put_info) {
Signature · 1 line
2.16.4
PATCH v7 12/12 xen: remove XEN_SYSCTL_set_parameter support
In reply to Juergen GrossThe functionality of XEN_SYSCTL_set_parameter is available via hypfs now, so it can be removed.
This allows to remove the kernel_param structure for runtime parameters by putting the now only used structure element into the hypfs node structure of the runtime parameters.
---
V6:
- new patch
V7:
- only comment out definition of XEN_SYSCTL_set_parameter (Jan Beulich)
--- tools/flask/policy/modules/dom0.te | 2 +- xen/arch/arm/xen.lds.S | 5 ---- xen/arch/x86/xen.lds.S | 5 ---- xen/common/hypfs.c | 12 +-------- xen/common/kernel.c | 11 -------- xen/common/sysctl.c | 36 -------------------------- xen/include/public/sysctl.h | 19 +------------- xen/include/xen/hypfs.h | 2 -- xen/include/xen/lib.h | 1 - xen/include/xen/param.h | 50 +++++++------------------------------ xen/xsm/flask/hooks.c | 3 --- xen/xsm/flask/policy/access_vectors | 2 -- 12 files changed, 12 insertions(+), 136 deletions(-)
tools/flask/policy/modules/dom0.te +1 -1
@@ -16,7 +16,7 @@ allow dom0_t xen_t:xen { allow dom0_t xen_t:xen2 { resource_op psr_cmt_op psr_alloc pmu_ctrl get_symbol get_cpu_levelling_caps get_cpu_featureset livepatch_op - coverage_op set_parameter + coverage_op }; # Allow dom0 to use all XENVER_ subops that have checks.
xen/arch/arm/xen.lds.S +0 -5
@@ -54,11 +54,6 @@ SECTIONS *(.data.rel.ro) *(.data.rel.ro.*) - . = ALIGN(POINTER_ALIGN); - __param_start = .; - *(.data.param) - __param_end = .; - __proc_info_start = .; *(.proc.info) __proc_info_end = .;
xen/arch/x86/xen.lds.S +0 -5
@@ -128,11 +128,6 @@ SECTIONS *(.ex_table.pre) __stop___pre_ex_table = .; - . = ALIGN(POINTER_ALIGN); - __param_start = .; - *(.data.param) - __param_end = .; - #if defined(CONFIG_HAS_VPCI) && defined(CONFIG_LATE_HWDOM) . = ALIGN(POINTER_ALIGN); __start_vpci_array = .;
xen/common/hypfs.c +1 -11
@@ -300,7 +300,7 @@ int hypfs_write_custom(struct hypfs_entry_leaf *leaf, goto out; p = container_of(leaf, struct param_hypfs, hypfs); - ret = p->param->par.func (buf); + ret = p->func (buf);if ( !ret ) leaf->e.size = ulen;
@@ -379,13 +379,3 @@ long do_hypfs_op(unsigned int cmd,return ret; } - -void hypfs_write_lock (void ) -{ -write_lock (&hypfs_lock); -} - -void hypfs_write_unlock (void ) -{ -write_unlock (&hypfs_lock); -}
xen/common/kernel.c +0 -11
@@ -196,17 +196,6 @@ static void __init _cmdline_parse(const char *cmdline)parse_params (cmdline, __setup_start, __setup_end); } -int runtime_parse (const char *line) -{ -int ret; - -hypfs_write_lock (); - ret =parse_params (line, __param_start, __param_end); -hypfs_write_unlock (); - -return ret; -} -/** * cmdline_parse -- parses the xen command line. * If CONFIG_CMDLINE is set, it would be parsed prior to @cmdline.
xen/common/sysctl.c +0 -36
@@ -471,42 +471,6 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) copyback =1 ;break ; -case XEN_SYSCTL_set_parameter: - { -#define XEN_SET_PARAMETER_MAX_SIZE 1023 -char *params; - -if ( op->u.set_parameter.pad[0 ] || op->u.set_parameter.pad[1 ] || - op->u.set_parameter.pad[2 ] ) - { - ret = -EINVAL ; -break ; - } -if ( op->u.set_parameter.size >XEN_SET_PARAMETER_MAX_SIZE ) - { - ret = -E2BIG ; -break ; - } - params =xmalloc_bytes (op->u.set_parameter.size +1 ); -if ( !params ) - { - ret = -ENOMEM ; -break ; - } -if (copy_from_guest (params, op->u.set_parameter.params, - op->u.set_parameter.size) ) - ret = -EFAULT ; -else - { - params[op->u.set_parameter.size] =0 ; - ret =runtime_parse (params); - } - -xfree (params); - -break ; - } -default : ret =arch_do_sysctl (op, u_sysctl); copyback =0 ;
xen/include/public/sysctl.h +1 -18
@@ -1026,22 +1026,6 @@ struct xen_sysctl_livepatch_op { } u; }; -/* -* XEN_SYSCTL_set_parameter -* -* Change hypervisor parameters at runtime. -* The input string is parsed similar to the boot parameters. -* Parameters are a single string terminated by a NUL byte of max. size -* characters. Multiple settings can be specified by separating them -* with blanks. -*/ - -struct xen_sysctl_set_parameter { -XEN_GUEST_HANDLE_64 (const_char) params;/* IN: pointer to parameters. */ -uint16_t size;/* IN: size of parameters. */ -uint16_t pad[3 ];/* IN: MUST be zero. */ -}; -#if defined(__i386__) || defined(__x86_64__)/* * XEN_SYSCTL_get_cpu_policy (x86 specific)
@@ -1106,7 +1090,7 @@ struct xen_sysctl {#define XEN_SYSCTL_get_cpu_levelling_caps 25#define XEN_SYSCTL_get_cpu_featureset 26#define XEN_SYSCTL_livepatch_op 27 -#define XEN_SYSCTL_set_parameter 28 +/* #define XEN_SYSCTL_set_parameter 28 */ #define XEN_SYSCTL_get_cpu_policy 29uint32_t interface_version;/* XEN_SYSCTL_INTERFACE_VERSION */ union {
@@ -1135,7 +1119,6 @@ struct xen_sysctl {struct xen_sysctl_cpu_levelling_caps cpu_levelling_caps;struct xen_sysctl_cpu_featureset cpu_featureset;struct xen_sysctl_livepatch_op livepatch; -struct xen_sysctl_set_parameter set_parameter;#if defined(__i386__) || defined(__x86_64__)struct xen_sysctl_cpu_policy cpu_policy;#endif
xen/include/xen/hypfs.h +0 -2
@@ -114,7 +114,5 @@ int hypfs_write_bool(struct hypfs_entry_leaf *leaf, XEN_GUEST_HANDLE_PARAM(void) uaddr, unsigned long ulen);int hypfs_write_custom (struct hypfs_entry_leaf *leaf,XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen); -void hypfs_write_lock (void ); -void hypfs_write_unlock (void );#endif /* __XEN_HYPFS_H__ */
xen/include/xen/lib.h +0 -1
@@ -75,7 +75,6 @@struct domain ;void cmdline_parse (const char *cmdline); -int runtime_parse (const char *line);int parse_bool (const char *s,const char *e);/**
xen/include/xen/param.h +9 -41
102 lines not on this page · raw message
xen/xsm/flask/hooks.c +0 -3
@@ -821,9 +821,6 @@ static int flask_sysctl(int cmd)case XEN_SYSCTL_coverage_op:return avc_current_has_perm (SECINITSID_XEN ,SECCLASS_XEN2 ,XEN2__COVERAGE_OP ,NULL ); -case XEN_SYSCTL_set_parameter: -return avc_current_has_perm (SECINITSID_XEN ,SECCLASS_XEN2 , -XEN2__SET_PARAMETER ,NULL );default :return avc_unknown_permission ("sysctl" , cmd);
xen/xsm/flask/policy/access_vectors +0 -2
@@ -99,8 +99,6 @@ class xen2 livepatch_op # XEN_SYSCTL_coverage_op coverage_op -# XEN_SYSCTL_set_parameter - set_parameter } # Classes domain and domain2 consist of operations that a domain performs on
Signature · 1 line
2.16.4