Add hypervisor sysfs-like support
v8 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 V8:
- addressed review comments
- added CONFIG_HYPFS config option
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 | 165 +++++++++ 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 | 90 +++++ 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 | 3 + xen/arch/arm/xen.lds.S | 12 +- xen/arch/x86/hvm/hypercall.c | 3 + xen/arch/x86/hvm/vmx/vmcs.c | 47 ++- xen/arch/x86/hvm/vmx/vmx.c | 4 +- xen/arch/x86/hypercall.c | 3 + xen/arch/x86/pv/domain.c | 24 +- xen/arch/x86/pv/hypercall.c | 3 + xen/arch/x86/xen.lds.S | 12 +- xen/common/Kconfig | 22 ++ xen/common/Makefile | 13 + xen/common/grant_table.c | 62 +++- xen/common/hypfs.c | 385 ++++++++++++++++++++ xen/common/kernel.c | 82 ++++- xen/common/sysctl.c | 36 -- xen/drivers/char/console.c | 77 +++- 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 | 10 + xen/include/xen/hypfs.h | 124 +++++++ xen/include/xen/kernel.h | 3 + xen/include/xen/lib.h | 1 - xen/include/xen/param.h | 123 +++++-- 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, 2379 insertions(+), 190 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.26.1
PATCH v8 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 ); + + 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
@@ -2482,7 +2482,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 ;
@@ -2553,8 +2553,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.26.1
PATCH v8 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
@@ -314,6 +314,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
@@ -39,6 +39,9 @@ $(subst include/,%/,$(AV_H_FILES)): $(AV_H_DEPEND) $(mkaccess) FORCE 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)
@@ -48,4 +51,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.26.1
PATCH v8 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)
V8:
- clarify syntax used in hypfs-paths.pandoc (George Dunlap)
--- docs/features/hypervisorfs.pandoc | 92 +++++++++++++++++++++++++ docs/misc/hypfs-paths.pandoc | 107 ++++++++++++++++++++++++++++++ 2 files changed, 199 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 +107 -0
107 lines not on this page · raw message
Signature · 1 line
2.26.1
PATCH v8 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.
---
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)
V8:
- add Kconfig item CONFIG_HYPFS (Jan Beulich)
- init write pointer in HYPFS_*_INIT_WRITABLE() (Jan Beulich)
- expand write ASSERT()s (Jan Beulich)
--- tools/flask/policy/modules/dom0.te | 2 +- xen/arch/arm/traps.c | 3 + xen/arch/x86/hvm/hypercall.c | 3 + xen/arch/x86/hypercall.c | 3 + xen/arch/x86/pv/hypercall.c | 3 + xen/common/Kconfig | 11 + xen/common/Makefile | 1 + xen/common/hypfs.c | 354 ++++++++++++++++++++++++++++ xen/include/Makefile | 1 + xen/include/public/hypfs.h | 127 ++++++++++ xen/include/public/xen.h | 1 + xen/include/xen/hypercall.h | 10 + xen/include/xen/hypfs.h | 122 ++++++++++ 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 + 19 files changed, 663 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 +3 -0
@@ -1381,6 +1381,9 @@ static arm_hypercall_t arm_hypercall_table[] = {#ifdef CONFIG_ARGO HYPERCALL(argo_op, 5),#endif +#ifdef CONFIG_HYPFS + HYPERCALL(hypfs_op, 5), +#endif };#ifndef NDEBUG
xen/arch/x86/hvm/hypercall.c +3 -0
@@ -150,6 +150,9 @@ static const hypercall_table_t hvm_hypercall_table[] = {#endif HYPERCALL (xenpmu_op),COMPAT_CALL (dm_op ), +#ifdef CONFIG_HYPFS +HYPERCALL (hypfs_op ), +#endifHYPERCALL (arch_1 ) };
xen/arch/x86/hypercall.c +3 -0
@@ -72,6 +72,9 @@ const hypercall_args_t hypercall_args_table[NR_hypercalls] =#ifdef CONFIG_HVM ARGS(hvm_op, 2), ARGS(dm_op, 3), +#endif +#ifdef CONFIG_HYPFS +ARGS (hypfs_op,5 ), #endifARGS (mca,1 ), ARGS(arch_1, 1),
xen/arch/x86/pv/hypercall.c +3 -0
@@ -84,6 +84,9 @@ const hypercall_table_t pv_hypercall_table[] = {#ifdef CONFIG_HVM HYPERCALL(hvm_op), COMPAT_CALL(dm_op), +#endif +#ifdef CONFIG_HYPFS +HYPERCALL (hypfs_op), #endifHYPERCALL (mca), HYPERCALL(arch_1),
xen/common/Kconfig +11 -0
@@ -116,6 +116,17 @@ config SPECULATIVE_HARDEN_BRANCH endmenu +config HYPFS + bool "Hypervisor file system support" + default y + ---help--- + Support Xen hypervisor file system. This file system is used to + present various hypervisor internal data to dom0 and in some + cases to allow modifying settings. Disabling the support might + result in some features not being available. + + If unsure, say Y. + config KEXEC bool "kexec support" default y
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-$(CONFIG_HYPFS) += 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 +354 -0
354 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 +10 -0
@@ -150,6 +150,16 @@ do_dm_op( unsigned int nr_bufs, XEN_GUEST_HANDLE_PARAM(xen_dm_op_buf_t) bufs); +#ifdef CONFIG_HYPFS +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); +#endif +#ifdef CONFIG_COMPAT extern int
xen/include/xen/hypfs.h new file +122 -0
122 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
@@ -1173,6 +1173,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 );
@@ -1812,6 +1817,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.26.1
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
xen/common/Makefile obj-y += domain.o · line 16
Quoted 10 lines · Juergen Gross
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-$(CONFIG_HYPFS) += hypfs.o obj-$(CONFIG_CRASH_DEBUG) += gdbstub.o obj-$(CONFIG_GRANT_TABLE) += grant_table.o obj-y += guestcopy.o
I guess I could/should have noticed this earlier - this isn't the correct insertion point, considering that we try to keep these alphabetically sorted.
Quoted 18 lines
xen/common/Makefile +18
-0+static struct hypfs_entry *hypfs_get_entry_rel(struct hypfs_entry_dir *dir, + const char *path) +{ + const char *end; + struct hypfs_entry *entry; + unsigned int name_len; + + if ( dir->e.type != XEN_HYPFS_TYPE_DIR ) + return NULL; + + if ( !*path ) + return &dir->e; + + end = strchr(path, '/'); + if ( !end ) + end = strchr(path, '\0'); + name_len = end - path; +
xen/common/Makefile
Quoted 10 lines
xen/common/Makefile +10
-0+ list_for_each_entry ( entry, &dir->dirlist, list ) + { + int cmp = strncmp(path, entry->name, name_len); + struct hypfs_entry_dir *d = container_of(entry, + struct hypfs_entry_dir, e); + + if ( cmp < 0 ) + return NULL; + if ( !cmp && strlen(entry->name) == name_len ) + return *end ? hypfs_get_entry_rel(d, end + 1) : entry;
The compiler may translate this into a tail call, but shouldn't we be worried about the nesting depth in case it doesn't? Perhaps this doesn't need addressing here, but rather by limiting the depth at which new entries can be created?
xen/common/Makefile
Quoted 10 lines
xen/common/Makefile +10
-0+int hypfs_read_dir(const struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr) +{ + const struct hypfs_entry_dir *d; + const struct hypfs_entry *e; + unsigned int size = entry->size; + + d = container_of(entry, const struct hypfs_entry_dir, e); + + list_for_each_entry ( e, &d->dirlist, list )
This function, in particular because of being non-static, makes me wonder how, with add_entry() taking a lock, it can be safe without any locking. Initially I thought the justification might be because all adding of entries is an init-time-only thing, but various involved functions aren't marked __init (and it is at least not implausible that down the road we might see new entries getting added during certain hotplug operations).
I do realize that do_hypfs_op() takes the necessary read lock, but then you're still building on the assumption that the function is reachable through only that code path, despite being non-static. An ASSERT() here would be the minimum I guess, but with read locks now being recursive I don't see why you couldn't read-lock here again.
The same goes for other non-static functions, albeit things may become more interesting for functions living on the XEN_HYPFS_OP_write_contents path (because write locks aren't recursive [yet]). I notice even hypfs_get_entry() is non-static, albeit I can't see why that is (perhaps a later patch needs it).
xen/common/Makefile
Quoted 9 lines
xen/common/Makefile +9
-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;
hypfs_write() checks ulen against max_size, but the function being non-static makes me once again wonder whether at the very leaset an ASSERT() wouldn't be wanted here.
xen/common/Makefile
Quoted 12 lines
xen/common/Makefile +12
-0+ 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;
How does this check play with gzip-ed strings?
xen/common/Makefile
Quoted 13 lines
xen/common/Makefile +13
-0+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) +{ + int ret; + struct hypfs_entry *entry; + static char path[XEN_HYPFS_MAX_PATHLEN]; + + if ( xsm_hypfs_op(XSM_PRIV) ) + return -EPERM; + + if ( cmd == XEN_HYPFS_OP_get_version ) + return XEN_HYPFS_VERSION;
Check that all args are zero/null for this sub-op, to allow future extension?
xen/common/Makefile
Quoted 11 lines
xen/common/Makefile +11
-0+#define HYPFS_FIXEDSIZE_INIT(var, typ, nam, contvar, wr) \ + struct hypfs_entry_leaf __read_mostly var = { \ + .e.type = typ, \ + .e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .e.name = nam, \ + .e.size = sizeof(contvar), \ + .e.max_size = wr ? sizeof(contvar) : 0, \ + .e.read = hypfs_read_leaf, \ + .e.write = wr, \ + .content = &contvar, \ + }
At the example of this, some of the macros look like they want parentheses added around uses of some of their parameters.
Jan
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
Quoted 15 lines · Jan Beulich
xen/common/Makefile obj-y += domain.o · line 16
Quoted 10 lines · Juergen Gross
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-$(CONFIG_HYPFS) += hypfs.o obj-$(CONFIG_CRASH_DEBUG) += gdbstub.o obj-$(CONFIG_GRANT_TABLE) += grant_table.o obj-y += guestcopy.oI guess I could/should have noticed this earlier - this isn't the correct insertion point, considering that we try to keep these alphabetically sorted.
Oh, the placement seems to be leftover from an early version when the file was named fs.c or so.
Quoted 26 lines
Quoted 26 lines
xen/common/Makefile +25
-0+static struct hypfs_entry *hypfs_get_entry_rel(struct hypfs_entry_dir *dir, + const char *path) +{ + const char *end; + struct hypfs_entry *entry; + unsigned int name_len; + + if ( dir->e.type != XEN_HYPFS_TYPE_DIR ) + return NULL; + + if ( !*path ) + return &dir->e; + + end = strchr(path, '/'); + if ( !end ) + end = strchr(path, '\0'); + name_len = end - path; + + list_for_each_entry ( entry, &dir->dirlist, list ) + { + int cmp = strncmp(path, entry->name, name_len); + struct hypfs_entry_dir *d = container_of(entry, + struct hypfs_entry_dir, e); + + if ( cmp < 0 )
Quoted 8 lines
xen/common/Makefile
Quoted 3 lines
xen/common/Makefile +3
-0+ return NULL; + if ( !cmp && strlen(entry->name) == name_len ) + return *end ? hypfs_get_entry_rel(d, end + 1) : entry;The compiler may translate this into a tail call, but shouldn't we be worried about the nesting depth in case it doesn't? Perhaps this doesn't need addressing here, but rather by limiting the depth at which new entries can be created?
Hmm, it should be possible to solve this without recursion. I'll have a try.
Quoted 20 lines
xen/common/Makefile
Quoted 11 lines
xen/common/Makefile +10
-0+int hypfs_read_dir(const struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr) +{ + const struct hypfs_entry_dir *d; + const struct hypfs_entry *e; + unsigned int size = entry->size; + + d = container_of(entry, const struct hypfs_entry_dir, e); + + list_for_each_entry ( e, &d->dirlist, list )This function, in particular because of being non-static, makes me wonder how, with
add_entry()taking a lock, it can be safe without any locking. Initially I thought the justification might be because all adding of entries is an init-time-only thing, but various involved functions aren't marked__init(and it is at least not implausible that down the road we might see new entries getting added during certain hotplug operations).
Quoted 6 lines
I do realize that
do_hypfs_op()takes the necessary read lock, but then you're still building on the assumption that the function is reachable through only that code path, despite being non-static. AnASSERT()here would be the minimum I guess, but with read locks now being recursive I don't see why you couldn't read-lock here again.
Right, will add the read-lock.
Quoted 4 lines
The same goes for other non-static functions, albeit things may become more interesting for functions living on the
XEN_HYPFS_OP_write_contentspath (because write locks aren't
Adding an ASSERT() in this regard should be rather easy.
Quoted 2 lines
recursive [yet]). I notice even
hypfs_get_entry()is non-static, albeit I can't see why that is (perhaps a later patch needs it).
No need for non-static, will change to static.
Quoted 14 lines
xen/common/Makefile
Quoted 10 lines
xen/common/Makefile +9
-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;
hypfs_write()checks ulen againstmax_size, but the function being non-static makes me once again wonder whether at the very leaset anASSERT()wouldn't be wanted here.
Okay.
Quoted 15 lines
xen/common/Makefile
Quoted 13 lines
xen/common/Makefile +12
-0+ 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;How does this check play with gzip-ed strings?
Hmm, right, will add a check for XEN_HYPFS_ENC_PLAIN.
Quoted 17 lines
Quoted 4 lines
xen/common/Makefile +3
-0+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)xen/common/Makefile
Quoted 10 lines
xen/common/Makefile +10
-0+{ + int ret; + struct hypfs_entry *entry; + static char path[XEN_HYPFS_MAX_PATHLEN]; + + if ( xsm_hypfs_op(XSM_PRIV) ) + return -EPERM; + + if ( cmd == XEN_HYPFS_OP_get_version ) + return XEN_HYPFS_VERSION;Check that all args are zero/null for this sub-op, to allow future extension?
Yes, good idea.
Quoted 13 lines
xen/common/Makefile
Quoted 12 lines
xen/common/Makefile +11
-0+#define HYPFS_FIXEDSIZE_INIT(var, typ, nam, contvar, wr) \ + struct hypfs_entry_leaf __read_mostly var = { \ + .e.type = typ, \ + .e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .e.name = nam, \ + .e.size = sizeof(contvar), \ + .e.max_size = wr ? sizeof(contvar) : 0, \ + .e.read = hypfs_read_leaf, \ + .e.write = wr, \ + .content = &contvar, \ + }
Quoted 2 lines
At the example of this, some of the macros look like they want parentheses added around uses of some of their parameters.
Hmm, which ones? As I've understood from previous patch reviews by you you only want those parameters with parantheses where they are really needed.
- var is a plain variable, so no parantheses
- typ _should_ be a XEN_HYPFS_TYPE_* define, so probably no parantheses (its usage in the macro doesn't call for using parantheses anyway)
- nam might be a candidate, but I can't come up with a reason to put it in parantheses here
- contvar has to be a variable (otherwise sizeof(contvar) wouldn't work), so no parantheses
- wr is a function pointer or NULL, so no parantheses
Juergen
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
Quoted 21 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
Quoted 11 lines · Juergen Gross
+#define
HYPFS_FIXEDSIZE_INIT(var, typ, nam, contvar, wr)\
+ structhypfs_entry_leaf__read_mostlyvar = { \
+ .e.type = typ, \
+ .e.encoding = XEN_HYPFS_ENC_PLAIN, \
+ .e.name = nam, \
+ .e.size = sizeof(contvar), \
+ .e.max_size = wr ? sizeof(contvar) : 0, \
+ .e.read = hypfs_read_leaf, \
+ .e.write = wr, \
+ .content = &contvar, \
+ }Quoted 2 lines
At the example of this, some of the macros look like they want parentheses added around uses of some of their parameters.
Hmm, which ones? As I've understood from previous patch reviews by you you only want those parameters with parantheses where they are really needed.
Quoted 8 lines
- var is a plain variable, so no parantheses
- typ _should_ be a XEN_HYPFS_TYPE_* define, so probably no parantheses (its usage in the macro doesn't call for using parantheses anyway)
- nam might be a candidate, but I can't come up with a reason to put it in parantheses here
- contvar has to be a variable (otherwise sizeof(contvar) wouldn't work), so no parantheses
- wr is a function pointer or NULL, so no parantheses
You have a point for uses as initializers, as there's no lower precedence operator than the assignment ones except comma, which would need parenthesizing in the macro invocation already. However, I disagree on what you say about contvar and wr - contvar is expected, but not required to be just an identifier. And wr in turn is expected but not required to by an identifier or NULL. I.e. the respective two lines where I think parentheses can't be avoided are
.e.max_size = (wr) ? sizeof(contvar) : 0,
and
.content = &(contvar),
.
Jan
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
Quoted 40 lines · Jan Beulich
Quoted 21 lines · Jürgen Groß
Quoted 13 lines · Jan Beulich
Quoted 11 lines · Juergen Gross
+#define
HYPFS_FIXEDSIZE_INIT(var, typ, nam, contvar, wr)\
+ structhypfs_entry_leaf__read_mostlyvar = { \
+ .e.type = typ, \
+ .e.encoding = XEN_HYPFS_ENC_PLAIN, \
+ .e.name = nam, \
+ .e.size = sizeof(contvar), \
+ .e.max_size = wr ? sizeof(contvar) : 0, \
+ .e.read = hypfs_read_leaf, \
+ .e.write = wr, \
+ .content = &contvar, \
+ }Quoted 2 lines
At the example of this, some of the macros look like they want parentheses added around uses of some of their parameters.
Hmm, which ones? As I've understood from previous patch reviews by you you only want those parameters with parantheses where they are really needed.
Quoted 8 lines
- var is a plain variable, so no parantheses
- typ _should_ be a XEN_HYPFS_TYPE_* define, so probably no parantheses (its usage in the macro doesn't call for using parantheses anyway)
- nam might be a candidate, but I can't come up with a reason to put it in parantheses here
- contvar has to be a variable (otherwise sizeof(contvar) wouldn't work), so no parantheses
- wr is a function pointer or NULL, so no paranthesesYou have a point for uses as initializers, as there's no lower precedence operator than the assignment ones except comma, which would need parenthesizing in the macro invocation already. However, I disagree on what you say about contvar and wr - contvar is expected, but not required to be just an identifier. And wr in turn is expected but not required to by an identifier or NULL. I.e. the respective two lines where I think parentheses can't be avoided are
Quoted 5 lines
.e.max_size = (wr) ? sizeof(contvar) : 0,and
.content = &(contvar),
Okay.
Juergen
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
In reply to Jürgen GroßQuoted 28 lines · Jürgen Groß
Quoted 20 lines · Jan Beulich
xen/common/hypfs.c line 163
Quoted 10 lines · Juergen Gross
xen/common/hypfs.c new file +10
-0+int hypfs_read_dir (const struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr) +{ + const struct hypfs_entry_dir *d; + const struct hypfs_entry *e; + unsigned int size = entry->size; + + d = container_of(entry, const struct hypfs_entry_dir, e); + + list_for_each_entry ( e, &d->dirlist, list )This function, in particular because of being non-static, makes me wonder how, with
add_entry()taking a lock, it can be safe without any locking. Initially I thought the justification might be because all adding of entries is an init-time-only thing, but various involved functions aren't marked__init(and it is at least not implausible that down the road we might see new entries getting added during certain hotplug operations).Quoted 6 lines
I do realize that
do_hypfs_op()takes the necessary read lock, but then you're still building on the assumption that the function is reachable through only that code path, despite being non-static. AnASSERT()here would be the minimum I guess, but with read locks now being recursive I don't see why you couldn't read-lock here again.
Quoted 8 lines
Right, will add the read-lock.
Quoted 4 lines
The same goes for other non-static functions, albeit things may become more interesting for functions living on the
XEN_HYPFS_OP_write_contentspath (because write locks aren'tAdding an
ASSERT()in this regard should be rather easy.
As the type specific read- and write-functions should only be called through the generic read/write functions I think it is better to have a percpu variable holding the current locking state and ASSERT() that to match. This will be cheaper than nesting locks and I don't have to worry about either write_lock nesting or making _is_write_locked_by_me() an official interface.
Juergen
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
Quoted 36 lines · Jürgen Groß
Quoted 35 lines · Jürgen Groß
Quoted 20 lines · Jan Beulich
xen/common/hypfs.c line 163
Quoted 10 lines · Juergen Gross
xen/common/hypfs.c new file +10
-0+int hypfs_read_dir (const struct hypfs_entry *entry, + XEN_GUEST_HANDLE_PARAM(void) uaddr) +{ + const struct hypfs_entry_dir *d; + const struct hypfs_entry *e; + unsigned int size = entry->size; + + d = container_of(entry, const struct hypfs_entry_dir, e); + + list_for_each_entry ( e, &d->dirlist, list )This function, in particular because of being non-static, makes me wonder how, with
add_entry()taking a lock, it can be safe without any locking. Initially I thought the justification might be because all adding of entries is an init-time-only thing, but various involved functions aren't marked__init(and it is at least not implausible that down the road we might see new entries getting added during certain hotplug operations).Quoted 6 lines
I do realize that
do_hypfs_op()takes the necessary read lock, but then you're still building on the assumption that the function is reachable through only that code path, despite being non-static. AnASSERT()here would be the minimum I guess, but with read locks now being recursive I don't see why you couldn't read-lock here again.Right, will add the read-lock.
Quoted 4 lines
The same goes for other non-static functions, albeit things may become more interesting for functions living on the
XEN_HYPFS_OP_write_contentspath (because write locks aren't
Quoted 8 lines
Quoted 1 line
Adding an
ASSERT()in this regard should be rather easy.As the type specific read- and write-functions should only be called through the generic read/write functions I think it is better to have a percpu variable holding the current locking state and
ASSERT()that to match. This will be cheaper than nesting locks and I don't have to worry about eitherwrite_locknesting or making_is_write_locked_by_me()an official interface.
Ah yes, this should do.
Jan
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
In reply to Juergen GrossQuoted 8 lines · Juergen Gross
xen/include/xen/hypfs.h new file +5
-0@@ -0,0 +1,122 @@ +#ifndef __XEN_HYPFS_H__ +#define __XEN_HYPFS_H__ + +#ifdef CONFIG_HYPFS +#include <xen/list.h>
xen/include/xen/hypfs.h line 15
Quoted 10 lines
xen/include/xen/hypfs.h new file +10
-0+#include <xen/string.h> +#include <public/hypfs.h> + +struct hypfs_entry_leaf ; + +struct hypfs_entry { +unsigned short type; +unsigned short encoding; +unsigned int size; +unsigned int max_size;
Btw with these, ...
xen/include/xen/hypfs.h line 21
Quoted 6 lines
xen/include/xen/hypfs.h new file +6
-0+const char *name; +struct list_head list; +int (*read)(const struct hypfs_entry *entry, +XEN_GUEST_HANDLE_PARAM (void ) uaddr); +int (*write)(struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen);
... why unsigned long here (noticed while looking at patch 9)?
Jan
Re: [PATCH v8 04/12] xen: add basic hypervisor filesystem support
Quoted 22 lines · Jan Beulich
Quoted 8 lines · Juergen Gross
xen/include/xen/hypfs.h new file +5
-0@@ -0,0 +1,122 @@ +#ifndef __XEN_HYPFS_H__ +#define __XEN_HYPFS_H__ + +#ifdef CONFIG_HYPFS +#include <xen/list.h> xen/include/xen/hypfs.h line 15
Quoted 10 lines
xen/include/xen/hypfs.h new file +10
-0+#include <xen/string.h> +#include <public/hypfs.h> + +struct hypfs_entry_leaf ; + +struct hypfs_entry { +unsigned short type; +unsigned short encoding; +unsigned int size; +unsigned int max_size;Btw with these, ...
Quoted 8 lines
xen/include/xen/hypfs.h line 21
Quoted 6 lines
xen/include/xen/hypfs.h new file +6
-0+const char *name; +struct list_head list; +int (*read)(const struct hypfs_entry *entry, +XEN_GUEST_HANDLE_PARAM (void ) uaddr); +int (*write)(struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen);... why unsigned long here (noticed while looking at patch 9)?
Indeed, will switch to unsigned int.
Juergen
PATCH v8 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
V8:
- add some comments regarding the semantics of the lib functions (George Dunlap)
--- .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 | 90 +++++ tools/libs/hypfs/libxenhypfs.map | 10 + tools/libs/hypfs/xenhypfs.pc.in | 10 + 8 files changed, 671 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
@@ -110,6 +110,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
@@ -132,6 +133,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 +90 -0
90 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.26.1
PATCH v8 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
@@ -368,6 +368,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.26.1
PATCH v8 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 | 47 ++++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+)
docs/misc/hypfs-paths.pandoc +45 -0
@@ -105,3 +105,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 +47 -0
59 lines not on this page · raw message
Signature · 1 line
2.26.1
PATCH v8 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)
V8:
- add dependency top CONFIG_HYPFS
- use macro for definition of leaf (Jan Beulich)
--- .gitignore | 2 ++ docs/misc/hypfs-paths.pandoc | 4 ++++ xen/common/Kconfig | 11 +++++++++++ xen/common/Makefile | 12 ++++++++++++ xen/common/kernel.c | 11 +++++++++++ xen/include/xen/kernel.h | 3 +++ 6 files changed, 43 insertions(+)
.gitignore +2 -0
@@ -298,6 +298,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
@@ -135,6 +135,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 +11 -0
@@ -127,6 +127,17 @@ config HYPFS If unsure, say Y. +config HYPFS_CONFIG + bool "Provide hypervisor .config via hypfs entry" + default y + depends on HYPFS + ---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 KEXEC bool "kexec support" 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 +11 -0
@@ -390,6 +390,10 @@ 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 HYPFS_STRING_INIT(config, "config"); +#endif +static int __init buildinfo_init (void ) {hypfs_add_dir (&hypfs_root, &buildinfo, true);
@@ -415,6 +419,13 @@ static int __init buildinfo_init(void)hypfs_add_leaf (&version, &major, true);hypfs_add_leaf (&version, &minor, true); +#ifdef CONFIG_HYPFS_CONFIG + config.e.encoding =XEN_HYPFS_ENC_GZIP ; + config.e.size = xen_config_data_size; + config.content = &xen_config_data; +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.26.1
Re: [PATCH v8 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 4 lines · Juergen Gross
Add the /buildinfo/config entry to the hypervisor filesystem. This entry contains the .config file used to build the hypervisor.
Signed-off-by Juergen Gross <[email protected]>
with a remark and one further adjustment:
xen/common/Makefile obj-$(CONFIG_UBSAN) += ubsan/ · line 84
Quoted 12 lines
xen/common/Makefile +8
-0@@ -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
This will want changing to the changed build infrastructure, such that in default (non-verbose, non-silent) mode a line gets output to stdout. But I'd be fine with this getting done subsequently.
xen/include/xen/kernel.h extern enum system_state { · line 103
Quoted 7 lines
xen/include/xen/kernel.h +1
-0@@ -100,5 +100,8 @@ extern enum system_state {bool_t is_active_kernel_text (unsigned long addr); +extern const char xen_config_data;
Surely you meant to add [] here, and then possibly omit the & on the line using the symbol?
Jan
Re: [PATCH v8 08/12] xen: add /buildinfo/config entry to hypervisor filesystem
Quoted 30 lines · Jan Beulich
Quoted 4 lines · Juergen Gross
Add the /buildinfo/config entry to the hypervisor filesystem. This entry contains the .config file used to build the hypervisor.
Signed-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>with a remark and one further adjustment:
xen/common/Makefile obj-$(CONFIG_UBSAN) += ubsan/ · line 84
Quoted 12 lines
xen/common/Makefile +8
-0@@ -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_dataThis will want changing to the changed build infrastructure, such that in default (non-verbose, non-silent) mode a line gets output to stdout. But I'd be fine with this getting done subsequently.
Quoted 4 lines
xen/include/xen/kernel.h +0
-0@@ -100,5 +100,8 @@ extern enum system_state {
Quoted 6 lines
xen/include/xen/kernel.h extern enum system_state { · line 103
Quoted 3 lines
xen/include/xen/kernel.h +1
-0bool_t is_active_kernel_text (unsigned long addr); +extern const char xen_config_data;Surely you meant to add [] here, and then possibly omit the & on the line using the symbol?
Of course. ;-p
Juergen
PATCH v8 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)
V8:
- modify alignment in Arm linker script to 8 (Julien Grall)
- fix ept runtime parameter reporting (Jan Beulich)
- rebase to support CONFIG_HYPFS
--- docs/misc/hypfs-paths.pandoc | 9 +++ xen/arch/arm/xen.lds.S | 7 ++ xen/arch/x86/hvm/vmx/vmcs.c | 29 +++++++- xen/arch/x86/pv/domain.c | 24 ++++++- xen/arch/x86/xen.lds.S | 7 ++ xen/common/grant_table.c | 62 ++++++++++++++---- xen/common/hypfs.c | 41 ++++++++++++ xen/common/kernel.c | 27 +++++++- xen/drivers/char/console.c | 77 ++++++++++++++++++++-- xen/include/xen/hypfs.h | 7 ++ xen/include/xen/param.h | 124 ++++++++++++++++++++++++++++++++++- 11 files changed, 390 insertions(+), 24 deletions(-)
docs/misc/hypfs-paths.pandoc +9 -0
@@ -154,3 +154,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 +7 -0
@@ -89,6 +89,13 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .; + +#ifdef CONFIG_HYPFS + . = ALIGN(8); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .; +#endif *(.data.rel) *(.data.rel.*) CONSTRUCTORS
xen/arch/x86/hvm/vmx/vmcs.c +28 -1
@@ -71,6 +71,27 @@ 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 ; +#ifdef CONFIG_HYPFS +static char opt_ept_setting[10 ]; + +static void update_ept_param (void ) +{ +if ( opt_ept_exec_sp >=0 ) +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , + 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); +} +#else +static void update_ept_param (void ) +{ +} +#endif +static int __init parse_ept_param (const char *s) {const char *ss;
@@ -97,6 +118,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 +139,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 +172,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 +22 -2
@@ -52,9 +52,27 @@ static __read_mostly enum {PCID_OFF ,PCID_ALL ,PCID_XPTI , - PCID_NOXPTI +PCID_NOXPTI , + PCID_END } opt_pcid =PCID_XPTI ; +#ifdef CONFIG_HYPFS +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]); +} +#endif + +static int parse_pcid (const char *s); +custom_runtime_param ("pcid" , parse_pcid, opt_pcid_init); +static int parse_pcid (const char *s) {int rc =0 ;
@@ -87,9 +105,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 +7 -0
@@ -279,6 +279,13 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .; + +#ifdef CONFIG_HYPFS + . = ALIGN(8); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .; +#endif } :text DECL_SECTION(.data) {
xen/common/grant_table.c +51 -11
87 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; }/**
@@ -429,6 +435,25 @@ static int __init buildinfo_init(void)return 0 ; }__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);#endif # define DO (fn) long do_##fn
xen/drivers/char/console.c +71 -6
141 lines not on this page · raw message
xen/include/xen/hypfs.h +7 -0
@@ -117,6 +117,13 @@ 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 ); +#else +static inline void hypfs_write_lock (void ) {} +static inline void hypfs_write_unlock (void ) {}#endif #endif /* __XEN_HYPFS_H__ */
xen/include/xen/param.h +121 -3
143 lines not on this page · raw message
Signature · 1 line
2.26.1
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 6 lines · Juergen Gross
xen/arch/arm/xen.lds.S +0
-0@@ -89,6 +89,13 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .;
xen/arch/arm/xen.lds.S SECTIONS · line 101
Quoted 10 lines
xen/arch/arm/xen.lds.S +7
-0+ +#ifdef CONFIG_HYPFS + . = ALIGN(8); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .; +#endif *(.data.rel) *(.data.rel.*) CONSTRUCTORS
I'm not the maintainer of this code, but I think it would be better if there was either no blank line inserted, or two (a 2nd one after your insertion).
xen/arch/x86/pv/domain.c static __read_mostly enum { · line 57
Quoted 10 lines
xen/arch/x86/pv/domain.c +2
-1@@ -52,9 +52,27 @@ static __read_mostly enum {PCID_OFF ,PCID_ALL ,PCID_XPTI , - PCID_NOXPTI +PCID_NOXPTI , + PCID_END } opt_pcid =PCID_XPTI ;
Is this change really needed? The only use looks to be ...
xen/arch/x86/pv/domain.c static __read_mostly enum { · line 60
Quoted 2 lines
xen/arch/x86/pv/domain.c +2
-0+#ifdef CONFIG_HYPFS +static const char opt_pcid_2_string[PCID_END][7] = {
... here, yet the arry would end up the same when using [][7].
Quoted 26 lines
xen/common/grant_table.c +18
-2@@ -85,8 +85,43 @@ struct grant_table {struct grant_table_arch arch; }; -static int parse_gnttab_limit (const char *param,const char *arg, -unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames =64 ; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, +char *parval) +{ +snprintf (parval,GRANT_CUSTOM_VAL_SZ ,"%u" , val); +custom_runtime_set_var_sz (par, parval,GRANT_CUSTOM_VAL_SZ ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ +update_gnttab_par (par, opt_max_grant_frames, opt_max_grant_frames_val);
xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ +update_gnttab_par (par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULL
This looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
#define update_gnttab_par(par, val, unused) update_gnttab_par(par, val) #define parse_gnttab_limit(par, arg, valp, unused) parse_gnttab_limit(par, arg, valp)
(placed right here)
Quoted 7 lines
xen/common/grant_table.c +3
-0@@ -281,6 +282,36 @@ int hypfs_write_bool(struct hypfs_entry_leaf *leaf,return 0 ; } +int hypfs_write_custom (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{
xen/common/grant_table.c int hypfs_write_bool(struct hypfs_entry_leaf *leaf, · line 297
Quoted 10 lines
xen/common/grant_table.c +10
-0+struct param_hypfs *p; +char *buf; +int ret; + + buf =xzalloc_array (char, ulen); +if ( !buf ) +return -ENOMEM ; + + ret = -EFAULT ; +if (copy_from_guest (buf, uaddr, ulen) )
As just indicated in an extra reply to patch 4, ulen not getting truncated here silently is well obscured (the max_size field type and the check against it elsewhere looks to guarantee this).
xen/common/grant_table.c int hypfs_write_bool(struct hypfs_entry_leaf *leaf, · line 308
Quoted 11 lines
xen/common/grant_table.c +11
-0+ goto out; + + ret = -EDOM ; +if (memchr (buf,0 , ulen) != (buf + ulen -1 ) ) + goto out; + + p = container_of(leaf, struct param_hypfs, hypfs); + ret = p->param->par.func (buf); + +if ( !ret ) + leaf->e.size = ulen;
Why? For "ept", "no-exec-sp" would yield "exec-sp=0", and hence you'd wrongly extend the size from what parse_ept_param_runtime() has already set through custom_runtime_set_var(). It looks to me as if there's no reason to update e.size here at all; it's the par.func() handlers which need to take care of this.
xen/drivers/char/console.c enum con_timestamp_mode · line 79
Quoted 8 lines
xen/drivers/char/console.c +1
-0@@ -75,12 +75,35 @@ enum con_timestamp_modeTSM_DATE_MS ,/* [YYYY-MM-DD HH:MM:SS.mmm] */ TSM_BOOT ,/* [SSSSSS.uuuuuu] */ TSM_RAW ,/* [XXXXXXXXXXXXXXXX] */ + TSM_END };
Just like for the PCID enumeration I don't think a sentinel is needed here.
xen/drivers/char/console.c enum con_timestamp_mode · line 89
Quoted 9 lines
xen/drivers/char/console.c +7
-0static enum con_timestamp_mode __read_mostly opt_con_timestamp_mode =TSM_NONE ; +#ifdef CONFIG_HYPFS +static const char con_timestamp_mode_2_string[TSM_END ][7 ] = { + [TSM_NONE ] ="none" , + [TSM_DATE ] ="date" , + [TSM_DATE_MS ] ="datems" , + [TSM_BOOT ] ="boot" , + [TSM_RAW] = "raw"
Add a trailing comma please (and as I notice only now then also in the similar PCID array).
To the subsequent code the gnttab comment applies as well.
Quoted 9 lines
xen/drivers/char/console.c +4
-1@@ -80,7 +81,120 @@ extern const struct kernel_param __param_start[], __param_end[];#define __rtparam __param(__dataparam) -#define custom_runtime_only_param (_name, _var) \ +#ifdef CONFIG_HYPFS + +struct param_hypfs { + const struct kernel_param *param;
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 97
Quoted 10 lines
xen/drivers/char/console.c +10
-0+struct hypfs_entry_leaf hypfs; +void (*init_leaf)(struct param_hypfs *par); +}; + +extern struct param_hypfs __paramhypfs_start[], __paramhypfs_end[]; + +#define __paramhypfs __used_section(".data.paramhypfs") + +#define __paramfs static __paramhypfs \ + __attribute__((__aligned__(sizeof(void *)))) struct param_hypfs
Why the attribute?
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 101
Quoted 4 lines
xen/drivers/char/console.c +4
-0+#define custom_runtime_set_var_sz (parfs, var, sz) \ + { \ + (parfs)->hypfs.content = var; \ + (parfs)->hypfs.e.max_size = sz; \
var and sz want parentheses around them.
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 110
Quoted 9 lines
xen/drivers/char/console.c +9
-0+ (parfs)->hypfs.e.size =strlen (var) +1 ; \ + } +#define custom_runtime_set_var (parfs, var) \ + custom_runtime_set_var_sz(parfs, var, sizeof(var)) + +#define param_2_parfs (par) &__parfs_##par + +/* initfunc needs to set size and content, e.g. via custom_runtime_set_var(). */ +#define custom_runtime_only_param (_name, _var, initfunc) \
I've started noticing it here, but the issue exists further up (and down) as well - please can you avoid identifiers with leading underscores that are in violation of the C standard? Even more so that here you're not even consistent across macro parameter names.
Quoted 63 lines
xen/drivers/char/console.c +63
-0+ __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type =OPT_CUSTOM , \ + .par.func = _var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .init_leaf = initfunc, \ + .hypfs.e.type =XEN_HYPFS_TYPE_STRING , \ + .hypfs.e.encoding =XEN_HYPFS_ENC_PLAIN , \ + .hypfs.e.name = _name, \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_custom } +#define boolean_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_BOOL, \ + .len = sizeof(_var) + \ + BUILD_BUG_ON_ZERO(sizeof(_var) != sizeof(bool)), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_BOOL, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_bool, \ + .hypfs.content = &_var } +#define integer_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_UINT, \ + .len = sizeof(_var), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_UINT, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } +#define size_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_SIZE, \ + .len = sizeof(_var), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_UINT, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } +#define string_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 183
Quoted 10 lines
xen/drivers/char/console.c +10
-0+ { .name = _name, \ + .type = OPT_STR, \ + .len = sizeof(_var), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type =XEN_HYPFS_TYPE_STRING , \ + .hypfs.e.encoding =XEN_HYPFS_ENC_PLAIN , \ + .hypfs.e.name = _name, \ + .hypfs.e.size =sizeof (_var), \
Is this really correct here?
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 194
Quoted 11 lines
xen/drivers/char/console.c +11
-0+ .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } + +#else + +struct param_hypfs { +}; + +#define param_2_parfs (par) NULL
Along the lines of the earlier comment, this looks latently dangerous.
Jan
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 13 lines · Jan Beulich
Quoted 12 lines · Juergen Gross
xen/arch/arm/xen.lds.S +6
-0@@ -89,6 +89,13 @@ SECTIONS __start_schedulers_array = .; *(.data.schedulers) __end_schedulers_array = .; + +#ifdef CONFIG_HYPFS + . = ALIGN(8); + __paramhypfs_start = .; + *(.data.paramhypfs) + __paramhypfs_end = .;
Quoted 8 lines
xen/arch/arm/xen.lds.S SECTIONS · line 101
Quoted 4 lines
xen/arch/arm/xen.lds.S +1
-0+#endif *(.data.rel) *(.data.rel.*) CONSTRUCTORSI'm not the maintainer of this code, but I think it would be better if there was either no blank line inserted, or two (a 2nd one after your insertion).
Okay (either one).
Quoted 14 lines
xen/arch/x86/pv/domain.c static __read_mostly enum { · line 57
Quoted 11 lines
xen/arch/x86/pv/domain.c +2
-1@@ -52,9 +52,27 @@ static __read_mostly enum {PCID_OFF ,PCID_ALL ,PCID_XPTI , - PCID_NOXPTI +PCID_NOXPTI , + PCID_END } opt_pcid =PCID_XPTI ;Is this change really needed? The only use looks to be ...
Quoted 4 lines
xen/arch/x86/pv/domain.c static __read_mostly enum { · line 60
Quoted 2 lines
xen/arch/x86/pv/domain.c +2
-0+#ifdef CONFIG_HYPFS +static const char opt_pcid_2_string[PCID_END][7] = {... here, yet the arry would end up the same when using [][7].
Hmm, true.
Quoted 42 lines
Quoted 27 lines
xen/common/grant_table.c +18
-2@@ -85,8 +85,43 @@ struct grant_table {struct grant_table_arch arch; }; -static int parse_gnttab_limit (const char *param,const char *arg, -unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames =64 ; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, +char *parval) +{ +snprintf (parval,GRANT_CUSTOM_VAL_SZ ,"%u" , val); +custom_runtime_set_var_sz (par, parval,GRANT_CUSTOM_VAL_SZ ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ +update_gnttab_par (par, opt_max_grant_frames, opt_max_grant_frames_val);xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ +update_gnttab_par (par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULLThis looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
Quoted 4 lines
#define
update_gnttab_par(par, val, unused)update_gnttab_par(par, val)#defineparse_gnttab_limit(par, arg, valp, unused)parse_gnttab_limit(par, arg, valp)(placed right here)
Who else would use those identifiers not related to hypfs?
Quoted 14 lines
Quoted 14 lines
xen/common/grant_table.c +9
-0@@ -281,6 +282,36 @@ int hypfs_write_bool(struct hypfs_entry_leaf *leaf,return 0 ; } +int hypfs_write_custom (struct hypfs_entry_leaf *leaf, +XEN_GUEST_HANDLE_PARAM (void ) uaddr,unsigned long ulen) +{ +struct param_hypfs *p; +char *buf; +int ret; + + buf =xzalloc_array (char, ulen); +if ( !buf )
Quoted 8 lines
xen/common/grant_table.c int hypfs_write_bool(struct hypfs_entry_leaf *leaf, · line 297
Quoted 4 lines
xen/common/grant_table.c +4
-0+return -ENOMEM ; + + ret = -EFAULT ; +if (copy_from_guest (buf, uaddr, ulen) )As just indicated in an extra reply to patch 4, ulen not getting truncated here silently is well obscured (the
max_sizefield type and the check against it elsewhere looks to guarantee this).
Yes, will change ulen to unsigned int.
Quoted 10 lines
Quoted 10 lines
xen/common/grant_table.c +9
-0+ goto out; + + ret = -EDOM ; +if (memchr (buf,0 , ulen) != (buf + ulen -1 ) ) + goto out; + + p = container_of(leaf, struct param_hypfs, hypfs); + ret = p->param->par.func (buf); +
Quoted 8 lines
xen/common/grant_table.c int hypfs_write_bool(struct hypfs_entry_leaf *leaf, · line 308
Quoted 2 lines
xen/common/grant_table.c +2
-0+if ( !ret ) + leaf->e.size = ulen;Why? For "ept", "no-exec-sp" would yield "exec-sp=0", and hence you'd wrongly extend the size from what
parse_ept_param_runtime()has already set throughcustom_runtime_set_var(). It looks to me as if there's no reason to update e.size here at all; it's thepar.func()handlers which need to take care of this.
Oh, indeed. Thanks for catching.
Quoted 12 lines
xen/drivers/char/console.c enum con_timestamp_mode · line 79
Quoted 9 lines
xen/drivers/char/console.c +1
-0@@ -75,12 +75,35 @@ enum con_timestamp_modeTSM_DATE_MS ,/* [YYYY-MM-DD HH:MM:SS.mmm] */ TSM_BOOT ,/* [SSSSSS.uuuuuu] */ TSM_RAW ,/* [XXXXXXXXXXXXXXXX] */ + TSM_END };Just like for the PCID enumeration I don't think a sentinel is needed here.
Yes.
Quoted 29 lines
xen/drivers/char/console.c enum con_timestamp_mode · line 89
Quoted 10 lines
xen/drivers/char/console.c +7
-0static enum con_timestamp_mode __read_mostly opt_con_timestamp_mode =TSM_NONE ; +#ifdef CONFIG_HYPFS +static const char con_timestamp_mode_2_string[TSM_END ][7 ] = { + [TSM_NONE ] ="none" , + [TSM_DATE ] ="date" , + [TSM_DATE_MS ] ="datems" , + [TSM_BOOT ] ="boot" , + [TSM_RAW] = "raw"Add a trailing comma please (and as I notice only now then also in the similar PCID array).
To the subsequent code the gnttab comment applies as well.
Quoted 13 lines
xen/drivers/char/console.c +8
-1@@ -80,7 +81,120 @@ extern const struct kernel_param __param_start[], __param_end[];#define __rtparam __param(__dataparam) -#define custom_runtime_only_param (_name, _var) \ +#ifdef CONFIG_HYPFS + +struct param_hypfs { +const struct kernel_param *param; +struct hypfs_entry_leaf hypfs; +void (*init_leaf)(struct param_hypfs *par); +}; +
Quoted 8 lines
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 97
Quoted 6 lines
xen/drivers/char/console.c +6
-0+extern struct param_hypfs __paramhypfs_start[], __paramhypfs_end[]; + +#define __paramhypfs __used_section(".data.paramhypfs") + +#define __paramfs static __paramhypfs \ + __attribute__((__aligned__(sizeof(void *)))) struct param_hypfsWhy the attribute?
Oh, copy and paste leftover.
Quoted 7 lines
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 101
Quoted 5 lines
xen/drivers/char/console.c +4
-0+#define custom_runtime_set_var_sz (parfs, var, sz) \ + { \ + (parfs)->hypfs.content = var; \ + (parfs)->hypfs.e.max_size = sz; \var and sz want parentheses around them.
Fine with me, but out of curiosity: what can go wrong without? Are you thinking of multi-statement arguments?
Quoted 16 lines
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 110
Quoted 10 lines
xen/drivers/char/console.c +9
-0+ (parfs)->hypfs.e.size =strlen (var) +1 ; \ + } +#define custom_runtime_set_var (parfs, var) \ + custom_runtime_set_var_sz(parfs, var, sizeof(var)) + +#define param_2_parfs (par) &__parfs_##par + +/* initfunc needs to set size and content, e.g. via custom_runtime_set_var(). */ +#define custom_runtime_only_param (_name, _var, initfunc) \I've started noticing it here, but the issue exists further up (and down) as well - please can you avoid identifiers with leading underscores that are in violation of the C standard? Even more so that here you're not even consistent across macro parameter names.
Basically I only extended the macro to take another parameter and I omitted the underscore exactly for the reason you mentioned.
In case you like it better I can prepend a patch to the series dropping all the leading single underscores from the macros in param.h.
Quoted 68 lines
Quoted 68 lines
xen/drivers/char/console.c +67
-0+ __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type =OPT_CUSTOM , \ + .par.func = _var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .init_leaf = initfunc, \ + .hypfs.e.type =XEN_HYPFS_TYPE_STRING , \ + .hypfs.e.encoding =XEN_HYPFS_ENC_PLAIN , \ + .hypfs.e.name = _name, \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_custom } +#define boolean_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_BOOL, \ + .len = sizeof(_var) + \ + BUILD_BUG_ON_ZERO(sizeof(_var) != sizeof(bool)), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_BOOL, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_bool, \ + .hypfs.content = &_var } +#define integer_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_UINT, \ + .len = sizeof(_var), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_UINT, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } +#define size_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_SIZE, \ + .len = sizeof(_var), \ + .par.var = &_var }; \ + __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type = XEN_HYPFS_TYPE_UINT, \ + .hypfs.e.encoding = XEN_HYPFS_ENC_PLAIN, \ + .hypfs.e.name = _name, \ + .hypfs.e.size = sizeof(_var), \ + .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } +#define string_runtime_only_param (_name, _var) \ + __rtparam __rtpar_##_var = \ + { .name = _name, \ + .type = OPT_STR, \ + .len = sizeof(_var), \ + .par.var = &_var }; \
Quoted 8 lines
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 183
Quoted 6 lines
xen/drivers/char/console.c +6
-0+ __paramfs __parfs_##_var = \ + { .param = &__rtpar_##_var, \ + .hypfs.e.type =XEN_HYPFS_TYPE_STRING , \ + .hypfs.e.encoding =XEN_HYPFS_ENC_PLAIN , \ + .hypfs.e.name = _name, \ + .hypfs.e.size =sizeof (_var), \Is this really correct here?
Hmm, right, 0 might be the better choice here, even if it shouldn't really matter.
Quoted 14 lines
xen/drivers/char/console.c extern const struct kernel_param __param_start[], __param_end[]; · line 194
Quoted 12 lines
xen/drivers/char/console.c +11
-0+ .hypfs.e.max_size = sizeof(_var), \ + .hypfs.e.read = hypfs_read_leaf, \ + .hypfs.e.write = hypfs_write_leaf, \ + .hypfs.content = &_var } + +#else + +struct param_hypfs { +}; + +#define param_2_parfs (par) NULLAlong the lines of the earlier comment, this looks latently dangerous.
In which way? How can the empty struct be dereferenced in a way not resulting in build time errors, other than using a cast which would be obviously wrong for the standard case when CONFIG_HYPFS is defined?
Juergen
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 42 lines · Jürgen Groß
Quoted 41 lines · Jan Beulich
Quoted 25 lines · Juergen Gross
xen/common/grant_table.c +18
-1@@ -85,8 +85,43 @@ struct grant_table { struct grant_table_arch arch; }; -static int parse_gnttab_limit(const char *param, const char *arg, - unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames = 64; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, + char *parval) +{ + snprintf(parval, GRANT_CUSTOM_VAL_SZ, "%u", val); + custom_runtime_set_var_sz(par, parval, GRANT_CUSTOM_VAL_SZ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_grant_frames, opt_max_grant_frames_val);xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULLThis looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
Quoted 6 lines
Quoted 4 lines
#define
update_gnttab_par(par, val, unused)update_gnttab_par(par, val)#defineparse_gnttab_limit(par, arg, valp, unused)parse_gnttab_limit(par, arg, valp)(placed right here)
Who else would use those identifiers not related to hypfs?
I can't see an obvious possible use, but people get creative, i.e. you never know. Passing NULL into a function without it being blindingly obvious that it won't ever get (de)referenced is an at least theoretical risk imo.
Quoted 9 lines
Quoted 6 lines
xen/common/grant_table.c struct grant_table { · line 119
Quoted 4 lines
xen/common/grant_table.c +4
-0+#define custom_runtime_set_var_sz (parfs, var, sz) \ + { \ + (parfs)->hypfs.content = var; \ + (parfs)->hypfs.e.max_size = sz; \var and sz want parentheses around them.
Fine with me, but out of curiosity: what can go wrong without? Are you thinking of multi-statement arguments?
Well, as just said in the reply on the patch 4 thread, you have a point about this being the right side of an assignment. Nevertheless such uses would look more consistent if parenthesized. The only cases where I see it reasonable to omit parentheses are
- parameters made the operands of # or ##,
- parameters handed on to further macros / functions unaltered,
- parameters representing struct/union field names,
- perhaps other special cases along the lines of the above that I can't seem to be able to think of right now.
Quoted 9 lines
Quoted 8 lines
xen/common/grant_table.c struct grant_table { · line 121
Quoted 2 lines
xen/common/grant_table.c +2
-0+/* initfunc needs to set size and content, e.g. via custom_runtime_set_var(). */ +#define custom_runtime_only_param (_name, _var, initfunc) \I've started noticing it here, but the issue exists further up (and down) as well - please can you avoid identifiers with leading underscores that are in violation of the C standard? Even more so that here you're not even consistent across macro parameter names.
Quoted 5 lines
Basically I only extended the macro to take another parameter and I omitted the underscore exactly for the reason you mentioned.
In case you like it better I can prepend a patch to the series dropping all the leading single underscores from the macros in
param.h.
That's code churn I don't view as strictly necessary - adjusting these can be done when they get touched anyway. But here we have a whole new body of code.
Quoted 7 lines
Quoted 3 lines
xen/common/grant_table.c struct grant_table { · line 122
Quoted 1 line
xen/common/grant_table.c +1
-0+#define param_2_parfs (par) NULLAlong the lines of the earlier comment, this looks latently dangerous.
In which way? How can the empty struct be dereferenced in a way not resulting in build time errors, other than using a cast which would be obviously wrong for the standard case when
CONFIG_HYPFSis defined?
Have the result of the macro passed to a function taking void *, e.g. memcpy().
Jan
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 46 lines · Jan Beulich
Quoted 45 lines · Jürgen Groß
Quoted 44 lines · Jan Beulich
Quoted 25 lines · Juergen Gross
xen/common/grant_table.c +18
-1@@ -85,8 +85,43 @@ struct grant_table { struct grant_table_arch arch; }; -static int parse_gnttab_limit(const char *param, const char *arg, - unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames = 64; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, + char *parval) +{ + snprintf(parval, GRANT_CUSTOM_VAL_SZ, "%u", val); + custom_runtime_set_var_sz(par, parval, GRANT_CUSTOM_VAL_SZ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_grant_frames, opt_max_grant_frames_val);xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULLThis looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
#define
update_gnttab_par(par, val, unused)update_gnttab_par(par, val)#defineparse_gnttab_limit(par, arg, valp, unused)parse_gnttab_limit(par, arg, valp)
Quoted 8 lines
Quoted 3 lines
Quoted 1 line
(placed right here)
Who else would use those identifiers not related to hypfs?
I can't see an obvious possible use, but people get creative, i.e. you never know. Passing NULL into a function without it being blindingly obvious that it won't ever get (de)referenced is an at least theoretical risk imo.
Hmm, what about using a special type for those content variables? Something like:
#ifdef CONFIG_HYPFS
#define hypfs_string_var char *
#else
#define hypfs_string_var char
#define opt_max_grant_frames_val 0
#define opt_max_maptrack_frames_val 0
#endif
And then use that as type for function parameters? This should make dereferencing pretty hard.
Other than that I have no really good idea how to avoid this problem.
Quoted 11 lines
Quoted 10 lines
Quoted 7 lines
xen/common/grant_table.c struct grant_table { · line 119
Quoted 5 lines
xen/common/grant_table.c +4
-0+#define custom_runtime_set_var_sz (parfs, var, sz) \ + { \ + (parfs)->hypfs.content = var; \ + (parfs)->hypfs.e.max_size = sz; \var and sz want parentheses around them.
Fine with me, but out of curiosity: what can go wrong without? Are you thinking of multi-statement arguments?
Quoted 9 lines
Well, as just said in the reply on the patch 4 thread, you have a point about this being the right side of an assignment. Nevertheless such uses would look more consistent if parenthesized. The only cases where I see it reasonable to omit parentheses are
- parameters made the operands of # or ##,
- parameters handed on to further macros / functions unaltered,
- parameters representing struct/union field names,
- perhaps other special cases along the lines of the above that I can't seem to be able to think of right now.
Okay.
Quoted 13 lines
Quoted 13 lines
Quoted 9 lines
xen/common/grant_table.c struct grant_table { · line 121
Quoted 3 lines
xen/common/grant_table.c +2
-0+/* initfunc needs to set size and content, e.g. via custom_runtime_set_var(). */ +#define custom_runtime_only_param (_name, _var, initfunc) \I've started noticing it here, but the issue exists further up (and down) as well - please can you avoid identifiers with leading underscores that are in violation of the C standard? Even more so that here you're not even consistent across macro parameter names.
Basically I only extended the macro to take another parameter and I omitted the underscore exactly for the reason you mentioned.
Quoted 6 lines
Quoted 2 lines
In case you like it better I can prepend a patch to the series dropping all the leading single underscores from the macros in
param.h.That's code churn I don't view as strictly necessary - adjusting these can be done when they get touched anyway. But here we have a whole new body of code.
Okay.
Quoted 11 lines
Quoted 8 lines
Quoted 4 lines
xen/common/grant_table.c struct grant_table { · line 122
Quoted 2 lines
xen/common/grant_table.c +1
-0+#define param_2_parfs (par) NULLAlong the lines of the earlier comment, this looks latently dangerous.
In which way? How can the empty struct be dereferenced in a way not resulting in build time errors, other than using a cast which would be obviously wrong for the standard case when
CONFIG_HYPFSis defined?Have the result of the macro passed to a function taking void *, e.g.
memcpy().
Any function like this needs either a guaranteed minimum size or a specific size as parameter. I can't imagine a valid use case leading to problems, TBH.
Juergen
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 67 lines · Jürgen Groß
Quoted 46 lines · Jan Beulich
Quoted 45 lines · Jürgen Groß
Quoted 44 lines · Jan Beulich
Quoted 25 lines · Juergen Gross
xen/common/grant_table.c +18
-1@@ -85,8 +85,43 @@ struct grant_table { struct grant_table_arch arch; }; -static int parse_gnttab_limit(const char *param, const char *arg, - unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames = 64; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, + char *parval) +{ + snprintf(parval, GRANT_CUSTOM_VAL_SZ, "%u", val); + custom_runtime_set_var_sz(par, parval, GRANT_CUSTOM_VAL_SZ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_grant_frames, opt_max_grant_frames_val);xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULLThis looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
#define
update_gnttab_par(par, val, unused)update_gnttab_par(par, val)#defineparse_gnttab_limit(par, arg, valp, unused)parse_gnttab_limit(par, arg, valp)Quoted 8 lines
Quoted 3 lines
Quoted 1 line
(placed right here)
Who else would use those identifiers not related to hypfs?
I can't see an obvious possible use, but people get creative, i.e. you never know. Passing NULL into a function without it being blindingly obvious that it won't ever get (de)referenced is an at least theoretical risk imo.
Hmm, what about using a special type for those content variables? Something like:
#ifdef
CONFIG_HYPFS
#define hypfs_string_var char *
#else
#define hypfs_string_var char
#define opt_max_grant_frames_val 0
#defineopt_max_maptrack_frames_val0
#endif
Quoted 4 lines
And then use that as type for function parameters? This should make dereferencing pretty hard.
Other than that I have no really good idea how to avoid this problem.
IOW (as suspected) you don't like my suggestion? Personally I think yours, having more #define-s, is at least not better than mine.
Jan
Re: [PATCH v8 09/12] xen: add runtime parameter access support to hypfs
Quoted 68 lines · Jan Beulich
Quoted 67 lines · Jürgen Groß
Quoted 46 lines · Jan Beulich
Quoted 45 lines · Jürgen Groß
Quoted 44 lines · Jan Beulich
Quoted 25 lines · Juergen Gross
xen/common/grant_table.c +18
-1@@ -85,8 +85,43 @@ struct grant_table { struct grant_table_arch arch; }; -static int parse_gnttab_limit(const char *param, const char *arg, - unsigned int *valp) +unsigned int __read_mostly opt_max_grant_frames = 64; +static unsigned int __read_mostly opt_max_maptrack_frames =1024 ; + +#ifdef CONFIG_HYPFS +#define GRANT_CUSTOM_VAL_SZ 12 +static char __read_mostly opt_max_grant_frames_val[GRANT_CUSTOM_VAL_SZ ]; +static char __read_mostly opt_max_maptrack_frames_val[GRANT_CUSTOM_VAL_SZ ]; + +static void update_gnttab_par (struct param_hypfs *par,unsigned int val, + char *parval) +{ + snprintf(parval, GRANT_CUSTOM_VAL_SZ, "%u", val); + custom_runtime_set_var_sz(par, parval, GRANT_CUSTOM_VAL_SZ); +} + +static void __init gnttab_max_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_grant_frames, opt_max_grant_frames_val);xen/common/grant_table.c struct grant_table { · line 115
Quoted 10 lines
xen/common/grant_table.c +10
-0+} + +static void __init max_maptrack_frames_init (struct param_hypfs *par) +{ + update_gnttab_par(par, opt_max_maptrack_frames, + opt_max_maptrack_frames_val); +} +#else +#define opt_max_grant_frames_val NULL +#define opt_max_maptrack_frames_val NULLThis looks latently dangerous to me (in case new uses of these two identifiers appeared), but I guess my alternative suggestion will be at best controversial, too:
#define
update_gnttab_par(par, val, unused)update_gnttab_par(par, val)#defineparse_gnttab_limit(par, arg, valp, unused)parse_gnttab_limit(par, arg, valp)Quoted 8 lines
Quoted 3 lines
Quoted 1 line
(placed right here)
Who else would use those identifiers not related to hypfs?
I can't see an obvious possible use, but people get creative, i.e. you never know. Passing NULL into a function without it being blindingly obvious that it won't ever get (de)referenced is an at least theoretical risk imo.
Hmm, what about using a special type for those content variables? Something like:
#ifdef
CONFIG_HYPFS
#define hypfs_string_var char *
#else
#define hypfs_string_var char
#define opt_max_grant_frames_val 0
#defineopt_max_maptrack_frames_val0
#endif
Quoted 7 lines
Quoted 4 lines
And then use that as type for function parameters? This should make dereferencing pretty hard.
Other than that I have no really good idea how to avoid this problem.
IOW (as suspected) you don't like my suggestion? Personally I think yours, having more #define-s, is at least not better than mine.
Oh, maybe I misunderstood you here. I thought you weren't happy with your solution either and suspected others (not me) wouldn't like it.
In case others don't reject it I'd be happy to use your variant.
Juergen
PATCH v8 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
@@ -178,7 +178,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.26.1
PATCH v8 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.26.1
PATCH v8 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)
V8:
- rebase to use CONFIG_HYPFS
--- tools/flask/policy/modules/dom0.te | 2 +- xen/arch/arm/xen.lds.S | 5 -- xen/arch/x86/hvm/vmx/vmcs.c | 38 ++++++------- 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 | 5 -- xen/include/xen/lib.h | 1 - xen/include/xen/param.h | 87 +++++------------------------ xen/xsm/flask/hooks.c | 3 - xen/xsm/flask/policy/access_vectors | 2 - 13 files changed, 34 insertions(+), 192 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/hvm/vmx/vmcs.c +17 -21
@@ -71,27 +71,6 @@ 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 ; -#ifdef CONFIG_HYPFS -static char opt_ept_setting[10 ]; - -static void update_ept_param (void ) -{ -if ( opt_ept_exec_sp >=0 ) -snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , - 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); -} -#else -static void update_ept_param (void ) -{ -} -#endif -static int __init parse_ept_param (const char *s) {const char *ss;
@@ -118,6 +97,22 @@ static int __init parse_ept_param(const char *s) }custom_param ("ept" , parse_ept_param); +#ifdef CONFIG_HYPFS +static char opt_ept_setting[10 ]; + +static void update_ept_param (void ) +{ +if ( opt_ept_exec_sp >=0 ) +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , + 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 parse_ept_param_runtime (const char *s);custom_runtime_only_param ("ept" , parse_ept_param_runtime, init_ept_param);
@@ -172,6 +167,7 @@ static int parse_ept_param_runtime(const char *s) return 0; } +#endif /* Dynamic (run-time adjusted) execution control flags. */ u32 vmx_pin_based_exec_control__read_mostly ;
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
@@ -302,7 +302,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;
@@ -383,13 +383,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 -5
@@ -119,11 +119,6 @@ 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 ); -#else -static inline void hypfs_write_lock (void ) {} -static inline void hypfs_write_unlock (void ) {}#endif #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 +14 -73
143 lines not on this page · raw message
xen/xsm/flask/hooks.c +0 -3
@@ -822,9 +822,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.26.1
Re: [PATCH v8 12/12] xen: remove XEN_SYSCTL_set_parameter support
On 08.05.2020 17:34, Juergen Gross wrote:
Besides the changes made, wouldn't it be worthwhile to change HYPFS Kconfig help wording from "result in some features not being available" to something mentioning runtime parameter setting in particular, and perhaps also from "might" to "will"?
Quoted 39 lines
xen/arch/x86/hvm/vmx/vmcs.c +5
-21@@ -71,27 +71,6 @@ 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 ; -#ifdef CONFIG_HYPFS -static char opt_ept_setting[10 ]; - -static void update_ept_param (void ) -{ -if ( opt_ept_exec_sp >=0 ) -snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , - 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); -} -#else -static void update_ept_param (void ) -{ -} -#endif -static int __init parse_ept_param (const char *s) {const char *ss;@@ -118,6 +97,22 @@ static int __init parse_ept_param(const char *s) }custom_param ("ept" , parse_ept_param); +#ifdef CONFIG_HYPFS +static char opt_ept_setting[10 ]; + +static void update_ept_param (void ) +{
xen/arch/x86/hvm/vmx/vmcs.c static int __init parse_ept_param(const char *s) · line 114
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c +10
-0+if ( opt_ept_exec_sp >=0 ) +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , + 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); +}
If I'm not mistaken this is pure code movement, and solely to be able to have ...
xen/arch/x86/hvm/vmx/vmcs.c static int parse_ept_param_runtime(const char *s) · line 170
Quoted 9 lines
xen/arch/x86/hvm/vmx/vmcs.c +2
-0+static int parse_ept_param_runtime (const char *s);custom_runtime_only_param ("ept" , parse_ept_param_runtime, init_ept_param);@@ -172,6 +167,7 @@ static int parse_ept_param_runtime(const char *s) return 0; } +#endif
... a single #ifdef region now including a few more lines. No strict need to change it, but couldn't the earlier patch have inserted the code in its final place right away?
xen/arch/x86/hvm/vmx/vmcs.c struct xen_sysctl { · line 1093
Quoted 6 lines
xen/arch/x86/hvm/vmx/vmcs.c +1
-1@@ -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 */
Nit: There are now 3 too many padding spaces. Granted that's how it was done for XEN_SYSCTL_tmem_op ...
In any event, as before,
Jan
Re: [PATCH v8 12/12] xen: remove XEN_SYSCTL_set_parameter support
Quoted 6 lines · Jan Beulich
On 08.05.2020 17:34, Juergen Gross wrote:
Besides the changes made, wouldn't it be worthwhile to change HYPFS
Kconfighelp wording from "result in some features not being available" to something mentioning runtime parameter setting in particular, and perhaps also from "might" to "will"?
Yes, good idea.
Quoted 60 lines
Quoted 40 lines
xen/arch/x86/hvm/vmx/vmcs.c +5
-21@@ -71,27 +71,6 @@ 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 ; -#ifdef CONFIG_HYPFS -static char opt_ept_setting[10 ]; - -static void update_ept_param (void ) -{ -if ( opt_ept_exec_sp >=0 ) -snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , - 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); -} -#else -static void update_ept_param (void ) -{ -} -#endif -static int __init parse_ept_param (const char *s) {const char *ss;@@ -118,6 +97,22 @@ static int __init parse_ept_param(const char *s) }custom_param ("ept" , parse_ept_param); +#ifdef CONFIG_HYPFS +static char opt_ept_setting[10 ]; + +static void update_ept_param (void ) +{xen/arch/x86/hvm/vmx/vmcs.c static int __init parse_ept_param(const char *s) · line 114
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c +10
-0+if ( opt_ept_exec_sp >=0 ) +snprintf (opt_ept_setting,sizeof (opt_ept_setting),"exec-sp=%d" , + 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); +}If I'm not mistaken this is pure code movement, and solely to be able to have ...
Quoted 6 lines
xen/arch/x86/hvm/vmx/vmcs.c +1
-0+static int parse_ept_param_runtime (const char *s);custom_runtime_only_param ("ept" , parse_ept_param_runtime, init_ept_param);@@ -172,6 +167,7 @@ static int parse_ept_param_runtime(const char *s)
Quoted 7 lines
xen/arch/x86/hvm/vmx/vmcs.c static int parse_ept_param_runtime(const char *s) · line 170
Quoted 3 lines
xen/arch/x86/hvm/vmx/vmcs.c +1
-0return 0; } +#endif ... a single #ifdef region now including a few more lines. No strict need to change it, but couldn't the earlier patch have inserted the code in its final place right away?
I can do that.
Quoted 10 lines
xen/arch/x86/hvm/vmx/vmcs.c struct xen_sysctl { · line 1093
Quoted 7 lines
xen/arch/x86/hvm/vmx/vmcs.c +1
-1@@ -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 */ Nit: There are now 3 too many padding spaces. Granted that's how it was done for
XEN_SYSCTL_tmem_op...
You said: like it was done with tmem. ;-)
Quoted 3 lines
In any event, as before,
Acked-by Jan Beulich <[email protected]>
Thanks,
Juergen