November 2017 - Linux-kselftest-mirror

[Linux-kselftest-mirror] [PATCH AUTOSEL for 4.9 04/52] x86/selftests: Add clobbers for int80 on x86_64

by alexander.levin＠verizon.com

From: Dmitry Safonov <dsafonov(a)virtuozzo.com> [ Upstream commit 2a4d0c627f5374f365a873dea4e10ae0bb437680 ] Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164 GCC can reuse these registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once GCC 6.1 and CLANG stored local variables in those registers and the kernel zerofied them during syscall: https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7f… By that reason I suggest to add those registers to clobbers in selftests. Also, as noted by Andy - removed unneeded clobber for flags in INT $0x80 inline asm. Signed-off-by: Dmitry Safonov <dsafonov(a)virtuozzo.com> Acked-by: Andy Lutomirski <luto(a)kernel.org> Cc: 0x7f454c46(a)gmail.com Cc: Borislav Petkov <bp(a)alien8.de> Cc: Borislav Petkov <bp(a)suse.de> Cc: Brian Gerst <brgerst(a)gmail.com> Cc: Denys Vlasenko <dvlasenk(a)redhat.com> Cc: H. Peter Anvin <hpa(a)zytor.com> Cc: Josh Poimboeuf <jpoimboe(a)redhat.com> Cc: Linus Torvalds <torvalds(a)linux-foundation.org> Cc: Peter Zijlstra <peterz(a)infradead.org> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: linux-kselftest(a)vger.kernel.org Link: http://lkml.kernel.org/r/20170213101336.20486-1-dsafonov@virtuozzo.com Signed-off-by: Ingo Molnar <mingo(a)kernel.org> Signed-off-by: Sasha Levin <alexander.levin(a)verizon.com> --- tools/testing/selftests/x86/fsgsbase.c | 2 +- tools/testing/selftests/x86/ldt_gdt.c | 16 +++++++++++----- tools/testing/selftests/x86/ptrace_syscall.c | 3 ++- tools/testing/selftests/x86/single_step_syscall.c | 5 ++++- 4 files changed, 18 insertions(+), 8 deletions(-) diff --git a/tools/testing/selftests/x86/fsgsbase.c b/tools/testing/selftests/x86/fsgsbase.c index 9b4610c6d3fb..f249e042b3b5 100644 --- a/tools/testing/selftests/x86/fsgsbase.c +++ b/tools/testing/selftests/x86/fsgsbase.c @@ -245,7 +245,7 @@ void do_unexpected_base(void) long ret; asm volatile ("int $0x80" : "=a" (ret) : "a" (243), "b" (low_desc) - : "flags"); + : "r8", "r9", "r10", "r11"); memcpy(&desc, low_desc, sizeof(desc)); munmap(low_desc, sizeof(desc)); diff --git a/tools/testing/selftests/x86/ldt_gdt.c b/tools/testing/selftests/x86/ldt_gdt.c index e717fed80219..b9a22f18566a 100644 --- a/tools/testing/selftests/x86/ldt_gdt.c +++ b/tools/testing/selftests/x86/ldt_gdt.c @@ -45,6 +45,12 @@ #define AR_DB (1 << 22) #define AR_G (1 << 23) +#ifdef __x86_64__ +# define INT80_CLOBBERS "r8", "r9", "r10", "r11" +#else +# define INT80_CLOBBERS +#endif + static int nerrs; /* Points to an array of 1024 ints, each holding its own index. */ @@ -634,7 +640,7 @@ static int invoke_set_thread_area(void) asm volatile ("int $0x80" : "=a" (ret), "+m" (low_user_desc) : "a" (243), "b" (low_user_desc) - : "flags"); + : INT80_CLOBBERS); return ret; } @@ -703,7 +709,7 @@ static void test_gdt_invalidation(void) "+a" (eax) : "m" (low_user_desc_clear), [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear) - : "flags"); + : INT80_CLOBBERS); if (sel != 0) { result = "FAIL"; @@ -734,7 +740,7 @@ static void test_gdt_invalidation(void) "+a" (eax) : "m" (low_user_desc_clear), [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear) - : "flags"); + : INT80_CLOBBERS); if (sel != 0) { result = "FAIL"; @@ -767,7 +773,7 @@ static void test_gdt_invalidation(void) "+a" (eax) : "m" (low_user_desc_clear), [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear) - : "flags"); + : INT80_CLOBBERS); #ifdef __x86_64__ syscall(SYS_arch_prctl, ARCH_GET_FS, &new_base); @@ -820,7 +826,7 @@ static void test_gdt_invalidation(void) "+a" (eax) : "m" (low_user_desc_clear), [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear) - : "flags"); + : INT80_CLOBBERS); #ifdef __x86_64__ syscall(SYS_arch_prctl, ARCH_GET_GS, &new_base); diff --git a/tools/testing/selftests/x86/ptrace_syscall.c b/tools/testing/selftests/x86/ptrace_syscall.c index b037ce9cf116..eaea92439708 100644 --- a/tools/testing/selftests/x86/ptrace_syscall.c +++ b/tools/testing/selftests/x86/ptrace_syscall.c @@ -58,7 +58,8 @@ static void do_full_int80(struct syscall_args32 *args) asm volatile ("int $0x80" : "+a" (args->nr), "+b" (args->arg0), "+c" (args->arg1), "+d" (args->arg2), - "+S" (args->arg3), "+D" (args->arg4), "+r" (bp)); + "+S" (args->arg3), "+D" (args->arg4), "+r" (bp) + : : "r8", "r9", "r10", "r11"); args->arg5 = bp; #else sys32_helper(args, int80_and_ret); diff --git a/tools/testing/selftests/x86/single_step_syscall.c b/tools/testing/selftests/x86/single_step_syscall.c index 50c26358e8b7..a48da95c18fd 100644 --- a/tools/testing/selftests/x86/single_step_syscall.c +++ b/tools/testing/selftests/x86/single_step_syscall.c @@ -56,9 +56,11 @@ static volatile sig_atomic_t sig_traps; #ifdef __x86_64__ # define REG_IP REG_RIP # define WIDTH "q" +# define INT80_CLOBBERS "r8", "r9", "r10", "r11" #else # define REG_IP REG_EIP # define WIDTH "l" +# define INT80_CLOBBERS #endif static unsigned long get_eflags(void) @@ -140,7 +142,8 @@ int main() printf("[RUN]\tSet TF and check int80\n"); set_eflags(get_eflags() | X86_EFLAGS_TF); - asm volatile ("int $0x80" : "=a" (tmp) : "a" (SYS_getpid)); + asm volatile ("int $0x80" : "=a" (tmp) : "a" (SYS_getpid) + : INT80_CLOBBERS); check_result(); /* -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 4 months

2
2
0 0

[Linux-kselftest-mirror] selftests: x86_64: kselftest mpx-mini-test_64 - no MPX support - failed - 3869 Aborted (core dumped)

by Naresh Kamboju

Hi, We have found "no MPX support" bug while running kselftests on SuperServer 5019S-ML - x86_64 device. Please provide your comments to fix this bug. LKFT: 4.4-rc 4.9-rc 4.13-rc 4.14-rc: x86: kselftest mpx-mini-test_64 - no MPX support - failed - 3869 Aborted (core dumped) (edit) https://bugs.linaro.org/show_bug.cgi?id=3497 NOTE: Please add your self to Bugzilla to add comments. Best regards Naresh Kamboju -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 4 months

