Enable build of full Xen for RISC-V
PATCH v11 4/9 xen/riscv: introduce bitops.h
In reply to Oleksii KurochkoTaken from Linux-6.4.0-rc1
Xen's bitops.h consists of several Linux's headers:
* linux/arch/include/asm/bitops.h:
* The following function were removed as they aren't used in Xen:
* test_and_set_bit_lock
* clear_bit_unlock
* __clear_bit_unlock
* The following functions were renamed in the way how they are used by common code:
* __test_and_set_bit
* __test_and_clear_bit
* The declaration and implementation of the following functios were updated to make Xen build happy:
* clear_bit
* set_bit
* __test_and_clear_bit
* __test_and_set_bit
---
Changes in V11:
- Nothing changed. Only rebase was done.
---
Changes in V10:
- update the error message BITS_PER_LONG -> BITOP_BITS_PER_WORD
---
Changes in V9:
- add Acked-by: Jan Beulich <[email protected]>
- drop redefinition of bitop_uint_t in asm/types.h as some operation in Xen common code expects to work with 32-bit quantities.
- s/BITS_PER_LONG/BITOP_BITS_PER_WORD in asm/bitops.h around __AMO() macros.
---
Changes in V8:
- define bitop_uint_t in <asm/types.h> after the changes in patch related to introduction of "introduce generic non-atomic test_*bit()".
- drop duplicated __set_bit() and __clear_bit().
- drop duplicated comment: /* Based on linux/arch/include/asm/bitops.h */.
- update type of res and mask in test_and_op_bit_ord(): unsigned long -> bitop_uint_t.
- drop 1 padding blank in test_and_op_bit_ord().
- update definition of test_and_set_bit(),test_and_clear_bit(),test_and_change_bit:
change return type to bool.
- change addr argument type of test_and_change_bit(): unsigned long * -> void *.
- move test_and_change_bit() closer to other test_and-s function.
- Code style fixes: tabs -> space.
- s/#undef __op_bit/#undef op_bit.
- update the commit message: delete information about generic-non-atomic.h changes as now it is a separate patch.
---
Changes in V7:
- Update the commit message.
- Drop "__" for __op_bit and __op_bit_ord as they are atomic.
- add comment above __set_bit and __clear_bit about why they are defined as atomic.
- align bitops_uint_t with __AMO().
- make changes after generic non-atomic test_*bit() were changed.
- s/__asm__ __volatile__/asm volatile
---
Changes in V6:
- rebase clean ups were done: drop unused asm-generic includes
---
Changes in V5:
- new patch
--- xen/arch/riscv/include/asm/bitops.h | 137 ++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 xen/arch/riscv/include/asm/bitops.h
xen/arch/riscv/include/asm/bitops.h new file +137 -0
@@ -0,0 +1,137 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright (C) 2012 Regents of the University of California */ + +#ifndef _ASM_RISCV_BITOPS_H +#define _ASM_RISCV_BITOPS_H + +#include <asm/system.h> + +#if BITOP_BITS_PER_WORD ==64 +#define __AMO (op) "amo" #op ".d" +#elif BITOP_BITS_PER_WORD ==32 +#define __AMO (op) "amo" #op ".w" +#else +#error "Unexpected BITOP_BITS_PER_WORD" +#endif + +/* Based on linux/arch/include/asm/bitops.h */ + +/* +* Non-atomic bit manipulation. +* +* Implemented using atomics to be interrupt safe. Could alternatively +* implement with local interrupt masking. +*/ +#define __set_bit (n, p) set_bit(n, p) +#define __clear_bit (n, p) clear_bit(n, p) + +#define test_and_op_bit_ord (op, mod, nr, addr, ord) \ +({ \ + bitop_uint_t res, mask; \ + mask = BITOP_MASK(nr); \ + asm volatile ( \ + __AMO(op) #ord " %0, %2, %1" \ + : "=r" (res), "+A" (addr[BITOP_WORD(nr)]) \ + : "r" (mod(mask)) \ + : "memory"); \ + ((res & mask) != 0); \ +}) + +#define op_bit_ord (op, mod, nr, addr, ord) \ + asm volatile ( \ + __AMO(op) #ord " zero, %1, %0" \ + : "+A" (addr[BITOP_WORD(nr)]) \ + : "r" (mod(BITOP_MASK(nr))) \ + : "memory"); + +#define test_and_op_bit (op, mod, nr, addr) \ + test_and_op_bit_ord(op, mod, nr, addr, .aqrl) +#define op_bit (op, mod, nr, addr) \ + op_bit_ord(op, mod, nr, addr, ) + +/* Bitmask modifiers */ +#define NOP (x) (x) +#define NOT (x) (~(x)) + +/** +* test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +*/ +static inline bool test_and_set_bit (int nr,volatile void *p) +{ +volatile bitop_uint_t *addr = p; + +return test_and_op_bit (or,NOP , nr, addr); +} + +/** +* test_and_clear_bit - Clear a bit and return its old value +* @nr: Bit to clear +* @addr: Address to count from +*/ +static inline bool test_and_clear_bit (int nr,volatile void *p) +{ +volatile bitop_uint_t *addr = p; + +return test_and_op_bit (and,NOT , nr, addr); +} + +/** +* test_and_change_bit - Toggle (change) a bit and return its old value +* @nr: Bit to change +* @addr: Address to count from +* +* This operation is atomic and cannot be reordered. +* It also implies a memory barrier. +*/ +static inline bool test_and_change_bit (int nr,volatile void *p) +{ +volatile bitop_uint_t *addr = p; + +return test_and_op_bit (xor,NOP , nr, addr); +} + +/** +* set_bit - Atomically set a bit in memory +* @nr: the bit to set +* @addr: the address to start counting from +* +* Note that @nr may be almost arbitrarily large; this function is not +* restricted to acting on a single-word quantity. +*/ +static inline void set_bit (int nr,volatile void *p) +{ +volatile bitop_uint_t *addr = p; + +op_bit (or,NOP , nr, addr); +} + +/** +* clear_bit - Clears a bit in memory +* @nr: Bit to clear +* @addr: Address to start counting from +*/ +static inline void clear_bit (int nr,volatile void *p) +{ +volatile bitop_uint_t *addr = p; + +op_bit (and,NOT , nr, addr); +} + +#undef test_and_op_bit +#undef op_bit +#undef NOP +#undef NOT +#undef __AMO + +#endif /* _ASM_RISCV_BITOPS_H */ + +/* +* Local variables: +* mode: C +* c-file-style: "BSD" +* c-basic-offset: 4 +* indent-tabs-mode: nil +* End: +*/
Signature · 1 line
2.45.0
PATCH v11 2/9 xen: introduce generic non-atomic test_*bit()
In reply to Oleksii KurochkoThe following generic functions were introduced:
* test_bit
* generic__test_and_set_bit
* generic__test_and_clear_bit
* generic__test_and_change_bit
These functions and macros can be useful for architectures that don't have corresponding arch-specific instructions.
Also, the patch introduces the following generics which are used by the functions mentioned above:
* BITOP_BITS_PER_WORD
* BITOP_MASK
* BITOP_WORD
* BITOP_TYPE
BITS_PER_BYTE was moved to xen/bitops.h as BITS_PER_BYTE is the same across architectures.
The following approach was chosen for generic*() and arch*() bit operation functions:
If the bit operation function that is going to be generic starts with the prefix "__", then the corresponding generic/arch function will also contain the "__" prefix. For example:
* test_bit() will be defined using arch_test_bit() and generic_test_bit().
* __test_and_set_bit() will be defined using arch__test_and_set_bit() and generic__test_and_set_bit().
---
version of the patch, but some changes were done, so I wasn't sure if I could use the R-by in this patch version.
The current patch can be merged without waiting for Andrew's patch series as
it was rebased on top of staging.
---
Changes in V11:
- fix identation in generic_test_bit() function.
- move definition of BITS_PER_BYTE from <arch>/bitops.h to xen/bitops.h
- drop the changes in arm64/livepatch.c.
- update the the comments on top of functions: generic__test_and_set_bit(), generic__test_and_clear_bit(), generic__test_and_change_bit(), generic_test_bit().
- Update footer after Signed-off section.
- Rebase the patch on top of staging branch, so it can be merged when necessary approves will be given.
- Update the commit message.
---
Changes in V10:
- update the commit message. ( re-order paragraphs and add explanation usage of prefix "__" in bit operation function names )
- add parentheses around the whole expression of bitop_bad_size() macros.
- move macros bitop_bad_size() above asm/bitops.h as it is not arch-specific anymore and there is no need for overriding it.
- drop macros check_bitop_size() and use "if ( bitop_bad_size(addr) ) __bitop_bad_size();" implictly where it is needed.
- in <xen/bitops.h> use 'int' as a first parameter for __test_and_*(), generic__test_and_*() to be consistent with how the mentioned functions were declared in the original per-arch functions.
- add 'const' to p variable in generic_test_bit().
- move definition of BITOP_BITS_PER_WORD and bitop_uint_t to xen/bitops.h as we don't allow for arch overrides these definitions anymore.
---
Changes in V9:
- move up xen/bitops.h in ppc/asm/page.h.
- update defintion of arch_check_bitop_size.
And drop correspondent macros from x86/asm/bitops.h
- drop parentheses in generic__test_and_set_bit() for definition of
local variable p.
- fix indentation inside #ifndef BITOP_TYPE...#endif
- update the commit message.
---
Changes in V8:
- drop __pure for function which uses volatile.
- drop unnessary () in generic__test_and_change_bit() for addr casting.
- update prototype of generic_test_bit() and test_bit(): now it returns bool instead of int.
- update generic_test_bit() to use BITOP_MASK().
- Deal with fls{l} changes: it should be in the patch with introduced generic fls{l}.
- add a footer with explanation of dependency on an uncommitted patch after Signed-off.
- abstract bitop_size().
- move BITOP_TYPE define to <xen/types.h>.
---
Changes in V7:
- move everything to xen/bitops.h to follow the same approach for all generic
bit ops.
- put together BITOP_BITS_PER_WORD and bitops_uint_t.
- make BITOP_MASK more generic.
- drop #ifdef ... #endif around BITOP_MASK, BITOP_WORD as they are generic
enough.
- drop "_" for generic__{test_and_set_bit,...}().
- drop " != 0" for functions which return bool.
- add volatile during the cast for generic__{...}().
- update the commit message.
- update arch related code to follow the proposed generic approach.
---
Changes in V6:
- Nothing changed ( only rebase )
---
Changes in V5:
- new patch
--- xen/arch/arm/include/asm/bitops.h | 69 ----------- xen/arch/ppc/include/asm/bitops.h | 54 --------- xen/arch/ppc/include/asm/page.h | 2 +- xen/arch/ppc/mm-radix.c | 2 +- xen/arch/x86/include/asm/bitops.h | 31 ++--- xen/include/xen/bitops.h | 185 ++++++++++++++++++++++++++++++ 6 files changed, 196 insertions(+), 147 deletions(-)
xen/arch/arm/include/asm/bitops.h +0 -69
@@ -22,11 +22,6 @@#define __set_bit (n,p) set_bit(n,p)#define __clear_bit (n,p) clear_bit(n,p) -#define BITOP_BITS_PER_WORD 32 -#define BITOP_MASK (nr) (1UL << ((nr) % BITOP_BITS_PER_WORD)) -#define BITOP_WORD (nr) ((nr) / BITOP_BITS_PER_WORD) -#define BITS_PER_BYTE 8 -#define ADDR (*(volatile int *) addr)#define CONST_ADDR (*(const volatile int *) addr)
@@ -76,70 +71,6 @@ bool test_and_change_bit_timeout(int nr, volatile void *p,bool clear_mask16_timeout (uint16_t mask,volatile void *p,unsigned int max_try); -/** -* __test_and_set_bit - Set a bit and return its old value -* @nr: Bit to set -* @addr: Address to count from -* -* This operation is non-atomic and can be reordered. -* If two examples of this operation race, one can appear to succeed -* but actually fail. You must protect multiple accesses with a lock. -*/ -static inline int __test_and_set_bit (int nr,volatile void *addr) -{ -unsigned int mask =BITOP_MASK (nr); -volatile unsigned int *p = - ((volatile unsigned int *)addr) +BITOP_WORD (nr); -unsigned int old = *p; - - *p = old | mask; -return (old & mask) !=0 ; -} - -/** -* __test_and_clear_bit - Clear a bit and return its old value -* @nr: Bit to clear -* @addr: Address to count from -* -* This operation is non-atomic and can be reordered. -* If two examples of this operation race, one can appear to succeed -* but actually fail. You must protect multiple accesses with a lock. -*/ -static inline int __test_and_clear_bit (int nr,volatile void *addr) -{ -unsigned int mask =BITOP_MASK (nr); -volatile unsigned int *p = - ((volatile unsigned int *)addr) +BITOP_WORD (nr); -unsigned int old = *p; - - *p = old & ~mask; -return (old & mask) !=0 ; -} - -/* WARNING: non atomic and it can be reordered! */ -static inline int __test_and_change_bit (int nr, -volatile void *addr) -{ -unsigned int mask =BITOP_MASK (nr); -volatile unsigned int *p = - ((volatile unsigned int *)addr) +BITOP_WORD (nr); -unsigned int old = *p; - - *p = old ^ mask; -return (old & mask) !=0 ; -} - -/** -* test_bit - Determine whether a bit is set -* @nr: bit number to test -* @addr: Address to start counting from -*/ -static inline int test_bit (int nr,const volatile void *addr) -{ -const volatile unsigned int *p = (const volatile unsigned int *)addr; -return 1UL & (p[BITOP_WORD (nr)] >> (nr & (BITOP_BITS_PER_WORD -1 ))); -} -/* * On ARMv5 and above those functions can be implemented around * the clz instruction for much better code efficiency.
xen/arch/ppc/include/asm/bitops.h +0 -54
72 lines not on this page · raw message
xen/arch/ppc/include/asm/page.h +1 -1
@@ -2,9 +2,9 @@#ifndef _ASM_PPC_PAGE_H#define _ASM_PPC_PAGE_H +#include <xen/bitops.h> #include <xen/types.h> -#include <asm/bitops.h> #include <asm/byteorder.h> #define PDE_VALID PPC_BIT(0)
xen/arch/ppc/mm-radix.c +1 -1
@@ -1,11 +1,11 @@/* SPDX-License-Identifier: GPL-2.0-or-later */ +#include <xen/bitops.h> #include <xen/init.h> #include <xen/kernel.h> #include <xen/mm.h> #include <xen/types.h> #include <xen/lib.h> -#include <asm/bitops.h> #include <asm/byteorder.h> #include <asm/early_printk.h> #include <asm/page.h>
xen/arch/x86/include/asm/bitops.h +9 -22
@@ -19,9 +19,6 @@#define ADDR (*(volatile int *) addr)#define CONST_ADDR (*(const volatile int *) addr) -extern void __bitop_bad_size (void ); -#define bitop_bad_size (addr) (sizeof(*(addr)) < 4) -/** * set_bit - Atomically set a bit in memory * @nr: the bit to set
@@ -175,7 +172,7 @@ static inline int test_and_set_bit(int nr, volatile void *addr) })/** -* __test_and_set_bit - Set a bit and return its old value +* arch__test_and_set_bit - Set a bit and return its old value * @nr: Bit to set * @addr: Address to count from *
@@ -183,7 +180,7 @@ static inline int test_and_set_bit(int nr, volatile void *addr)* If two examples of this operation race, one can appear to succeed * but actually fail. You must protect multiple accesses with a lock. */ -static inline int __test_and_set_bit (int nr,void *addr) +static inline int arch__test_and_set_bit (int nr,volatile void *addr) {int oldbit;
@@ -194,10 +191,7 @@ static inline int __test_and_set_bit(int nr, void *addr)return oldbit; } -#define __test_and_set_bit (nr, addr) ({ \ - if ( bitop_bad_size(addr) ) __bitop_bad_size(); \ - __test_and_set_bit(nr, addr); \ -}) +#define arch__test_and_set_bit arch__test_and_set_bit/** * test_and_clear_bit - Clear a bit and return its old value
@@ -224,7 +218,7 @@ static inline int test_and_clear_bit(int nr, volatile void *addr) })/** -* __test_and_clear_bit - Clear a bit and return its old value +* arch__test_and_clear_bit - Clear a bit and return its old value * @nr: Bit to set * @addr: Address to count from *
@@ -232,7 +226,7 @@ static inline int test_and_clear_bit(int nr, volatile void *addr)* If two examples of this operation race, one can appear to succeed * but actually fail. You must protect multiple accesses with a lock. */ -static inline int __test_and_clear_bit (int nr,void *addr) +static inline int arch__test_and_clear_bit (int nr,volatile void *addr) {int oldbit;
@@ -243,13 +237,10 @@ static inline int __test_and_clear_bit(int nr, void *addr)return oldbit; } -#define __test_and_clear_bit (nr, addr) ({ \ - if ( bitop_bad_size(addr) ) __bitop_bad_size(); \ - __test_and_clear_bit(nr, addr); \ -}) +#define arch__test_and_clear_bit arch__test_and_clear_bit/* WARNING: non atomic and it can be reordered! */ -static inline int __test_and_change_bit (int nr,void *addr) +static inline int arch__test_and_change_bit (int nr,volatile void *addr) {int oldbit;
@@ -260,10 +251,7 @@ static inline int __test_and_change_bit(int nr, void *addr)return oldbit; } -#define __test_and_change_bit (nr, addr) ({ \ - if ( bitop_bad_size(addr) ) __bitop_bad_size(); \ - __test_and_change_bit(nr, addr); \ -}) +#define arch__test_and_change_bit arch__test_and_change_bit/** * test_and_change_bit - Change a bit and return its new value
@@ -307,8 +295,7 @@ static inline int variable_test_bit(int nr, const volatile void *addr)return oldbit; } -#define test_bit (nr, addr) ({ \ - if ( bitop_bad_size(addr) ) __bitop_bad_size(); \ +#define arch_test_bit (nr, addr) ({ \ __builtin_constant_p(nr) ? \ constant_test_bit(nr, addr) : \ variable_test_bit(nr, addr); \
xen/include/xen/bitops.h +185 -0
193 lines not on this page · raw message
Signature · 1 line
2.45.0
PATCH v11 3/9 xen/bitops: implement fls{l}() in common logic
In reply to Oleksii KurochkoTo avoid the compilation error below, it is needed to update to places in common/page_alloc.c where flsl() is used as now flsl() returns unsigned int:
./include/xen/kernel.h:18:21: error: comparison of distinct pointer types lacks a cast [-Werror]
18 | (void) (&_x == &_y); \
| ^~
common/page_alloc.c:1843:34: note: in expansion of macro 'min'
1843 | unsigned int inc_order = min(MAX_ORDER, flsl(e - s) - 1);generic_fls{l} was used instead of __builtin_clz{l}(x) as if x is 0, the result in undefined.
The prototype of the per-architecture fls{l}() functions was changed to return 'unsigned int' to align with the generic implementation of these functions and avoid introducing signed/unsigned mismatches.
---
The current one patch can be merged w/o waiting of Andrew's patch series.
Andrew C. could you please consider the following patch to be as a part of your bit operation patch series if your patch series will be in staging before mine:
https://gitlab.com/xen-project/people/olkur/xen/-/commit/24a346c7aa4f51ba34eacb7bfee2808e431daf00
Thanks in advance.
---
Changes in V11:
- drop unnessary case and fix code style for x86's arch_flsl()
- rebase on top of staging, so it can be merged to staging if necessary apporves will be given
- move changes related to fls related function to separate patch on top of Andrew's patch series as the C file with tests is introduced in his patch series. The patch is mentioned in footer.
---
Changes in V10:
- update return type of arch_flsl() across arcitectures to 'unsigned int' to be aligned with return type of generic flsl() in xen/bitops.h.
- switch inline to always_inline for arch_flsl() across architectures to be in sync with other similar changes.
- define arch_flsl as arch_fls not just only fls.
- update the commit message ( add information that per-arch fls{l)() protypes were changed ).
---
Changes in V9:
- update return type of fls and flsl() to unsigned int to be aligned with other bit ops.
- update places where return value of fls() and flsl() is compared with int.
- update the commit message.
---
Changes in V8:
- do proper rebase: back definition of fls{l} to the current patch.
- drop the changes which removed ffz() in PPC. it should be done not
in this patch.
- add a message after Signed-off.
---
Changes in V7:
- Code style fixes
---
Changes in V6:
- new patch for the patch series.
--- xen/arch/arm/include/asm/arm32/bitops.h | 2 +- xen/arch/arm/include/asm/arm64/bitops.h | 6 ++---- xen/arch/arm/include/asm/bitops.h | 9 +++------ xen/arch/ppc/include/asm/bitops.h | 2 -- xen/arch/x86/include/asm/bitops.h | 12 +++++++----- xen/common/page_alloc.c | 4 ++-- xen/include/xen/bitops.h | 24 ++++++++++++++++++++++++ 7 files changed, 39 insertions(+), 20 deletions(-)
xen/arch/arm/include/asm/arm32/bitops.h +1 -1
@@ -1,7 +1,7 @@#ifndef _ARM_ARM32_BITOPS_H#define _ARM_ARM32_BITOPS_H -#define flsl fls +#define arch_flsl arch_fls/* * Little endian assembly bitops. nr = 0 -> byte 0 bit 0.
xen/arch/arm/include/asm/arm64/bitops.h +2 -4
@@ -1,17 +1,15 @@#ifndef _ARM_ARM64_BITOPS_H#define _ARM_ARM64_BITOPS_H -static inline int flsl (unsigned long x) +static always_inline unsigned int arch_flsl(unsigned long x) {uint64_t ret; -if (__builtin_constant_p (x)) -return generic_flsl (x); - asm("clz\t%0, %1" :"=r" (ret) :"r" (x));return BITS_PER_LONG - ret; } +#define arch_flsl arch_flsl/* Based on linux/include/asm-generic/bitops/find.h */
xen/arch/arm/include/asm/bitops.h +3 -6
@@ -76,17 +76,14 @@ bool clear_mask16_timeout(uint16_t mask, volatile void *p,* the clz instruction for much better code efficiency. */ -static inline int fls (unsigned int x) +static always_inline unsigned int arch_fls(unsigned int x) { -int ret; - -if (__builtin_constant_p (x)) -return generic_fls (x); +unsigned int ret; asm("clz\t%" __OP32"0, %" __OP32"1" :"=r" (ret) :"r" (x));return 32 - ret; } - +#define arch_fls arch_fls#define ffs (x) ({ unsigned int __t = (x); fls(ISOLATE_LSB(__t)); })#define ffsl (x) ({ unsigned long __t = (x); flsl(ISOLATE_LSB(__t)); })
xen/arch/ppc/include/asm/bitops.h +0 -2
@@ -117,8 +117,6 @@ static inline int test_and_set_bit(unsigned int nr, volatile void *addr) (volatile unsigned int *)addr + BITOP_WORD(nr)) != 0; } -#define flsl (x) generic_flsl(x) -#define fls (x) generic_fls(x)#define ffs (x) ({ unsigned int t_ = (x); fls(t_ & -t_); })#define ffsl (x) ({ unsigned long t_ = (x); flsl(t_ & -t_); })
xen/arch/x86/include/asm/bitops.h +7 -5
@@ -434,20 +434,21 @@ static inline int ffs(unsigned int x)* * This is defined the same way as ffs. */ -static inline int flsl (unsigned long x) +static always_inline unsigned int arch_flsl(unsigned long x) { -long r; +unsigned long r; asm ("bsr %1,%0\n\t" "jnz 1f\n\t" "mov $-1,%0\n" "1:" :"=r" (r) :"rm" (x)); -return (int )r+1 ; +return r +1 ; } +#define arch_flsl arch_flsl -static inline int fls (unsigned int x) +static always_inline unsigned int arch_fls(unsigned int x) { -int r; +unsigned int r; asm ("bsr %1,%0\n\t" "jnz 1f\n\t"
@@ -455,6 +456,7 @@ static inline int fls(unsigned int x) "1:" : "=r" (r) : "rm" (x)); return r +1 ; } +#define arch_fls arch_fls/** * hweightN - returns the hamming weight of a N-bit word
xen/common/page_alloc.c +2 -2
@@ -1842,7 +1842,7 @@ static void _init_heap_pages(const struct page_info *pg,* Note that the value of ffsl() and flsl() starts from 1 so we need * to decrement it by 1. */ -unsigned int inc_order =min (MAX_ORDER ,flsl (e - s) -1 ); +unsigned int inc_order =min (MAX_ORDER +0U ,flsl (e - s) -1 );if ( s ) inc_order =min (inc_order,ffsl (s) -1U );
@@ -2266,7 +2266,7 @@ void __init xenheap_max_mfn(unsigned long mfn)ASSERT (!first_node_initialised);ASSERT (!xenheap_bits);BUILD_BUG_ON ((PADDR_BITS -PAGE_SHIFT ) >=BITS_PER_LONG ); - xenheap_bits =min (flsl (mfn +1 ) -1 +PAGE_SHIFT ,PADDR_BITS ); + xenheap_bits =min (flsl (mfn +1 ) -1 +PAGE_SHIFT ,PADDR_BITS +0U );printk (XENLOG_INFO "Xen heap: %u bits\n" , xenheap_bits); }
xen/include/xen/bitops.h +24 -0
@@ -290,6 +290,30 @@ static always_inline bool test_bit(int nr, const volatile void *addr)test_bit (nr, addr); \ }) +static always_inline __pure unsigned int fls(unsigned int x) +{ +if (__builtin_constant_p (x) ) +return generic_fls (x); + +#ifndef arch_fls +#define arch_fls generic_fls +#endif + +return arch_fls (x); +} + +static always_inline __pure unsigned int flsl(unsigned long x) +{ +if (__builtin_constant_p (x) ) +return generic_flsl (x); + +#ifndef arch_flsl +#define arch_flsl generic_flsl +#endif + +return arch_flsl (x); +} +#ifndef find_next_bit/** * find_next_bit - find the next set bit in a memory region
Signature · 1 line
2.45.0
PATCH v11 5/9 xen/riscv: add definition of __read_mostly
In reply to Oleksii KurochkoThe definition of __read_mostly should be removed in:
https://lore.kernel.org/xen-devel/[email protected]/
The patch introduces it in arch-specific header to not block enabling of full Xen build for RISC-V.
---
- [PATCH] move __read_mostly to xen/cache.h [2]
Right now, the patch series doesn't have a direct dependency on [2] and it provides __read_mostly in the patch:
[PATCH v3 26/34] xen/riscv: add definition of __read_mostly
However, it will be dropped as soon as [2] is merged or at least when the final version of the patch [2] is provided.
Considering that there is still no still final decision regarding patch [2] my suggestion is to merge RISC-V specific patch and just drop the changes in patch [2].
[2] https://lore.kernel.org/xen-devel/[email protected]/
---
Changes in V9-V11:
- Only rebase was done.
---
Change in V8:
- update the footer after Signed-off.
---
Changes in V4-V7:
- Nothing changed. Only rebase.
--- xen/arch/riscv/include/asm/cache.h | 2 ++ 1 file changed, 2 insertions(+)
xen/arch/riscv/include/asm/cache.h +2 -0
@@ -3,4 +3,6 @@#ifndef _ASM_RISCV_CACHE_H#define _ASM_RISCV_CACHE_H +#define __read_mostly __section(".data.read_mostly") +#endif /* _ASM_RISCV_CACHE_H */
Signature · 1 line
2.45.0
PATCH v11 6/9 xen/riscv: add minimal stuff to mm.h to build full Xen
In reply to Oleksii Kurochko---
Changes in V8-V11:
- Nothing changed only rebase.
---
Changes in V7:
- update argument type of maddr_to_virt() function: unsigned long -> paddr_t
- rename argument of PFN_ORDER(): pfn -> pg.
- add Acked-by: Jan Beulich <[email protected]>
---
Changes in V6:
- drop __virt_to_maddr() ( transform to macro ) and __maddr_to_virt ( rename to maddr_to_virt ).
- parenthesize va in definition of vmap_to_mfn().
- Code style fixes.
---
Changes in V5:
- update the comment around "struct domain *domain;" : zero -> NULL
- fix ident. for unsigned long val;
- put page_to_virt() and virt_to_page() close to each other.
- drop unnessary leading underscore
- drop a space before the comment: /* Count of uses of this frame as its current type. */
- drop comment about a page 'not as a shadow'. it is not necessary for RISC-V
---
Changes in V4:
- update an argument name of PFN_ORDERN macros.
- drop pad at the end of 'struct page_info'.
- Change message -> subject in "Changes in V3"
- delete duplicated macros from riscv/mm.h
- fix identation in struct page_info
- align comment for PGC_ macros
- update definitions of domain_set_alloc_bitsize() and domain_clamp_alloc_bitsize()
- drop unnessary comments.
- s/BUG/BUG_ON("...")
- define __virt_to_maddr, __maddr_to_virt as stubs
- add inclusion of xen/mm-frame.h for mfn_x and others
- include "xen/mm.h" instead of "asm/mm.h" to fix compilation issues:
In file included from arch/riscv/setup.c:7:
./arch/riscv/include/asm/mm.h:60:28: error: field 'list' has incomplete type
60 | struct page_list_entry list;
| ^~~~
./arch/riscv/include/asm/mm.h:81:43: error: 'MAX_ORDER' undeclared here (not in a function)
81 | unsigned long first_dirty:MAX_ORDER + 1;
| ^~~~~~~~~
./arch/riscv/include/asm/mm.h:81:31: error: bit-field 'first_dirty' width not an integer constant
81 | unsigned long first_dirty:MAX_ORDER + 1;
- Define __virt_to_mfn() and __mfn_to_virt() using maddr_to_mfn() and mfn_to_maddr().
---
Changes in V3:
- update the commit title
- introduce DIRECTMAP_VIRT_START.
- drop changes related pfn_to_paddr() and paddr_to_pfn as they were remvoe in
[PATCH v2 32/39] xen/riscv: add minimal stuff to asm/page.h to build full Xen
- code style fixes.
- drop get_page_nr and put_page_nr as they don't need for time being
- drop CONFIG_STATIC_MEMORY related things
- code style fixes
---
Changes in V2:
- define stub for arch_get_dma_bitsize(void)
--- xen/arch/riscv/include/asm/mm.h | 240 ++++++++++++++++++++++++++++++++ xen/arch/riscv/mm.c | 2 +- xen/arch/riscv/setup.c | 2 +- 3 files changed, 242 insertions(+), 2 deletions(-)
xen/arch/riscv/include/asm/mm.h +240 -0
@@ -3,11 +3,246 @@#ifndef _ASM_RISCV_MM_H#define _ASM_RISCV_MM_H +#include <public/xen.h> +#include <xen/bug.h> +#include <xen/mm-frame.h> +#include <xen/pdx.h> +#include <xen/types.h> +#include <asm/page-bits.h> #define pfn_to_paddr (pfn) ((paddr_t)(pfn) << PAGE_SHIFT)#define paddr_to_pfn (pa) ((unsigned long)((pa) >> PAGE_SHIFT)) +#define paddr_to_pdx (pa) mfn_to_pdx(maddr_to_mfn(pa)) +#define gfn_to_gaddr (gfn) pfn_to_paddr(gfn_x(gfn)) +#define gaddr_to_gfn (ga) _gfn(paddr_to_pfn(ga)) +#define mfn_to_maddr (mfn) pfn_to_paddr(mfn_x(mfn)) +#define maddr_to_mfn (ma) _mfn(paddr_to_pfn(ma)) +#define vmap_to_mfn (va) maddr_to_mfn(virt_to_maddr((vaddr_t)(va))) +#define vmap_to_page (va) mfn_to_page(vmap_to_mfn(va)) + +static inline void *maddr_to_virt (paddr_t ma) +{ +BUG_ON ("unimplemented" ); +return NULL ; +} + +#define virt_to_maddr (va) ({ BUG_ON("unimplemented"); 0; }) + +/* Convert between Xen-heap virtual addresses and machine frame numbers. */ +#define __virt_to_mfn (va) mfn_x(maddr_to_mfn(virt_to_maddr(va))) +#define __mfn_to_virt (mfn) maddr_to_virt(mfn_to_maddr(_mfn(mfn))) + +/* +* We define non-underscored wrappers for above conversion functions. +* These are overriden in various source files while underscored version +* remain intact. +*/ +#define virt_to_mfn (va) __virt_to_mfn(va) +#define mfn_to_virt (mfn) __mfn_to_virt(mfn) + +struct page_info +{ +/* Each frame can be threaded onto a doubly-linked list. */ +struct page_list_entry list; + +/* Reference count and various PGC_xxx flags and fields. */ +unsigned long count_info; + +/* Context-dependent fields follow... */ +union { +/* Page is in use: ((count_info & PGC_count_mask) != 0). */ +struct { +/* Type reference count and various PGT_xxx flags and fields. */ +unsigned long type_info; + } inuse; + +/* Page is on a free list: ((count_info & PGC_count_mask) == 0). */ +union { +struct { +/* +* Index of the first *possibly* unscrubbed page in the buddy. +* One more bit than maximum possible order to accommodate +* INVALID_DIRTY_IDX. +*/ +#define INVALID_DIRTY_IDX ((1UL << (MAX_ORDER + 1)) - 1) +unsigned long first_dirty:MAX_ORDER +1 ; + +/* Do TLBs need flushing for safety before next page use? */ +bool need_tlbflush:1 ; + +#define BUDDY_NOT_SCRUBBING 0 +#define BUDDY_SCRUBBING 1 +#define BUDDY_SCRUB_ABORT 2 +unsigned long scrub_state:2 ; + }; + +unsigned long val; + } free; + } u; + +union { +/* Page is in use */ +struct { +/* Owner of this page (NULL if page is anonymous). */ +struct domain *domain; + } inuse; + +/* Page is on a free list. */ +struct { +/* Order-size of the free chunk this page is the head of. */ +unsigned int order; + } free; + } v; + +union { +/* +* Timestamp from 'TLB clock', used to avoid extra safety flushes. +* Only valid for: a) free pages, and b) pages with zero type count +*/ +uint32_t tlbflush_timestamp; + }; +}; + +#define frame_table ((struct page_info *)FRAMETABLE_VIRT_START) + +/* PDX of the first page in the frame table. */ +extern unsigned long frametable_base_pdx; + +/* Convert between machine frame numbers and page-info structures. */ +#define mfn_to_page (mfn) \ + (frame_table + (mfn_to_pdx(mfn) - frametable_base_pdx)) +#define page_to_mfn (pg) \ + pdx_to_mfn((unsigned long)((pg) - frame_table) + frametable_base_pdx) + +static inline void *page_to_virt (const struct page_info *pg) +{ +return mfn_to_virt (mfn_x (page_to_mfn (pg))); +} + +/* Convert between Xen-heap virtual addresses and page-info structures. */ +static inline struct page_info *virt_to_page (const void *v) +{ +BUG_ON ("unimplemented" ); +return NULL ; +} + +/* +* Common code requires get_page_type and put_page_type. +* We don't care about typecounts so we just do the minimum to make it +* happy. +*/ +static inline int get_page_type (struct page_info *page,unsigned long type) +{ +return 1 ; +} + +static inline void put_page_type (struct page_info *page) +{ +} + +static inline void put_page_and_type (struct page_info *page) +{ +put_page_type (page); +put_page (page); +} + +/* +* RISC-V does not have an M2P, but common code expects a handful of +* M2P-related defines and functions. Provide dummy versions of these. +*/ +#define INVALID_M2P_ENTRY (~0UL) +#define SHARED_M2P_ENTRY (~0UL - 1UL) +#define SHARED_M2P (_e) ((_e) == SHARED_M2P_ENTRY) + +#define set_gpfn_from_mfn (mfn, pfn) do { (void)(mfn), (void)(pfn); } while (0) +#define mfn_to_gfn (d, mfn) ((void)(d), _gfn(mfn_x(mfn))) + +#define PDX_GROUP_SHIFT (PAGE_SHIFT + VPN_BITS) + +static inline unsigned long domain_get_maximum_gpfn (struct domain *d) +{ +BUG_ON ("unimplemented" ); +return 0 ; +} + +static inline long arch_memory_op (int op,XEN_GUEST_HANDLE_PARAM (void ) arg) +{ +BUG_ON ("unimplemented" ); +return 0 ; +} + +/* +* On RISCV, all the RAM is currently direct mapped in Xen. +* Hence return always true. +*/ +static inline bool arch_mfns_in_directmap (unsigned long mfn,unsigned long nr) +{ +return true; +} + +#define PG_shift (idx) (BITS_PER_LONG - (idx)) +#define PG_mask (x, idx) (x ## UL << PG_shift(idx)) + +#define PGT_none PG_mask(0, 1)/* no special uses of this page */ +#define PGT_writable_page PG_mask(1, 1)/* has writable mappings? */ +#define PGT_type_mask PG_mask(1, 1)/* Bits 31 or 63. */ + +/* Count of uses of this frame as its current type. */ +#define PGT_count_width PG_shift(2) +#define PGT_count_mask ((1UL << PGT_count_width) - 1) + +/* +* Page needs to be scrubbed. Since this bit can only be set on a page that is +* free (i.e. in PGC_state_free) we can reuse PGC_allocated bit. +*/ +#define _PGC_need_scrub _PGC_allocated +#define PGC_need_scrub PGC_allocated + +/* Cleared when the owning guest 'frees' this page. */ +#define _PGC_allocated PG_shift(1) +#define PGC_allocated PG_mask(1, 1) +/* Page is Xen heap? */ +#define _PGC_xen_heap PG_shift(2) +#define PGC_xen_heap PG_mask(1, 2) +/* Page is broken? */ +#define _PGC_broken PG_shift(7) +#define PGC_broken PG_mask(1, 7) +/* Mutually-exclusive page states: { inuse, offlining, offlined, free }. */ +#define PGC_state PG_mask(3, 9) +#define PGC_state_inuse PG_mask(0, 9) +#define PGC_state_offlining PG_mask(1, 9) +#define PGC_state_offlined PG_mask(2, 9) +#define PGC_state_free PG_mask(3, 9) +#define page_state_is (pg, st) (((pg)->count_info&PGC_state) == PGC_state_##st) + +/* Count of references to this frame. */ +#define PGC_count_width PG_shift(9) +#define PGC_count_mask ((1UL << PGC_count_width) - 1) + +#define _PGC_extra PG_shift(10) +#define PGC_extra PG_mask(1, 10) + +#define is_xen_heap_page (page) ((page)->count_info & PGC_xen_heap) +#define is_xen_heap_mfn (mfn) \ + (mfn_valid(mfn) && is_xen_heap_page(mfn_to_page(mfn))) + +#define is_xen_fixed_mfn (mfn) \ + ((mfn_to_maddr(mfn) >= virt_to_maddr((vaddr_t)_start)) && \ + (mfn_to_maddr(mfn) <= virt_to_maddr((vaddr_t)_end - 1))) + +#define page_get_owner (p) (p)->v.inuse.domain +#define page_set_owner (p, d) ((p)->v.inuse.domain = (d)) + +/* TODO: implement */ +#define mfn_valid (mfn) ({ (void)(mfn); 0; }) + +#define domain_set_alloc_bitsize (d) ((void)(d)) +#define domain_clamp_alloc_bitsize (d, b) ((void)(d), (b)) + +#define PFN_ORDER (pg) ((pg)->v.free.order) +extern unsigned char cpu0_boot_stack[];void setup_initial_pagetables (void );
@@ -20,4 +255,9 @@ unsigned long calc_phys_offset(void);void turn_on_mmu (unsigned long ra); +static inline unsigned int arch_get_dma_bitsize (void ) +{ +return 32 ;/* TODO */ +} +#endif /* _ASM_RISCV_MM_H */
xen/arch/riscv/mm.c +1 -1
@@ -5,12 +5,12 @@#include <xen/init.h> #include <xen/kernel.h> #include <xen/macros.h> +#include <xen/mm.h> #include <xen/pfn.h> #include <asm/early_printk.h> #include <asm/csr.h> #include <asm/current.h> -#include <asm/mm.h> #include <asm/page.h> #include <asm/processor.h>
xen/arch/riscv/setup.c +1 -1
@@ -2,9 +2,9 @@#include <xen/compile.h> #include <xen/init.h> +#include <xen/mm.h> #include <asm/early_printk.h> -#include <asm/mm.h> /* Xen stack for bringing up the first CPU. */ unsigned char __initdata cpu0_boot_stack[STACK_SIZE ]
Signature · 1 line
2.45.0
v11 cover Enable build of full Xen for RISC-V
This patch series performs all of the additions necessary to drop the build overrides for RISCV and enable the full Xen build. Except in cases where compatibile implementations already exist (e.g. atomic.h and bitops.h), the newly added definitions are simple.
The patch series is based on the following patch series:
- [PATCH 0/7] xen/bitops: Reduce the mess, starting with ffs() [1]
- [PATCH] move __read_mostly to xen/cache.h [2]
Right now, the patch series doesn't have a direct dependency on [2] and it provides __read_mostly in the patch:
[PATCH v3 26/34] xen/riscv: add definition of __read_mostly
However, it will be dropped as soon as [2] is merged or at least when the final version of the patch [2] is provided.
As an option, it can be considered to merge arch-specific patch and then just rebase [2] and drop arch-specific changes.
[1] https://lore.kernel.org/xen-devel/[email protected]/T/#t
[2] https://lore.kernel.org/xen-devel/[email protected]/
---
Changes in V11:
- Patch was merged to staging:
- [PATCH v10 05/14] xen/riscv: introduce cmpxchg.h
- [PATCH v10 06/14] xen/riscv: introduce atomic.h
- [PATCH v10 07/14] xen/riscv: introduce monitor.h
- [PATCH v10 09/14] xen/riscv: add required things to current.h
- [PATCH v10 11/14] xen/riscv: introduce vm_event_*() functions
- Other changes are specific to specific patches. Please look at changes for specific patch.
---
Changes in V10:
- Patch was merged to staging:
- [PATCH v9 04/15] xen/bitops: put __ffs() into linux compatible header
- Other changes are specific to specific patches. Please look at changes for specific patch.
---
Changes in V9:
- Patch was merged to staging:
- [PATCH v8 07/17] xen/riscv: introduce io.h
- [PATCH v7 14/19] xen/riscv: add minimal stuff to page.h to build full Xen
- Other changes are specific to specific patches. Please look at changes for specific patch.
---
Changes in V8:
- Patch was merged to staging:
- [PATCH v7 01/19] automation: introduce fixed randconfig for RISC-V
- [PATCH v7 03/19] xen/riscv: introduce extenstion support check by compiler
- Other changes are specific to specific patches. Please look at changes for specific patch.
- Update the commit message:
- drop the dependency from STATIC_ASSERT_UNREACHABLE() implementation.
- Add suggestion to merge arch-specific changes related to __read_mostly.
---
Changes in V7:
- Patch was merged to staging:
[PATCH v6 15/20] xen/riscv: add minimal stuff to processor.h to build full Xen.
- Other changes are specific to specific patches. Please look at changes for specific patch.
---
Changes in V6:
- Update the cover letter message: drop already merged dependecies and add
a new one.
- Patches were merged to staging:
- [PATCH v5 02/23] xen/riscv: use some asm-generic headers ( even v4 was merged to staging branch, I just wasn't apply changes on top of the latest staging branch )
- [PATCH v5 03/23] xen/riscv: introduce nospec.h
- [PATCH v5 10/23] xen/riscv: introduces acrquire, release and full barriers
- Introduce new patches:
- xen/riscv: introduce extenstion support check by compiler
- xen/bitops: put __ffs() and ffz() into linux compatible header
- xen/bitops: implement fls{l}() in common logic
- The following patches were dropped:
- drop some patches related to bitops operations as they were introduced in another
patch series [...]
- introduce new version for generic __ffs(), ffz() and fls{l}().
- Merge patch from patch series "[PATCH v9 0/7] Introduce generic headers" to this patch series as only one patch left in the generic headers patch series and it is more about RISC-V.
- Other changes are specific to specific patches. please look at specific patch.
---
Changes in V5:
- Update the cover letter as one of the dependencies were merged to staging.
- Was introduced asm-generic for atomic ops and separate patches for asm-generic bit ops
- Moved fence.h to separate patch to deal with some patches dependecies on fence.h
- Patches were dropped as they were merged to staging:
* [PATCH v4 03/30] xen: add support in public/hvm/save.h for PPC and RISC-V
* [PATCH v4 04/30] xen/riscv: introduce cpufeature.h
* [PATCH v4 05/30] xen/riscv: introduce guest_atomics.h
* [PATCH v4 06/30] xen: avoid generation of empty asm/iommu.h
* [PATCH v4 08/30] xen/riscv: introduce setup.h
* [PATCH v4 10/30] xen/riscv: introduce flushtlb.h
* [PATCH v4 11/30] xen/riscv: introduce smp.h
* [PATCH v4 15/30] xen/riscv: introduce irq.h
* [PATCH v4 16/30] xen/riscv: introduce p2m.h
* [PATCH v4 17/30] xen/riscv: introduce regs.h
* [PATCH v4 18/30] xen/riscv: introduce time.h
* [PATCH v4 19/30] xen/riscv: introduce event.h
* [PATCH v4 22/30] xen/riscv: define an address of frame table
- Other changes are specific to specific patches. please look at specific patch
---
Changes in V4:
- Update the cover letter message: new patch series dependencies.
- Some patches were merged to staging, so they were dropped in this patch series:
[PATCH v3 09/34] xen/riscv: introduce system.h
[PATCH v3 18/34] xen/riscv: introduce domain.h
[PATCH v3 19/34] xen/riscv: introduce guest_access.h
- Was sent out of this patch series:
[PATCH v3 16/34] xen/lib: introduce generic find next bit operations
- [PATCH v3 17/34] xen/riscv: add compilation of generic find-next-bit.c was droped as CONFIG_GENERIC_FIND_NEXT_BIT was dropped.
- All other changes are specific to a specific patch.
---
Changes in V3:
- Update the cover letter message
- The following patches were dropped as they were merged to staging:
[PATCH v2 03/39] xen/riscv:introduce asm/byteorder.h
[PATCH v2 04/39] xen/riscv: add public arch-riscv.h
[PATCH v2 05/39] xen/riscv: introduce spinlock.h
[PATCH v2 20/39] xen/riscv: define bug frame tables in xen.lds.S
[PATCH v2 34/39] xen: add RISCV support for pmu.h
[PATCH v2 35/39] xen: add necessary headers to common to build full Xen for RISC-V
- Instead of the following patches were introduced new:
[PATCH v2 10/39] xen/riscv: introduce asm/iommu.h
[PATCH v2 11/39] xen/riscv: introduce asm/nospec.h
- remove "asm/" for commit messages which start with "xen/riscv:"
- code style updates.
- add emulation of {cmp}xchg_* for 1 and 2 bytes types.
- code style fixes.
- add SPDX and footer for the newly added headers.
- introduce generic find-next-bit.c.
- some other mionor changes. ( details please find in a patch )
---
Changes in V2:
- Drop the following patches as they are the part of [2]:
[PATCH v1 06/57] xen/riscv: introduce paging.h
[PATCH v1 08/57] xen/riscv: introduce asm/device.h
[PATCH v1 10/57] xen/riscv: introduce asm/grant_table.h
[PATCH v1 12/57] xen/riscv: introduce asm/hypercall.h
[PATCH v1 13/57] xen/riscv: introduce asm/iocap.h
[PATCH v1 15/57] xen/riscv: introduce asm/mem_access.h
[PATCH v1 18/57] xen/riscv: introduce asm/random.h
[PATCH v1 21/57] xen/riscv: introduce asm/xenoprof.h
[PATCH v1 24/57] xen/riscv: introduce asm/percpu.h
[PATCH v1 29/57] xen/riscv: introduce asm/hardirq.h
[PATCH v1 33/57] xen/riscv: introduce asm/altp2m.h
[PATCH v1 38/57] xen/riscv: introduce asm/monitor.h
[PATCH v1 39/57] xen/riscv: introduce asm/numa.h
[PATCH v1 42/57] xen/riscv: introduce asm/softirq.h
- xen/lib.h in most of the cases were changed to xen/bug.h as
mostly functionilty of bug.h is used.
- align arch-riscv.h with Arm's version of it.
- change the Author of commit with introduction of asm/atomic.h.
- update some definition from spinlock.h.
- code style changes.
---
Oleksii Kurochko (9):
xen/riscv: disable unnecessary configs
xen: introduce generic non-atomic test_*bit()
xen/bitops: implement fls{l}() in common logic
xen/riscv: introduce bitops.h
xen/riscv: add definition of __read_mostly
xen/riscv: add minimal stuff to mm.h to build full Xen
xen/riscv: add minimal amount of stubs to build full Xen
xen/riscv: enable full Xen build
xen/README: add compiler and binutils versions for RISC-V64
README | 4 + automation/gitlab-ci/build.yaml | 4 + xen/arch/arm/include/asm/arm32/bitops.h | 2 +- xen/arch/arm/include/asm/arm64/bitops.h | 6 +- xen/arch/arm/include/asm/bitops.h | 78 +---- xen/arch/ppc/include/asm/bitops.h | 56 ---- xen/arch/ppc/include/asm/page.h | 2 +- xen/arch/ppc/mm-radix.c | 2 +- xen/arch/riscv/Makefile | 17 +- xen/arch/riscv/arch.mk | 4 - xen/arch/riscv/configs/tiny64_defconfig | 12 +- xen/arch/riscv/early_printk.c | 168 ---------- xen/arch/riscv/include/asm/bitops.h | 137 ++++++++ xen/arch/riscv/include/asm/cache.h | 2 + xen/arch/riscv/include/asm/domain.h | 2 + xen/arch/riscv/include/asm/mm.h | 240 ++++++++++++++ xen/arch/riscv/include/asm/p2m.h | 2 + xen/arch/riscv/mm.c | 52 ++- xen/arch/riscv/setup.c | 10 +- xen/arch/riscv/stubs.c | 415 ++++++++++++++++++++++++ xen/arch/riscv/traps.c | 25 ++ xen/arch/x86/include/asm/bitops.h | 43 +-- xen/common/page_alloc.c | 4 +- xen/include/xen/bitops.h | 209 ++++++++++++ 24 files changed, 1147 insertions(+), 349 deletions(-) create mode 100644 xen/arch/riscv/include/asm/bitops.h create mode 100644 xen/arch/riscv/stubs.c
Signature · 1 line
2.45.0
PATCH v11 1/9 xen/riscv: disable unnecessary configs
Disables unnecessary configs for two cases:
1. By utilizing EXTRA_FIXED_RANDCONFIG for randconfig builds (GitLab CI jobs).
2. By using tiny64_defconfig for non-randconfig builds.
Only configs which lead to compilation issues were disabled.
Remove lines related to disablement of configs which aren't affected compilation:
-# CONFIG_SCHED_CREDIT is not set
-# CONFIG_SCHED_RTDS is not set
-# CONFIG_SCHED_NULL is not set
-# CONFIG_SCHED_ARINC653 is not set
-# CONFIG_TRACEBUFFER is not set
-# CONFIG_HYPFS is not set
-# CONFIG_SPECULATIVE_HARDEN_ARRAY is not set
To allow CONFIG_ARGO build happy it was included <asm/p2m.h> to <asm/domain.h> as ARGO requires p2m_type_t ( p2m_ram_rw ) and declaration of check_get_page_from_gfn() from xen/p2m-common.h.
Also, it was included <xen/errno.h> to asm/p2m.h as after the latter was included to <asm/domain.h> the compilation error that EINVAL, EOPNOTSUPP aren't declared started to occur.
CONFIG_XSM=n as it requires an introduction of:
* boot_module_find_by_kind()
* BOOTMOD_XSM
* struct bootmodule
* copy_from_paddr()
The mentioned things aren't introduced now.
CPU_BOOT_TIME_CPUPOOLS requires an introduction of cpu_physical_id() and acpi_disabled, so it is disabled for now.
PERF_COUNTERS requires asm/perf.h and asm/perfc-defn.h, so it is also disabled for now, as RISC-V hasn't introduced this headers yet.
LIVEPATCH isn't ready for RISC-V too and it can be overriden by randconfig, so to avoid compilation errors for randconfig it is disabled for now.
---
Changes in V10-V11:
- Nothing changed. Only rebase.
---
Changes in V9:
- update the commit message: add info about LIVEPATCH and PERF_COUNTERS.
---
Changes in V8:
- disabled CPU_BOOT_TIME_CPUPOOLS as it requires an introduction of cpu_physical_id() and acpi_disabled.
- leave XSM disabled, add explanation in the commit message.
- drop HYPFS as the patch was provided to resolve compilation issue when this condif is enabled for RISC-V.
- include asm/p2m.h to asm/domain.h, and xen/errno.h to asm/p2m.h to drop ARGO config from tiny64_defconfing and build.yaml.
- update the commit message.
---
Changes in V7:
- Disable only configs which cause compilation issues.
- Update the commit message.
---
Changes in V6:
- Nothing changed. Only rebase.
---
Changes in V5:
- Rebase and drop duplicated configs in EXTRA_FIXED_RANDCONFIG list
- Update the commit message
---
Changes in V4:
- Nothing changed. Only rebase
---
Changes in V3:
- Remove EXTRA_FIXED_RANDCONFIG for non-randconfig jobs.
For non-randconfig jobs, it is sufficient to disable configs by using the defconfig.
- Remove double blank lines in build.yaml file before archlinux-current-gcc-riscv64-debug
---
Changes in V2:
- update the commit message.
- remove xen/arch/riscv/Kconfig changes.
--- automation/gitlab-ci/build.yaml | 4 ++++ xen/arch/riscv/configs/tiny64_defconfig | 12 +++++------- xen/arch/riscv/include/asm/domain.h | 2 ++ xen/arch/riscv/include/asm/p2m.h | 2 ++ 4 files changed, 13 insertions(+), 7 deletions(-)
automation/gitlab-ci/build.yaml +4 -0
@@ -494,10 +494,14 @@ alpine-3.18-gcc-debug-arm64-earlyprintk: .riscv-fixed-randconfig: variables: &riscv-fixed-randconfig EXTRA_FIXED_RANDCONFIG: | + CONFIG_BOOT_TIME_CPUPOOLS=n CONFIG_COVERAGE=n CONFIG_EXPERT=y CONFIG_GRANT_TABLE=n CONFIG_MEM_ACCESS=n + CONFIG_PERF_COUNTERS=n + CONFIG_LIVEPATCH=n + CONFIG_XSM=n archlinux-current-gcc-riscv64: extends: .gcc-riscv64-cross-build
xen/arch/riscv/configs/tiny64_defconfig +5 -7
@@ -1,12 +1,10 @@ -# CONFIG_SCHED_CREDIT is not set -# CONFIG_SCHED_RTDS is not set -# CONFIG_SCHED_NULL is not set -# CONFIG_SCHED_ARINC653 is not set -# CONFIG_TRACEBUFFER is not set -# CONFIG_HYPFS is not set +# CONFIG_BOOT_TIME_CPUPOOLS is not set # CONFIG_GRANT_TABLE is not set -# CONFIG_SPECULATIVE_HARDEN_ARRAY is not set # CONFIG_MEM_ACCESS is not set +# CONFIG_PERF_COUNTERS is not set +# CONFIG_COVERAGE is not set +# CONFIG_LIVEPATCH is not set +# CONFIG_XSM is not set CONFIG_RISCV_64=y CONFIG_DEBUG=y
xen/arch/riscv/include/asm/domain.h +2 -0
@@ -5,6 +5,8 @@#include <xen/xmalloc.h> #include <public/hvm/params.h> +#include <asm/p2m.h> +struct hvm_domain {uint64_t params[HVM_NR_PARAMS ];
xen/arch/riscv/include/asm/p2m.h +2 -0
@@ -2,6 +2,8 @@#ifndef __ASM_RISCV_P2M_H__#define __ASM_RISCV_P2M_H__ +#include <xen/errno.h> +#include <asm/page-bits.h> #define paddr_bits PADDR_BITS
Signature · 1 line
2.45.0
PATCH v11 9/9 xen/README: add compiler and binutils versions for RISC-V64
In reply to Oleksii KurochkoThis patch doesn't represent a strict lower bound for GCC and GNU Binutils; rather, these versions are specifically employed by the Xen RISC-V container and are anticipated to undergo continuous testing. Older GCC and GNU Binutils would work,
but this is not a guarantee.
While it is feasible to utilize Clang, it's important to note that, currently, there is no Xen RISC-V CI job in place to verify the seamless functioning of the build with Clang.
--
Changes in V5-V11:
- Nothing changed. Only rebase.
---
Changes in V6:
- update the message in README.
---
Changes in V5:
- update the commit message and README file with additional explanation about GCC and GNU Binutils version. Additionally, it was added information about Clang.
---
Changes in V4:
- Update version of GCC (12.2) and GNU Binutils (2.39) to the version which are in Xen's contrainter for RISC-V
---
Changes in V3:
- new patch
--- README | 4 ++++ 1 file changed, 4 insertions(+)
README +4 -0
@@ -48,6 +48,10 @@ provided by your OS distributor: - For ARM 64-bit: - GCC 5.1 or later - GNU Binutils 2.24 or later + - For RISC-V 64-bit: + - GCC 12.2 or later + - GNU Binutils 2.39 or later + Older GCC and GNU Binutils would work, but this is not a guarantee. * POSIX compatible awk * Development install of zlib (e.g., zlib-dev) * Development install of Python 2.7 or later (e.g., python-dev)
Signature · 1 line
2.45.0
PATCH v11 7/9 xen/riscv: add minimal amount of stubs to build full Xen
In reply to Oleksii Kurochko---
Changes in V7-V11:
- Only rebase was done.
---
Changes in V6:
- update the commit in stubs.c around /* ... common/irq.c ... */
- add Acked-by: Jan Beulich <[email protected]>
---
Changes in V5:
- drop unrelated changes
- assert_failed("unimplmented...") change to BUG_ON()
---
Changes in V4:
- added new stubs which are necessary for compilation after rebase: __cpu_up(), __cpu_disable(), __cpu_die() from smpboot.c
- back changes related to printk() in early_printk() as they should be removed in the next patch to avoid compilation error.
- update definition of cpu_khz: __read_mostly -> __ro_after_init.
- drop vm_event_reset_vmtrace(). It is defibed in asm-generic/vm_event.h.
- move vm_event_*() functions from stubs.c to riscv/vm_event.c.
- s/BUG/BUG_ON("unimplemented") in stubs.c
- back irq_actor_none() and irq_actor_none() as common/irq.c isn't compiled at this moment, so this function are needed to avoid compilation error.
- defined max_page to avoid compilation error, it will be removed as soon as common/page_alloc.c will be compiled.
---
Changes in V3:
- code style fixes.
- update attribute for frametable_base_pdx and frametable_virt_end to __ro_after_init. insteaf of read_mostly.
- use BUG() instead of assert_failed/WARN for newly introduced stubs.
- drop "#include <public/vm_event.h>" in stubs.c and use forward declaration instead.
- drop ack_node() and end_node() as they aren't used now.
---
Changes in V2:
- define udelay stub
- remove 'select HAS_PDX' from RISC-V Kconfig because of
https://lore.kernel.org/xen-devel/[email protected]/
--- xen/arch/riscv/Makefile | 1 + xen/arch/riscv/mm.c | 50 +++++ xen/arch/riscv/setup.c | 8 + xen/arch/riscv/stubs.c | 439 ++++++++++++++++++++++++++++++++++++++++ xen/arch/riscv/traps.c | 25 +++ 5 files changed, 523 insertions(+) create mode 100644 xen/arch/riscv/stubs.c
xen/arch/riscv/Makefile +1 -0
@@ -4,6 +4,7 @@ obj-y += mm.o obj-$(CONFIG_RISCV_64) += riscv64/ obj-y += sbi.o obj-y += setup.o +obj-y += stubs.o obj-y += traps.o obj-y += vm_event.o
xen/arch/riscv/mm.c +50 -0
64 lines not on this page · raw message
xen/arch/riscv/setup.c +8 -0
@@ -1,11 +1,19 @@/* SPDX-License-Identifier: GPL-2.0-only */ +#include <xen/bug.h> #include <xen/compile.h> #include <xen/init.h> #include <xen/mm.h> +#include <public/version.h> +#include <asm/early_printk.h> +void arch_get_xen_caps (xen_capabilities_info_t *info) +{ +BUG_ON ("unimplemented" ); +} +/* Xen stack for bringing up the first CPU. */ unsigned char __initdata cpu0_boot_stack[STACK_SIZE ]__aligned(STACK_SIZE) ;
xen/arch/riscv/stubs.c new file +439 -0
439 lines not on this page · raw message
xen/arch/riscv/traps.c +25 -0
@@ -4,6 +4,10 @@* * RISC-V Trap handlers */ + +#include <xen/lib.h> +#include <xen/sched.h> +#include <asm/processor.h> #include <asm/traps.h>
@@ -11,3 +15,24 @@ void do_trap(struct cpu_user_regs *cpu_regs) {die (); } + +void vcpu_show_execution_state (struct vcpu *v) +{ +BUG_ON ("unimplemented" ); +} + +void show_execution_state (const struct cpu_user_regs *regs) +{ +printk ("implement show_execution_state(regs)\n" ); +} + +void arch_hypercall_tasklet_result (struct vcpu *v,long res) +{ +BUG_ON ("unimplemented" ); +} + +enum mc_disposition arch_do_multicall_call (struct mc_state *state) +{ +BUG_ON ("unimplemented" ); +return mc_continue; +}
Signature · 1 line
2.45.0
PATCH v11 8/9 xen/riscv: enable full Xen build
In reply to Oleksii Kurochko---
At least this patch cann't be merged w/o Andrew's patch series is merged as ffs related functions are used from that patch series:
https://lore.kernel.org/xen-devel/[email protected]/T/#t
---
Changes in V5-V11:
- Nothing changed. Only rebase.
- Add the footer after Signed-off section.
---
Changes in V4:
- drop stubs for irq_actor_none() and irq_actor_none() as common/irq.c is compiled now.
- drop defintion of max_page in stubs.c as common/page_alloc.c is compiled now.
- drop printk() related changes in riscv/early_printk.c as common version will be used.
---
Changes in V3:
- Reviewed-by: Jan Beulich <[email protected]>
- unrealted change dropped in tiny64_defconfig
---
Changes in V2:
- Nothing changed. Only rebase.
---
xen/arch/riscv/Makefile | 16 +++- xen/arch/riscv/arch.mk | 4 - xen/arch/riscv/early_printk.c | 168 ---------------------------------- xen/arch/riscv/stubs.c | 24 ----- 4 files changed, 15 insertions(+), 197 deletions(-)
xen/arch/riscv/Makefile +15 -1
@@ -12,10 +12,24 @@ $(TARGET): $(TARGET)-syms $(OBJCOPY) -O binary -S $< $@ $(TARGET)-syms: $(objtree)/prelink.o $(obj)/xen.lds - $(LD) $(XEN_LDFLAGS) -T $(obj)/xen.lds -N $< $(build_id_linker) -o $@ + $(LD) $(XEN_LDFLAGS) -T $(obj)/xen.lds -N $< \ + $(objtree)/common/symbols-dummy.o -o $(dot-target).0 + $(NM) -pa --format=sysv $(dot-target).0 \ + | $(objtree)/tools/symbols $(all_symbols) --sysv --sort \ + > $(dot-target).0.S + $(MAKE) $(build)=$(@D) $(dot-target).0.o + $(LD) $(XEN_LDFLAGS) -T $(obj)/xen.lds -N $< \ + $(dot-target).0.o -o $(dot-target).1 + $(NM) -pa --format=sysv $(dot-target).1 \ + | $(objtree)/tools/symbols $(all_symbols) --sysv --sort \ + > $(dot-target).1.S + $(MAKE) $(build)=$(@D) $(dot-target).1.o + $(LD) $(XEN_LDFLAGS) -T $(obj)/xen.lds -N $< $(build_id_linker) \ + $(dot-target).1.o -o $@ $(NM) -pa --format=sysv $@ \ | $(objtree)/tools/symbols --all-symbols --xensyms --sysv --sort \ > [email protected] + rm -f $(@D)/.$(@F).[0-9]* $(obj)/xen.lds: $(src)/xen.lds.S FORCE $(call if_changed_dep,cpp_lds_S)
xen/arch/riscv/arch.mk +0 -4
@@ -38,7 +38,3 @@ extensions := $(subst $(space),,$(extensions)) # -mcmodel=medlow would force Xen into the lower half. CFLAGS += $(riscv-generic-flags)$(extensions) -mstrict-align -mcmodel=medany - -# TODO: Drop override when more of the build is working -override ALL_OBJS-y = arch/$(SRCARCH)/built_in.o -override ALL_LIBS-y =
xen/arch/riscv/early_printk.c +0 -168
171 lines not on this page · raw message
xen/arch/riscv/stubs.c +0 -24
@@ -24,12 +24,6 @@ DEFINE_PER_CPU_READ_MOSTLY(cpumask_var_t, cpu_core_mask);nodemask_t __read_mostly node_online_map = { { [0 ] =1UL } }; -/* -* max_page is defined in page_alloc.c which isn't complied for now. -* definition of max_page will be remove as soon as page_alloc is built. -*/ -unsigned long __read_mostly max_page; -/* time.c */ unsigned long __ro_after_init cpu_khz;/* CPU clock frequency in kHz. */
@@ -419,21 +413,3 @@ void __cpu_die(unsigned int cpu) {BUG_ON ("unimplemented" ); } - -/* -* The following functions are defined in common/irq.c, but common/irq.c isn't -* built for now. These changes will be removed there when common/irq.c is -* ready. -*/ - -void cf_check irq_actor_none(struct irq_desc *desc) -{ -BUG_ON ("unimplemented" ); -} - -unsigned int cf_check irq_startup_none(struct irq_desc *desc) -{ -BUG_ON ("unimplemented" ); - -return 0 ; -}
Signature · 1 line
2.45.0
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
In reply to Oleksii KurochkoQuoted 29 lines · Oleksii Kurochko
The following generic functions were introduced:
*test_bit
*generic__test_and_set_bit
*generic__test_and_clear_bit
*generic__test_and_change_bitThese functions and macros can be useful for architectures that don't have corresponding arch-specific instructions.
Also, the patch introduces the following generics which are used by the functions mentioned above:
*BITOP_BITS_PER_WORD
*BITOP_MASK
*BITOP_WORD
*BITOP_TYPE
BITS_PER_BYTEwas moved toxen/bitops.hasBITS_PER_BYTEis the same across architectures.The following approach was chosen for generic*() and arch*() bit operation functions:
If the bit operation function that is going to be generic starts with the prefix "__", then the corresponding generic/arch function will also contain the "__" prefix. For example:
*test_bit()will be defined usingarch_test_bit()andgeneric_test_bit().
*__test_and_set_bit()will be defined usingarch__test_and_set_bit()andgeneric__test_and_set_bit().
Quoted 5 lines
Signed-off-by Oleksii Kurochko <[email protected]>---
version of the patch, but some changes were done, so I wasn't sure if I could use the R-by in this patch version.
That really depends on the nature of the changes. Seeing the pretty long list below, I think it was appropriate to drop the R-b.
Quoted 4 lines
---
Changes in V11:
- fix identation ingeneric_test_bit()function.
- move definition ofBITS_PER_BYTEfrom <arch>/bitops.h toxen/bitops.h
I realize you were asked to do this, but I'm not overly happy with it. BITS_PER_BYTE is far more similar to BITS_PER_LONG than to BITOP_BITS_PER_WORD. Plus in any event that change is entirely unrelated here.
Quoted 22 lines
- drop the changes in
arm64/livepatch.c.
- update the the comments on top of functions:generic__test_and_set_bit(),generic__test_and_clear_bit(),generic__test_and_change_bit(),generic_test_bit().
- Update footer after Signed-off section.
- Rebase the patch on top of staging branch, so it can be merged when necessary approves will be given.
- Update the commit message.--- xen/arch/arm/include/asm/bitops.h | 69 ----------- xen/arch/ppc/include/asm/bitops.h | 54 --------- xen/arch/ppc/include/asm/page.h | 2 +- xen/arch/ppc/mm-radix.c | 2 +- xen/arch/x86/include/asm/bitops.h | 31 ++--- xen/include/xen/bitops.h | 185 ++++++++++++++++++++++++++++++ 6 files changed, 196 insertions(+), 147 deletions(-)xen/include/xen/bitops.h +0
-0@@ -103,8 +103,193 @@ static inline int generic_flsl(unsigned long x)* Include this here because some architectures need generic_ffs/fls in * scope
xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 114
Quoted 10 lines
xen/include/xen/bitops.h +9
-0*/ + +#define BITOP_BITS_PER_WORD 32 +typedef uint32_t bitop_uint_t ; + +#define BITOP_MASK (nr) ((bitop_uint_t)1 << ((nr) % BITOP_BITS_PER_WORD)) + +#define BITOP_WORD (nr) ((nr) / BITOP_BITS_PER_WORD) + +#define BITS_PER_BYTE 8
This, if to be moved at all, very clearly doesn't belong here. As much as it's unrelated to this change, it's also unrelated to bitops as a whole.
Quoted 5 lines
xen/include/xen/bitops.h +5
-0+extern void __bitop_bad_size (void ); + +#define bitop_bad_size (addr) (sizeof(*(addr)) < sizeof(bitop_uint_t)) + +/* --------------------- Please tidy above here --------------------- */
xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 130
Quoted 10 lines
xen/include/xen/bitops.h +8
-0+#include <asm/bitops.h> +/** +* generic__test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +* +* This operation is non-atomic and can be reordered. +* If two examples of this operation race, one can appear to succeed
Why "examples"? Do you mean "instances"? It's further unclear what "succeed" and "fail" here mean. The function after all has two
purposes: Checking and setting the specified bit. Therefore I think you mean "succeed in updating the bit in memory", yet then it's still unclear what the "appear" here means: The caller has no indication of success/failure. Therefore I think "appear to" also wants dropping.
xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 130
Quoted 1 line
xen/include/xen/bitops.h +1
-0+* but actually fail. You must protect multiple accesses with a lock.
That's not "must". An often better alternative is to use the atomic forms instead. "Multiple" is imprecise, too: "Potentially racy" or some such would come closer.
Also did Julien(?) really ask that these comments be reproduced on both the functions supposed to be used throughout the codebase _and_ the generic_*() ones (being merely internal helpers/fallbacks)?
xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 192
Quoted 9 lines
xen/include/xen/bitops.h +9
-0+/** +* generic_test_bit - Determine whether a bit is set +* @nr: bit number to test +* @addr: Address to start counting from +* +* This operation is non-atomic and can be reordered. +* If two examples of this operation race, one can appear to succeed +* but actually fail. You must protect multiple accesses with a lock. +*/
You got carried away updating comments - there's no raciness for simple test_bit(). As is also expressed by its name not having those double underscores that the others have.
Quoted 17 lines
xen/include/xen/bitops.h +17
-0+static always_inline bool generic_test_bit(int nr, const volatile void *addr) +{ +bitop_uint_t mask =BITOP_MASK (nr); +const volatile bitop_uint_t *p = + (const volatile bitop_uint_t *)addr +BITOP_WORD (nr); + +return (*p & mask); +} + +/** +* __test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +* +* This operation is non-atomic and can be reordered. +* If two examples of this operation race, one can appear to succeed +* but actually fail. You must protect multiple accesses with a lock.
xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 219
Quoted 10 lines
xen/include/xen/bitops.h +10
-0+*/ +static always_inline bool +__test_and_set_bit (int nr,volatile void *addr) +{ +#ifndef arch__test_and_set_bit +#define arch__test_and_set_bit generic__test_and_set_bit +#endif + +return arch__test_and_set_bit (nr, addr); +}
See Julien's comments on the earlier version as well as what Andrew has now done for ffs()/fls(), avoiding the largely pointless fallback #define.
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 48 lines · Jan Beulich
Quoted 30 lines · Oleksii Kurochko
The following generic functions were introduced:
*test_bit
*generic__test_and_set_bit
*generic__test_and_clear_bit
*generic__test_and_change_bitThese functions and macros can be useful for architectures that don't have corresponding arch-specific instructions.
Also, the patch introduces the following generics which are used by the functions mentioned above:
*BITOP_BITS_PER_WORD
*BITOP_MASK
*BITOP_WORD
*BITOP_TYPE
BITS_PER_BYTEwas moved toxen/bitops.hasBITS_PER_BYTEis the same
across architectures.The following approach was chosen for generic*() and arch*() bit operation functions:
If the bit operation function that is going to be generic starts with the prefix "__", then the corresponding generic/arch function will also contain the "__" prefix. For example:
*test_bit()will be defined usingarch_test_bit()andgeneric_test_bit().
*__test_and_set_bit()will be defined usingarch__test_and_set_bit()andgeneric__test_and_set_bit().Quoted 7 lines
Signed-off-by Oleksii Kurochko <[email protected]>---
the previous
version of the patch, but some changes were done, so I wasn't sure if I could
use the R-by in this patch version.That really depends on the nature of the changes. Seeing the pretty long list below, I think it was appropriate to drop the R-b.
Quoted 5 lines
---
Changes in V11:
- fix identation ingeneric_test_bit()function.
- move definition ofBITS_PER_BYTEfrom <arch>/bitops.h toxen/bitops.h
Quoted 6 lines
I realize you were asked to do this, but I'm not overly happy with it.
BITS_PER_BYTEis far more similar toBITS_PER_LONGthan toBITOP_BITS_PER_WORD. Plus in any event that change is entirely unrelated
here.
So where then it should be introduced? x86 introduces that in config.h, Arm in asm/bitops.h.
I am okay to revert this change and make a separate patch.
Quoted 72 lines
Quoted 35 lines
- drop the changes in
arm64/livepatch.c.
- update the the comments on top of functions:generic__test_and_set_bit(), generic__test_and_clear_bit(),generic__test_and_change_bit(),generic_test_bit().
- Update footer after Signed-off section.
- Rebase the patch on top of staging branch, so it can be merged when necessary
approves will be given.
- Update the commit message.
---
xen/arch/arm/include/asm/bitops.h | 69 -----------xen/arch/ppc/include/asm/bitops.h| 54 --------- xen/arch/ppc/include/asm/page.h | 2 +- xen/arch/ppc/mm-radix.c | 2 +-xen/arch/x86/include/asm/bitops.h| 31 ++--- xen/include/xen/bitops.h | 185
++++++++++++++++++++++++++++++6 files changed, 196 insertions(+), 147 deletions(-)xen/include/xen/bitops.h +0
-0@@ -103,8 +103,193 @@ static inline int generic_flsl(unsigned long x) * Include this here because some architectures needgeneric_ffs/fls in
* scope
*/xen/include/xen/bitops.h +5
-0+ +#define BITOP_BITS_PER_WORD 32 +typedef uint32_t bitop_uint_t ; + +#define BITOP_MASK (nr) ((bitop_uint_t)1 << ((nr) %
BITOP_BITS_PER_WORD))xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 114
Quoted 4 lines
xen/include/xen/bitops.h +4
-0+ +#define BITOP_WORD (nr) ((nr) / BITOP_BITS_PER_WORD) + +#define BITS_PER_BYTE 8This, if to be moved at all, very clearly doesn't belong here. As much
as it's unrelated to this change, it's also unrelated to bitops as a whole.Quoted 10 lines
xen/include/xen/bitops.h +3
-0+extern void __bitop_bad_size (void ); + +#define bitop_bad_size (addr) (sizeof(*(addr)) <
sizeof(bitop_uint_t))xen/include/xen/bitops.h +3
-1+ +/* --------------------- Please tidy above here ------------------ --- */ +#include <
asm/bitops.h>Quoted 8 lines
+/**
+ *generic__test_and_set_bit- Set a bit and return its old value
+ * @nr: Bit to set
+ * @addr: Address to count from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeedWhy "examples"? Do you mean "instances"? It's further unclear what "succeed" and "fail" here mean. The function after all has two
purposes: Checking and setting the specified bit. Therefore I think you mean "succeed in updating the bit in memory", yet then it's still unclear what the "appear" here means: The caller has no indication of success/failure. Therefore I think "appear to" also wants dropping.
Quoted 6 lines
Quoted 2 lines
+ * but actually fail. You must protect multiple accesses with a lock.
That's not "must". An often better alternative is to use the atomic forms instead. "Multiple" is imprecise, too: "Potentially racy" or some such would come closer.
I think we can go only with:
" This operation is non-atomic and can be reordered."
and drop:
" If two examples of this operation race, one can appear to ... "
Quoted 4 lines
Also did Julien(?) really ask that these comments be reproduced on both the functions supposed to be used throughout the codebase _and_ the generic_*() ones (being merely internal helpers/fallbacks)?
At least, I understood that in this way.
Quoted 13 lines
Quoted 12 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a lock.
+ */
Quoted 3 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those double underscores that the others have.
Then it is true for every function in this header. Based on the naming the conclusion can be done if it is atomic/npn-atomic and can/can't be reordered. So the comments aren't seem very useful.
~ Oleksii
Quoted 38 lines
Quoted 22 lines
+static
always_inlineboolgeneric_test_bit(int nr, const volatile void *addr)xen/include/xen/bitops.h +15
-0+{ + bitop_uint_t mask = BITOP_MASK(nr); + const volatile bitop_uint_t *p = + (const volatile bitop_uint_t *)addr + BITOP_WORD(nr); + + return (*p & mask); +} + +/** +* __test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +* +* This operation is non-atomic and can be reordered. +* If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a lock.
+ */xen/include/xen/bitops.h static inline int generic_flsl(unsigned long x) · line 219
Quoted 9 lines
xen/include/xen/bitops.h +9
-0+static always_inline bool +__test_and_set_bit (int nr,volatile void *addr) +{ +#ifndef arch__test_and_set_bit +#define arch__test_and_set_bit generic__test_and_set_bit +#endif + + return arch__test_and_set_bit(nr, addr); +}See Julien's comments on the earlier version as well as what Andrew has
now done for ffs()/fls(), avoiding the largely pointless fallback #define.Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Hi Oleksii,
Quoted 49 lines · Oleksii K.
Quoted 48 lines · Jan Beulich
Quoted 30 lines · Oleksii Kurochko
The following generic functions were introduced:
*test_bit
*generic__test_and_set_bit
*generic__test_and_clear_bit
*generic__test_and_change_bitThese functions and macros can be useful for architectures that don't have corresponding arch-specific instructions.
Also, the patch introduces the following generics which are used by the functions mentioned above:
*BITOP_BITS_PER_WORD
*BITOP_MASK
*BITOP_WORD
*BITOP_TYPE
BITS_PER_BYTEwas moved toxen/bitops.hasBITS_PER_BYTEis the same
across architectures.The following approach was chosen for generic*() and arch*() bit operation functions:
If the bit operation function that is going to be generic starts with the prefix "__", then the corresponding generic/arch function will also contain the "__" prefix. For example:
*test_bit()will be defined usingarch_test_bit()andgeneric_test_bit().
*__test_and_set_bit()will be defined usingarch__test_and_set_bit()andgeneric__test_and_set_bit().Quoted 7 lines
Signed-off-by Oleksii Kurochko <[email protected]>---
the previous
version of the patch, but some changes were done, so I wasn't sure
if I could
use the R-by in this patch version.That really depends on the nature of the changes. Seeing the pretty long list below, I think it was appropriate to drop the R-b.
Quoted 5 lines
---
Changes in V11:
- fix identation ingeneric_test_bit()function.
- move definition ofBITS_PER_BYTEfrom <arch>/bitops.h toxen/bitops.h
Quoted 8 lines
Quoted 6 lines
I realize you were asked to do this, but I'm not overly happy with it.
BITS_PER_BYTEis far more similar toBITS_PER_LONGthan toBITOP_BITS_PER_WORD. Plus in any event that change is entirely unrelated
here.So where then it should be introduced? x86 introduces that in
config.h, Arm inasm/bitops.h.
I would be fine if it is defined in config.h for Arm.
Quoted 1 line
I am okay to revert this change and make a separate patch.
[...]
Quoted 4 lines
Quoted 3 lines
Also did Julien(?) really ask that these comments be reproduced on both the functions supposed to be used throughout the codebase _and_ the generic_*() ones (being merely internal helpers/fallbacks)?
At least, I understood that in this way.
I suggested to duplicate. But I also proposed an alternative to move the comment:
"I think this comment should be duplicated (or moved to) on top of"
I don't have a strong preference which one is used.
Quoted 14 lines
Quoted 14 lines
Quoted 13 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a lock.
+ */
Quoted 6 lines
Quoted 3 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those double underscores that the others have.Then it is true for every function in this header. Based on the naming the conclusion can be done if it is atomic/npn-atomic and can/can't be reordered.
So let me start with that my only request is to keep the existing comments as you move it. It looks like there were none of test_bit() before.
Quoted 1 line
So the comments aren't seem very useful.
The comments *are* useful. We had several instances where non-Arm folks thought all the operations were atomic on Arm as well. And the usual suggestion is to add barriers in the Arm version which is a no-go.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
In reply to Oleksii K.Quoted 14 lines · Oleksii K.
Quoted 13 lines · Jan Beulich
Quoted 11 lines · Oleksii Kurochko
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a lock.
+ */
Quoted 6 lines
Quoted 3 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those double underscores that the others have.Then it is true for every function in this header. Based on the naming the conclusion can be done if it is atomic/npn-atomic and can/can't be reordered. So the comments aren't seem very useful.
I disagree - test_bit() is different, in not being a read-modify-write operation.
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
In reply to Julien GrallQuoted 23 lines · Julien Grall
Quoted 17 lines
Quoted 13 lines
Quoted 4 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting fromQuoted 8 lines
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a
lock.
+ */Quoted 4 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those
double underscores that the others have.Quoted 5 lines
Then it is true for every function in this header. Based on the naming
the conclusion can be done if it is atomic/npn-atomic and can/can't be
reordered.
Quoted 3 lines
So let me start with that my only request is to keep the existing comments as you move it. It looks like there were none of
test_bit()before.
Just to clarify that I understand correctly.
Do we need any comment above functions generic_*()? Based on that they are implemented in generic way they will be always "non-atomic and can be reordered.".
Do you find the following comment useful?
" * If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock."
It seems to me that it can dropped as basically "non-atomic and can be reordered." means that.
~ Oleksii
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 24 lines · Oleksii K.
Quoted 23 lines · Julien Grall
Quoted 22 lines
Quoted 13 lines
Quoted 4 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting fromQuoted 8 lines
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a
lock.
+ */Quoted 4 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those
double underscores that the others have.Then it is true for every function in this header. Based on the naming
the conclusion can be done if it is atomic/npn-atomic and can/can't be
reordered.
Quoted 8 lines
Quoted 3 lines
So let me start with that my only request is to keep the existing comments as you move it. It looks like there were none of
test_bit()before.Just to clarify that I understand correctly.
Do we need any comment above functions generic_*()? Based on that they are implemented in generic way they will be always "non-atomic and can be reordered.".
I indicated before that I think reproducing the same comments __test_and_* already have also for generic_* isn't overly useful. If someone insisted on them being there as well, I could live with that, though.
Quoted 7 lines
Do you find the following comment useful?
" * If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock."It seems to me that it can dropped as basically "non-atomic and can be reordered." means that.
I agree, or else - as indicated before - the wording would need to further change. Yet iirc you've added that in response to a comment from Julien, so you'll primarily want his input as to the presence of something along these lines.
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Hi,
Quoted 30 lines · Jan Beulich
Quoted 29 lines · Oleksii K.
Quoted 23 lines · Julien Grall
Quoted 17 lines
Quoted 13 lines
Quoted 4 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting fromQuoted 8 lines
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a
lock.
+ */Quoted 4 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those
double underscores that the others have.Quoted 5 lines
Then it is true for every function in this header. Based on the naming
the conclusion can be done if it is atomic/npn-atomic and can/can't be
reordered.Quoted 3 lines
So let me start with that my only request is to keep the existing comments as you move it. It looks like there were none of
test_bit()before.Just to clarify that I understand correctly.
Quoted 7 lines
Quoted 3 lines
Do we need any comment above functions generic_*()? Based on that they are implemented in generic way they will be always "non-atomic and can be reordered.".
I indicated before that I think reproducing the same comments __test_and_* already have also for generic_* isn't overly useful. If someone insisted on them being there as well, I could live with that, though.
Would you be ok if the comment is only on top of the __test_and_* version? (So no comments on top of the generic_*)
Quoted 6 lines
Quoted 6 lines
Do you find the following comment useful?
" * If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock."
Quoted 7 lines
Quoted 2 lines
It seems to me that it can dropped as basically "non-atomic and can be reordered." means that.
I agree, or else - as indicated before - the wording would need to further change. Yet iirc you've added that in response to a comment from Julien, so you'll primarily want his input as to the presence of something along these lines.
I didn't realise this was an existing comment. I think the suggestion is a little bit odd because you could use the atomic version of the helper.
Looking at Linux, the second sentence was dropped. But not the first one. I would suggest to do the same. IOW keep:
"
If two examples of this operation race, one can appear to succeed but actually fail. "
Signature · 1 line
Julien Grall
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 37 lines · Julien Grall
Hi,
Quoted 34 lines · Jan Beulich
Quoted 32 lines · Oleksii K.
Quoted 23 lines · Julien Grall
Quoted 17 lines
Quoted 13 lines
Quoted 4 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting fromQuoted 8 lines
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail. You must protect multiple accesses with a
lock.
+ */Quoted 4 lines
You got carried away updating comments - there's no raciness for simple
test_bit(). As is also expressed by its name not having those
double underscores that the others have.Quoted 5 lines
Then it is true for every function in this header. Based on the naming
the conclusion can be done if it is atomic/npn-atomic and can/can't be
reordered.Quoted 3 lines
So let me start with that my only request is to keep the existing comments as you move it. It looks like there were none of
test_bit()before.Just to clarify that I understand correctly.
Do we need any comment above functions generic_*()? Based on that they are implemented in generic way they will be always "non-atomic and can be reordered.".
Quoted 6 lines
Quoted 3 lines
I indicated before that I think reproducing the same comments __test_and_* already have also for generic_* isn't overly useful. If someone insisted on them being there as well, I could live with that, though.
Would you be ok if the comment is only on top of the __test_and_* version? (So no comments on top of the generic_*)
That's my preferred variant, actually. The alternative I would also be okay-ish with is to have the comments also ahead of generic_*.
Quoted 16 lines
Quoted 5 lines
Quoted 5 lines
Do you find the following comment useful?
" * If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock."Quoted 7 lines
Quoted 2 lines
It seems to me that it can dropped as basically "non-atomic and can be reordered." means that.
I agree, or else - as indicated before - the wording would need to further change. Yet iirc you've added that in response to a comment from Julien, so you'll primarily want his input as to the presence of something along these lines.
I didn't realise this was an existing comment. I think the suggestion is a little bit odd because you could use the atomic version of the helper.
Quoted 7 lines
Looking at Linux, the second sentence was dropped. But not the first one. I would suggest to do the same. IOW keep:
"
If two examples of this operation race, one can appear to succeed but actually fail.
"
As indicated, I'm okay with that being retained, but only in a form that actually makes sense. I've explained before (to Oleksii) what I consider wrong in this way of wording things.
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
static always_inline bool test_bit(int nr, const volatile void *addr)On
Quoted 95 lines · Jan Beulich
Quoted 47 lines · Julien Grall
Hi,
Quoted 44 lines · Jan Beulich
Quoted 42 lines · Oleksii K.
Quoted 29 lines · Julien Grall
Quoted 21 lines
Quoted 15 lines
Quoted 6 lines
+/**
+ *generic_test_bit- Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ *
+ * This operation is non-atomic and can be reordered.Quoted 8 lines
+ * If two examples of this operation race, one can appear to
succeed
+ * but actually fail. You must protect multiple accesses with
a
lock.
+ */Quoted 6 lines
You got carried away updating comments - there's no raciness for
simpletest_bit(). As is also expressed by its name not having
those
double underscores that the others have.Quoted 7 lines
Then it is true for every function in this header. Based on the
naming
the conclusion can be done if it is atomic/npn-atomic and can/can't
be
reordered.Quoted 5 lines
So let me start with that my only request is to keep the existing
comments as you move it. It looks like there were none oftest_bit()
before.Just to clarify that I understand correctly.
Do we need any comment above functions generic_*()? Based on that they
are implemented in generic way they will be always "non-atomic and can
be reordered.".Quoted 8 lines
Quoted 5 lines
I indicated before that I think reproducing the same comments __test_and_*
already have also for generic_* isn't overly useful. If someone insisted
on them being there as well, I could live with that, though.Would you be ok if the comment is only on top of the __test_and_* version? (So no comments on top of the generic_*)
That's my preferred variant, actually. The alternative I would also be
okay-ish with is to have the comments also ahead of generic_*.Quoted 28 lines
Quoted 11 lines
Quoted 10 lines
Do you find the following comment useful?
" * If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock."It seems to me that it can dropped as basically "non-atomic and can be
reordered." means that.Quoted 7 lines
I agree, or else - as indicated before - the wording would need to further
change. Yet iirc you've added that in response to a comment from Julien,
so you'll primarily want his input as to the presence of something along
these lines.I didn't realise this was an existing comment. I think the suggestion is
a little bit odd because you could use the atomic version of the helper.Looking at Linux, the second sentence was dropped. But not the first
one. I would suggest to do the same. IOW keep:Quoted 5 lines
"
If two examples of this operation race, one can appear to succeed but
actually fail.
"
Quoted 5 lines
As indicated, I'm okay with that being retained, but only in a form that
actually makes sense. I've explained before (to Oleksii) what I consider
wrong in this way of wording things.
Would it be suitable to rephrase it in the following way:
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a lock.
+ * If two instances of this operation race, one may succeed in updating
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
static always_inline bool
__test_and_set_bit(int nr, volatile void *addr)
@@ -228,8 +191,9 @@ __test_and_set_bit(int nr, volatile void *addr)
* @addr: Address to count from
*
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a lock.
+ * If two instances of this operation race, one may succeed in clearing
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
static always_inline bool
__test_and_clear_bit(int nr, volatile void *addr)
@@ -251,8 +215,9 @@ __test_and_clear_bit(int nr, volatile void *addr)
* @addr: Address to count from
*
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a lock.
+ * If two instances of this operation race, one may succeed in changing
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
static always_inline bool
__test_and_change_bit(int nr, volatile void *addr)
@@ -274,8 +239,9 @@ __test_and_change_bit(int nr, volatile void *addr)
* @addr: Address to start counting from
*
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a lock.
+ * If two instances of this operation race, one may succeed in testing
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
static always_inline bool test_bit(int nr, const volatile void
*addr)
~ Oleksii
Quoted 2 lines
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 24 lines · Oleksii K.
static
always_inlinebooltest_bit(int nr, const volatile void *addr)OnQuoted 16 lines · Jan Beulich
Quoted 9 lines · Julien Grall
I didn't realise this was an existing comment. I think the suggestion is
a little bit odd because you could use the atomic version of the helper.Looking at Linux, the second sentence was dropped. But not the first
one. I would suggest to do the same. IOW keep:Quoted 5 lines
"
If two examples of this operation race, one can appear to succeed but
actually fail.
"Quoted 5 lines
As indicated, I'm okay with that being retained, but only in a form that
actually makes sense. I've explained before (to Oleksii) what I consider
wrong in this way of wording things.
Quoted 14 lines
Would it be suitable to rephrase it in the following way:
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a lock.
+ * If two instances of this operation race, one may succeed in updating
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
staticalways_inlinebool
__test_and_set_bit(int nr, volatile void *addr)
You've lost the "appear to" ahead of "succeed". Yet even with the adjustment I still don't see what the "appear to succeed" really is supposed to mean here. The issue (imo) isn't with success or failure, but with the write of one CPU potentially being immediately overwritten by another CPU, not observing the bit change that the first CPU did. IOW both will succeed (or appear to succeed), but one update may end up being lost. Maybe "..., both may update memory with their view of the new value, not taking into account the update the respectively other one did"? Or "..., both will appear to succeed, but one of the updates may be lost"?
Jan
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 45 lines · Jan Beulich
Quoted 28 lines · Oleksii K.
static
always_inlinebooltest_bit(int nr, const volatile void *addr)OnQuoted 18 lines · Jan Beulich
Quoted 10 lines · Julien Grall
I didn't realise this was an existing comment. I think the suggestion is
a little bit odd because you could use the atomic version of the
helper.Looking at Linux, the second sentence was dropped. But not the first
one. I would suggest to do the same. IOW keep:Quoted 6 lines
"
If two examples of this operation race, one can appear to succeed
but
actually fail.
"Quoted 6 lines
As indicated, I'm okay with that being retained, but only in a form
that
actually makes sense. I've explained before (to Oleksii) what I consider
wrong in this way of wording things.Quoted 15 lines
Would it be suitable to rephrase it in the following way:
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with a
lock.
+ * If two instances of this operation race, one may succeed in updating
+ * the bit in memory, but actually fail. It should be protected from
+ * potentially racy behavior.
*/
staticalways_inlinebool
__test_and_set_bit(int nr, volatile void *addr)
Quoted 16 lines
You've lost the "appear to" ahead of "succeed". Yet even with the adjustment
I still don't see what the "appear to succeed" really is supposed to mean
here. The issue (imo) isn't with success or failure, but with the write of
one CPU potentially being immediately overwritten by another CPU, not observing the bit change that the first CPU did. IOW both will succeed (or
appear to succeed), but one update may end up being lost. Maybe "..., both
may update memory with their view of the new value, not taking into account
the update the respectively other one did"? Or "..., both will appear to
succeed, but one of the updates may be lost"?
For me, the first one is clearer.
Julien, would that be okay for you?
~ Oleksii
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Quoted 70 lines · Oleksii K.
Quoted 61 lines · Jan Beulich
Quoted 39 lines · Oleksii K.
static
always_inlinebooltest_bit(int nr, const volatile void *addr)OnQuoted 19 lines · Jan Beulich
Quoted 11 lines · Julien Grall
I didn't realise this was an existing comment. I think the suggestion is
a little bit odd because you could use the atomic version of the
helper.Looking at Linux, the second sentence was dropped. But not the
first
one. I would suggest to do the same. IOW keep:Quoted 6 lines
"
If two examples of this operation race, one can appear to succeed
but
actually fail.
"Quoted 6 lines
As indicated, I'm okay with that being retained, but only in a form
that
actually makes sense. I've explained before (to Oleksii) what I consider
wrong in this way of wording things.Would it be suitable to rephrase it in the following way:
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses with
a
lock.
+ * If two instances of this operation race, one may succeed inQuoted 8 lines
updating
+ * the bit in memory, but actually fail. It should be protected
from
+ * potentially racy behavior.
*/
staticalways_inlinebool__test_and_set_bit(int nr, volatile void *addr)You've lost the "appear to" ahead of "succeed". Yet even with the adjustment
I still don't see what the "appear to succeed" really is supposed to
mean
here. The issue (imo) isn't with success or failure, but with the write of
one CPU potentially being immediately overwritten by another CPU, not
observing the bit change that the first CPU did. IOW both will succeed (or
appear to succeed), but one update may end up being lost. MaybeQuoted 8 lines
"...,
both
may update memory with their view of the new value, not taking into account
the update the respectively other one did"? Or "..., both will appear
to
succeed, but one of the updates may be lost"?
Quoted 1 line
For me, the first one is clearer.
If then this part of the comment is needed for test_bit() as it is doing only reading?
Quoted 1 line
Julien, would that be okay for you?
~ Oleksii
Re: [PATCH v11 2/9] xen: introduce generic non-atomic test_*bit()
Hi,
Quoted 71 lines · Oleksii K.
Quoted 70 lines · Oleksii K.
Quoted 69 lines · Jan Beulich
Quoted 39 lines · Oleksii K.
static
always_inlinebooltest_bit(int nr, const volatile void *addr)OnQuoted 19 lines · Jan Beulich
Quoted 11 lines · Julien Grall
I didn't realise this was an existing comment. I think the suggestion is
a little bit odd because you could use the atomic version of the
helper.Looking at Linux, the second sentence was dropped. But not the
first
one. I would suggest to do the same. IOW keep:Quoted 6 lines
"
If two examples of this operation race, one can appear to succeed
but
actually fail.
"Quoted 6 lines
As indicated, I'm okay with that being retained, but only in a form
that
actually makes sense. I've explained before (to Oleksii) what I consider
wrong in this way of wording things.Would it be suitable to rephrase it in the following way:
* This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail. You must protect multiple accesses
with
a
lock.
+ * If two instances of this operation race, one may succeed
inQuoted 8 lines
updating
+ * the bit in memory, but actually fail. It should be
protected
from
+ * potentially racy behavior.
*/
staticalways_inlinebool__test_and_set_bit(int nr, volatile void *addr)You've lost the "appear to" ahead of "succeed". Yet even with the adjustment
I still don't see what the "appear to succeed" really is supposed to
mean
here. The issue (imo) isn't with success or failure, but with the write of
one CPU potentially being immediately overwritten by another CPU, not
observing the bit change that the first CPU did. IOW both will succeed (or
appear to succeed), but one update may end up being lost. Maybe "...,
both
may update memory with their view of the new value, not taking into account
the update the respectively other one did"? Or "..., both will appear
to
succeed, but one of the updates may be lost"?
Quoted 1 line
Quoted 1 line
For me, the first one is clearer.
I actually find the second better because it explicitely spell out the issue. I can live with the first one though.
Quoted 2 lines
If then this part of the comment is needed for
test_bit()as it is doing only reading?
I don't think so. As Jan said, test_bit() is not a read-modify-write operation.
Cheers,
Signature · 1 line
Julien Grall