3
6
0 0

[Linux-kselftest-mirror] [PATCH 2/2] [RFC] packet: experimental support for 64-bit timestamps

by Arnd Bergmann

I tried to figure out what it would take to do a version 4 mmap packet socket interface to completely avoid the y2106 overflow problem. This is what I came up with, reusing most of the v3 code, except for the parts where we access the timestamps. For kselftest, I'm adding support for testing v4 in addition to v1-v3, but the test currently does not look at the timestamps, so it won't check that the timestamp format actually works as intended, only that I didn't break the parts that worked in the v3 selftest. Overall, this is more of a mess than I expected, so it's probably not worth doing a v4 format just for the timestamp, but the patch can serve as a reference for anyone that needs a new format for other reasons and fixes this along with the other changes. Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> --- Untested and rather invasive, so don't apply this part without discussion and testing --- include/uapi/linux/if_packet.h | 24 +++++- net/packet/af_packet.c | 115 ++++++++++++++++++++-------- tools/testing/selftests/net/psock_tpacket.c | 65 +++++++++------- 3 files changed, 142 insertions(+), 62 deletions(-) diff --git a/include/uapi/linux/if_packet.h b/include/uapi/linux/if_packet.h index 67b61d91d89b..c2cf29acdd40 100644 --- a/include/uapi/linux/if_packet.h +++ b/include/uapi/linux/if_packet.h @@ -177,8 +177,27 @@ struct tpacket3_hdr { __u8 tp_padding[8]; }; +struct tpacket4_hdr { + __u32 tp_next_offset; + __u32 tp_nsec_hi; + __u32 tp_nsec_lo; + __u32 tp_snaplen; + __u32 tp_len; + __u32 tp_status; + __u16 tp_mac; + __u16 tp_net; + /* pkt_hdr variants */ + union { + struct tpacket_hdr_variant1 hv1; + }; + __u8 tp_padding[8]; +}; + struct tpacket_bd_ts { - unsigned int ts_sec; + union { + unsigned int ts_nsec_hi; + unsigned int ts_sec; + }; union { unsigned int ts_usec; unsigned int ts_nsec; @@ -250,7 +269,8 @@ struct tpacket_block_desc { enum tpacket_versions { TPACKET_V1, TPACKET_V2, - TPACKET_V3 + TPACKET_V3, + TPACKET_V4, }; /* diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c index 7432c6699818..34a07e4a93a5 100644 --- a/net/packet/af_packet.c +++ b/net/packet/af_packet.c @@ -164,6 +164,7 @@ union tpacket_uhdr { struct tpacket_hdr *h1; struct tpacket2_hdr *h2; struct tpacket3_hdr *h3; + struct tpacket4_hdr *h4; void *raw; }; @@ -200,7 +201,7 @@ static void prb_retire_current_block(struct tpacket_kbdq_core *, struct packet_sock *, unsigned int status); static int prb_queue_frozen(struct tpacket_kbdq_core *); static void prb_open_block(struct tpacket_kbdq_core *, - struct tpacket_block_desc *); + struct tpacket_block_desc *, struct packet_sock *po); static void prb_retire_rx_blk_timer_expired(struct timer_list *); static void _prb_refresh_rx_retire_blk_timer(struct tpacket_kbdq_core *); static void prb_fill_rxhash(struct tpacket_kbdq_core *, struct tpacket3_hdr *); @@ -404,6 +405,7 @@ static void __packet_set_status(struct packet_sock *po, void *frame, int status) flush_dcache_page(pgv_to_page(&h.h2->tp_status)); break; case TPACKET_V3: + case TPACKET_V4: h.h3->tp_status = status; flush_dcache_page(pgv_to_page(&h.h3->tp_status)); break; @@ -430,6 +432,7 @@ static int __packet_get_status(struct packet_sock *po, void *frame) flush_dcache_page(pgv_to_page(&h.h2->tp_status)); return h.h2->tp_status; case TPACKET_V3: + case TPACKET_V4: flush_dcache_page(pgv_to_page(&h.h3->tp_status)); return h.h3->tp_status; default: @@ -439,17 +442,17 @@ static int __packet_get_status(struct packet_sock *po, void *frame) } } -static __u32 tpacket_get_timestamp(struct sk_buff *skb, struct timespec64 *ts, +static __u32 tpacket_get_timestamp(struct sk_buff *skb, s64 *stamp, unsigned int flags) { struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb); if (shhwtstamps && (flags & SOF_TIMESTAMPING_RAW_HARDWARE) && - ktime_to_timespec64_cond(shhwtstamps->hwtstamp, ts)) + (*stamp = ktime_to_ns(shhwtstamps->hwtstamp))) return TP_STATUS_TS_RAW_HARDWARE; - if (ktime_to_timespec64_cond(skb->tstamp, ts)) + if ((*stamp = ktime_to_ns(skb->tstamp))) return TP_STATUS_TS_SOFTWARE; return 0; @@ -460,19 +463,15 @@ static __u32 __packet_set_timestamp(struct packet_sock *po, void *frame, { union tpacket_uhdr h; struct timespec64 ts; + s64 stamp; __u32 ts_status; - if (!(ts_status = tpacket_get_timestamp(skb, &ts, po->tp_tstamp))) + if (!(ts_status = tpacket_get_timestamp(skb, &stamp, po->tp_tstamp))) return 0; h.raw = frame; - /* - * versions 1 through 3 overflow the timestamps in y2106, since they - * all store the seconds in a 32-bit unsigned integer. - * If we create a version 4, that should have a 64-bit timestamp, - * either 64-bit seconds + 32-bit nanoseconds, or just 64-bit - * nanoseconds. - */ + + ts = ns_to_timespec64(stamp); switch (po->tp_version) { case TPACKET_V1: h.h1->tp_sec = ts.tv_sec; @@ -486,6 +485,9 @@ static __u32 __packet_set_timestamp(struct packet_sock *po, void *frame, h.h3->tp_sec = ts.tv_sec; h.h3->tp_nsec = ts.tv_nsec; break; + case TPACKET_V4: + h.h4->tp_nsec_hi = upper_32_bits(stamp); + h.h4->tp_nsec_lo = lower_32_bits(stamp); default: WARN(1, "TPACKET version not supported.\n"); BUG(); @@ -633,7 +635,7 @@ static void init_prb_bdqc(struct packet_sock *po, p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv); prb_init_ft_ops(p1, req_u); prb_setup_retire_blk_timer(po); - prb_open_block(p1, pbd); + prb_open_block(p1, pbd, po); } /* Do NOT update the last_blk_num first. @@ -730,7 +732,7 @@ static void prb_retire_rx_blk_timer_expired(struct timer_list *t) * opening a block thaws the queue,restarts timer * Thawing/timer-refresh is a side effect. */ - prb_open_block(pkc, pbd); + prb_open_block(pkc, pbd, po); goto out; } } @@ -792,30 +794,43 @@ static void prb_close_block(struct tpacket_kbdq_core *pkc1, { __u32 status = TP_STATUS_USER | stat; - struct tpacket3_hdr *last_pkt; + struct tpacket3_hdr *last_pkt_v3; + struct tpacket4_hdr *last_pkt_v4; struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1; struct sock *sk = &po->sk; if (po->stats.stats3.tp_drops) status |= TP_STATUS_LOSING; - last_pkt = (struct tpacket3_hdr *)pkc1->prev; - last_pkt->tp_next_offset = 0; + last_pkt_v3 = (struct tpacket3_hdr *)pkc1->prev; + last_pkt_v4 = (struct tpacket4_hdr *)pkc1->prev; + last_pkt_v3->tp_next_offset = 0; /* Get the ts of the last pkt */ if (BLOCK_NUM_PKTS(pbd1)) { - h1->ts_last_pkt.ts_sec = last_pkt->tp_sec; - h1->ts_last_pkt.ts_nsec = last_pkt->tp_nsec; + if (po->tp_version == TPACKET_V3) { + h1->ts_last_pkt.ts_sec = last_pkt_v3->tp_sec; + h1->ts_last_pkt.ts_nsec = last_pkt_v3->tp_nsec; + } else { + h1->ts_last_pkt.ts_nsec_hi = last_pkt_v4->tp_nsec_hi; + h1->ts_last_pkt.ts_nsec = last_pkt_v4->tp_nsec_lo; + } } else { /* Ok, we tmo'd - so get the current time. * * It shouldn't really happen as we don't close empty * blocks. See prb_retire_rx_blk_timer_expired(). */ - struct timespec64 ts; - ktime_get_real_ts64(&ts); - h1->ts_last_pkt.ts_sec = ts.tv_sec; - h1->ts_last_pkt.ts_nsec = ts.tv_nsec; + if (po->tp_version == TPACKET_V3) { + struct timespec64 ts; + ktime_get_real_ts64(&ts); + h1->ts_last_pkt.ts_sec = ts.tv_sec; + h1->ts_last_pkt.ts_nsec = ts.tv_nsec; + } else { + u64 ns = ktime_get_real_ns(); + h1->ts_last_pkt.ts_nsec_hi = upper_32_bits(ns); + h1->ts_last_pkt.ts_nsec = lower_32_bits(ns); + } } smp_wmb(); @@ -841,9 +856,8 @@ static void prb_thaw_queue(struct tpacket_kbdq_core *pkc) * */ static void prb_open_block(struct tpacket_kbdq_core *pkc1, - struct tpacket_block_desc *pbd1) + struct tpacket_block_desc *pbd1, struct packet_sock *po) { - struct timespec64 ts; struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1; smp_rmb(); @@ -856,10 +870,19 @@ static void prb_open_block(struct tpacket_kbdq_core *pkc1, BLOCK_NUM_PKTS(pbd1) = 0; BLOCK_LEN(pbd1) = BLK_PLUS_PRIV(pkc1->blk_sizeof_priv); - ktime_get_real_ts64(&ts); - h1->ts_first_pkt.ts_sec = ts.tv_sec; - h1->ts_first_pkt.ts_nsec = ts.tv_nsec; + if (po->tp_version == TPACKET_V3) { + struct timespec64 ts; + + ktime_get_real_ts64(&ts); + h1->ts_first_pkt.ts_sec = ts.tv_sec; + h1->ts_first_pkt.ts_nsec = ts.tv_nsec; + } else { + s64 ns = ktime_get_real_ns(); + + h1->ts_first_pkt.ts_nsec_hi = upper_32_bits(ns); + h1->ts_first_pkt.ts_nsec = lower_32_bits(ns); + } pkc1->pkblk_start = (char *)pbd1; pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv); @@ -936,7 +959,7 @@ static void *prb_dispatch_next_block(struct tpacket_kbdq_core *pkc, * open this block and return the offset where the first packet * needs to get stored. */ - prb_open_block(pkc, pbd); + prb_open_block(pkc, pbd, po); return (void *)pkc->nxt_offset; } @@ -1068,7 +1091,7 @@ static void *__packet_lookup_frame_in_block(struct packet_sock *po, * opening a block also thaws the queue. * Thawing is a side effect. */ - prb_open_block(pkc, pbd); + prb_open_block(pkc, pbd, po); } } @@ -1113,6 +1136,7 @@ static void *packet_current_rx_frame(struct packet_sock *po, po->rx_ring.head, status); return curr; case TPACKET_V3: + case TPACKET_V4: return __packet_lookup_frame_in_block(po, skb, status, len); default: WARN(1, "TPACKET version not supported\n"); @@ -1171,6 +1195,7 @@ static void packet_increment_rx_head(struct packet_sock *po, case TPACKET_V2: return packet_increment_head(rb); case TPACKET_V3: + case TPACKET_V4: default: WARN(1, "TPACKET version not supported.\n"); BUG(); @@ -1279,7 +1304,7 @@ static int __packet_rcv_has_room(struct packet_sock *po, struct sk_buff *skb) return ROOM_NONE; } - if (po->tp_version == TPACKET_V3) { + if (po->tp_version == TPACKET_V3 || po->tp_version == TPACKET_V4) { if (__tpacket_v3_has_room(po, ROOM_POW_OFF)) ret = ROOM_NORMAL; else if (__tpacket_v3_has_room(po, 0)) @@ -2192,6 +2217,7 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, unsigned short macoff, netoff, hdrlen; struct sk_buff *copy_skb = NULL; struct timespec64 ts; + u64 ns; __u32 ts_status; bool is_drop_n_account = false; bool do_vnet = false; @@ -2318,7 +2344,9 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, skb_copy_bits(skb, 0, h.raw + macoff, snaplen); - if (!(ts_status = tpacket_get_timestamp(skb, &ts, po->tp_tstamp))) + if ((ts_status = tpacket_get_timestamp(skb, &ns, po->tp_tstamp))) + ts = ns_to_timespec64(ns); + else ktime_get_real_ts64(&ts); status |= ts_status; @@ -2365,6 +2393,19 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, memset(h.h3->tp_padding, 0, sizeof(h.h3->tp_padding)); hdrlen = sizeof(*h.h3); break; + case TPACKET_V4: + /* identical to v3, except for the timestamp */ + h.h4->tp_status |= status; + h.h4->tp_len = skb->len; + h.h4->tp_snaplen = snaplen; + h.h4->tp_mac = macoff; + h.h4->tp_net = netoff; + ns = timespec64_to_ns(&ts); + h.h4->tp_nsec_hi = upper_32_bits(ns); + h.h4->tp_nsec_lo = lower_32_bits(ns); + memset(h.h3->tp_padding, 0, sizeof(h.h3->tp_padding)); + hdrlen = sizeof(*h.h3); + break; default: BUG(); } @@ -2570,6 +2611,7 @@ static int tpacket_parse_header(struct packet_sock *po, void *frame, ph.raw = frame; switch (po->tp_version) { + case TPACKET_V4: case TPACKET_V3: if (ph.h3->tp_next_offset != 0) { pr_warn_once("variable sized slot not supported"); @@ -2596,6 +2638,7 @@ static int tpacket_parse_header(struct packet_sock *po, void *frame, off_max = po->tx_ring.frame_size - tp_len; if (po->sk.sk_type == SOCK_DGRAM) { switch (po->tp_version) { + case TPACKET_V4: case TPACKET_V3: off = ph.h3->tp_net; break; @@ -2608,6 +2651,7 @@ static int tpacket_parse_header(struct packet_sock *po, void *frame, } } else { switch (po->tp_version) { + case TPACKET_V4: case TPACKET_V3: off = ph.h3->tp_mac; break; @@ -3658,6 +3702,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv len = sizeof(req_u.req); break; case TPACKET_V3: + case TPACKET_V4: default: len = sizeof(req_u.req3); break; @@ -3693,6 +3738,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv case TPACKET_V1: case TPACKET_V2: case TPACKET_V3: + case TPACKET_V4: break; default: return -EINVAL; @@ -3868,7 +3914,7 @@ static int packet_getsockopt(struct socket *sock, int level, int optname, memset(&po->stats, 0, sizeof(po->stats)); spin_unlock_bh(&sk->sk_receive_queue.lock); - if (po->tp_version == TPACKET_V3) { + if (po->tp_version == TPACKET_V3 || po->tp_version == TPACKET_V4) { lv = sizeof(struct tpacket_stats_v3); st.stats3.tp_packets += st.stats3.tp_drops; data = &st.stats3; @@ -3906,6 +3952,7 @@ static int packet_getsockopt(struct socket *sock, int level, int optname, val = sizeof(struct tpacket2_hdr); break; case TPACKET_V3: + case TPACKET_V4: val = sizeof(struct tpacket3_hdr); break; default: @@ -4250,6 +4297,7 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, po->tp_hdrlen = TPACKET2_HDRLEN; break; case TPACKET_V3: + case TPACKET_V4: po->tp_hdrlen = TPACKET3_HDRLEN; break; } @@ -4284,6 +4332,7 @@ static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u, if (unlikely(!pg_vec)) goto out; switch (po->tp_version) { + case TPACKET_V4: case TPACKET_V3: /* Block transmit is not supported yet */ if (!tx_ring) { diff --git a/tools/testing/selftests/net/psock_tpacket.c b/tools/testing/selftests/net/psock_tpacket.c index 7f6cd9fdacf3..b497632b6a70 100644 --- a/tools/testing/selftests/net/psock_tpacket.c +++ b/tools/testing/selftests/net/psock_tpacket.c @@ -3,7 +3,8 @@ * Author: Daniel Borkmann <dborkman(a)redhat.com> * Chetan Loke <loke.chetan(a)gmail.com> (TPACKET_V3 usage example) * - * A basic test of packet socket's TPACKET_V1/TPACKET_V2/TPACKET_V3 behavior. + * A basic test of packet socket's TPACKET_V1/TPACKET_V2/TPACKET_V3/TPACKET_V4 + * behavior. * * Control: * Test the setup of the TPACKET socket with different patterns that are @@ -19,6 +20,7 @@ * - TPACKET_V1: RX_RING, TX_RING * - TPACKET_V2: RX_RING, TX_RING * - TPACKET_V3: RX_RING + * - TPACKET_V4: RX_RING * * License (GPLv2): * @@ -310,12 +312,12 @@ static inline void __v2_tx_user_ready(struct tpacket2_hdr *hdr) __sync_synchronize(); } -static inline int __v3_tx_kernel_ready(struct tpacket3_hdr *hdr) +static inline int __v3_v4_tx_kernel_ready(struct tpacket3_hdr *hdr) { return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING)); } -static inline void __v3_tx_user_ready(struct tpacket3_hdr *hdr) +static inline void __v3_v4_tx_user_ready(struct tpacket3_hdr *hdr) { hdr->tp_status = TP_STATUS_SEND_REQUEST; __sync_synchronize(); @@ -329,7 +331,8 @@ static inline int __tx_kernel_ready(void *base, int version) case TPACKET_V2: return __v2_tx_kernel_ready(base); case TPACKET_V3: - return __v3_tx_kernel_ready(base); + case TPACKET_V4: + return __v3_v4_tx_kernel_ready(base); default: bug_on(1); return 0; @@ -346,7 +349,8 @@ static inline void __tx_user_ready(void *base, int version) __v2_tx_user_ready(base); break; case TPACKET_V3: - __v3_tx_user_ready(base); + case TPACKET_V4: + __v3_v4_tx_user_ready(base); break; } } @@ -372,6 +376,7 @@ static inline void *get_next_frame(struct ring *ring, int n) case TPACKET_V2: return ring->rd[n].iov_base; case TPACKET_V3: + case TPACKET_V4: return f0 + (n * ring->req3.tp_frame_size); default: bug_on(1); @@ -454,7 +459,8 @@ static void walk_tx(int sock, struct ring *ring) packet_len); total_bytes += ppd.v2->tp_h.tp_snaplen; break; - case TPACKET_V3: { + case TPACKET_V3: + case TPACKET_V4: { struct tpacket3_hdr *tx = next; tx->tp_snaplen = packet_len; @@ -517,22 +523,22 @@ static void walk_v1_v2(int sock, struct ring *ring) walk_tx(sock, ring); } -static uint64_t __v3_prev_block_seq_num = 0; +static uint64_t __v3_v4_prev_block_seq_num = 0; -void __v3_test_block_seq_num(struct block_desc *pbd) +void __v3_v4_test_block_seq_num(struct block_desc *pbd) { - if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) { + if (__v3_v4_prev_block_seq_num + 1 != pbd->h1.seq_num) { fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected " "seq:%"PRIu64" != actual seq:%"PRIu64"\n", - __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1, + __v3_v4_prev_block_seq_num, __v3_v4_prev_block_seq_num + 1, (uint64_t) pbd->h1.seq_num); exit(1); } - __v3_prev_block_seq_num = pbd->h1.seq_num; + __v3_v4_prev_block_seq_num = pbd->h1.seq_num; } -static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num) +static void __v3_v4_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num) { if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) { fprintf(stderr, "\nblock:%u with %upackets, expected " @@ -542,23 +548,23 @@ static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int bloc } } -static void __v3_test_block_header(struct block_desc *pbd, const int block_num) +static void __v3_v4_test_block_header(struct block_desc *pbd, const int block_num) { if ((pbd->h1.block_status & TP_STATUS_USER) == 0) { fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num); exit(1); } - __v3_test_block_seq_num(pbd); + __v3_v4_test_block_seq_num(pbd); } -static void __v3_walk_block(struct block_desc *pbd, const int block_num) +static void __v3_v4_walk_block(struct block_desc *pbd, const int block_num) { int num_pkts = pbd->h1.num_pkts, i; unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd)); struct tpacket3_hdr *ppd; - __v3_test_block_header(pbd, block_num); + __v3_v4_test_block_header(pbd, block_num); ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd + pbd->h1.offset_to_first_pkt); @@ -580,17 +586,17 @@ static void __v3_walk_block(struct block_desc *pbd, const int block_num) __sync_synchronize(); } - __v3_test_block_len(pbd, bytes_with_padding, block_num); + __v3_v4_test_block_len(pbd, bytes_with_padding, block_num); total_bytes += bytes; } -void __v3_flush_block(struct block_desc *pbd) +void __v3_v4_flush_block(struct block_desc *pbd) { pbd->h1.block_status = TP_STATUS_KERNEL; __sync_synchronize(); } -static void walk_v3_rx(int sock, struct ring *ring) +static void walk_v3_v4_rx(int sock, struct ring *ring) { unsigned int block_num = 0; struct pollfd pfd; @@ -614,8 +620,8 @@ static void walk_v3_rx(int sock, struct ring *ring) while ((pbd->h1.block_status & TP_STATUS_USER) == 0) poll(&pfd, 1, 1); - __v3_walk_block(pbd, block_num); - __v3_flush_block(pbd); + __v3_v4_walk_block(pbd, block_num); + __v3_v4_flush_block(pbd); block_num = (block_num + 1) % ring->rd_num; } @@ -623,7 +629,7 @@ static void walk_v3_rx(int sock, struct ring *ring) pair_udp_close(udp_sock); if (total_packets != 2 * NUM_PACKETS) { - fprintf(stderr, "walk_v3_rx: received %u out of %u pkts\n", + fprintf(stderr, "walk_v3_v4_rx: received %u out of %u pkts\n", total_packets, NUM_PACKETS); exit(1); } @@ -631,10 +637,10 @@ static void walk_v3_rx(int sock, struct ring *ring) fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, total_bytes >> 1); } -static void walk_v3(int sock, struct ring *ring) +static void walk_v3_v4(int sock, struct ring *ring) { if (ring->type == PACKET_RX_RING) - walk_v3_rx(sock, ring); + walk_v3_v4_rx(sock, ring); else walk_tx(sock, ring); } @@ -655,7 +661,7 @@ static void __v1_v2_fill(struct ring *ring, unsigned int blocks) ring->flen = ring->req.tp_frame_size; } -static void __v3_fill(struct ring *ring, unsigned int blocks, int type) +static void __v3_v4_fill(struct ring *ring, unsigned int blocks, int type) { if (type == PACKET_RX_RING) { ring->req3.tp_retire_blk_tov = 64; @@ -671,7 +677,7 @@ static void __v3_fill(struct ring *ring, unsigned int blocks, int type) ring->req3.tp_block_nr; ring->mm_len = ring->req3.tp_block_size * ring->req3.tp_block_nr; - ring->walk = walk_v3; + ring->walk = walk_v3_v4; ring->rd_num = ring->req3.tp_block_nr; ring->flen = ring->req3.tp_block_size; } @@ -695,7 +701,8 @@ static void setup_ring(int sock, struct ring *ring, int version, int type) break; case TPACKET_V3: - __v3_fill(ring, blocks, type); + case TPACKET_V4: + __v3_v4_fill(ring, blocks, type); ret = setsockopt(sock, SOL_PACKET, type, &ring->req3, sizeof(ring->req3)); break; @@ -804,6 +811,7 @@ static const char *tpacket_str[] = { [TPACKET_V1] = "TPACKET_V1", [TPACKET_V2] = "TPACKET_V2", [TPACKET_V3] = "TPACKET_V3", + [TPACKET_V4] = "TPACKET_V4", }; static const char *type_str[] = { @@ -854,6 +862,9 @@ int main(void) ret |= test_tpacket(TPACKET_V3, PACKET_RX_RING); ret |= test_tpacket(TPACKET_V3, PACKET_TX_RING); + ret |= test_tpacket(TPACKET_V4, PACKET_RX_RING); + ret |= test_tpacket(TPACKET_V4, PACKET_TX_RING); + if (ret) return 1; -- 2.9.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 4 months

4
7
0 0

[Linux-kselftest-mirror] [PATCH 0/2] selftests: ftrace: Fix multiple-kprobe testcase

by Masami Hiramatsu

Hi, These patches are fixing a bug and improve testcase to ensure adding 256 kprobe events for test. The 1st patch is clearly a bug, so it should be fixed in stable kernel too. Thank you, --- Masami Hiramatsu (2): [BUGFIX] selftest: ftrace: Fix to pick text symbols for kprobes selftest: ftrace: Fix to add 256 kprobe events correctly .../ftrace/test.d/kprobe/multiple_kprobes.tc | 21 +++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) -- Masami Hiramatsu (Linaro) <mhiramat(a)kernel.org> -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

1
2
0 0

Re: [Linux-kselftest-mirror] [RFC PATCH for 4.15 v3 15/22] rseq: selftests: Provide self-tests

by Peter Zijlstra

On Tue, Nov 21, 2017 at 09:18:53AM -0500, Mathieu Desnoyers wrote: > +int percpu_list_push(struct percpu_list *list, struct percpu_list_node *node) > +{ > + intptr_t *targetptr, newval, expect; > + int cpu, ret; > + > + /* Try fast path. */ > + cpu = rseq_cpu_start(); > + /* Load list->c[cpu].head with single-copy atomicity. */ > + expect = (intptr_t)READ_ONCE(list->c[cpu].head); > + newval = (intptr_t)node; > + targetptr = (intptr_t *)&list->c[cpu].head; > + node->next = (struct percpu_list_node *)expect; > + ret = rseq_cmpeqv_storev(targetptr, expect, newval, cpu); > + if (likely(!ret)) > + return cpu; > + return cpu; > +} > +static inline __attribute__((always_inline)) > +int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, > + int cpu) > +{ > + __asm__ __volatile__ goto ( > + RSEQ_ASM_DEFINE_TABLE(3, __rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) > + RSEQ_ASM_STORE_RSEQ_CS(1, 3b, rseq_cs) > + RSEQ_ASM_CMP_CPU_ID(cpu_id, current_cpu_id, 4f) So the actual C part of the RSEQ is subject to an ABA, right? We can get migrated to another CPU and back again without then failing here. It used to be that this was caught by the sequence count, but that is now gone. The thing that makes it work is the compare against @v: > + "cmpq %[v], %[expect]\n\t" > + "jnz 5f\n\t" That then ensures things are still as we observed them before (although this itself is also subject to ABA). This means all RSEQ primitives that have a C part must have a cmp-and- form, but I suppose that was already pretty much the case anyway. I just don't remember seeing that spelled out anywhere. Then again, I've not yet read that manpage. > + /* final store */ > + "movq %[newv], %[v]\n\t" > + "2:\n\t" > + RSEQ_ASM_DEFINE_ABORT(4, __rseq_failure, RSEQ_SIG, "", abort) > + RSEQ_ASM_DEFINE_CMPFAIL(5, __rseq_failure, "", cmpfail) > + : /* gcc asm goto does not allow outputs */ > + : [cpu_id]"r"(cpu), > + [current_cpu_id]"m"(__rseq_abi.cpu_id), > + [rseq_cs]"m"(__rseq_abi.rseq_cs), > + [v]"m"(*v), > + [expect]"r"(expect), > + [newv]"r"(newv) > + : "memory", "cc", "rax" > + : abort, cmpfail > + ); > + return 0; > +abort: > + return -1; > +cmpfail: > + return 1; > +} -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

2
3
0 0

Re: [Linux-kselftest-mirror] [RFC PATCH for 4.15 v3 15/22] rseq: selftests: Provide self-tests

by Peter Zijlstra

On Tue, Nov 21, 2017 at 09:18:53AM -0500, Mathieu Desnoyers wrote: > diff --git a/tools/testing/selftests/rseq/rseq-x86.h b/tools/testing/selftests/rseq/rseq-x86.h > new file mode 100644 > index 000000000000..63e81d6c61fa > --- /dev/null > +++ b/tools/testing/selftests/rseq/rseq-x86.h > @@ -0,0 +1,898 @@ > +/* > + * rseq-x86.h > + * > + * (C) Copyright 2016 - Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> > + * > + * Permission is hereby granted, free of charge, to any person obtaining a copy > + * of this software and associated documentation files (the "Software"), to deal > + * in the Software without restriction, including without limitation the rights > + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell > + * copies of the Software, and to permit persons to whom the Software is > + * furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice shall be included in > + * all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE > + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, > + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE > + * SOFTWARE. > + */ > + > +#include <stdint.h> > + > +#define RSEQ_SIG 0x53053053 > + > +#ifdef __x86_64__ > + > +#define rseq_smp_mb() __asm__ __volatile__ ("mfence" : : : "memory") See commit: 450cbdd0125c ("locking/x86: Use LOCK ADD for smp_mb() instead of MFENCE") > +#define rseq_smp_rmb() barrier() > +#define rseq_smp_wmb() barrier() > + > +#define rseq_smp_load_acquire(p) \ > +__extension__ ({ \ > + __typeof(*p) ____p1 = RSEQ_READ_ONCE(*p); \ > + barrier(); \ > + ____p1; \ > +}) > + > +#define rseq_smp_acquire__after_ctrl_dep() rseq_smp_rmb() > + > +#define rseq_smp_store_release(p, v) \ > +do { \ > + barrier(); \ > + RSEQ_WRITE_ONCE(*p, v); \ > +} while (0) > + > +#define RSEQ_ASM_DEFINE_TABLE(label, section, version, flags, \ > + start_ip, post_commit_offset, abort_ip) \ > + ".pushsection " __rseq_str(section) ", \"aw\"\n\t" \ > + ".balign 32\n\t" \ > + __rseq_str(label) ":\n\t" \ > + ".long " __rseq_str(version) ", " __rseq_str(flags) "\n\t" \ > + ".quad " __rseq_str(start_ip) ", " __rseq_str(post_commit_offset) ", " __rseq_str(abort_ip) "\n\t" \ > + ".popsection\n\t" OK, so this creates table entry, but why is @section an argument, AFAICT its _always_ the same thing, no? > +#define RSEQ_ASM_STORE_RSEQ_CS(label, cs_label, rseq_cs) \ > + RSEQ_INJECT_ASM(1) \ > + "leaq " __rseq_str(cs_label) "(%%rip), %%rax\n\t" \ > + "movq %%rax, %[" __rseq_str(rseq_cs) "]\n\t" \ > + __rseq_str(label) ":\n\t" And this sets the TLS variable to point to the table entry from the previous macro, no? But again @rseq_cs seems to always be the very same, why is that an argument? > +#define RSEQ_ASM_CMP_CPU_ID(cpu_id, current_cpu_id, label) \ > + RSEQ_INJECT_ASM(2) \ > + "cmpl %[" __rseq_str(cpu_id) "], %[" __rseq_str(current_cpu_id) "]\n\t" \ > + "jnz " __rseq_str(label) "\n\t" more things that are always the same it seems.. > +#define RSEQ_ASM_DEFINE_ABORT(label, section, sig, teardown, abort_label) \ > + ".pushsection " __rseq_str(section) ", \"ax\"\n\t" \ > + /* Disassembler-friendly signature: nopl <sig>(%rip). */\ > + ".byte 0x0f, 0x1f, 0x05\n\t" \ > + ".long " __rseq_str(sig) "\n\t" \ > + __rseq_str(label) ":\n\t" \ > + teardown \ > + "jmp %l[" __rseq_str(abort_label) "]\n\t" \ > + ".popsection\n\t" @section and @sig seem to always be the same... > +#define RSEQ_ASM_DEFINE_CMPFAIL(label, section, teardown, cmpfail_label) \ > + ".pushsection " __rseq_str(section) ", \"ax\"\n\t" \ > + __rseq_str(label) ":\n\t" \ > + teardown \ > + "jmp %l[" __rseq_str(cmpfail_label) "]\n\t" \ > + ".popsection\n\t" Somewhat failing to see the point of this macro, it seems to just obfuscate the normal failure path. > +static inline __attribute__((always_inline)) > +int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, > + int cpu) I find this a very confusing name for what is essentially compare-and-exchange or compare-and-swap, no? > +{ > + __asm__ __volatile__ goto ( > + RSEQ_ASM_DEFINE_TABLE(3, __rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) So we set up the section, but unreadably so... reducing the number of arguments would help a lot. Rename the current one to __RSEQ_ASM_DEFINE_TABLE() and then use: #define RSEQ_ASM_DEFINE_TABLE(label, start_ip, post_commit_ip, abort_ip) \ __RSEQ_ASM_DEFINE_TABLE(label, __rseq_table, 0x0, 0x0, start_ip, \ (post_commit_ip - start_ip), abort_ip) or something, such that we can write: RSEQ_ASM_DEFINE_TABLE(3, 1f, 2f, 4f) /* start, commit, abort */ > + RSEQ_ASM_STORE_RSEQ_CS(1, 3b, rseq_cs) And here we open start the rseq by storing the table entry pointer into the TLS thingy. > + RSEQ_ASM_CMP_CPU_ID(cpu_id, current_cpu_id, 4f) > + "cmpq %[v], %[expect]\n\t" > + "jnz 5f\n\t" "jnz %l[cmpfail]\n\t" was too complicated? > + /* final store */ > + "movq %[newv], %[v]\n\t" > + "2:\n\t" > + RSEQ_ASM_DEFINE_ABORT(4, __rseq_failure, RSEQ_SIG, "", abort) > + RSEQ_ASM_DEFINE_CMPFAIL(5, __rseq_failure, "", cmpfail) > + : /* gcc asm goto does not allow outputs */ > + : [cpu_id]"r"(cpu), > + [current_cpu_id]"m"(__rseq_abi.cpu_id), > + [rseq_cs]"m"(__rseq_abi.rseq_cs), > + [v]"m"(*v), > + [expect]"r"(expect), > + [newv]"r"(newv) : [cpu_id] "r" (cpu), [current_cpu_id] "m" (__rseq_abi.cpu_id), [rseq_cs] "m" (__rseq_abi.rseq_cs), [v] "m" (*v), [expect] "r" (expect), [newv] "r" (newv) or something does read much better > + : "memory", "cc", "rax" > + : abort, cmpfail > + ); > + return 0; > +abort: > + return -1; > +cmpfail: > + return 1; > +} > + > +static inline __attribute__((always_inline)) > +int rseq_cmpnev_storeoffp_load(intptr_t *v, intptr_t expectnot, > + off_t voffp, intptr_t *load, int cpu) so this thing does what now? It compares @v to @expectnot, when _not_ matching it will store @voffp into @v and load something..? > +{ > + __asm__ __volatile__ goto ( > + RSEQ_ASM_DEFINE_TABLE(3, __rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) > + RSEQ_ASM_STORE_RSEQ_CS(1, 3b, rseq_cs) > + RSEQ_ASM_CMP_CPU_ID(cpu_id, current_cpu_id, 4f) > + "cmpq %[v], %[expectnot]\n\t" > + "jz 5f\n\t" So I would prefer "je" in this context, or rather: je %l[cmpfail] > + "movq %[v], %%rax\n\t" loads @v in A But it could already have changed since the previous load from cmp, no? Would it not make sense to put this load before the cmp and use A instead? > + "movq %%rax, %[load]\n\t" stores A in @load > + "addq %[voffp], %%rax\n\t" adds @off to A > + "movq (%%rax), %%rax\n\t" loads (A) in A > + /* final store */ > + "movq %%rax, %[v]\n\t" stores A in @v So the whole thing loads @v into @load, adds and offset, dereferences and adds that back in @v, provided @v doesn't match @expected.. whee. > + "2:\n\t" > + RSEQ_ASM_DEFINE_ABORT(4, __rseq_failure, RSEQ_SIG, "", abort) > + RSEQ_ASM_DEFINE_CMPFAIL(5, __rseq_failure, "", cmpfail) > + : /* gcc asm goto does not allow outputs */ > + : [cpu_id]"r"(cpu), > + [current_cpu_id]"m"(__rseq_abi.cpu_id), > + [rseq_cs]"m"(__rseq_abi.rseq_cs), > + /* final store input */ > + [v]"m"(*v), > + [expectnot]"r"(expectnot), > + [voffp]"er"(voffp), > + [load]"m"(*load) > + : "memory", "cc", "rax" > + : abort, cmpfail > + ); > + return 0; > +abort: > + return -1; > +cmpfail: > + return 1; > +} > +#elif __i386__ > + > +/* > + * Support older 32-bit architectures that do not implement fence > + * instructions. > + */ > +#define rseq_smp_mb() \ > + __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory") > +#define rseq_smp_rmb() \ > + __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory") > +#define rseq_smp_wmb() \ > + __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory") Oh shiny, you're supporting that OOSTORE and PPRO_FENCE nonsense? Going by commit: 09df7c4c8097 ("x86: Remove CONFIG_X86_OOSTORE") That smp_wmb() one was an 'optimization' (forced store buffer flush) but not a correctness thing. And we dropped that stuff from the kernel a _long_ time ago. Ideally we'd kill that PPRO_FENCE crap too. -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

2
1
0 0

Re: [Linux-kselftest-mirror] [RFC PATCH for 4.15 v3 15/22] rseq: selftests: Provide self-tests

by Peter Zijlstra

On Tue, Nov 21, 2017 at 09:18:53AM -0500, Mathieu Desnoyers wrote: > Implements two basic tests of RSEQ functionality, and one more > exhaustive parameterizable test. > > The first, "basic_test" only asserts that RSEQ works moderately > correctly. E.g. that the CPUID pointer works. > > "basic_percpu_ops_test" is a slightly more "realistic" variant, > implementing a few simple per-cpu operations and testing their > correctness. > > "param_test" is a parametrizable restartable sequences test. See > the "--help" output for usage. > > A run_param_test.sh script runs many variants of the parametrizable > tests. > > As part of those tests, a helper library "rseq" implements a user-space > API around restartable sequences. It uses the cpu_opv system call as > fallback when single-stepped by a debugger. It exposes the instruction > pointer addresses where the rseq assembly blocks begin and end, as well > as the associated abort instruction pointer, in the __rseq_table > section. This section allows debuggers may know where to place > breakpoints when single-stepping through assembly blocks which may be > aborted at any point by the kernel. Could I ask you to split this in smaller bits? I'd start with just the rseq library, using only the rseq interface. Then add the whole cpu_opv fallback stuff. Then add the selftests using librseq. As is this is a tad much to read in a single go. -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

2
1
0 0

Re: [Linux-kselftest-mirror] [PATCH update for 4.15 3/3] rseq: selftests: Provide self-tests (v4)

by Shuah Khan

On 11/21/2017 03:19 PM, Mathieu Desnoyers wrote: > Implements two basic tests of RSEQ functionality, and one more > exhaustive parameterizable test. > > The first, "basic_test" only asserts that RSEQ works moderately > correctly. E.g. that the CPUID pointer works. > > "basic_percpu_ops_test" is a slightly more "realistic" variant, > implementing a few simple per-cpu operations and testing their > correctness. > > "param_test" is a parametrizable restartable sequences test. See > the "--help" output for usage. > > A run_param_test.sh script runs many variants of the parametrizable > tests. > > As part of those tests, a helper library "rseq" implements a user-space > API around restartable sequences. It uses the cpu_opv system call as > fallback when single-stepped by a debugger. It exposes the instruction > pointer addresses where the rseq assembly blocks begin and end, as well > as the associated abort instruction pointer, in the __rseq_table > section. This section allows debuggers may know where to place > breakpoints when single-stepping through assembly blocks which may be > aborted at any point by the kernel. > > The rseq library expose APIs that present the fast-path operations. > The new from userspace is, e.g. for a counter increment: > > cpu = rseq_cpu_start(); > ret = rseq_addv(&data->c[cpu].count, 1, cpu); > if (likely(!ret)) > return 0; /* Success. */ > do { > cpu = rseq_current_cpu(); > ret = cpu_op_addv(&data->c[cpu].count, 1, cpu); > if (likely(!ret)) > return 0; /* Success. */ > } while (ret > 0 || errno == EAGAIN); > perror("cpu_op_addv"); > return -1; /* Unexpected error. */ > > PowerPC tests have been implemented by Boqun Feng. > > Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> > CC: Russell King <linux(a)arm.linux.org.uk> > CC: Catalin Marinas <catalin.marinas(a)arm.com> > CC: Will Deacon <will.deacon(a)arm.com> > CC: Thomas Gleixner <tglx(a)linutronix.de> > CC: Paul Turner <pjt(a)google.com> > CC: Andrew Hunter <ahh(a)google.com> > CC: Peter Zijlstra <peterz(a)infradead.org> > CC: Andy Lutomirski <luto(a)amacapital.net> > CC: Andi Kleen <andi(a)firstfloor.org> > CC: Dave Watson <davejwatson(a)fb.com> > CC: Chris Lameter <cl(a)linux.com> > CC: Ingo Molnar <mingo(a)redhat.com> > CC: "H. Peter Anvin" <hpa(a)zytor.com> > CC: Ben Maurer <bmaurer(a)fb.com> > CC: Steven Rostedt <rostedt(a)goodmis.org> > CC: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> > CC: Josh Triplett <josh(a)joshtriplett.org> > CC: Linus Torvalds <torvalds(a)linux-foundation.org> > CC: Andrew Morton <akpm(a)linux-foundation.org> > CC: Boqun Feng <boqun.feng(a)gmail.com> > CC: Shuah Khan <shuah(a)kernel.org> > CC: linux-kselftest(a)vger.kernel.org > CC: linux-api(a)vger.kernel.org > --- > Changes since v1: > - Provide abort-ip signature: The abort-ip signature is located just > before the abort-ip target. It is currently hardcoded, but a > user-space application could use the __rseq_table to iterate on all > abort-ip targets and use a random value as signature if needed in the > future. > - Add rseq_prepare_unload(): Libraries and JIT code using rseq critical > sections need to issue rseq_prepare_unload() on each thread at least > once before reclaim of struct rseq_cs. > - Use initial-exec TLS model, non-weak symbol: The initial-exec model is > signal-safe, whereas the global-dynamic model is not. Remove the > "weak" symbol attribute from the __rseq_abi in rseq.c. The rseq.so > library will have ownership of that symbol, and there is not reason for > an application or user library to try to define that symbol. > The expected use is to link against libreq.so, which owns and provide > that symbol. > - Set cpu_id to -2 on register error > - Add rseq_len syscall parameter, rseq_cs version > - Ensure disassember-friendly signature: x86 32/64 disassembler have a > hard time decoding the instruction stream after a bad instruction. Use > a nopl instruction to encode the signature. Suggested by Andy Lutomirski. > - Exercise parametrized tests variants in a shell scripts. > - Restartable sequences selftests: Remove use of event counter. > - Use cpu_id_start field: With the cpu_id_start field, the C > preparation phase of the fast-path does not need to compare cpu_id < 0 > anymore. > - Signal-safe registration and refcounting: Allow libraries using > librseq.so to register it from signal handlers. > - Use OVERRIDE_TARGETS in makefile. > - Use "m" constraints for rseq_cs field. > > Changes since v2: > - Update based on Thomas Gleixner's comments. > > Changes since v3: > - Generate param_test_skip_fastpath and param_test_benchmark with > -DSKIP_FASTPATH and -DBENCHMARK (respectively). Add param_test_fastpath > to run_param_test.sh. > --- > MAINTAINERS | 1 + > tools/testing/selftests/Makefile | 1 + > tools/testing/selftests/rseq/.gitignore | 4 + > tools/testing/selftests/rseq/Makefile | 33 + > .../testing/selftests/rseq/basic_percpu_ops_test.c | 333 +++++ > tools/testing/selftests/rseq/basic_test.c | 55 + > tools/testing/selftests/rseq/param_test.c | 1285 ++++++++++++++++++++ > tools/testing/selftests/rseq/rseq-arm.h | 535 ++++++++ > tools/testing/selftests/rseq/rseq-ppc.h | 567 +++++++++ > tools/testing/selftests/rseq/rseq-x86.h | 898 ++++++++++++++ > tools/testing/selftests/rseq/rseq.c | 116 ++ > tools/testing/selftests/rseq/rseq.h | 154 +++ > tools/testing/selftests/rseq/run_param_test.sh | 126 ++ > 13 files changed, 4108 insertions(+) > create mode 100644 tools/testing/selftests/rseq/.gitignore > create mode 100644 tools/testing/selftests/rseq/Makefile > create mode 100644 tools/testing/selftests/rseq/basic_percpu_ops_test.c > create mode 100644 tools/testing/selftests/rseq/basic_test.c > create mode 100644 tools/testing/selftests/rseq/param_test.c > create mode 100644 tools/testing/selftests/rseq/rseq-arm.h > create mode 100644 tools/testing/selftests/rseq/rseq-ppc.h > create mode 100644 tools/testing/selftests/rseq/rseq-x86.h > create mode 100644 tools/testing/selftests/rseq/rseq.c > create mode 100644 tools/testing/selftests/rseq/rseq.h > create mode 100755 tools/testing/selftests/rseq/run_param_test.sh > Looks good. Acked-by: Shuah Khan <shuahkh(a)osg.samsung.com> thanks, -- Shuah -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

2
1
0 0

[Linux-kselftest-mirror] [PATCH update for 4.15 1/3] selftests: lib.mk: Introduce OVERRIDE_TARGETS

by Mathieu Desnoyers

Introduce OVERRIDE_TARGETS to allow tests to express dependencies on header files and .so, which require to override the selftests lib.mk targets. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> CC: Russell King <linux(a)arm.linux.org.uk> CC: Catalin Marinas <catalin.marinas(a)arm.com> CC: Will Deacon <will.deacon(a)arm.com> CC: Thomas Gleixner <tglx(a)linutronix.de> CC: Paul Turner <pjt(a)google.com> CC: Andrew Hunter <ahh(a)google.com> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Andy Lutomirski <luto(a)amacapital.net> CC: Andi Kleen <andi(a)firstfloor.org> CC: Dave Watson <davejwatson(a)fb.com> CC: Chris Lameter <cl(a)linux.com> CC: Ingo Molnar <mingo(a)redhat.com> CC: "H. Peter Anvin" <hpa(a)zytor.com> CC: Ben Maurer <bmaurer(a)fb.com> CC: Steven Rostedt <rostedt(a)goodmis.org> CC: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> CC: Josh Triplett <josh(a)joshtriplett.org> CC: Linus Torvalds <torvalds(a)linux-foundation.org> CC: Andrew Morton <akpm(a)linux-foundation.org> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Shuah Khan <shuah(a)kernel.org> CC: linux-kselftest(a)vger.kernel.org CC: linux-api(a)vger.kernel.org --- tools/testing/selftests/lib.mk | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/testing/selftests/lib.mk b/tools/testing/selftests/lib.mk index 5bef05d6ba39..441d7bc63bb7 100644 --- a/tools/testing/selftests/lib.mk +++ b/tools/testing/selftests/lib.mk @@ -105,6 +105,9 @@ COMPILE.S = $(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c LINK.S = $(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH) endif +# Selftest makefiles can override those targets by setting +# OVERRIDE_TARGETS = 1. +ifeq ($(OVERRIDE_TARGETS),) $(OUTPUT)/%:%.c $(LINK.c) $^ $(LDLIBS) -o $@ @@ -113,5 +116,6 @@ $(OUTPUT)/%.o:%.S $(OUTPUT)/%:%.S $(LINK.S) $^ $(LDLIBS) -o $@ +endif .PHONY: run_tests all clean install emit_tests -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

2
4
0 0

Re: [Linux-kselftest-mirror] [RFC PATCH for 4.15 v3 15/22] rseq: selftests: Provide self-tests

by Mathieu Desnoyers

----- On Nov 21, 2017, at 10:34 AM, shuah shuah(a)kernel.org wrote: [...] >> --- >> MAINTAINERS | 1 + >> tools/testing/selftests/Makefile | 1 + >> tools/testing/selftests/rseq/.gitignore | 4 + > > Thanks for the .gitignore files. It is commonly missed change, I end > up adding one to clean things up after tests get in. I'm used to receive patches where contributors forget to add new files to gitignore within my own projects, which may contribute to my awareness of this pain point. :) [...] >> + >> +void *test_percpu_inc_thread(void *arg) >> +{ >> + struct inc_thread_test_data *thread_data = arg; >> + struct inc_test_data *data = thread_data->data; >> + long long i, reps; >> + >> + if (!opt_disable_rseq && thread_data->reg >> + && rseq_register_current_thread()) >> + abort(); >> + reps = thread_data->reps; >> + for (i = 0; i < reps; i++) { >> + int cpu, ret; >> + >> +#ifndef SKIP_FASTPATH >> + /* Try fast path. */ >> + cpu = rseq_cpu_start(); >> + ret = rseq_addv(&data->c[cpu].count, 1, cpu); >> + if (likely(!ret)) >> + goto next; >> +#endif > > So the test needs to compiled with this enabled? I think it would be better > to make this an argument to be abel to select at test start time as opposed > to making this compile time option. Remember that these tests get run in > automated test rings. Making this a compile time otpion pertty much ensures > that this path will not be tested. > > So I would reccommend adding a paratemer. > >> + slowpath: >> + __attribute__((unused)); >> + for (;;) { >> + /* Fallback on cpu_opv system call. */ >> + cpu = rseq_current_cpu(); >> + ret = cpu_op_addv(&data->c[cpu].count, 1, cpu); >> + if (likely(!ret)) >> + break; >> + assert(ret >= 0 || errno == EAGAIN); >> + } >> + next: >> + __attribute__((unused)); >> +#ifndef BENCHMARK >> + if (i != 0 && !(i % (reps / 10))) >> + printf_verbose("tid %d: count %lld\n", (int) gettid(), i); >> +#endif > > Same comment as before. Avoid compile time options. The goal of those compiler define are to generate the altered code without adding branches into the fast-paths. Here is an alternative solution that should take care of your concern: I'll build multiple targets for param_test.c: param_test param_test_skip_fastpath (built with -DSKIP_FASTPATH) param_test_benchmark (build with -DBENCHMARK) I'll update run_param_test.sh to run both param_test and param_test_skip_fastpath. Note that "param_test_benchmark" is only useful for benchmarking, so I don't plan to run it from run_param_test.sh which is meant to track regressions. Is that approach OK with you ? Thanks, Mathieu -- Mathieu Desnoyers EfficiOS Inc. http://www.efficios.com -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

6 years, 5 months

3
4
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror November 2017