From 634a8a8873d76c4faaf99990a41c985d9cd6b7e9 Mon Sep 17 00:00:00 2001 From: Andrew Turner Date: Sun, 3 Feb 2019 12:46:27 +0000 Subject: [PATCH 01/36] Enable COVERAGE and KCOV by default on arm64 and amd64. This allows userspace to trace the kernel using the coverage sanitizer found in clang. It will also allow other coverage tools to be built as modules and attach into the same framework. Sponsored by: DARPA, AFRL --- sys/amd64/conf/GENERIC | 4 ++-- sys/arm64/conf/GENERIC | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC index 9a8532ba6f03..ef7b1a0660ff 100644 --- a/sys/amd64/conf/GENERIC +++ b/sys/amd64/conf/GENERIC @@ -102,8 +102,8 @@ options MALLOC_DEBUG_MAXZONES=8 # Separate malloc(9) zones options VERBOSE_SYSINIT=0 # Support debug.verbose_sysinit, off by default # Kernel Sanitizers -#options COVERAGE # Generic kernel coverage. Used by KCOV -#options KCOV # Kernel Coverage Sanitizer +options COVERAGE # Generic kernel coverage. Used by KCOV +options KCOV # Kernel Coverage Sanitizer # Warning: KUBSAN can result in a kernel too large for loader to load #options KUBSAN # Kernel Undefined Behavior Sanitizer diff --git a/sys/arm64/conf/GENERIC b/sys/arm64/conf/GENERIC index 641ad1cac97e..a5e182ea6682 100644 --- a/sys/arm64/conf/GENERIC +++ b/sys/arm64/conf/GENERIC @@ -94,8 +94,8 @@ options USB_DEBUG # enable debug msgs options VERBOSE_SYSINIT=0 # Support debug.verbose_sysinit, off by default # Kernel Sanitizers -#options COVERAGE # Generic kernel coverage. Used by KCOV -#options KCOV # Kernel Coverage Sanitizer +options COVERAGE # Generic kernel coverage. Used by KCOV +options KCOV # Kernel Coverage Sanitizer # Warning: KUBSAN can result in a kernel too large for loader to load #options KUBSAN # Kernel Undefined Behavior Sanitizer From d0488e698f29e98840eb8c3cb6910ee2acfb6c21 Mon Sep 17 00:00:00 2001 From: Mark Johnston Date: Sun, 3 Feb 2019 18:38:58 +0000 Subject: [PATCH 02/36] Fix a race in vm_page_dequeue_deferred(). To detect the case where the page is already marked for a deferred dequeue, we must read the "queue" and "aflags" fields in a precise order. Otherwise, a race with a concurrent vm_page_dequeue_complete() could leave the page with PGA_DEQUEUE set despite it already having been dequeued. Fix the problem by using vm_page_queue() to check the queue state, which correctly handles the race. Reviewed by: kib Tested by: pho MFC after: 3 days Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D19039 --- sys/vm/vm_page.c | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c index 90efbbe03660..527d322d7833 100644 --- a/sys/vm/vm_page.c +++ b/sys/vm/vm_page.c @@ -3279,18 +3279,13 @@ vm_page_dequeue_complete(vm_page_t m) void vm_page_dequeue_deferred(vm_page_t m) { - int queue; + uint8_t queue; vm_page_assert_locked(m); - queue = atomic_load_8(&m->queue); - if (queue == PQ_NONE) { - KASSERT((m->aflags & PGA_QUEUE_STATE_MASK) == 0, - ("page %p has queue state", m)); + if ((queue = vm_page_queue(m)) == PQ_NONE) return; - } - if ((m->aflags & PGA_DEQUEUE) == 0) - vm_page_aflag_set(m, PGA_DEQUEUE); + vm_page_aflag_set(m, PGA_DEQUEUE); vm_pqbatch_submit_page(m, queue); } @@ -3386,7 +3381,7 @@ vm_page_requeue(vm_page_t m) { vm_page_assert_locked(m); - KASSERT(m->queue != PQ_NONE, + KASSERT(vm_page_queue(m) != PQ_NONE, ("%s: page %p is not logically enqueued", __func__, m)); if ((m->aflags & PGA_REQUEUE) == 0) From 1e2b3e6f92db4967a4b85b125c8765ba407a22e1 Mon Sep 17 00:00:00 2001 From: Mark Johnston Date: Sun, 3 Feb 2019 18:43:20 +0000 Subject: [PATCH 03/36] Allow vm_page_free_prep() to dequeue pages without the page lock. This is a step towards being able to free pages without the page lock held. The approach is simply to add an implementation of vm_page_dequeue_deferred() which does not assert that the page lock is held. Formally, the page lock is required to set PGA_DEQUEUE, but in the case of vm_page_free_prep() we get the same mutual exclusion for free by virtue of the fact that no other references to the page may exist. No functional change intended. Reviewed by: kib (previous version) MFC after: 2 weeks Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D19065 --- sys/vm/vm_page.c | 37 +++++++++++++++++++++++++++++++++---- sys/vm/vm_page.h | 6 ++++-- 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c index 527d322d7833..7c3aeaef7456 100644 --- a/sys/vm/vm_page.c +++ b/sys/vm/vm_page.c @@ -3175,7 +3175,11 @@ vm_pqbatch_submit_page(vm_page_t m, uint8_t queue) struct vm_pagequeue *pq; int domain; - vm_page_assert_locked(m); + KASSERT((m->oflags & VPO_UNMANAGED) == 0, + ("page %p is unmanaged", m)); + KASSERT(mtx_owned(vm_page_lockptr(m)) || + (m->object == NULL && (m->aflags & PGA_DEQUEUE) != 0), + ("missing synchronization for page %p", m)); KASSERT(queue < PQ_COUNT, ("invalid queue %d", queue)); domain = vm_phys_domain(m); @@ -3197,8 +3201,9 @@ vm_pqbatch_submit_page(vm_page_t m, uint8_t queue) /* * The page may have been logically dequeued before we acquired the - * page queue lock. In this case, the page lock prevents the page - * from being logically enqueued elsewhere. + * page queue lock. In this case, since we either hold the page lock + * or the page is being freed, a different thread cannot be concurrently + * enqueuing the page. */ if (__predict_true(m->queue == queue)) vm_pqbatch_process_page(pq, m); @@ -3289,6 +3294,30 @@ vm_page_dequeue_deferred(vm_page_t m) vm_pqbatch_submit_page(m, queue); } +/* + * A variant of vm_page_dequeue_deferred() that does not assert the page + * lock and is only to be called from vm_page_free_prep(). It is just an + * open-coded implementation of vm_page_dequeue_deferred(). Because the + * page is being freed, we can assume that nothing else is scheduling queue + * operations on this page, so we get for free the mutual exclusion that + * is otherwise provided by the page lock. + */ +static void +vm_page_dequeue_deferred_free(vm_page_t m) +{ + uint8_t queue; + + KASSERT(m->object == NULL, ("page %p has an object reference", m)); + + if ((m->aflags & PGA_DEQUEUE) != 0) + return; + atomic_thread_fence_acq(); + if ((queue = m->queue) == PQ_NONE) + return; + vm_page_aflag_set(m, PGA_DEQUEUE); + vm_pqbatch_submit_page(m, queue); +} + /* * vm_page_dequeue: * @@ -3474,7 +3503,7 @@ vm_page_free_prep(vm_page_t m) * dequeue. */ if ((m->oflags & VPO_UNMANAGED) == 0) - vm_page_dequeue_deferred(m); + vm_page_dequeue_deferred_free(m); m->valid = 0; vm_page_undirty(m); diff --git a/sys/vm/vm_page.h b/sys/vm/vm_page.h index cf00912487ef..401d3498f786 100644 --- a/sys/vm/vm_page.h +++ b/sys/vm/vm_page.h @@ -351,8 +351,10 @@ extern struct mtx_padalign pa_lock[]; * queue, and cleared when the dequeue request is processed. A page may * have PGA_DEQUEUE set and PGA_ENQUEUED cleared, for instance if a dequeue * is requested after the page is scheduled to be enqueued but before it is - * actually inserted into the page queue. The page lock must be held to set - * this flag, and the queue lock for the page must be held to clear it. + * actually inserted into the page queue. For allocated pages, the page lock + * must be held to set this flag, but it may be set by vm_page_free_prep() + * without the page lock held. The page queue lock must be held to clear the + * PGA_DEQUEUE flag. * * PGA_REQUEUE is set when the page is scheduled to be enqueued or requeued * in its page queue. The page lock must be held to set this flag, and the From cbb65b7ec50b5af6f8e75f8bea3575f080597e47 Mon Sep 17 00:00:00 2001 From: Konstantin Belousov Date: Sun, 3 Feb 2019 21:28:58 +0000 Subject: [PATCH 04/36] i386: Do not ever store to other-CPU counter64 slot. On CPUs supporting cmpxchg8b, fetch is performed by cmpxchg8b on corresponding CPU slot, which unconditionally write to the slot. If for that slot, the owner CPU increments it, then both CPUs might run the cmpxchg8b instruction concurrently and this might race and override the incremental write. So the counter update would be lost. Fix it by implementing fetch as IPI and accumulation of result. It is acceptable for rare counter64 fetch operation to be more expensive. Diagnosed and tested by: Andreas Longwitz Sponsored by: The FreeBSD Foundation MFC after: 2 weeks --- sys/i386/include/counter.h | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/sys/i386/include/counter.h b/sys/i386/include/counter.h index 7fd26d2a9600..278f89123a4f 100644 --- a/sys/i386/include/counter.h +++ b/sys/i386/include/counter.h @@ -72,7 +72,12 @@ counter_64_inc_8b(uint64_t *p, int64_t inc) } #ifdef IN_SUBR_COUNTER_C -static inline uint64_t +struct counter_u64_fetch_cx8_arg { + uint64_t res; + uint64_t *p; +}; + +static uint64_t counter_u64_read_one_8b(uint64_t *p) { uint32_t res_lo, res_high; @@ -87,9 +92,22 @@ counter_u64_read_one_8b(uint64_t *p) return (res_lo + ((uint64_t)res_high << 32)); } +static void +counter_u64_fetch_cx8_one(void *arg1) +{ + struct counter_u64_fetch_cx8_arg *arg; + uint64_t val; + + arg = arg1; + val = counter_u64_read_one_8b((uint64_t *)((char *)arg->p + + UMA_PCPU_ALLOC_SIZE * PCPU_GET(cpuid))); + atomic_add_64(&arg->res, val); +} + static inline uint64_t counter_u64_fetch_inline(uint64_t *p) { + struct counter_u64_fetch_cx8_arg arg; uint64_t res; int i; @@ -108,9 +126,10 @@ counter_u64_fetch_inline(uint64_t *p) } critical_exit(); } else { - CPU_FOREACH(i) - res += counter_u64_read_one_8b((uint64_t *)((char *)p + - UMA_PCPU_ALLOC_SIZE * i)); + arg.p = p; + arg.res = 0; + smp_rendezvous(NULL, counter_u64_fetch_cx8_one, NULL, &arg); + res = arg.res; } return (res); } From f02bc51c09e10a655510374e4f346a19d7bea551 Mon Sep 17 00:00:00 2001 From: Konstantin Belousov Date: Sun, 3 Feb 2019 21:31:40 +0000 Subject: [PATCH 05/36] Do not call PHOLD() while owning the allproc_lock sx. Otherwise the lock might recurse in faultin() if the process is swapped out. Reported by: zeising Sponsored by: The FreeBSD Foundation MFC after: 1 week --- sys/kern/kern_proc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c index 036e8ed6af63..61ac3016ea28 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -3112,8 +3112,8 @@ stop_all_proc(void) PROC_UNLOCK(p); continue; } - _PHOLD(p); sx_xunlock(&allproc_lock); + _PHOLD(p); r = thread_single(p, SINGLE_ALLPROC); if (r != 0) restart = true; From 6a69d2a40030779dfd5ff2d284a85735d9ca1dcf Mon Sep 17 00:00:00 2001 From: Alexander Motin Date: Mon, 4 Feb 2019 01:20:56 +0000 Subject: [PATCH 06/36] Use switch instead of chained if/else to improve readability. Submitted by: Ryan Moeller MFC after: 1 week Sponsored by: iXsystems, Inc. Differential Revision: https://reviews.freebsd.org/D19051 --- sys/cam/scsi/scsi_enc_ses.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/sys/cam/scsi/scsi_enc_ses.c b/sys/cam/scsi/scsi_enc_ses.c index 54026b0b07ed..5e9d2dc94d2d 100644 --- a/sys/cam/scsi/scsi_enc_ses.c +++ b/sys/cam/scsi/scsi_enc_ses.c @@ -2729,13 +2729,13 @@ ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc) if (sstr->bufsiz > 0xffff) return (EINVAL); /* buffer size too large */ - if (ioc == ENCIOC_SETSTRING) { + switch (ioc) { + case ENCIOC_SETSTRING: payload = sstr->bufsiz + 4; /* header for SEND DIAGNOSTIC */ amt = 0 - payload; buf = ENC_MALLOC(payload); if (buf == NULL) - return ENOMEM; - + return (ENOMEM); ses_page_cdb(cdb, payload, 0, CAM_DIR_OUT); /* Construct the page request */ buf[0] = SesStringOut; @@ -2743,12 +2743,14 @@ ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc) buf[2] = sstr->bufsiz >> 8; buf[3] = sstr->bufsiz & 0xff; memcpy(&buf[4], sstr->buf, sstr->bufsiz); - } else if (ioc == ENCIOC_GETSTRING) { + break; + case ENCIOC_GETSTRING: payload = sstr->bufsiz; amt = payload; ses_page_cdb(cdb, payload, SesStringIn, CAM_DIR_IN); buf = sstr->buf; - } else if (ioc == ENCIOC_GETENCNAME) { + break; + case ENCIOC_GETENCNAME: if (ses_cache->ses_nsubencs < 1) return (ENODEV); enc_desc = ses_cache->subencs[0]; @@ -2768,7 +2770,7 @@ ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc) size = sstr->bufsiz; copyout(str, sstr->buf, size); return (size == rsize ? 0 : ENOMEM); - } else if (ioc == ENCIOC_GETENCID) { + case ENCIOC_GETENCID: if (ses_cache->ses_nsubencs < 1) return (ENODEV); enc_desc = ses_cache->subencs[0]; @@ -2782,13 +2784,13 @@ ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc) size = sstr->bufsiz; copyout(str, sstr->buf, size); return (size == rsize ? 0 : ENOMEM); - } else - return EINVAL; - + default: + return (EINVAL); + } ret = enc_runcmd(enc, cdb, 6, buf, &amt); if (ioc == ENCIOC_SETSTRING) ENC_FREE(buf); - return ret; + return (ret); } /** From fe74eaab7cab7d0a61b3f274df940b0bd0e6be67 Mon Sep 17 00:00:00 2001 From: Alexander Motin Date: Mon, 4 Feb 2019 01:24:10 +0000 Subject: [PATCH 07/36] Check element type before setting LEDs. With r319610, sesutil started twiddling the bits of every SES device. Not everything is a disk slot, there are also fan controllers, temperature sensors, even power supplies, among other things controlled by SES. Add a type check to make sure we are only operating on device slot and array device slot elements. Other type elements will be skipped, but it would be simple to add additional cases for controlling the ident LEDs of other element types (which are not necessarily the same bits). Rather than doing raw bit manipulation of an unstructured byte array using unnamed numeric constants, leverage existing code abstractions. Submitted by: Ryan Moeller MFC after: 1 week Sponsored by: iXsystems, Inc. Differential Revision: https://reviews.freebsd.org/D19052 --- usr.sbin/sesutil/sesutil.c | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/usr.sbin/sesutil/sesutil.c b/usr.sbin/sesutil/sesutil.c index b31c1980fc0c..21c48cc38c6f 100644 --- a/usr.sbin/sesutil/sesutil.c +++ b/usr.sbin/sesutil/sesutil.c @@ -112,28 +112,30 @@ usage(FILE *out, const char *subcmd) } static void -do_led(int fd, unsigned int idx, bool onoff, bool setfault) +do_led(int fd, unsigned int idx, elm_type_t type, bool onoff, bool setfault) { + int state = onoff ? 1 : 0; encioc_elm_status_t o; + struct ses_ctrl_dev_slot *slot; o.elm_idx = idx; if (ioctl(fd, ENCIOC_GETELMSTAT, (caddr_t) &o) < 0) { close(fd); xo_err(EXIT_FAILURE, "ENCIOC_GETELMSTAT"); } - o.cstat[0] |= 0x80; - if (setfault) { - if (onoff) - o.cstat[3] |= 0x20; + slot = (struct ses_ctrl_dev_slot *) &o.cstat[0]; + switch (type) { + case ELMTYP_DEVICE: + case ELMTYP_ARRAY_DEV: + ses_ctrl_common_set_select(&slot->common, 1); + if (setfault) + ses_ctrl_dev_slot_set_rqst_fault(slot, state); else - o.cstat[3] &= 0xdf; - } else { - if (onoff) - o.cstat[2] |= 0x02; - else - o.cstat[2] &= 0xfd; + ses_ctrl_dev_slot_set_rqst_ident(slot, state); + break; + default: + return; } - if (ioctl(fd, ENCIOC_SETELMSTAT, (caddr_t) &o) < 0) { close(fd); xo_err(EXIT_FAILURE, "ENCIOC_SETELMSTAT"); @@ -250,14 +252,15 @@ sesled(int argc, char **argv, bool setfault) xo_errx(EXIT_FAILURE, "Requested SES ID does not exist"); } - do_led(fd, sesid, onoff, setfault); + do_led(fd, sesid, objp[sesid].elm_type, onoff, setfault); ndisks++; close(fd); break; } for (j = 0; j < nobj; j++) { if (all) { - do_led(fd, objp[j].elm_idx, onoff, setfault); + do_led(fd, objp[j].elm_idx, objp[j].elm_type, + onoff, setfault); continue; } memset(&objdn, 0, sizeof(objdn)); @@ -274,7 +277,7 @@ sesled(int argc, char **argv, bool setfault) } if (objdn.elm_names_len > 0) { if (disk_match(objdn.elm_devnames, disk, len)) { - do_led(fd, objdn.elm_idx, + do_led(fd, objdn.elm_idx, objp[j].elm_type, onoff, setfault); ndisks++; break; From 56335f9994b389cadba49a9c8a70ba4e05d0699e Mon Sep 17 00:00:00 2001 From: Gregory Neil Shapiro Date: Mon, 4 Feb 2019 02:18:27 +0000 Subject: [PATCH 08/36] Add support for the authinfo map Submitted by: keramida --- etc/mail/Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/etc/mail/Makefile b/etc/mail/Makefile index f8e5b7759c62..cb63592804d3 100644 --- a/etc/mail/Makefile +++ b/etc/mail/Makefile @@ -60,8 +60,8 @@ # ------------------------------------------------------------------------ # # The Makefile knows about the following maps: -# access, bitdomain, domaintable, genericstable, mailertable, userdb, -# uucpdomain, virtusertable +# access, authinfo, bitdomain, domaintable, genericstable, mailertable, +# userdb, uucpdomain, virtusertable # .ifndef SENDMAIL_MC @@ -125,7 +125,7 @@ SENDMAIL_MAP_PERMS?= 0640 # type to use when calling makemap. # SENDMAIL_MAP_SRC+= mailertable domaintable bitdomain uucpdomain \ - genericstable virtusertable access + genericstable virtusertable access authinfo SENDMAIL_MAP_OBJ= SENDMAIL_MAP_TYPE?= hash From 5c4611cd3f3aa28e49dd85d675e8aeb8106ed61a Mon Sep 17 00:00:00 2001 From: Cy Schubert Date: Mon, 4 Feb 2019 05:37:16 +0000 Subject: [PATCH 09/36] Remove two more #ifdefs missed in r343701. MFC after: 1 month X-MFC with: r343701 --- sys/contrib/ipfilter/netinet/fil.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/sys/contrib/ipfilter/netinet/fil.c b/sys/contrib/ipfilter/netinet/fil.c index 0036c3a55917..8334d7e71e5a 100644 --- a/sys/contrib/ipfilter/netinet/fil.c +++ b/sys/contrib/ipfilter/netinet/fil.c @@ -6119,9 +6119,7 @@ ipf_getifname(ifp, buffer) char *buffer; { static char namebuf[LIFNAMSIZ]; -# if defined(MENTAT) || defined(__FreeBSD__) || defined(__osf__) || \ - defined(__sgi) || defined(linux) || defined(_AIX51) || \ - (defined(sun) && !defined(__SVR4) && !defined(__svr4__)) +# if defined(MENTAT) || defined(__FreeBSD__) int unit, space; char temp[20]; char *s; @@ -6131,9 +6129,7 @@ ipf_getifname(ifp, buffer) buffer = namebuf; (void) strncpy(buffer, ifp->if_name, LIFNAMSIZ); buffer[LIFNAMSIZ - 1] = '\0'; -# if defined(MENTAT) || defined(__FreeBSD__) || defined(__osf__) || \ - defined(__sgi) || defined(_AIX51) || \ - (defined(sun) && !defined(__SVR4) && !defined(__svr4__)) +# if defined(MENTAT) || defined(__FreeBSD__) for (s = buffer; *s; s++) ; unit = ifp->if_unit; From bac4817b3a18f4fefbb8a0e1bb16c60a20141ce8 Mon Sep 17 00:00:00 2001 From: Michael Tuexen Date: Mon, 4 Feb 2019 13:30:47 +0000 Subject: [PATCH 10/36] Add missing SCTP_EOR entry. MFC after: 3 days --- lib/libsysdecode/flags.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/libsysdecode/flags.c b/lib/libsysdecode/flags.c index c98897fed8c6..ae2b5ff057e1 100644 --- a/lib/libsysdecode/flags.c +++ b/lib/libsysdecode/flags.c @@ -1208,7 +1208,7 @@ sysdecode_sctp_pr_policy(int policy) static struct name_table sctpsndflags[] = { X(SCTP_EOF) X(SCTP_ABORT) X(SCTP_UNORDERED) X(SCTP_ADDR_OVER) - X(SCTP_SENDALL) X(SCTP_SACK_IMMEDIATELY) XEND + X(SCTP_SENDALL) X(SCTP_EOR) X(SCTP_SACK_IMMEDIATELY) XEND }; bool From 617404825192eaa3137a7d587b8551d732962808 Mon Sep 17 00:00:00 2001 From: Leandro Lupori Date: Mon, 4 Feb 2019 16:02:03 +0000 Subject: [PATCH 11/36] powerpc64: Add a trap stack area Currently, the trap code switches to the the temporary stack in the dbtrap section. It works in most cases, but in the beginning of the execution, the temp stack is being used, as starting in the powerpc_init() code. In this current scenario, the stack is being overwritten, which causes the return of breakpoint() to take abnormal execution. This current patchset create a small stack to use by the dbtrap: codepath avoiding the corruption of the temporary stack. PR: 224872 Submitted by: breno.leitao_gmail.com Reviewed by: jhibbits Differential Revision: https://reviews.freebsd.org/D14484 --- sys/powerpc/aim/locore32.S | 6 ++++++ sys/powerpc/aim/locore64.S | 8 ++++++++ sys/powerpc/aim/trap_subr32.S | 4 ++-- sys/powerpc/aim/trap_subr64.S | 4 ++-- 4 files changed, 18 insertions(+), 4 deletions(-) diff --git a/sys/powerpc/aim/locore32.S b/sys/powerpc/aim/locore32.S index 56033fcbaa44..9f84bbf34777 100644 --- a/sys/powerpc/aim/locore32.S +++ b/sys/powerpc/aim/locore32.S @@ -60,6 +60,12 @@ GLOBAL(__endkernel) GLOBAL(tmpstk) .space TMPSTKSZ +#ifdef KDB +#define TRAPSTKSZ 4096 /* 4k trap stack */ +GLOBAL(trapstk) + .space TRAPSTKSZ +#endif + .text .globl btext btext: diff --git a/sys/powerpc/aim/locore64.S b/sys/powerpc/aim/locore64.S index 2d1d160160a2..88856777fb39 100644 --- a/sys/powerpc/aim/locore64.S +++ b/sys/powerpc/aim/locore64.S @@ -65,6 +65,14 @@ GLOBAL(tmpstk) TOC_ENTRY(tmpstk) TOC_ENTRY(can_wakeup) +#ifdef KDB +#define TRAPSTKSZ 4096 /* 4k trap stack */ +GLOBAL(trapstk) + .space TRAPSTKSZ +TOC_ENTRY(trapstk) +#endif + + /* * Entry point for bootloaders that do not fully implement ELF and start * at the beginning of the image (kexec, notably). In its own section so diff --git a/sys/powerpc/aim/trap_subr32.S b/sys/powerpc/aim/trap_subr32.S index 4f691e7edb5c..2543dd169c54 100644 --- a/sys/powerpc/aim/trap_subr32.S +++ b/sys/powerpc/aim/trap_subr32.S @@ -864,8 +864,8 @@ dbtrap: mtsprg3 %r1 lwz %r1,TRAP_TOCBASE(0) /* get new SP */ - lwz %r1,tmpstk@got(%r1) - addi %r1,%r1,TMPSTKSZ-16 + lwz %r1,trapstk@got(%r1) + addi %r1,%r1,TRAPSTKSZ-16 FRAME_SETUP(PC_DBSAVE) /* Call C trap code: */ diff --git a/sys/powerpc/aim/trap_subr64.S b/sys/powerpc/aim/trap_subr64.S index 7f655a4cf5f4..ee88fffc6b38 100644 --- a/sys/powerpc/aim/trap_subr64.S +++ b/sys/powerpc/aim/trap_subr64.S @@ -897,8 +897,8 @@ dbtrap: mtsprg3 %r1 GET_TOCBASE(%r1) /* get new SP */ - ld %r1,TOC_REF(tmpstk)(%r1) - addi %r1,%r1,(TMPSTKSZ-48) + ld %r1,TOC_REF(trapstk)(%r1) + addi %r1,%r1,(TRAPSTKSZ-48) FRAME_SETUP(PC_DBSAVE) /* Call C trap code: */ From ef0815415061ac0309789b7526179365872646b6 Mon Sep 17 00:00:00 2001 From: Alexander Motin Date: Mon, 4 Feb 2019 16:13:41 +0000 Subject: [PATCH 12/36] Add missed tunables/sysctls for some new vdev variables. While there, make few existing sysctls writeable, since there is no reason not to. MFC after: 1 week --- .../opensolaris/uts/common/fs/zfs/vdev.c | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c index 95fa6b38bf50..28b90f74e21b 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c @@ -165,29 +165,38 @@ static vdev_ops_t *vdev_ops_table[] = { /* target number of metaslabs per top-level vdev */ int vdev_max_ms_count = 200; -SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, max_ms_count, CTLFLAG_RDTUN, +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, max_ms_count, CTLFLAG_RWTUN, &vdev_max_ms_count, 0, - "Maximum number of metaslabs per top-level vdev"); + "Target number of metaslabs per top-level vdev"); /* minimum number of metaslabs per top-level vdev */ int vdev_min_ms_count = 16; -SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, min_ms_count, CTLFLAG_RDTUN, +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, min_ms_count, CTLFLAG_RWTUN, &vdev_min_ms_count, 0, "Minimum number of metaslabs per top-level vdev"); /* practical upper limit of total metaslabs per top-level vdev */ int vdev_ms_count_limit = 1ULL << 17; +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, max_ms_count_limit, CTLFLAG_RWTUN, + &vdev_ms_count_limit, 0, + "Maximum number of metaslabs per top-level vdev"); /* lower limit for metaslab size (512M) */ int vdev_default_ms_shift = 29; -SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, default_ms_shift, CTLFLAG_RDTUN, +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, default_ms_shift, CTLFLAG_RWTUN, &vdev_default_ms_shift, 0, - "Shift between vdev size and number of metaslabs"); + "Default shift between vdev size and number of metaslabs"); /* upper limit for metaslab size (256G) */ int vdev_max_ms_shift = 38; +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, max_ms_shift, CTLFLAG_RWTUN, + &vdev_max_ms_shift, 0, + "Maximal shift between vdev size and number of metaslabs"); boolean_t vdev_validate_skip = B_FALSE; +SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, validate_skip, CTLFLAG_RWTUN, + &vdev_validate_skip, 0, + "Bypass vdev validation"); /* * Since the DTL space map of a vdev is not expected to have a lot of From 2d01f2dee3186137a7cff88d2aa5ee0e7a84e93a Mon Sep 17 00:00:00 2001 From: Andrew Turner Date: Mon, 4 Feb 2019 16:55:24 +0000 Subject: [PATCH 13/36] Only enable trace-cmp on Clang and modern GCC. It's was only added to GCC 8.1 so don't try to enable it for earlier releases. Reported by: lwhsu Sponsored by: DARPA, AFRL --- sys/conf/files | 2 +- sys/conf/kern.pre.mk | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/sys/conf/files b/sys/conf/files index c7c15cd3738c..d3c2c0324135 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -3808,7 +3808,7 @@ kern/kern_idle.c standard kern/kern_intr.c standard kern/kern_jail.c standard kern/kern_kcov.c optional kcov \ - compile-with "${NORMAL_C} -fno-sanitize-coverage=trace-pc,trace-cmp" + compile-with "${NORMAL_C} -fno-sanitize=all" kern/kern_khelp.c standard kern/kern_kthread.c standard kern/kern_ktr.c optional ktr diff --git a/sys/conf/kern.pre.mk b/sys/conf/kern.pre.mk index ef90658147d2..407bfee936c9 100644 --- a/sys/conf/kern.pre.mk +++ b/sys/conf/kern.pre.mk @@ -120,7 +120,12 @@ SAN_CFLAGS+= -fsanitize=undefined COVERAGE_ENABLED!= grep COVERAGE opt_global.h || true ; echo .if !empty(COVERAGE_ENABLED) +.if ${COMPILER_TYPE} == "clang" || \ + (${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 80100) SAN_CFLAGS+= -fsanitize-coverage=trace-pc,trace-cmp +.else +SAN_CFLAGS+= -fsanitize-coverage=trace-pc +.endif .endif CFLAGS+= ${SAN_CFLAGS} From 0f166953f72731daca1ddf8311d6e828723ff062 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Mon, 4 Feb 2019 18:07:03 +0000 Subject: [PATCH 14/36] Use NLDT to get number of LDTs on i386 Compiling a GENERIC kernel for i386 with clang 8.0 results in the following warning: /usr/src/sys/i386/i386/sys_machdep.c:542:40: error: 'sizeof ((ldt))' will return the size of the pointer, not the array itself [-Werror,-Wsizeof-pointer-div] nldt = pldt != NULL ? pldt->ldt_len : nitems(ldt); ^~~~~~~~~~~ /usr/src/sys/sys/param.h:299:32: note: expanded from macro 'nitems' #define nitems(x) (sizeof((x)) / sizeof((x)[0])) ~~~~~~~~~~~ ^ Indeed, 'ldt' is declared as 'union descriptor *', so nitems() is not the right way to determine the number of LDTs. Instead, the NLDT define from sys/x86/include/segments.h should be used. Reviewed by: kib MFC after: 3 days Differential Revision: https://reviews.freebsd.org/D19074 --- sys/i386/i386/sys_machdep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/i386/i386/sys_machdep.c b/sys/i386/i386/sys_machdep.c index 7d576db90fc4..b5bac44f9d58 100644 --- a/sys/i386/i386/sys_machdep.c +++ b/sys/i386/i386/sys_machdep.c @@ -539,7 +539,7 @@ i386_get_ldt(struct thread *td, struct i386_ldt_args *uap) data = malloc(num * sizeof(union descriptor), M_TEMP, M_WAITOK); mtx_lock_spin(&dt_lock); pldt = td->td_proc->p_md.md_ldt; - nldt = pldt != NULL ? pldt->ldt_len : nitems(ldt); + nldt = pldt != NULL ? pldt->ldt_len : NLDT; if (uap->start >= nldt) { num = 0; } else { From ee8a8076a2bedc9c0db6f2991b8e7fcaf559b09b Mon Sep 17 00:00:00 2001 From: Emmanuel Vadot Date: Mon, 4 Feb 2019 18:29:23 +0000 Subject: [PATCH 15/36] release: arm64: rpi3: Install the RPI3B+ DTB file We should use the correct DTB file otherwise the firmware uses the RPI3B one. MFC after: 1 week --- release/arm64/RPI3.conf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/release/arm64/RPI3.conf b/release/arm64/RPI3.conf index 22f5de3105e2..734d11f07fc9 100644 --- a/release/arm64/RPI3.conf +++ b/release/arm64/RPI3.conf @@ -4,7 +4,7 @@ # DTB_DIR="/usr/local/share/rpi-firmware" -DTB="bcm2710-rpi-3-b.dtb" +DTB="bcm2710-rpi-3-b.dtb bcm2710-rpi-3-b-plus.dtb" EMBEDDED_TARGET_ARCH="aarch64" EMBEDDED_TARGET="arm64" EMBEDDEDBUILD=1 From 90b924a12e2b1780c5891aaba5f4cb7e346251d4 Mon Sep 17 00:00:00 2001 From: Emmanuel Vadot Date: Mon, 4 Feb 2019 18:30:47 +0000 Subject: [PATCH 16/36] release: arm64: pine64-lts: Use the newly created u-boot-pine64-lts port In U-Boot 2019.01 there is now a config for this board, use it for the release image. MFC after: 1 week --- release/arm64/PINE64-LTS.conf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/release/arm64/PINE64-LTS.conf b/release/arm64/PINE64-LTS.conf index 8d480007fe5b..a73b3c8a1a91 100644 --- a/release/arm64/PINE64-LTS.conf +++ b/release/arm64/PINE64-LTS.conf @@ -6,7 +6,7 @@ EMBEDDED_TARGET_ARCH="aarch64" EMBEDDED_TARGET="arm64" EMBEDDEDBUILD=1 -EMBEDDEDPORTS="sysutils/u-boot-sopine" +EMBEDDEDPORTS="sysutils/u-boot-pine64-lts" FAT_SIZE="54m -b 1m" FAT_TYPE="16" IMAGE_SIZE="2560M" @@ -18,7 +18,7 @@ FDT_OVERLAYS="sun50i-a64-sid,sun50i-a64-ths,sun50i-a64-timer,sun50i-a64-opp" export BOARDNAME="PINE64-LTS" arm_install_uboot() { - UBOOT_DIR="/usr/local/share/u-boot/u-boot-sopine" + UBOOT_DIR="/usr/local/share/u-boot/u-boot-pine64-lts" UBOOT_FILES="u-boot-sunxi-with-spl.bin" chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILES} \ of=/dev/${mddev} bs=1k seek=8 conv=sync From 8e0c33c6d3c2d6cee33833cb18c2e77653fb23e6 Mon Sep 17 00:00:00 2001 From: Enji Cooper Date: Mon, 4 Feb 2019 19:12:45 +0000 Subject: [PATCH 17/36] Avoid the DNS lookup for "localhost" ci.FreeBSD.org does not have access to a DNS resolver/network (unlike my test VM), so in order for the test to pass on the host, it needs to avoid the DNS lookup by using the numeric host address representation. PR: 235200 Reviewed by: asomers, lwhsu Approved by: emaste (mentor) MFC after: 2 weeks MFC with: r343362, r343365, r343367-r343368, r343461 Differential Revision: https://reviews.freebsd.org/D19026 --- lib/libc/tests/sys/sendfile_test.c | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/lib/libc/tests/sys/sendfile_test.c b/lib/libc/tests/sys/sendfile_test.c index 822bb917f9c3..0bebc6ff7544 100644 --- a/lib/libc/tests/sys/sendfile_test.c +++ b/lib/libc/tests/sys/sendfile_test.c @@ -97,22 +97,31 @@ generate_random_port(int seed) static void resolve_localhost(struct addrinfo **res, int domain, int type, int port) { + const char *host; char *serv; struct addrinfo hints; int error; - ATF_REQUIRE_MSG(domain == AF_INET || domain == AF_INET6, - "unhandled domain: %d", domain); + switch (domain) { + case AF_INET: + host = "127.0.0.1"; + break; + case AF_INET6: + host = "::1"; + break; + default: + atf_tc_fail("unhandled domain: %d", domain); + } ATF_REQUIRE_MSG(asprintf(&serv, "%d", port) >= 0, "asprintf failed: %s", strerror(errno)); memset(&hints, 0, sizeof(hints)); hints.ai_family = domain; - hints.ai_flags = AI_ADDRCONFIG|AI_NUMERICSERV; + hints.ai_flags = AI_ADDRCONFIG|AI_NUMERICSERV|AI_NUMERICHOST; hints.ai_socktype = type; - error = getaddrinfo("localhost", serv, &hints, res); + error = getaddrinfo(host, serv, &hints, res); ATF_REQUIRE_EQ_MSG(error, 0, "getaddrinfo failed: %s", gai_strerror(error)); free(serv); From ed0a3e8637befd1e79f15d949ff75678a3b39a34 Mon Sep 17 00:00:00 2001 From: Alexander Motin Date: Mon, 4 Feb 2019 20:09:22 +0000 Subject: [PATCH 18/36] s/Maximal/Maximum/ in sysctl description. Submitted by: smh MFC after: 1 week --- sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c index 28b90f74e21b..67f26e0cb027 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev.c @@ -191,7 +191,7 @@ SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, default_ms_shift, CTLFLAG_RWTUN, int vdev_max_ms_shift = 38; SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, max_ms_shift, CTLFLAG_RWTUN, &vdev_max_ms_shift, 0, - "Maximal shift between vdev size and number of metaslabs"); + "Maximum shift between vdev size and number of metaslabs"); boolean_t vdev_validate_skip = B_FALSE; SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, validate_skip, CTLFLAG_RWTUN, From bfce461ee9cf85d2e0cc2caa7756af4ee61ec8ab Mon Sep 17 00:00:00 2001 From: Marius Strobl Date: Mon, 4 Feb 2019 20:46:57 +0000 Subject: [PATCH 19/36] o As illustrated by e. g. figure 7-14 of the Intel 82599 10 GbE controller datasheet revision 3.3, in the context of Ethernet MACs the control data describing the packet buffers typically are named "descriptors". Each of these descriptors references one buffer, multiple of which a packet can be composed of. By contrast, in comments, messages and the names of structure members, iflib(4) refers to DMA resources employed for RX and TX buffers (rather than control data) as "desc(riptors)". This odd naming convention of iflib(4) made reviewing r343085 and identifying wrong and missing bus_dmamap_sync(9) calls in particular way harder than it already is. This convention may also explain why the netmap(4) part of iflib(4) pairs the DMA tags for control data with DMA maps of buffers and vice versa in calls to bus_dma(9) functions. Therefore, change iflib(4) to refer to buf(fers) when buffers and not the usual understanding of descriptors is meant. This change does not include corrections to the DMA resources used in the netmap(4) parts. However, it revises error messages to state which kind of allocation/creation failed. Specifically, the "Unable to allocate tx_buffer (map) memory" copy & pasted inappropriately on several occasions was replaced with proper messages. o Enhance some other error messages to indicate which half - RX or TX - they apply to instead of using identical text in both cases and generally canonicalize them. o Correct the descriptions of iflib_{r,t}xsd_alloc() to reflect reality; current code doesn't use {r,t}x_buffer structures. o In iflib_queues_alloc(): - Remove redundant BUS_DMA_NOWAIT of iflib_dma_alloc() calls, - change the M_WAITOK from malloc(9) calls into M_NOWAIT. The return values are already checked, deferred DMA allocations not being an option at this point, BUS_DMA_NOWAIT has to be used anyway and prior malloc(9) calls in this function also specify M_NOWAIT. Reviewed by: shurd Differential Revision: https://reviews.freebsd.org/D19067 --- sys/net/iflib.c | 216 +++++++++++++++++++++++++++--------------------- 1 file changed, 123 insertions(+), 93 deletions(-) diff --git a/sys/net/iflib.c b/sys/net/iflib.c index 0a566753e9d6..8fa6c9c440d0 100644 --- a/sys/net/iflib.c +++ b/sys/net/iflib.c @@ -353,8 +353,8 @@ struct iflib_txq { uint8_t ift_closed; uint8_t ift_update_freq; struct iflib_filter_info ift_filter_info; - bus_dma_tag_t ift_desc_tag; - bus_dma_tag_t ift_tso_desc_tag; + bus_dma_tag_t ift_buf_tag; + bus_dma_tag_t ift_tso_buf_tag; iflib_dma_info_t ift_ifdi; #define MTX_NAME_LEN 16 char ift_mtx_name[MTX_NAME_LEN]; @@ -389,7 +389,7 @@ struct iflib_fl { iflib_rxsd_array_t ifl_sds; iflib_rxq_t ifl_rxq; uint8_t ifl_id; - bus_dma_tag_t ifl_desc_tag; + bus_dma_tag_t ifl_buf_tag; iflib_dma_info_t ifl_ifdi; uint64_t ifl_bus_addrs[IFLIB_MAX_RX_REFRESH] __aligned(CACHE_LINE_SIZE); caddr_t ifl_vm_addrs[IFLIB_MAX_RX_REFRESH]; @@ -922,10 +922,9 @@ iflib_netmap_txsync(struct netmap_kring *kring, int flags) if_ctx_t ctx = ifp->if_softc; iflib_txq_t txq = &ctx->ifc_txqs[kring->ring_id]; - bus_dmamap_sync(txq->ift_desc_tag, txq->ift_ifdi->idi_map, + bus_dmamap_sync(txq->ift_buf_tag, txq->ift_ifdi->idi_map, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); - /* * First part: process new packets to send. * nm_i is the current index in the netmap kring, @@ -992,7 +991,8 @@ iflib_netmap_txsync(struct netmap_kring *kring, int flags) if (slot->flags & NS_BUF_CHANGED) { /* buffer has changed, reload map */ - netmap_reload_map(na, txq->ift_desc_tag, txq->ift_sds.ifsd_map[nic_i], addr); + netmap_reload_map(na, txq->ift_buf_tag, + txq->ift_sds.ifsd_map[nic_i], addr); } /* make sure changes to the buffer are synced */ bus_dmamap_sync(txq->ift_ifdi->idi_tag, txq->ift_sds.ifsd_map[nic_i], @@ -1005,7 +1005,7 @@ iflib_netmap_txsync(struct netmap_kring *kring, int flags) kring->nr_hwcur = nm_i; /* synchronize the NIC ring */ - bus_dmamap_sync(txq->ift_desc_tag, txq->ift_ifdi->idi_map, + bus_dmamap_sync(txq->ift_buf_tag, txq->ift_ifdi->idi_map, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); /* (re)start the tx unit up to slot nic_i (excluded) */ @@ -1072,8 +1072,9 @@ iflib_netmap_rxsync(struct netmap_kring *kring, int flags) for (i = 0, fl = rxq->ifr_fl; i < rxq->ifr_nfl; i++, fl++) { if (fl->ifl_sds.ifsd_map == NULL) continue; - bus_dmamap_sync(rxq->ifr_fl[i].ifl_desc_tag, fl->ifl_ifdi->idi_map, - BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); + bus_dmamap_sync(rxq->ifr_fl[i].ifl_buf_tag, + fl->ifl_ifdi->idi_map, + BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); } /* * First part: import newly received packets. @@ -1199,7 +1200,8 @@ iflib_netmap_txq_init(if_ctx_t ctx, iflib_txq_t txq) * netmap slot index, si */ int si = netmap_idx_n2k(na->tx_rings[txq->ift_id], i); - netmap_load_map(na, txq->ift_desc_tag, txq->ift_sds.ifsd_map[i], NMB(na, slot + si)); + netmap_load_map(na, txq->ift_buf_tag, txq->ift_sds.ifsd_map[i], + NMB(na, slot + si)); } } @@ -1576,12 +1578,13 @@ _iflib_irq_alloc(if_ctx_t ctx, if_irq_t irq, int rid, /********************************************************************* * - * Allocate memory for tx_buffer structures. The tx_buffer stores all - * the information needed to transmit a packet on the wire. This is - * called only once at attach, setup is done every reset. + * Allocate DMA resources for TX buffers as well as memory for the TX + * mbuf map. TX DMA maps (non-TSO/TSO) and TX mbuf map are kept in a + * iflib_sw_tx_desc_array structure, storing all the information that + * is needed to transmit a packet on the wire. This is called only + * once at attach, setup is done every reset. * **********************************************************************/ - static int iflib_txsd_alloc(iflib_txq_t txq) { @@ -1607,7 +1610,7 @@ iflib_txsd_alloc(iflib_txq_t txq) } /* - * Setup DMA descriptor areas. + * Set up DMA tags for TX buffers. */ if ((err = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0, /* alignment, bounds */ @@ -1620,7 +1623,7 @@ iflib_txsd_alloc(iflib_txq_t txq) 0, /* flags */ NULL, /* lockfunc */ NULL, /* lockfuncarg */ - &txq->ift_desc_tag))) { + &txq->ift_buf_tag))) { device_printf(dev,"Unable to allocate TX DMA tag: %d\n", err); device_printf(dev,"maxsize: %ju nsegments: %d maxsegsize: %ju\n", (uintmax_t)sctx->isc_tx_maxsize, nsegments, (uintmax_t)sctx->isc_tx_maxsegsize); @@ -1638,38 +1641,42 @@ iflib_txsd_alloc(iflib_txq_t txq) 0, /* flags */ NULL, /* lockfunc */ NULL, /* lockfuncarg */ - &txq->ift_tso_desc_tag))) { - device_printf(dev,"Unable to allocate TX TSO DMA tag: %d\n", err); + &txq->ift_tso_buf_tag))) { + device_printf(dev, "Unable to allocate TSO TX DMA tag: %d\n", + err); goto fail; } + + /* Allocate memory for the TX mbuf map. */ if (!(txq->ift_sds.ifsd_m = (struct mbuf **) malloc(sizeof(struct mbuf *) * scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO))) { - device_printf(dev, "Unable to allocate tx_buffer memory\n"); + device_printf(dev, "Unable to allocate TX mbuf map memory\n"); err = ENOMEM; goto fail; } - /* Create the descriptor buffer dma maps */ + /* + * Create the DMA maps for TX buffers. + */ if ((txq->ift_sds.ifsd_map = (bus_dmamap_t *)malloc( sizeof(bus_dmamap_t) * scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO)) == NULL) { - device_printf(dev, "Unable to allocate tx_buffer map memory\n"); + device_printf(dev, + "Unable to allocate TX buffer DMA map memory\n"); err = ENOMEM; goto fail; } - if (tso && (txq->ift_sds.ifsd_tso_map = (bus_dmamap_t *)malloc( sizeof(bus_dmamap_t) * scctx->isc_ntxd[txq->ift_br_offset], M_IFLIB, M_NOWAIT | M_ZERO)) == NULL) { - device_printf(dev, "Unable to allocate TSO tx_buffer " - "map memory\n"); + device_printf(dev, + "Unable to allocate TSO TX buffer map memory\n"); err = ENOMEM; goto fail; } - for (int i = 0; i < scctx->isc_ntxd[txq->ift_br_offset]; i++) { - err = bus_dmamap_create(txq->ift_desc_tag, 0, + err = bus_dmamap_create(txq->ift_buf_tag, 0, &txq->ift_sds.ifsd_map[i]); if (err != 0) { device_printf(dev, "Unable to create TX DMA map\n"); @@ -1677,7 +1684,7 @@ iflib_txsd_alloc(iflib_txq_t txq) } if (!tso) continue; - err = bus_dmamap_create(txq->ift_tso_desc_tag, 0, + err = bus_dmamap_create(txq->ift_tso_buf_tag, 0, &txq->ift_sds.ifsd_tso_map[i]); if (err != 0) { device_printf(dev, "Unable to create TSO TX DMA map\n"); @@ -1700,9 +1707,9 @@ iflib_txsd_destroy(if_ctx_t ctx, iflib_txq_t txq, int i) if (txq->ift_sds.ifsd_map != NULL) map = txq->ift_sds.ifsd_map[i]; if (map != NULL) { - bus_dmamap_sync(txq->ift_desc_tag, map, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_desc_tag, map); - bus_dmamap_destroy(txq->ift_desc_tag, map); + bus_dmamap_sync(txq->ift_buf_tag, map, BUS_DMASYNC_POSTWRITE); + bus_dmamap_unload(txq->ift_buf_tag, map); + bus_dmamap_destroy(txq->ift_buf_tag, map); txq->ift_sds.ifsd_map[i] = NULL; } @@ -1710,10 +1717,10 @@ iflib_txsd_destroy(if_ctx_t ctx, iflib_txq_t txq, int i) if (txq->ift_sds.ifsd_tso_map != NULL) map = txq->ift_sds.ifsd_tso_map[i]; if (map != NULL) { - bus_dmamap_sync(txq->ift_tso_desc_tag, map, + bus_dmamap_sync(txq->ift_tso_buf_tag, map, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_tso_desc_tag, map); - bus_dmamap_destroy(txq->ift_tso_desc_tag, map); + bus_dmamap_unload(txq->ift_tso_buf_tag, map); + bus_dmamap_destroy(txq->ift_tso_buf_tag, map); txq->ift_sds.ifsd_tso_map[i] = NULL; } } @@ -1737,13 +1744,13 @@ iflib_txq_destroy(iflib_txq_t txq) free(txq->ift_sds.ifsd_m, M_IFLIB); txq->ift_sds.ifsd_m = NULL; } - if (txq->ift_desc_tag != NULL) { - bus_dma_tag_destroy(txq->ift_desc_tag); - txq->ift_desc_tag = NULL; + if (txq->ift_buf_tag != NULL) { + bus_dma_tag_destroy(txq->ift_buf_tag); + txq->ift_buf_tag = NULL; } - if (txq->ift_tso_desc_tag != NULL) { - bus_dma_tag_destroy(txq->ift_tso_desc_tag); - txq->ift_tso_desc_tag = NULL; + if (txq->ift_tso_buf_tag != NULL) { + bus_dma_tag_destroy(txq->ift_tso_buf_tag); + txq->ift_tso_buf_tag = NULL; } } @@ -1757,14 +1764,14 @@ iflib_txsd_free(if_ctx_t ctx, iflib_txq_t txq, int i) return; if (txq->ift_sds.ifsd_map != NULL) { - bus_dmamap_sync(txq->ift_desc_tag, + bus_dmamap_sync(txq->ift_buf_tag, txq->ift_sds.ifsd_map[i], BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_desc_tag, txq->ift_sds.ifsd_map[i]); + bus_dmamap_unload(txq->ift_buf_tag, txq->ift_sds.ifsd_map[i]); } if (txq->ift_sds.ifsd_tso_map != NULL) { - bus_dmamap_sync(txq->ift_tso_desc_tag, + bus_dmamap_sync(txq->ift_tso_buf_tag, txq->ift_sds.ifsd_tso_map[i], BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_tso_desc_tag, + bus_dmamap_unload(txq->ift_tso_buf_tag, txq->ift_sds.ifsd_tso_map[i]); } m_free(*mp); @@ -1803,10 +1810,13 @@ iflib_txq_setup(iflib_txq_t txq) /********************************************************************* * - * Allocate memory for rx_buffer structures. Since we use one - * rx_buffer per received packet, the maximum number of rx_buffer's - * that we'll need is equal to the number of receive descriptors - * that we've allocated. + * Allocate DMA resources for RX buffers as well as memory for the RX + * mbuf map, direct RX cluster pointer map and RX cluster bus address + * map. RX DMA map, RX mbuf map, direct RX cluster pointer map and + * RX cluster map are kept in a iflib_sw_rx_desc_array structure. + * Since we use use one entry in iflib_sw_rx_desc_array per received + * packet, the maximum number of entries we'll need is equal to the + * number of hardware receive descriptors that we've allocated. * **********************************************************************/ static int @@ -1825,6 +1835,7 @@ iflib_rxsd_alloc(iflib_rxq_t rxq) fl = rxq->ifr_fl; for (int i = 0; i < rxq->ifr_nfl; i++, fl++) { fl->ifl_size = scctx->isc_nrxd[rxq->ifr_fl_offset]; /* this isn't necessarily the same */ + /* Set up DMA tag for RX buffers. */ err = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */ 1, 0, /* alignment, bounds */ BUS_SPACE_MAXADDR, /* lowaddr */ @@ -1836,45 +1847,56 @@ iflib_rxsd_alloc(iflib_rxq_t rxq) 0, /* flags */ NULL, /* lockfunc */ NULL, /* lockarg */ - &fl->ifl_desc_tag); + &fl->ifl_buf_tag); if (err) { - device_printf(dev, "%s: bus_dma_tag_create failed %d\n", - __func__, err); + device_printf(dev, + "Unable to allocate RX DMA tag: %d\n", err); goto fail; } + + /* Allocate memory for the RX mbuf map. */ if (!(fl->ifl_sds.ifsd_m = (struct mbuf **) malloc(sizeof(struct mbuf *) * scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) { - device_printf(dev, "Unable to allocate tx_buffer memory\n"); + device_printf(dev, + "Unable to allocate RX mbuf map memory\n"); err = ENOMEM; goto fail; } + + /* Allocate memory for the direct RX cluster pointer map. */ if (!(fl->ifl_sds.ifsd_cl = (caddr_t *) malloc(sizeof(caddr_t) * scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) { - device_printf(dev, "Unable to allocate tx_buffer memory\n"); + device_printf(dev, + "Unable to allocate RX cluster map memory\n"); err = ENOMEM; goto fail; } + /* Allocate memory for the RX cluster bus address map. */ if (!(fl->ifl_sds.ifsd_ba = (bus_addr_t *) malloc(sizeof(bus_addr_t) * scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) { - device_printf(dev, "Unable to allocate rx bus addr memory\n"); + device_printf(dev, + "Unable to allocate RX bus address map memory\n"); err = ENOMEM; goto fail; } - /* Create the descriptor buffer dma maps */ + /* + * Create the DMA maps for RX buffers. + */ if (!(fl->ifl_sds.ifsd_map = (bus_dmamap_t *) malloc(sizeof(bus_dmamap_t) * scctx->isc_nrxd[rxq->ifr_fl_offset], M_IFLIB, M_NOWAIT | M_ZERO))) { - device_printf(dev, "Unable to allocate tx_buffer map memory\n"); + device_printf(dev, + "Unable to allocate RX buffer DMA map memory\n"); err = ENOMEM; goto fail; } - for (int i = 0; i < scctx->isc_nrxd[rxq->ifr_fl_offset]; i++) { - err = bus_dmamap_create(fl->ifl_desc_tag, 0, &fl->ifl_sds.ifsd_map[i]); + err = bus_dmamap_create(fl->ifl_buf_tag, 0, + &fl->ifl_sds.ifsd_map[i]); if (err != 0) { device_printf(dev, "Unable to create RX buffer DMA map\n"); goto fail; @@ -1974,7 +1996,7 @@ _iflib_fl_refill(if_ctx_t ctx, iflib_fl_t fl, int count) cb_arg.error = 0; MPASS(sd_map != NULL); - err = bus_dmamap_load(fl->ifl_desc_tag, sd_map[frag_idx], + err = bus_dmamap_load(fl->ifl_buf_tag, sd_map[frag_idx], cl, fl->ifl_buf_size, _rxq_refill_cb, &cb_arg, BUS_DMA_NOWAIT); if (err != 0 || cb_arg.error) { @@ -1986,7 +2008,7 @@ _iflib_fl_refill(if_ctx_t ctx, iflib_fl_t fl, int count) break; } - bus_dmamap_sync(fl->ifl_desc_tag, sd_map[frag_idx], + bus_dmamap_sync(fl->ifl_buf_tag, sd_map[frag_idx], BUS_DMASYNC_PREREAD); sd_ba[frag_idx] = bus_addr = cb_arg.seg.ds_addr; sd_cl[frag_idx] = cl; @@ -2087,14 +2109,14 @@ iflib_fl_bufs_free(iflib_fl_t fl) if (*sd_cl != NULL) { sd_map = fl->ifl_sds.ifsd_map[i]; - bus_dmamap_sync(fl->ifl_desc_tag, sd_map, + bus_dmamap_sync(fl->ifl_buf_tag, sd_map, BUS_DMASYNC_POSTREAD); - bus_dmamap_unload(fl->ifl_desc_tag, sd_map); + bus_dmamap_unload(fl->ifl_buf_tag, sd_map); if (*sd_cl != NULL) uma_zfree(fl->ifl_zone, *sd_cl); // XXX: Should this get moved out? if (iflib_in_detach(fl->ifl_rxq->ifr_ctx)) - bus_dmamap_destroy(fl->ifl_desc_tag, sd_map); + bus_dmamap_destroy(fl->ifl_buf_tag, sd_map); if (*sd_m != NULL) { m_init(*sd_m, M_NOWAIT, MT_DATA, 0); uma_zfree(zone_mbuf, *sd_m); @@ -2196,23 +2218,23 @@ iflib_rx_sds_free(iflib_rxq_t rxq) if (rxq->ifr_fl != NULL) { for (i = 0; i < rxq->ifr_nfl; i++) { fl = &rxq->ifr_fl[i]; - if (fl->ifl_desc_tag != NULL) { + if (fl->ifl_buf_tag != NULL) { if (fl->ifl_sds.ifsd_map != NULL) { for (j = 0; j < fl->ifl_size; j++) { if (fl->ifl_sds.ifsd_map[j] == NULL) continue; bus_dmamap_sync( - fl->ifl_desc_tag, + fl->ifl_buf_tag, fl->ifl_sds.ifsd_map[j], BUS_DMASYNC_POSTREAD); bus_dmamap_unload( - fl->ifl_desc_tag, + fl->ifl_buf_tag, fl->ifl_sds.ifsd_map[j]); } } - bus_dma_tag_destroy(fl->ifl_desc_tag); - fl->ifl_desc_tag = NULL; + bus_dma_tag_destroy(fl->ifl_buf_tag); + fl->ifl_buf_tag = NULL; } free(fl->ifl_sds.ifsd_m, M_IFLIB); free(fl->ifl_sds.ifsd_cl, M_IFLIB); @@ -2497,9 +2519,9 @@ rxd_frag_to_sd(iflib_rxq_t rxq, if_rxd_frag_t irf, int unload, if_rxsd_t sd) /* not valid assert if bxe really does SGE from non-contiguous elements */ MPASS(fl->ifl_cidx == cidx); - bus_dmamap_sync(fl->ifl_desc_tag, map, BUS_DMASYNC_POSTREAD); + bus_dmamap_sync(fl->ifl_buf_tag, map, BUS_DMASYNC_POSTREAD); if (unload) - bus_dmamap_unload(fl->ifl_desc_tag, map); + bus_dmamap_unload(fl->ifl_buf_tag, map); fl->ifl_cidx = (fl->ifl_cidx + 1) & (fl->ifl_size-1); if (__predict_false(fl->ifl_cidx == 0)) fl->ifl_gen = 0; @@ -2582,7 +2604,7 @@ iflib_rxd_pkt_get(iflib_rxq_t rxq, if_rxd_info_t ri) m->m_data += 2; #endif memcpy(m->m_data, *sd.ifsd_cl, ri->iri_len); - bus_dmamap_sync(rxq->ifr_fl->ifl_desc_tag, + bus_dmamap_sync(rxq->ifr_fl->ifl_buf_tag, rxq->ifr_fl->ifl_sds.ifsd_map[ri->iri_frags[0].irf_idx], BUS_DMASYNC_PREREAD); m->m_len = ri->iri_frags[0].irf_len; @@ -3083,9 +3105,9 @@ iflib_remove_mbuf(iflib_txq_t txq) ifsd_m = txq->ift_sds.ifsd_m; m = ifsd_m[pidx]; ifsd_m[pidx] = NULL; - bus_dmamap_unload(txq->ift_desc_tag, txq->ift_sds.ifsd_map[pidx]); + bus_dmamap_unload(txq->ift_buf_tag, txq->ift_sds.ifsd_map[pidx]); if (txq->ift_sds.ifsd_tso_map != NULL) - bus_dmamap_unload(txq->ift_tso_desc_tag, + bus_dmamap_unload(txq->ift_tso_buf_tag, txq->ift_sds.ifsd_tso_map[pidx]); #if MEMORY_LOGGING txq->ift_dequeued++; @@ -3162,6 +3184,7 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) if_ctx_t ctx; if_shared_ctx_t sctx; if_softc_ctx_t scctx; + bus_dma_tag_t buf_tag; bus_dma_segment_t *segs; struct mbuf *m_head, **ifsd_m; void *next_txd; @@ -3169,7 +3192,6 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) struct if_pkt_info pi; int remap = 0; int err, nsegs, ndesc, max_segs, pidx, cidx, next, ntxd; - bus_dma_tag_t desc_tag; ctx = txq->ift_ctx; sctx = ctx->ifc_sctx; @@ -3200,13 +3222,13 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) ifsd_m = txq->ift_sds.ifsd_m; if (m_head->m_pkthdr.csum_flags & CSUM_TSO) { - desc_tag = txq->ift_tso_desc_tag; + buf_tag = txq->ift_tso_buf_tag; max_segs = scctx->isc_tx_tso_segments_max; map = txq->ift_sds.ifsd_tso_map[pidx]; - MPASS(desc_tag != NULL); + MPASS(buf_tag != NULL); MPASS(max_segs > 0); } else { - desc_tag = txq->ift_desc_tag; + buf_tag = txq->ift_buf_tag; max_segs = scctx->isc_tx_nsegments; map = txq->ift_sds.ifsd_map[pidx]; } @@ -3238,7 +3260,7 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) } retry: - err = bus_dmamap_load_mbuf_sg(desc_tag, map, m_head, segs, &nsegs, + err = bus_dmamap_load_mbuf_sg(buf_tag, map, m_head, segs, &nsegs, BUS_DMA_NOWAIT); defrag: if (__predict_false(err)) { @@ -3284,7 +3306,7 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) */ if (__predict_false(nsegs + 2 > TXQ_AVAIL(txq))) { txq->ift_no_desc_avail++; - bus_dmamap_unload(desc_tag, map); + bus_dmamap_unload(buf_tag, map); DBG_COUNTER_INC(encap_txq_avail_fail); DBG_COUNTER_INC(encap_txd_encap_fail); if ((txq->ift_task.gt_task.ta_flags & TASK_ENQUEUED) == 0) @@ -3311,7 +3333,7 @@ iflib_encap(iflib_txq_t txq, struct mbuf **m_headp) #ifdef PKT_DEBUG print_pkt(&pi); #endif - bus_dmamap_sync(desc_tag, map, BUS_DMASYNC_PREWRITE); + bus_dmamap_sync(buf_tag, map, BUS_DMASYNC_PREWRITE); if ((err = ctx->isc_txd_encap(ctx->ifc_softc, &pi)) == 0) { bus_dmamap_sync(txq->ift_ifdi->idi_tag, txq->ift_ifdi->idi_map, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); @@ -3387,16 +3409,16 @@ iflib_tx_desc_free(iflib_txq_t txq, int n) if ((m = ifsd_m[cidx]) != NULL) { prefetch(&ifsd_m[(cidx + CACHE_PTR_INCREMENT) & mask]); if (m->m_pkthdr.csum_flags & CSUM_TSO) { - bus_dmamap_sync(txq->ift_tso_desc_tag, + bus_dmamap_sync(txq->ift_tso_buf_tag, txq->ift_sds.ifsd_tso_map[cidx], BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_tso_desc_tag, + bus_dmamap_unload(txq->ift_tso_buf_tag, txq->ift_sds.ifsd_tso_map[cidx]); } else { - bus_dmamap_sync(txq->ift_desc_tag, + bus_dmamap_sync(txq->ift_buf_tag, txq->ift_sds.ifsd_map[cidx], BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(txq->ift_desc_tag, + bus_dmamap_unload(txq->ift_buf_tag, txq->ift_sds.ifsd_map[cidx]); } /* XXX we don't support any drivers that batch packets yet */ @@ -5203,15 +5225,18 @@ iflib_queues_alloc(if_ctx_t ctx) for (txconf = i = 0, cpu = CPU_FIRST(); i < ntxqsets; i++, txconf++, txq++, cpu = CPU_NEXT(cpu)) { /* Set up some basics */ - if ((ifdip = malloc(sizeof(struct iflib_dma_info) * ntxqs, M_IFLIB, M_WAITOK|M_ZERO)) == NULL) { - device_printf(dev, "failed to allocate iflib_dma_info\n"); + if ((ifdip = malloc(sizeof(struct iflib_dma_info) * ntxqs, + M_IFLIB, M_NOWAIT | M_ZERO)) == NULL) { + device_printf(dev, + "Unable to allocate TX DMA info memory\n"); err = ENOMEM; goto err_tx_desc; } txq->ift_ifdi = ifdip; for (j = 0; j < ntxqs; j++, ifdip++) { - if (iflib_dma_alloc(ctx, txqsizes[j], ifdip, BUS_DMA_NOWAIT)) { - device_printf(dev, "Unable to allocate Descriptor memory\n"); + if (iflib_dma_alloc(ctx, txqsizes[j], ifdip, 0)) { + device_printf(dev, + "Unable to allocate TX descriptors\n"); err = ENOMEM; goto err_tx_desc; } @@ -5255,8 +5280,10 @@ iflib_queues_alloc(if_ctx_t ctx) for (rxconf = i = 0; i < nrxqsets; i++, rxconf++, rxq++) { /* Set up some basics */ - if ((ifdip = malloc(sizeof(struct iflib_dma_info) * nrxqs, M_IFLIB, M_WAITOK|M_ZERO)) == NULL) { - device_printf(dev, "failed to allocate iflib_dma_info\n"); + if ((ifdip = malloc(sizeof(struct iflib_dma_info) * nrxqs, + M_IFLIB, M_NOWAIT | M_ZERO)) == NULL) { + device_printf(dev, + "Unable to allocate RX DMA info memory\n"); err = ENOMEM; goto err_tx_desc; } @@ -5266,8 +5293,9 @@ iflib_queues_alloc(if_ctx_t ctx) rxq->ifr_ntxqirq = 1; rxq->ifr_txqid[0] = i; for (j = 0; j < nrxqs; j++, ifdip++) { - if (iflib_dma_alloc(ctx, rxqsizes[j], ifdip, BUS_DMA_NOWAIT)) { - device_printf(dev, "Unable to allocate Descriptor memory\n"); + if (iflib_dma_alloc(ctx, rxqsizes[j], ifdip, 0)) { + device_printf(dev, + "Unable to allocate RX descriptors\n"); err = ENOMEM; goto err_tx_desc; } @@ -5319,7 +5347,8 @@ iflib_queues_alloc(if_ctx_t ctx) } } if ((err = IFDI_TX_QUEUES_ALLOC(ctx, vaddrs, paddrs, ntxqs, ntxqsets)) != 0) { - device_printf(ctx->ifc_dev, "device queue allocation failed\n"); + device_printf(ctx->ifc_dev, + "Unable to allocate device TX queue\n"); iflib_tx_structures_free(ctx); free(vaddrs, M_IFLIB); free(paddrs, M_IFLIB); @@ -5340,7 +5369,8 @@ iflib_queues_alloc(if_ctx_t ctx) } } if ((err = IFDI_RX_QUEUES_ALLOC(ctx, vaddrs, paddrs, nrxqs, nrxqsets)) != 0) { - device_printf(ctx->ifc_dev, "device queue allocation failed\n"); + device_printf(ctx->ifc_dev, + "Unable to allocate device RX queue\n"); iflib_tx_structures_free(ctx); free(vaddrs, M_IFLIB); free(paddrs, M_IFLIB); From e4314da2e45770e4b9b3be74f4b552045a041d3a Mon Sep 17 00:00:00 2001 From: Konstantin Belousov Date: Mon, 4 Feb 2019 21:16:15 +0000 Subject: [PATCH 20/36] Fixes for very early use of the pthread_mutex_* and libthr malloc. When libthr is statically linked into the binary, order of the constructors execution is not deterministic. It is possible for the application constructor to use pthread_mutex_* functions before the libthr initialization was done. Handle it by: - making thr_malloc.c locking functions operational when curthread is not yet set; - making __thr_malloc_init() idempotent, allowing more than one call to it; - unconditionally calling __thr_malloc_init() before initializing a process-private mutex. Reported and tested by: mmel Sponsored by: The FreeBSD Foundation MFC after: 1 week --- lib/libthr/thread/thr_malloc.c | 6 ++++++ lib/libthr/thread/thr_mutex.c | 1 + 2 files changed, 7 insertions(+) diff --git a/lib/libthr/thread/thr_malloc.c b/lib/libthr/thread/thr_malloc.c index 157c72f10d6c..2f1c81142942 100644 --- a/lib/libthr/thread/thr_malloc.c +++ b/lib/libthr/thread/thr_malloc.c @@ -46,6 +46,8 @@ void __thr_malloc_init(void) { + if (npagesizes != 0) + return; npagesizes = getpagesizes(pagesizes_d, nitems(pagesizes_d)); if (npagesizes == -1) { npagesizes = 1; @@ -59,6 +61,8 @@ static void thr_malloc_lock(struct pthread *curthread) { + if (curthread == NULL) + return; curthread->locklevel++; _thr_umutex_lock(&thr_malloc_umtx, TID(curthread)); } @@ -67,6 +71,8 @@ static void thr_malloc_unlock(struct pthread *curthread) { + if (curthread == NULL) + return; _thr_umutex_unlock(&thr_malloc_umtx, TID(curthread)); curthread->locklevel--; _thr_ast(curthread); diff --git a/lib/libthr/thread/thr_mutex.c b/lib/libthr/thread/thr_mutex.c index f6f37c1264e2..4db653843311 100644 --- a/lib/libthr/thread/thr_mutex.c +++ b/lib/libthr/thread/thr_mutex.c @@ -390,6 +390,7 @@ __pthread_mutex_init(pthread_mutex_t * __restrict mutex, } if (mutex_attr == NULL || (*mutex_attr)->m_pshared == PTHREAD_PROCESS_PRIVATE) { + __thr_malloc_init(); return (mutex_init(mutex, mutex_attr ? *mutex_attr : NULL, __thr_calloc)); } From 52467047aa7dd6d21f6303b28e4278cab2d8fe48 Mon Sep 17 00:00:00 2001 From: Warner Losh Date: Mon, 4 Feb 2019 21:28:25 +0000 Subject: [PATCH 21/36] Regularize the Netflix copyright Use recent best practices for Copyright form at the top of the license: 1. Remove all the All Rights Reserved clauses on our stuff. Where we piggybacked others, use a separate line to make things clear. 2. Use "Netflix, Inc." everywhere. 3. Use a single line for the copyright for grep friendliness. 4. Use date ranges in all places for our stuff. Approved by: Netflix Legal (who gave me the form), adrian@ (pmc files) --- lib/libefivar/efi-osdep.h | 1 - lib/libefivar/efivar-dp-format.c | 1 - lib/libefivar/efivar-dp-parse.c | 1 - lib/libefivar/efivar-dp-xlate.c | 1 - lib/libefivar/efivar-dp.h | 1 - lib/libefivar/efivar.3 | 1 + lib/libefivar/efivar.c | 1 - lib/libefivar/efivar.h | 1 - lib/libefivar/uefi-dplib.h | 1 - lib/libefivar/uefi-dputil.c | 1 - sbin/devmatch/devmatch.8 | 4 +--- sbin/devmatch/devmatch.c | 3 +-- sbin/nvmecontrol/modules/wdc/wdc.c | 3 +-- sbin/nvmecontrol/nc_util.c | 3 +-- sbin/nvmecontrol/ns.c | 2 +- sbin/nvmecontrol/nvmecontrol_ext.h | 2 +- sbin/nvmecontrol/power.c | 3 +-- share/man/man4/nda.4 | 4 ++-- share/man/man9/kern_testfrwk.9 | 3 +-- stand/efi/libefi/efienv.c | 1 - stand/efi/libefi/env.c | 2 +- stand/efi/libefi/wchar.c | 2 +- stand/efi/loader/main.c | 3 ++- stand/forth/efi.4th | 4 ++-- stand/i386/libi386/biospci.c | 3 ++- stand/libsa/abort.c | 2 +- stand/libsa/xlocale_private.h | 2 +- sys/cam/nvme/nvme_all.c | 2 +- sys/cam/nvme/nvme_all.h | 2 +- sys/cam/nvme/nvme_da.c | 2 +- sys/crypto/aesni/aesencdec.h | 3 ++- sys/dev/efidev/efidev.c | 1 - sys/dev/nvme/nvme_sim.c | 2 +- sys/dev/tcp_log/tcp_log_dev.c | 3 +-- sys/dev/tcp_log/tcp_log_dev.h | 3 +-- sys/kern/subr_boot.c | 2 +- sys/netinet/tcp_hpts.c | 2 +- sys/netinet/tcp_hpts.h | 2 +- sys/netinet/tcp_log_buf.c | 3 +-- sys/netinet/tcp_log_buf.h | 3 +-- sys/netinet/tcp_stacks/rack.c | 3 +-- sys/netinet/tcp_stacks/rack_bbr_common.h | 4 +--- sys/netinet/tcp_stacks/sack_filter.c | 4 +--- sys/netinet/tcp_stacks/sack_filter.h | 4 +--- sys/netinet/tcp_stacks/tcp_rack.h | 3 +-- sys/sys/boot.h | 2 +- sys/sys/efiio.h | 1 - sys/sys/kern_prefetch.h | 2 +- sys/tests/callout_test.h | 3 +-- sys/tests/callout_test/callout_test.c | 3 ++- sys/tests/framework/kern_testfrwk.c | 3 +-- sys/tests/kern_testfrwk.h | 3 +-- usr.sbin/efibootmgr/efibootmgr.8 | 4 ++-- usr.sbin/efibootmgr/efibootmgr.c | 1 - usr.sbin/efidp/efidp.8 | 4 ++-- usr.sbin/efidp/efidp.c | 1 - usr.sbin/efivar/efiutil.c | 1 - usr.sbin/efivar/efiutil.h | 1 - usr.sbin/efivar/efivar.8 | 4 ++-- usr.sbin/efivar/efivar.c | 1 - usr.sbin/mpsutil/mps_cmd.c | 1 - usr.sbin/mpsutil/mps_debug.c | 1 - usr.sbin/mpsutil/mps_show.c | 1 - usr.sbin/mpsutil/mpsutil.c | 1 - usr.sbin/pmcstat/pmcpl_annotate_cg.c | 4 +++- usr.sbin/pmcstat/pmcpl_annotate_cg.h | 4 +++- usr.sbin/pmcstudy/eval_expr.c | 3 +-- usr.sbin/pmcstudy/eval_expr.h | 3 +-- usr.sbin/pmcstudy/pmcstudy.8 | 4 ++-- usr.sbin/pmcstudy/pmcstudy.c | 3 +-- 70 files changed, 63 insertions(+), 100 deletions(-) diff --git a/lib/libefivar/efi-osdep.h b/lib/libefivar/efi-osdep.h index 406f2ba44fde..b971eab5899d 100644 --- a/lib/libefivar/efi-osdep.h +++ b/lib/libefivar/efi-osdep.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar-dp-format.c b/lib/libefivar/efivar-dp-format.c index 41b89da0b97f..aa875dc45e70 100644 --- a/lib/libefivar/efivar-dp-format.c +++ b/lib/libefivar/efivar-dp-format.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar-dp-parse.c b/lib/libefivar/efivar-dp-parse.c index c06d9dcc7b79..3fc4fd8a62fd 100644 --- a/lib/libefivar/efivar-dp-parse.c +++ b/lib/libefivar/efivar-dp-parse.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar-dp-xlate.c b/lib/libefivar/efivar-dp-xlate.c index bdd8fbe25675..55be29c5b547 100644 --- a/lib/libefivar/efivar-dp-xlate.c +++ b/lib/libefivar/efivar-dp-xlate.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar-dp.h b/lib/libefivar/efivar-dp.h index 92276c3efeea..5a8db37f36fc 100644 --- a/lib/libefivar/efivar-dp.h +++ b/lib/libefivar/efivar-dp.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar.3 b/lib/libefivar/efivar.3 index 4cde5004ee28..046664abcb17 100644 --- a/lib/libefivar/efivar.3 +++ b/lib/libefivar/efivar.3 @@ -1,3 +1,4 @@ +.\" .\" Copyright 2016 Netflix, Inc. .\" All rights reserved. .\" diff --git a/lib/libefivar/efivar.c b/lib/libefivar/efivar.c index bfde632c7a84..76b83d3bbdbe 100644 --- a/lib/libefivar/efivar.c +++ b/lib/libefivar/efivar.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/efivar.h b/lib/libefivar/efivar.h index 6fb75a765052..2bdf92d35690 100644 --- a/lib/libefivar/efivar.h +++ b/lib/libefivar/efivar.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/uefi-dplib.h b/lib/libefivar/uefi-dplib.h index 1a1f3e256029..10f145086697 100644 --- a/lib/libefivar/uefi-dplib.h +++ b/lib/libefivar/uefi-dplib.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/lib/libefivar/uefi-dputil.c b/lib/libefivar/uefi-dputil.c index 06b43f40bb04..9f1f86a25ebe 100644 --- a/lib/libefivar/uefi-dputil.c +++ b/lib/libefivar/uefi-dputil.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sbin/devmatch/devmatch.8 b/sbin/devmatch/devmatch.8 index 2d534bc402a8..bf36c276c823 100644 --- a/sbin/devmatch/devmatch.8 +++ b/sbin/devmatch/devmatch.8 @@ -1,7 +1,5 @@ .\" -.\" Copyright (c) 2017 Netflix, Inc -.\" -.\" All rights reserved. +.\" Copyright (c) 2017 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/sbin/devmatch/devmatch.c b/sbin/devmatch/devmatch.c index 938760bec32f..d5d698576076 100644 --- a/sbin/devmatch/devmatch.c +++ b/sbin/devmatch/devmatch.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2017 Netflix, Inc - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sbin/nvmecontrol/modules/wdc/wdc.c b/sbin/nvmecontrol/modules/wdc/wdc.c index e6ec249addf8..6060abbbfcd5 100644 --- a/sbin/nvmecontrol/modules/wdc/wdc.c +++ b/sbin/nvmecontrol/modules/wdc/wdc.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2017 Netflix, Inc - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sbin/nvmecontrol/nc_util.c b/sbin/nvmecontrol/nc_util.c index 77de11fc987b..8f73256003a5 100644 --- a/sbin/nvmecontrol/nc_util.c +++ b/sbin/nvmecontrol/nc_util.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2017 Netflix, Inc - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sbin/nvmecontrol/ns.c b/sbin/nvmecontrol/ns.c index ce762d59fb37..bb996fabdf2e 100644 --- a/sbin/nvmecontrol/ns.c +++ b/sbin/nvmecontrol/ns.c @@ -1,7 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2017 Netflix, Inc + * Copyright (c) 2017 Netflix, Inc. * Copyright (C) 2018 Alexander Motin * * Redistribution and use in source and binary forms, with or without diff --git a/sbin/nvmecontrol/nvmecontrol_ext.h b/sbin/nvmecontrol/nvmecontrol_ext.h index 43042dfafdf9..d60fcd4d8a2c 100644 --- a/sbin/nvmecontrol/nvmecontrol_ext.h +++ b/sbin/nvmecontrol/nvmecontrol_ext.h @@ -1,7 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (C) 2018 Netflix + * Copyright (C) 2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sbin/nvmecontrol/power.c b/sbin/nvmecontrol/power.c index 3adbaf1d4eb2..7e5cac49713e 100644 --- a/sbin/nvmecontrol/power.c +++ b/sbin/nvmecontrol/power.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2016 Netflix, Inc - * All rights reserved. + * Copyright (c) 2016 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/share/man/man4/nda.4 b/share/man/man4/nda.4 index bc1240e2c019..9e9bff5922dc 100644 --- a/share/man/man4/nda.4 +++ b/share/man/man4/nda.4 @@ -1,5 +1,5 @@ -.\" Copyright (c) 2017 Netflix, Inc -.\" All rights reserved. +.\" +.\" Copyright (c) 2017 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/share/man/man9/kern_testfrwk.9 b/share/man/man9/kern_testfrwk.9 index 653cb5e89c60..76fb4535fc9c 100644 --- a/share/man/man9/kern_testfrwk.9 +++ b/share/man/man9/kern_testfrwk.9 @@ -1,6 +1,5 @@ .\" -.\" Copyright (c) 2015 Netflix Inc. -.\" All rights reserved. +.\" Copyright (c) 2015 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/stand/efi/libefi/efienv.c b/stand/efi/libefi/efienv.c index 1ee6beeb518f..06c54f80bc3c 100644 --- a/stand/efi/libefi/efienv.c +++ b/stand/efi/libefi/efienv.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2018 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/stand/efi/libefi/env.c b/stand/efi/libefi/env.c index 58337c47df41..77e232343040 100644 --- a/stand/efi/libefi/env.c +++ b/stand/efi/libefi/env.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Netflix, Inc. All Rights Reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/stand/efi/libefi/wchar.c b/stand/efi/libefi/wchar.c index d8d81aca4bcc..0a2b96b64f45 100644 --- a/stand/efi/libefi/wchar.c +++ b/stand/efi/libefi/wchar.c @@ -1,5 +1,5 @@ /*- - * Copyright 2016 Netflix, Inc. All Rights Reserved. + * Copyright 2016 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/stand/efi/loader/main.c b/stand/efi/loader/main.c index 060bc975e8d4..fb6c97ab73de 100644 --- a/stand/efi/loader/main.c +++ b/stand/efi/loader/main.c @@ -1,9 +1,10 @@ /*- * Copyright (c) 2008-2010 Rui Paulo * Copyright (c) 2006 Marcel Moolenaar - * Copyright (c) 2018 Netflix, Inc * All rights reserved. * + * Copyright (c) 2018 Netflix, Inc. + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: diff --git a/stand/forth/efi.4th b/stand/forth/efi.4th index 827b4348087b..abcf12cffccd 100644 --- a/stand/forth/efi.4th +++ b/stand/forth/efi.4th @@ -1,5 +1,5 @@ -\ Copyright (c) 2016 Netflix, Inc -\ All rights reserved. +\ +\ Copyright (c) 2016 Netflix, Inc. \ \ Redistribution and use in source and binary forms, with or without \ modification, are permitted provided that the following conditions diff --git a/stand/i386/libi386/biospci.c b/stand/i386/libi386/biospci.c index e13a5b9f37ef..968533e210c4 100644 --- a/stand/i386/libi386/biospci.c +++ b/stand/i386/libi386/biospci.c @@ -1,8 +1,9 @@ /*- * Copyright (c) 1998 Michael Smith - * Copyright (c) 2016 Netflix, Inc * All rights reserved. * + * Copyright (c) 2016 Netflix, Inc. + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: diff --git a/stand/libsa/abort.c b/stand/libsa/abort.c index 4b3a2c7e00c2..d8f66ca0ba23 100644 --- a/stand/libsa/abort.c +++ b/stand/libsa/abort.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Netflix. All Rights Reserved. + * Copyright (c) 2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/stand/libsa/xlocale_private.h b/stand/libsa/xlocale_private.h index 96eed3722769..074aca692550 100644 --- a/stand/libsa/xlocale_private.h +++ b/stand/libsa/xlocale_private.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2018 Netflix + * Copyright (c) 2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/cam/nvme/nvme_all.c b/sys/cam/nvme/nvme_all.c index f79785f77786..d9faea1d7849 100644 --- a/sys/cam/nvme/nvme_all.c +++ b/sys/cam/nvme/nvme_all.c @@ -1,7 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2015 Netflix, Inc + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/cam/nvme/nvme_all.h b/sys/cam/nvme/nvme_all.h index e31c1e5e0d7d..2141700a9226 100644 --- a/sys/cam/nvme/nvme_all.h +++ b/sys/cam/nvme/nvme_all.h @@ -1,7 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2015 Netflix, Inc + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/cam/nvme/nvme_da.c b/sys/cam/nvme/nvme_da.c index 9e2f26bec07c..9f708d6ad40d 100644 --- a/sys/cam/nvme/nvme_da.c +++ b/sys/cam/nvme/nvme_da.c @@ -1,7 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2015 Netflix, Inc + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/crypto/aesni/aesencdec.h b/sys/crypto/aesni/aesencdec.h index 80951a48aad4..73add364c0aa 100644 --- a/sys/crypto/aesni/aesencdec.h +++ b/sys/crypto/aesni/aesencdec.h @@ -1,8 +1,9 @@ /*- * Copyright 2013 John-Mark Gurney - * Copyright 2015 Netflix, Inc. * All rights reserved. * + * Copyright 2015 Netflix, Inc. + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: diff --git a/sys/dev/efidev/efidev.c b/sys/dev/efidev/efidev.c index 01b6c379b0c0..b585db4f0117 100644 --- a/sys/dev/efidev/efidev.c +++ b/sys/dev/efidev/efidev.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/dev/nvme/nvme_sim.c b/sys/dev/nvme/nvme_sim.c index 424c4ecfd5dd..7593920c15fa 100644 --- a/sys/dev/nvme/nvme_sim.c +++ b/sys/dev/nvme/nvme_sim.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2016 Netflix, Inc + * Copyright (c) 2016 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/dev/tcp_log/tcp_log_dev.c b/sys/dev/tcp_log/tcp_log_dev.c index c62e106da55f..bea2dd95b0dd 100644 --- a/sys/dev/tcp_log/tcp_log_dev.c +++ b/sys/dev/tcp_log/tcp_log_dev.c @@ -1,8 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2016-2017 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016-2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/dev/tcp_log/tcp_log_dev.h b/sys/dev/tcp_log/tcp_log_dev.h index 90f0364a2fed..808271f8640b 100644 --- a/sys/dev/tcp_log/tcp_log_dev.h +++ b/sys/dev/tcp_log/tcp_log_dev.h @@ -1,8 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2016 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/kern/subr_boot.c b/sys/kern/subr_boot.c index 00890c3150d7..4aa135df5c83 100644 --- a/sys/kern/subr_boot.c +++ b/sys/kern/subr_boot.c @@ -10,7 +10,7 @@ * Copyright (c) 2014 Roger Pau Monné * All Rights Reserved. * Copyright (c) 2018 Kyle Evans - * Copyright (c) 2018 Netflix + * Copyright (c) 2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_hpts.c b/sys/netinet/tcp_hpts.c index f3737888f3d0..74e796103f8a 100644 --- a/sys/netinet/tcp_hpts.c +++ b/sys/netinet/tcp_hpts.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2016-2018 Netflix Inc. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_hpts.h b/sys/netinet/tcp_hpts.h index 04c867698915..ea15bc1ab320 100644 --- a/sys/netinet/tcp_hpts.h +++ b/sys/netinet/tcp_hpts.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2016-2018 Netflix Inc. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_log_buf.c b/sys/netinet/tcp_log_buf.c index 9dd6ee8acb1e..3225ce9c31b7 100644 --- a/sys/netinet/tcp_log_buf.c +++ b/sys/netinet/tcp_log_buf.c @@ -1,8 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2016-2018 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_log_buf.h b/sys/netinet/tcp_log_buf.h index e569395a1aed..0662d1b5d4ad 100644 --- a/sys/netinet/tcp_log_buf.h +++ b/sys/netinet/tcp_log_buf.h @@ -1,8 +1,7 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2016-2018 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_stacks/rack.c b/sys/netinet/tcp_stacks/rack.c index 608b6e7e15ad..975367fa7a82 100644 --- a/sys/netinet/tcp_stacks/rack.c +++ b/sys/netinet/tcp_stacks/rack.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2016-2018 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_stacks/rack_bbr_common.h b/sys/netinet/tcp_stacks/rack_bbr_common.h index d52022daee66..c3d661cfd972 100644 --- a/sys/netinet/tcp_stacks/rack_bbr_common.h +++ b/sys/netinet/tcp_stacks/rack_bbr_common.h @@ -1,9 +1,7 @@ #ifndef __pacer_timer_h__ #define __pacer_timer_h__ /*- - * Copyright (c) 2017 - * Netflix Inc. - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_stacks/sack_filter.c b/sys/netinet/tcp_stacks/sack_filter.c index 993d5851db79..2ef0eadfa944 100644 --- a/sys/netinet/tcp_stacks/sack_filter.c +++ b/sys/netinet/tcp_stacks/sack_filter.c @@ -1,7 +1,5 @@ /*- - * Copyright (c) 2017 - * Netflix Inc. - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_stacks/sack_filter.h b/sys/netinet/tcp_stacks/sack_filter.h index 3ef0f1693f5b..3ef986209566 100644 --- a/sys/netinet/tcp_stacks/sack_filter.h +++ b/sys/netinet/tcp_stacks/sack_filter.h @@ -1,9 +1,7 @@ #ifndef __sack_filter_h__ #define __sack_filter_h__ /*- - * Copyright (c) 2017 - * Netflix Inc. - * All rights reserved. + * Copyright (c) 2017 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/netinet/tcp_stacks/tcp_rack.h b/sys/netinet/tcp_stacks/tcp_rack.h index c7132ba81893..76c3eb2e5b70 100644 --- a/sys/netinet/tcp_stacks/tcp_rack.h +++ b/sys/netinet/tcp_stacks/tcp_rack.h @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2016 - * Netflix Inc. All rights reserved. + * Copyright (c) 2016 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/sys/boot.h b/sys/sys/boot.h index 3cfebedff19c..68b9e1e0daf3 100644 --- a/sys/sys/boot.h +++ b/sys/sys/boot.h @@ -1,9 +1,9 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2018 Netflix * Copyright (c) 2014 Roger Pau Monné * All rights reserved. + * Copyright (c) 2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/sys/efiio.h b/sys/sys/efiio.h index 1e1cff67b62f..87fed9c3afd8 100644 --- a/sys/sys/efiio.h +++ b/sys/sys/efiio.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/sys/kern_prefetch.h b/sys/sys/kern_prefetch.h index dd6cf3fa19d7..6945132f12e0 100644 --- a/sys/sys/kern_prefetch.h +++ b/sys/sys/kern_prefetch.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2016-2018 Netflix Inc. + * Copyright (c) 2016-2018 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/tests/callout_test.h b/sys/tests/callout_test.h index 2f470dc8bbca..a30b2ad95fe8 100644 --- a/sys/tests/callout_test.h +++ b/sys/tests/callout_test.h @@ -1,8 +1,7 @@ #ifndef __callout_test_h__ #define __callout_test_h__ /*- - * Copyright (c) 2015 - * Netflix Incorporated, All rights reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/tests/callout_test/callout_test.c b/sys/tests/callout_test/callout_test.c index c42e9decb4bb..ce585380b94a 100644 --- a/sys/tests/callout_test/callout_test.c +++ b/sys/tests/callout_test/callout_test.c @@ -1,5 +1,6 @@ /*- - * Copyright (c) 2015 Netflix Inc. All rights reserved. + * Copyright (c) 2015 Netflix, Inc. + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: diff --git a/sys/tests/framework/kern_testfrwk.c b/sys/tests/framework/kern_testfrwk.c index 2ef1c6f02a50..3e88faa5e8f8 100644 --- a/sys/tests/framework/kern_testfrwk.c +++ b/sys/tests/framework/kern_testfrwk.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2015 - * Netflix Incorporated, All rights reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/sys/tests/kern_testfrwk.h b/sys/tests/kern_testfrwk.h index 844eea411313..dbb4733df962 100644 --- a/sys/tests/kern_testfrwk.h +++ b/sys/tests/kern_testfrwk.h @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2015 - * Netflix Incorporated, All rights reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/efibootmgr/efibootmgr.8 b/usr.sbin/efibootmgr/efibootmgr.8 index 689d53d200f0..c19e8f18799a 100644 --- a/usr.sbin/efibootmgr/efibootmgr.8 +++ b/usr.sbin/efibootmgr/efibootmgr.8 @@ -1,5 +1,5 @@ -.\" Copyright (c) 2017-2018 Netflix, Inc -.\" All rights reserved. +.\" +.\" Copyright (c) 2017-2018 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/usr.sbin/efibootmgr/efibootmgr.c b/usr.sbin/efibootmgr/efibootmgr.c index 06bd55866c69..5793388fbcc0 100644 --- a/usr.sbin/efibootmgr/efibootmgr.c +++ b/usr.sbin/efibootmgr/efibootmgr.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017-2018 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/efidp/efidp.8 b/usr.sbin/efidp/efidp.8 index 40bd7b945759..ad98428a97a5 100644 --- a/usr.sbin/efidp/efidp.8 +++ b/usr.sbin/efidp/efidp.8 @@ -1,5 +1,5 @@ -.\" Copyright (c) 2017 Netflix, Inc -.\" All rights reserved. +.\" +.\" Copyright (c) 2017 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/usr.sbin/efidp/efidp.c b/usr.sbin/efidp/efidp.c index e12491ecabf5..aef154112d66 100644 --- a/usr.sbin/efidp/efidp.c +++ b/usr.sbin/efidp/efidp.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/efivar/efiutil.c b/usr.sbin/efivar/efiutil.c index 0ccf2950df2a..ff35b29bf9cc 100644 --- a/usr.sbin/efivar/efiutil.c +++ b/usr.sbin/efivar/efiutil.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/efivar/efiutil.h b/usr.sbin/efivar/efiutil.h index 143fd464f6ca..dbcb598c789e 100644 --- a/usr.sbin/efivar/efiutil.h +++ b/usr.sbin/efivar/efiutil.h @@ -1,6 +1,5 @@ /*- * Copyright (c) 2017 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/efivar/efivar.8 b/usr.sbin/efivar/efivar.8 index 7113ba931e46..215708dd8afe 100644 --- a/usr.sbin/efivar/efivar.8 +++ b/usr.sbin/efivar/efivar.8 @@ -1,5 +1,5 @@ -.\" Copyright (c) 2017 Netflix, Inc -.\" All rights reserved. +.\" +.\" Copyright (c) 2017 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/usr.sbin/efivar/efivar.c b/usr.sbin/efivar/efivar.c index f278ecd78b6a..8146812534e4 100644 --- a/usr.sbin/efivar/efivar.c +++ b/usr.sbin/efivar/efivar.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2016 Netflix, Inc. - * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/mpsutil/mps_cmd.c b/usr.sbin/mpsutil/mps_cmd.c index 6053c9265261..8e1e431d65f3 100644 --- a/usr.sbin/mpsutil/mps_cmd.c +++ b/usr.sbin/mpsutil/mps_cmd.c @@ -2,7 +2,6 @@ * Copyright (c) 2015 Baptiste Daroussin * * Copyright (c) 2015 Netflix, Inc. - * All rights reserved. * Written by: Scott Long * * Copyright (c) 2008 Yahoo!, Inc. diff --git a/usr.sbin/mpsutil/mps_debug.c b/usr.sbin/mpsutil/mps_debug.c index 24ddbd2cb11d..4c462ef65f6c 100644 --- a/usr.sbin/mpsutil/mps_debug.c +++ b/usr.sbin/mpsutil/mps_debug.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2018 Netflix, Inc. - * All rights reserved. * Written by: Scott Long * * Redistribution and use in source and binary forms, with or without diff --git a/usr.sbin/mpsutil/mps_show.c b/usr.sbin/mpsutil/mps_show.c index 81265aacf7bb..57aed20a7d60 100644 --- a/usr.sbin/mpsutil/mps_show.c +++ b/usr.sbin/mpsutil/mps_show.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2015 Netflix, Inc. - * All rights reserved. * Written by: Scott Long * * Copyright (c) 2008 Yahoo!, Inc. diff --git a/usr.sbin/mpsutil/mpsutil.c b/usr.sbin/mpsutil/mpsutil.c index cb15d0d0a566..d7209afd175f 100644 --- a/usr.sbin/mpsutil/mpsutil.c +++ b/usr.sbin/mpsutil/mpsutil.c @@ -1,6 +1,5 @@ /*- * Copyright (c) 2015 Netflix, Inc. - * All rights reserved. * Written by: Scott Long * * Copyright (c) 2008 Yahoo!, Inc. diff --git a/usr.sbin/pmcstat/pmcpl_annotate_cg.c b/usr.sbin/pmcstat/pmcpl_annotate_cg.c index b8ad3c697cab..d6274e1f2b73 100644 --- a/usr.sbin/pmcstat/pmcpl_annotate_cg.c +++ b/usr.sbin/pmcstat/pmcpl_annotate_cg.c @@ -3,9 +3,11 @@ * * Copyright (c) 2005-2007, Joseph Koshy * Copyright (c) 2007 The FreeBSD Foundation - * Copyright (c) 2014, Adrian Chadd, Netflix Inc. * All rights reserved. * + * Copyright (c) 2014 Netflix, Inc. + * Written by: Adrian Chadd + * * Portions of this software were developed by A. Joseph Koshy under * sponsorship from the FreeBSD Foundation and Google, Inc. * diff --git a/usr.sbin/pmcstat/pmcpl_annotate_cg.h b/usr.sbin/pmcstat/pmcpl_annotate_cg.h index cf11c8de519d..afd5209ee756 100644 --- a/usr.sbin/pmcstat/pmcpl_annotate_cg.h +++ b/usr.sbin/pmcstat/pmcpl_annotate_cg.h @@ -3,9 +3,11 @@ * * Copyright (c) 2005-2007, Joseph Koshy * Copyright (c) 2007 The FreeBSD Foundation - * Copyright (c) 2014, Adrian Chadd, Netflix Inc. * All rights reserved. * + * Copyright (c) 2014 Netflix, Inc. + * Written by: Adrian Chadd + * * Portions of this software were developed by A. Joseph Koshy under * sponsorship from the FreeBSD Foundation and Google, Inc. * diff --git a/usr.sbin/pmcstudy/eval_expr.c b/usr.sbin/pmcstudy/eval_expr.c index d8999a98ab99..984e5ea72176 100644 --- a/usr.sbin/pmcstudy/eval_expr.c +++ b/usr.sbin/pmcstudy/eval_expr.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2015 Netflix Inc. - * All rights reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/pmcstudy/eval_expr.h b/usr.sbin/pmcstudy/eval_expr.h index f095513a8aa5..2c264ff711b2 100644 --- a/usr.sbin/pmcstudy/eval_expr.h +++ b/usr.sbin/pmcstudy/eval_expr.h @@ -1,8 +1,7 @@ #ifndef __eval_expr_h__ #define __eval_expr_h__ /*- - * Copyright (c) 2015 Netflix Inc. - * All rights reserved. + * Copyright (c) 2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions diff --git a/usr.sbin/pmcstudy/pmcstudy.8 b/usr.sbin/pmcstudy/pmcstudy.8 index a3ec51ad8c1a..34d76b1de80c 100644 --- a/usr.sbin/pmcstudy/pmcstudy.8 +++ b/usr.sbin/pmcstudy/pmcstudy.8 @@ -1,5 +1,5 @@ -.\" Copyright (c) 2015 -.\" Netflix Inc. +.\" +.\" Copyright (c) 2015 Netflix, Inc. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions diff --git a/usr.sbin/pmcstudy/pmcstudy.c b/usr.sbin/pmcstudy/pmcstudy.c index 3cf1f8e328a8..69d926a05e5d 100644 --- a/usr.sbin/pmcstudy/pmcstudy.c +++ b/usr.sbin/pmcstudy/pmcstudy.c @@ -1,6 +1,5 @@ /*- - * Copyright (c) 2014, 2015 Netflix Inc. - * All rights reserved. + * Copyright (c) 2014-2015 Netflix, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions From ccc2d07e776d1d014b27d01cc5eaf4e0d4fd811c Mon Sep 17 00:00:00 2001 From: Konstantin Belousov Date: Mon, 4 Feb 2019 23:57:59 +0000 Subject: [PATCH 22/36] Update CPUID bits definitions and CPU identification based on changes in SDM rev. 069. Sponsored by: The FreeBSD Foundation MFC after: 3 days --- sys/x86/include/specialreg.h | 6 ++++++ sys/x86/x86/identcpu.c | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/sys/x86/include/specialreg.h b/sys/x86/include/specialreg.h index 2ccffee6ddfd..5e223fa60de6 100644 --- a/sys/x86/include/specialreg.h +++ b/sys/x86/include/specialreg.h @@ -436,7 +436,12 @@ #define CPUID_STDEXT2_UMIP 0x00000004 #define CPUID_STDEXT2_PKU 0x00000008 #define CPUID_STDEXT2_OSPKE 0x00000010 +#define CPUID_STDEXT2_WAITPKG 0x00000020 +#define CPUID_STDEXT2_GFNI 0x00000100 #define CPUID_STDEXT2_RDPID 0x00400000 +#define CPUID_STDEXT2_CLDEMOTE 0x02000000 +#define CPUID_STDEXT2_MOVDIRI 0x08000000 +#define CPUID_STDEXT2_MOVDIRI64B 0x10000000 #define CPUID_STDEXT2_SGXLC 0x40000000 /* @@ -446,6 +451,7 @@ #define CPUID_STDEXT3_STIBP 0x08000000 #define CPUID_STDEXT3_L1D_FLUSH 0x10000000 #define CPUID_STDEXT3_ARCH_CAP 0x20000000 +#define CPUID_STDEXT3_CORE_CAP 0x40000000 #define CPUID_STDEXT3_SSBD 0x80000000 /* MSR IA32_ARCH_CAP(ABILITIES) bits */ diff --git a/sys/x86/x86/identcpu.c b/sys/x86/x86/identcpu.c index b46f7cdcd630..f38cc2688804 100644 --- a/sys/x86/x86/identcpu.c +++ b/sys/x86/x86/identcpu.c @@ -981,7 +981,12 @@ printcpuinfo(void) "\003UMIP" "\004PKU" "\005OSPKE" + "\006WAITPKG" + "\011GFNI" "\027RDPID" + "\032CLDEMOTE" + "\034MOVDIRI" + "\035MOVDIRI64B" "\037SGXLC" ); } @@ -994,6 +999,7 @@ printcpuinfo(void) "\034STIBP" "\035L1DFL" "\036ARCH_CAP" + "\037CORE_CAP" "\040SSBD" ); } From 334fd3dabc9e8f913e7b509e9ccdcb835fbf43f0 Mon Sep 17 00:00:00 2001 From: Matt Macy Date: Tue, 5 Feb 2019 00:31:25 +0000 Subject: [PATCH 23/36] Fix deterministic builds by sorting input to fts in jevents Reported by: emaste@ --- lib/libpmc/pmu-events/jevents.c | 95 ++++++++++++++++++++++++++++++++- 1 file changed, 93 insertions(+), 2 deletions(-) diff --git a/lib/libpmc/pmu-events/jevents.c b/lib/libpmc/pmu-events/jevents.c index 4bf9d7e1d5e3..c59780e3d59e 100644 --- a/lib/libpmc/pmu-events/jevents.c +++ b/lib/libpmc/pmu-events/jevents.c @@ -54,6 +54,10 @@ #include "json.h" #include "jevents.h" +static int +nftw_ordered(const char *path, int (*fn)(const char *, const struct stat *, int, + struct FTW *), int nfds, int ftwflags); + _Noreturn void _Exit(int); int verbose; @@ -1122,7 +1126,7 @@ int main(int argc, char *argv[]) maxfds = get_maxfds(); mapfile = NULL; - rc = nftw(ldirname, preprocess_arch_std_files, maxfds, 0); + rc = nftw_ordered(ldirname, preprocess_arch_std_files, maxfds, 0); if (rc && verbose) { pr_info("%s: Error preprocessing arch standard files %s: %s\n", prog, ldirname, strerror(errno)); @@ -1135,7 +1139,7 @@ int main(int argc, char *argv[]) goto empty_map; } - rc = nftw(ldirname, process_one_file, maxfds, 0); + rc = nftw_ordered(ldirname, process_one_file, maxfds, 0); if (rc && verbose) { pr_info("%s: Error walking file tree %s\n", prog, ldirname); goto empty_map; @@ -1169,3 +1173,90 @@ int main(int argc, char *argv[]) free_arch_std_events(); return 0; } + +#include + +static int +fts_compare(const FTSENT * const *a, const FTSENT * const *b) +{ + return (strcmp((*a)->fts_name, (*b)->fts_name)); +} + +static int +nftw_ordered(const char *path, int (*fn)(const char *, const struct stat *, int, + struct FTW *), int nfds, int ftwflags) +{ + char * const paths[2] = { (char *)path, NULL }; + struct FTW ftw; + FTSENT *cur; + FTS *ftsp; + int error = 0, ftsflags, fnflag, postorder, sverrno; + + /* XXX - nfds is currently unused */ + if (nfds < 1) { + errno = EINVAL; + return (-1); + } + + ftsflags = FTS_COMFOLLOW; + if (!(ftwflags & FTW_CHDIR)) + ftsflags |= FTS_NOCHDIR; + if (ftwflags & FTW_MOUNT) + ftsflags |= FTS_XDEV; + if (ftwflags & FTW_PHYS) + ftsflags |= FTS_PHYSICAL; + else + ftsflags |= FTS_LOGICAL; + postorder = (ftwflags & FTW_DEPTH) != 0; + ftsp = fts_open(paths, ftsflags, fts_compare); + if (ftsp == NULL) + return (-1); + while ((cur = fts_read(ftsp)) != NULL) { + switch (cur->fts_info) { + case FTS_D: + if (postorder) + continue; + fnflag = FTW_D; + break; + case FTS_DC: + continue; + case FTS_DNR: + fnflag = FTW_DNR; + break; + case FTS_DP: + if (!postorder) + continue; + fnflag = FTW_DP; + break; + case FTS_F: + case FTS_DEFAULT: + fnflag = FTW_F; + break; + case FTS_NS: + case FTS_NSOK: + fnflag = FTW_NS; + break; + case FTS_SL: + fnflag = FTW_SL; + break; + case FTS_SLNONE: + fnflag = FTW_SLN; + break; + default: + error = -1; + goto done; + } + ftw.base = cur->fts_pathlen - cur->fts_namelen; + ftw.level = cur->fts_level; + error = fn(cur->fts_path, cur->fts_statp, fnflag, &ftw); + if (error != 0) + break; + } +done: + sverrno = errno; + if (fts_close(ftsp) != 0 && error == 0) + error = -1; + else + errno = sverrno; + return (error); +} From c3eb848ce318b5ba6ea9db7f0331baf80b4c2bf6 Mon Sep 17 00:00:00 2001 From: Conrad Meyer Date: Tue, 5 Feb 2019 03:32:58 +0000 Subject: [PATCH 24/36] extattr_list_vp: Only take shared vnode lock List is a 'read'-type operation that does not modify shared state; it's safe for multiple thread to proceed concurrently. This is reflected in the vnode operation LISTEXTATTR locking protocol specification, which only requires a shared lock. (Similar to previous r248933.) Reported by: Case van Rij Reviewed by: kib, mjg Sponsored by: Dell EMC Isilon Differential Revision: https://reviews.freebsd.org/D19082 --- sys/kern/vfs_extattr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c index 2903fd37a068..30d6f84b6636 100644 --- a/sys/kern/vfs_extattr.c +++ b/sys/kern/vfs_extattr.c @@ -633,7 +633,7 @@ extattr_list_vp(struct vnode *vp, int attrnamespace, void *data, if (nbytes > IOSIZE_MAX) return (EINVAL); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); + vn_lock(vp, LK_SHARED | LK_RETRY); auiop = NULL; sizep = NULL; From e682df53972c409956a52c6c274bbd8be0367177 Mon Sep 17 00:00:00 2001 From: Conrad Meyer Date: Tue, 5 Feb 2019 04:47:21 +0000 Subject: [PATCH 25/36] extattr_list_vp: Narrow locked section somewhat Suggested by: mjg Reviewed by: kib, mjg Sponsored by: Dell EMC Isilon Differential Revision: https://reviews.freebsd.org/D19083 --- sys/kern/vfs_extattr.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c index 30d6f84b6636..4086289afa0a 100644 --- a/sys/kern/vfs_extattr.c +++ b/sys/kern/vfs_extattr.c @@ -633,8 +633,6 @@ extattr_list_vp(struct vnode *vp, int attrnamespace, void *data, if (nbytes > IOSIZE_MAX) return (EINVAL); - vn_lock(vp, LK_SHARED | LK_RETRY); - auiop = NULL; sizep = NULL; cnt = 0; @@ -653,24 +651,25 @@ extattr_list_vp(struct vnode *vp, int attrnamespace, void *data, } else sizep = &size; + vn_lock(vp, LK_SHARED | LK_RETRY); + #ifdef MAC error = mac_vnode_check_listextattr(td->td_ucred, vp, attrnamespace); - if (error) - goto done; + if (error) { + VOP_UNLOCK(vp, 0); + return (error); + } #endif error = VOP_LISTEXTATTR(vp, attrnamespace, auiop, sizep, td->td_ucred, td); + VOP_UNLOCK(vp, 0); if (auiop != NULL) { cnt -= auio.uio_resid; td->td_retval[0] = cnt; } else td->td_retval[0] = size; -#ifdef MAC -done: -#endif - VOP_UNLOCK(vp, 0); return (error); } From 9c22a13345e44788c4984fe52179f9157283b51b Mon Sep 17 00:00:00 2001 From: Justin Hibbits Date: Tue, 5 Feb 2019 04:47:41 +0000 Subject: [PATCH 26/36] powerpc: Don't idle with the wait instruction on booke It appears idling via 'wait' on e5500 causes strange behaviors, such as top(1) simply hanging sporadically, until input. Until this can possibly be sorted out (interrupt issue?), just don't idle on this hardware. The SoCs are low power already, and the wait state doesn't save much anyway. --- sys/powerpc/powerpc/cpu.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/sys/powerpc/powerpc/cpu.c b/sys/powerpc/powerpc/cpu.c index b517f478de11..da2f94da1a92 100644 --- a/sys/powerpc/powerpc/cpu.c +++ b/sys/powerpc/powerpc/cpu.c @@ -767,11 +767,6 @@ cpu_idle_booke(sbintime_t sbt) case FSL_E500mc: case FSL_E5500: case FSL_E6500: - /* - * Base binutils doesn't know what the 'wait' instruction is, so - * use the opcode encoding here. - */ - __asm __volatile(".long 0x7c00007c"); break; default: powerpc_sync(); From cc9b5471a001347a56e2139aeb5f28a8ed01e04a Mon Sep 17 00:00:00 2001 From: "Jayachandran C." Date: Tue, 5 Feb 2019 06:25:35 +0000 Subject: [PATCH 27/36] arm, acpi: increase size of memory region arrays Bump up MAX_HWCNT and MAX_EXCNT to 32 when ACPI is enabled. These are the sizes of the hwregions and exregions arrays respectively. ACPI firmware typically has more memory regions and the current value of 16 is not sufficient for some platforms. This commit fixes a failure seen with AMI firmware on Cavium's Sabre ThunderX2 reference platform. This platform needs 21 physical memory regions and 18 excluded regions to boot correctly with the current firmware release. Reviewed by: andrew Differential Revision: https://reviews.freebsd.org/D19073 --- sys/arm/arm/physmem.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sys/arm/arm/physmem.c b/sys/arm/arm/physmem.c index 52ccf3b03f41..6c20dcf9bfce 100644 --- a/sys/arm/arm/physmem.c +++ b/sys/arm/arm/physmem.c @@ -29,6 +29,7 @@ #include __FBSDID("$FreeBSD$"); +#include "opt_acpi.h" #include "opt_ddb.h" /* @@ -48,8 +49,13 @@ __FBSDID("$FreeBSD$"); * that can be allocated, or both, depending on the exclusion flags associated * with the region. */ +#ifdef DEV_ACPI +#define MAX_HWCNT 32 /* ACPI needs more regions */ +#define MAX_EXCNT 32 +#else #define MAX_HWCNT 16 #define MAX_EXCNT 16 +#endif #if defined(__arm__) #define MAX_PHYS_ADDR 0xFFFFFFFFull From e4c42fa266eae1a26cd6a429ad265ddfc399f3b7 Mon Sep 17 00:00:00 2001 From: Michael Tuexen Date: Tue, 5 Feb 2019 10:13:51 +0000 Subject: [PATCH 28/36] Fix an off-by-one error in the input validation of the SCTP_RESET_STREAMS socketoption. This was found by running syzkaller. MFC after: 3 days --- sys/netinet/sctp_usrreq.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sys/netinet/sctp_usrreq.c b/sys/netinet/sctp_usrreq.c index e582f5607665..27863c60e91e 100644 --- a/sys/netinet/sctp_usrreq.c +++ b/sys/netinet/sctp_usrreq.c @@ -4654,13 +4654,13 @@ sctp_setopt(struct socket *so, int optname, void *optval, size_t optsize, } for (i = 0; i < strrst->srs_number_streams; i++) { if ((send_in) && - (strrst->srs_stream_list[i] > stcb->asoc.streamincnt)) { + (strrst->srs_stream_list[i] >= stcb->asoc.streamincnt)) { SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL); error = EINVAL; break; } if ((send_out) && - (strrst->srs_stream_list[i] > stcb->asoc.streamoutcnt)) { + (strrst->srs_stream_list[i] >= stcb->asoc.streamoutcnt)) { SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL); error = EINVAL; break; From baed5270e1a6863444b97ccb107d08b317eb84a3 Mon Sep 17 00:00:00 2001 From: Michael Tuexen Date: Tue, 5 Feb 2019 10:29:31 +0000 Subject: [PATCH 29/36] Only reduce the PMTU after the send call. The only way to increase it, is via PMTUD. This fixes an MTU issue reported by Timo Voelker. MFC after: 3 days --- sys/netinet/sctp_output.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/sys/netinet/sctp_output.c b/sys/netinet/sctp_output.c index 7fe1b2107e12..0f496dd4e90b 100644 --- a/sys/netinet/sctp_output.c +++ b/sys/netinet/sctp_output.c @@ -4289,10 +4289,12 @@ sctp_lowlevel_chunk_output(struct sctp_inpcb *inp, if (net->port) { mtu -= sizeof(struct udphdr); } - if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) { - sctp_mtu_size_reset(inp, &stcb->asoc, mtu); + if (mtu < net->mtu) { + if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) { + sctp_mtu_size_reset(inp, &stcb->asoc, mtu); + } + net->mtu = mtu; } - net->mtu = mtu; } } else if (ro->ro_rt == NULL) { /* route was freed */ @@ -4647,10 +4649,12 @@ sctp_lowlevel_chunk_output(struct sctp_inpcb *inp, if (net->port) { mtu -= sizeof(struct udphdr); } - if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) { - sctp_mtu_size_reset(inp, &stcb->asoc, mtu); + if (mtu < net->mtu) { + if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) { + sctp_mtu_size_reset(inp, &stcb->asoc, mtu); + } + net->mtu = mtu; } - net->mtu = mtu; } } else if (ifp) { if (ND_IFINFO(ifp)->linkmtu && From 75f4f3ed51ea3eb78ed77e255845aa301b657bc4 Mon Sep 17 00:00:00 2001 From: Vincenzo Maffione Date: Tue, 5 Feb 2019 12:10:48 +0000 Subject: [PATCH 30/36] netmap: refactor logging macros and pipes Changelist: - Replace ND, D and RD macros with nm_prdis, nm_prinf, nm_prerr and nm_prlim, to avoid possible naming conflicts. - Add netmap_krings_mode_commit() helper function and use that to reduce code duplication. - Refactor pipes control code to export some functions that can be reused by the veth driver (on Linux) and epair(4). - Add check to reject API requests with version less than 11. - Small code refactoring for the null adapter. MFC after: 1 week --- sys/dev/netmap/if_ptnet.c | 55 ++-- sys/dev/netmap/if_vtnet_netmap.h | 46 +--- sys/dev/netmap/netmap.c | 82 +++--- sys/dev/netmap/netmap_bdg.c | 60 ++--- sys/dev/netmap/netmap_freebsd.c | 2 - sys/dev/netmap/netmap_generic.c | 27 +- sys/dev/netmap/netmap_kern.h | 27 +- sys/dev/netmap/netmap_legacy.c | 13 +- sys/dev/netmap/netmap_mem2.c | 62 ++--- sys/dev/netmap/netmap_monitor.c | 43 ++- sys/dev/netmap/netmap_null.c | 22 +- sys/dev/netmap/netmap_offloadings.c | 46 ++-- sys/dev/netmap/netmap_pipe.c | 391 +++++++++++++++------------- sys/dev/netmap/netmap_vale.c | 51 ++-- 14 files changed, 436 insertions(+), 491 deletions(-) diff --git a/sys/dev/netmap/if_ptnet.c b/sys/dev/netmap/if_ptnet.c index 02f91ee3d888..5ba34aa67600 100644 --- a/sys/dev/netmap/if_ptnet.c +++ b/sys/dev/netmap/if_ptnet.c @@ -1151,10 +1151,10 @@ ptnet_sync_from_csb(struct ptnet_softc *sc, struct netmap_adapter *na) kring->nr_hwtail = kring->rtail = kring->ring->tail = ktoa->hwtail; - ND("%d,%d: csb {hc %u h %u c %u ht %u}", t, i, + nm_prdis("%d,%d: csb {hc %u h %u c %u ht %u}", t, i, ktoa->hwcur, atok->head, atok->cur, ktoa->hwtail); - ND("%d,%d: kring {hc %u rh %u rc %u h %u c %u ht %u rt %u t %u}", + nm_prdis("%d,%d: kring {hc %u rh %u rc %u h %u c %u ht %u rt %u t %u}", t, i, kring->nr_hwcur, kring->rhead, kring->rcur, kring->ring->head, kring->ring->cur, kring->nr_hwtail, kring->rtail, kring->ring->tail); @@ -1179,7 +1179,6 @@ ptnet_nm_register(struct netmap_adapter *na, int onoff) struct ptnet_softc *sc = if_getsoftc(ifp); int native = (na == &sc->ptna->hwup.up); struct ptnet_queue *pq; - enum txrx t; int ret = 0; int i; @@ -1194,7 +1193,7 @@ ptnet_nm_register(struct netmap_adapter *na, int onoff) * in the RX rings, since we will not receive further interrupts * until these will be processed. */ if (native && !onoff && na->active_fds == 0) { - D("Exit netmap mode, re-enable interrupts"); + nm_prinf("Exit netmap mode, re-enable interrupts"); for (i = 0; i < sc->num_rings; i++) { pq = sc->queues + i; pq->atok->appl_need_kick = 1; @@ -1230,30 +1229,14 @@ ptnet_nm_register(struct netmap_adapter *na, int onoff) /* If not native, don't call nm_set_native_flags, since we don't want * to replace if_transmit method, nor set NAF_NETMAP_ON */ if (native) { - for_rx_tx(t) { - for (i = 0; i <= nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_on(kring)) { - kring->nr_mode = NKR_NETMAP_ON; - } - } - } + netmap_krings_mode_commit(na, onoff); nm_set_native_flags(na); } } else { if (native) { nm_clear_native_flags(na); - for_rx_tx(t) { - for (i = 0; i <= nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_off(kring)) { - kring->nr_mode = NKR_NETMAP_OFF; - } - } - } + netmap_krings_mode_commit(na, onoff); } if (sc->ptna->backend_users == 0) { @@ -1728,7 +1711,7 @@ ptnet_drain_transmit_queue(struct ptnet_queue *pq, unsigned int budget, if (!PTNET_Q_TRYLOCK(pq)) { /* We failed to acquire the lock, schedule the taskqueue. */ - RD(1, "Deferring TX work"); + nm_prlim(1, "Deferring TX work"); if (may_resched) { taskqueue_enqueue(pq->taskq, &pq->task); } @@ -1738,7 +1721,7 @@ ptnet_drain_transmit_queue(struct ptnet_queue *pq, unsigned int budget, if (unlikely(!(ifp->if_drv_flags & IFF_DRV_RUNNING))) { PTNET_Q_UNLOCK(pq); - RD(1, "Interface is down"); + nm_prlim(1, "Interface is down"); return ENETDOWN; } @@ -1776,7 +1759,7 @@ ptnet_drain_transmit_queue(struct ptnet_queue *pq, unsigned int budget, break; } - RD(1, "Found more slots by doublecheck"); + nm_prlim(1, "Found more slots by doublecheck"); /* More slots were freed before reactivating * the interrupts. */ atok->appl_need_kick = 0; @@ -1815,7 +1798,7 @@ ptnet_drain_transmit_queue(struct ptnet_queue *pq, unsigned int budget, continue; } } - ND(1, "%s: [csum_flags %lX] vnet hdr: flags %x " + nm_prdis(1, "%s: [csum_flags %lX] vnet hdr: flags %x " "csum_start %u csum_ofs %u hdr_len = %u " "gso_size %u gso_type %x", __func__, mhead->m_pkthdr.csum_flags, vh->flags, @@ -1890,7 +1873,7 @@ ptnet_drain_transmit_queue(struct ptnet_queue *pq, unsigned int budget, } if (count >= budget && may_resched) { - DBG(RD(1, "out of budget: resched, %d mbufs pending\n", + DBG(nm_prlim(1, "out of budget: resched, %d mbufs pending\n", drbr_inuse(ifp, pq->bufring))); taskqueue_enqueue(pq->taskq, &pq->task); } @@ -1932,7 +1915,7 @@ ptnet_transmit(if_t ifp, struct mbuf *m) err = drbr_enqueue(ifp, pq->bufring, m); if (err) { /* ENOBUFS when the bufring is full */ - RD(1, "%s: drbr_enqueue() failed %d\n", + nm_prlim(1, "%s: drbr_enqueue() failed %d\n", __func__, err); pq->stats.errors ++; return err; @@ -2077,13 +2060,13 @@ ptnet_rx_eof(struct ptnet_queue *pq, unsigned int budget, bool may_resched) /* There is no good reason why host should * put the header in multiple netmap slots. * If this is the case, discard. */ - RD(1, "Fragmented vnet-hdr: dropping"); + nm_prlim(1, "Fragmented vnet-hdr: dropping"); head = ptnet_rx_discard(kring, head); pq->stats.iqdrops ++; deliver = 0; goto skip; } - ND(1, "%s: vnet hdr: flags %x csum_start %u " + nm_prdis(1, "%s: vnet hdr: flags %x csum_start %u " "csum_ofs %u hdr_len = %u gso_size %u " "gso_type %x", __func__, vh->flags, vh->csum_start, vh->csum_offset, vh->hdr_len, @@ -2147,7 +2130,7 @@ ptnet_rx_eof(struct ptnet_queue *pq, unsigned int budget, bool may_resched) /* The very last slot prepared by the host has * the NS_MOREFRAG set. Drop it and continue * the outer cycle (to do the double-check). */ - RD(1, "Incomplete packet: dropping"); + nm_prlim(1, "Incomplete packet: dropping"); m_freem(mhead); pq->stats.iqdrops ++; goto host_sync; @@ -2185,7 +2168,7 @@ ptnet_rx_eof(struct ptnet_queue *pq, unsigned int budget, bool may_resched) | VIRTIO_NET_HDR_F_DATA_VALID))) { if (unlikely(ptnet_rx_csum(mhead, vh))) { m_freem(mhead); - RD(1, "Csum offload error: dropping"); + nm_prlim(1, "Csum offload error: dropping"); pq->stats.iqdrops ++; deliver = 0; } @@ -2231,7 +2214,7 @@ ptnet_rx_eof(struct ptnet_queue *pq, unsigned int budget, bool may_resched) if (count >= budget && may_resched) { /* If we ran out of budget or the double-check found new * slots to process, schedule the taskqueue. */ - DBG(RD(1, "out of budget: resched h %u t %u\n", + DBG(nm_prlim(1, "out of budget: resched h %u t %u\n", head, ring->tail)); taskqueue_enqueue(pq->taskq, &pq->task); } @@ -2246,7 +2229,7 @@ ptnet_rx_task(void *context, int pending) { struct ptnet_queue *pq = context; - DBG(RD(1, "%s: pq #%u\n", __func__, pq->kring_id)); + DBG(nm_prlim(1, "%s: pq #%u\n", __func__, pq->kring_id)); ptnet_rx_eof(pq, PTNET_RX_BUDGET, true); } @@ -2255,7 +2238,7 @@ ptnet_tx_task(void *context, int pending) { struct ptnet_queue *pq = context; - DBG(RD(1, "%s: pq #%u\n", __func__, pq->kring_id)); + DBG(nm_prlim(1, "%s: pq #%u\n", __func__, pq->kring_id)); ptnet_drain_transmit_queue(pq, PTNET_TX_BUDGET, true); } @@ -2273,7 +2256,7 @@ ptnet_poll(if_t ifp, enum poll_cmd cmd, int budget) KASSERT(sc->num_rings > 0, ("Found no queues in while polling ptnet")); queue_budget = MAX(budget / sc->num_rings, 1); - RD(1, "Per-queue budget is %d", queue_budget); + nm_prlim(1, "Per-queue budget is %d", queue_budget); while (budget) { unsigned int rcnt = 0; diff --git a/sys/dev/netmap/if_vtnet_netmap.h b/sys/dev/netmap/if_vtnet_netmap.h index 65ab77383fe0..1d17c02ef753 100644 --- a/sys/dev/netmap/if_vtnet_netmap.h +++ b/sys/dev/netmap/if_vtnet_netmap.h @@ -90,7 +90,6 @@ vtnet_netmap_reg(struct netmap_adapter *na, int state) struct ifnet *ifp = na->ifp; struct vtnet_softc *sc = ifp->if_softc; int success; - enum txrx t; int i; /* Drain the taskqueues to make sure that there are no worker threads @@ -132,44 +131,11 @@ vtnet_netmap_reg(struct netmap_adapter *na, int state) success = (ifp->if_drv_flags & IFF_DRV_RUNNING) ? 0 : ENXIO; if (state) { - for_rx_tx(t) { - /* Hardware rings. */ - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_on(kring)) - kring->nr_mode = NKR_NETMAP_ON; - } - - /* Host rings. */ - for (i = 0; i < nma_get_host_nrings(na, t); i++) { - struct netmap_kring *kring = - NMR(na, t)[nma_get_nrings(na, t) + i]; - - if (nm_kring_pending_on(kring)) - kring->nr_mode = NKR_NETMAP_ON; - } - } + netmap_krings_mode_commit(na, state); + nm_set_native_flags(na); } else { nm_clear_native_flags(na); - for_rx_tx(t) { - /* Hardware rings. */ - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_off(kring)) - kring->nr_mode = NKR_NETMAP_OFF; - } - - /* Host rings. */ - for (i = 0; i < nma_get_host_nrings(na, t); i++) { - struct netmap_kring *kring = - NMR(na, t)[nma_get_nrings(na, t) + i]; - - if (nm_kring_pending_off(kring)) - kring->nr_mode = NKR_NETMAP_OFF; - } - } + netmap_krings_mode_commit(na, state); } VTNET_CORE_UNLOCK(sc); @@ -396,7 +362,7 @@ vtnet_netmap_rxsync(struct netmap_kring *kring, int flags) /* Skip the virtio-net header. */ len -= sc->vtnet_hdr_size; if (unlikely(len < 0)) { - RD(1, "Truncated virtio-net-header, " + nm_prlim(1, "Truncated virtio-net-header, " "missing %d bytes", -len); len = 0; } @@ -408,7 +374,7 @@ vtnet_netmap_rxsync(struct netmap_kring *kring, int flags) kring->nr_hwtail = nm_i; kring->nr_kflags &= ~NKR_PENDINTR; } - ND("[B] h %d c %d hwcur %d hwtail %d", ring->head, ring->cur, + nm_prdis("[B] h %d c %d hwcur %d hwtail %d", ring->head, ring->cur, kring->nr_hwcur, kring->nr_hwtail); /* @@ -423,7 +389,7 @@ vtnet_netmap_rxsync(struct netmap_kring *kring, int flags) virtqueue_notify(vq); } - ND("[C] h %d c %d t %d hwcur %d hwtail %d", ring->head, ring->cur, + nm_prdis("[C] h %d c %d t %d hwcur %d hwtail %d", ring->head, ring->cur, ring->tail, kring->nr_hwcur, kring->nr_hwtail); return 0; diff --git a/sys/dev/netmap/netmap.c b/sys/dev/netmap/netmap.c index 61739bec59ee..993c63da06c2 100644 --- a/sys/dev/netmap/netmap.c +++ b/sys/dev/netmap/netmap.c @@ -893,7 +893,7 @@ netmap_krings_create(struct netmap_adapter *na, u_int tailroom) kring->rtail = kring->nr_hwtail = (t == NR_TX ? ndesc - 1 : 0); snprintf(kring->name, sizeof(kring->name) - 1, "%s %s%d", na->name, nm_txrx2str(t), i); - ND("ktx %s h %d c %d t %d", + nm_prdis("ktx %s h %d c %d t %d", kring->name, kring->rhead, kring->rcur, kring->rtail); err = nm_os_selinfo_init(&kring->si, kring->name); if (err) { @@ -955,7 +955,7 @@ netmap_hw_krings_delete(struct netmap_adapter *na) for (i = nma_get_nrings(na, NR_RX); i < lim; i++) { struct mbq *q = &NMR(na, NR_RX)[i]->rx_queue; - ND("destroy sw mbq with len %d", mbq_len(q)); + nm_prdis("destroy sw mbq with len %d", mbq_len(q)); mbq_purge(q); mbq_safe_fini(q); } @@ -1176,7 +1176,7 @@ netmap_grab_packets(struct netmap_kring *kring, struct mbq *q, int force) if ((slot->flags & NS_FORWARD) == 0 && !force) continue; if (slot->len < 14 || slot->len > NETMAP_BUF_SIZE(na)) { - RD(5, "bad pkt at %d len %d", n, slot->len); + nm_prlim(5, "bad pkt at %d len %d", n, slot->len); continue; } slot->flags &= ~NS_FORWARD; // XXX needed ? @@ -1290,7 +1290,7 @@ netmap_txsync_to_host(struct netmap_kring *kring, int flags) */ mbq_init(&q); netmap_grab_packets(kring, &q, 1 /* force */); - ND("have %d pkts in queue", mbq_len(&q)); + nm_prdis("have %d pkts in queue", mbq_len(&q)); kring->nr_hwcur = head; kring->nr_hwtail = head + lim; if (kring->nr_hwtail > lim) @@ -1338,7 +1338,7 @@ netmap_rxsync_from_host(struct netmap_kring *kring, int flags) struct netmap_slot *slot = &ring->slot[nm_i]; m_copydata(m, 0, len, NMB(na, slot)); - ND("nm %d len %d", nm_i, len); + nm_prdis("nm %d len %d", nm_i, len); if (netmap_debug & NM_DEBUG_HOST) nm_prinf("%s", nm_dump_buf(NMB(na, slot),len, 128, NULL)); @@ -1603,7 +1603,7 @@ netmap_unget_na(struct netmap_adapter *na, struct ifnet *ifp) #define NM_FAIL_ON(t) do { \ if (unlikely(t)) { \ - RD(5, "%s: fail '" #t "' " \ + nm_prlim(5, "%s: fail '" #t "' " \ "h %d c %d t %d " \ "rh %d rc %d rt %d " \ "hc %d ht %d", \ @@ -1635,7 +1635,7 @@ nm_txsync_prologue(struct netmap_kring *kring, struct netmap_ring *ring) u_int cur = ring->cur; /* read only once */ u_int n = kring->nkr_num_slots; - ND(5, "%s kcur %d ktail %d head %d cur %d tail %d", + nm_prdis(5, "%s kcur %d ktail %d head %d cur %d tail %d", kring->name, kring->nr_hwcur, kring->nr_hwtail, ring->head, ring->cur, ring->tail); @@ -1671,7 +1671,7 @@ nm_txsync_prologue(struct netmap_kring *kring, struct netmap_ring *ring) } } if (ring->tail != kring->rtail) { - RD(5, "%s tail overwritten was %d need %d", kring->name, + nm_prlim(5, "%s tail overwritten was %d need %d", kring->name, ring->tail, kring->rtail); ring->tail = kring->rtail; } @@ -1698,7 +1698,7 @@ nm_rxsync_prologue(struct netmap_kring *kring, struct netmap_ring *ring) uint32_t const n = kring->nkr_num_slots; uint32_t head, cur; - ND(5,"%s kc %d kt %d h %d c %d t %d", + nm_prdis(5,"%s kc %d kt %d h %d c %d t %d", kring->name, kring->nr_hwcur, kring->nr_hwtail, ring->head, ring->cur, ring->tail); @@ -1733,7 +1733,7 @@ nm_rxsync_prologue(struct netmap_kring *kring, struct netmap_ring *ring) } } if (ring->tail != kring->rtail) { - RD(5, "%s tail overwritten was %d need %d", + nm_prlim(5, "%s tail overwritten was %d need %d", kring->name, ring->tail, kring->rtail); ring->tail = kring->rtail; @@ -1762,7 +1762,7 @@ netmap_ring_reinit(struct netmap_kring *kring) int errors = 0; // XXX KASSERT nm_kr_tryget - RD(10, "called for %s", kring->name); + nm_prlim(10, "called for %s", kring->name); // XXX probably wrong to trust userspace kring->rhead = ring->head; kring->rcur = ring->cur; @@ -1778,17 +1778,17 @@ netmap_ring_reinit(struct netmap_kring *kring) u_int idx = ring->slot[i].buf_idx; u_int len = ring->slot[i].len; if (idx < 2 || idx >= kring->na->na_lut.objtotal) { - RD(5, "bad index at slot %d idx %d len %d ", i, idx, len); + nm_prlim(5, "bad index at slot %d idx %d len %d ", i, idx, len); ring->slot[i].buf_idx = 0; ring->slot[i].len = 0; } else if (len > NETMAP_BUF_SIZE(kring->na)) { ring->slot[i].len = 0; - RD(5, "bad len at slot %d idx %d len %d", i, idx, len); + nm_prlim(5, "bad len at slot %d idx %d len %d", i, idx, len); } } if (errors) { - RD(10, "total %d errors", errors); - RD(10, "%s reinit, cur %d -> %d tail %d -> %d", + nm_prlim(10, "total %d errors", errors); + nm_prlim(10, "%s reinit, cur %d -> %d tail %d -> %d", kring->name, ring->cur, kring->nr_hwcur, ring->tail, kring->nr_hwtail); @@ -1825,7 +1825,7 @@ netmap_interp_ringid(struct netmap_priv_d *priv, uint32_t nr_mode, case NR_REG_NULL: priv->np_qfirst[t] = 0; priv->np_qlast[t] = nma_get_nrings(na, t); - ND("ALL/PIPE: %s %d %d", nm_txrx2str(t), + nm_prdis("ALL/PIPE: %s %d %d", nm_txrx2str(t), priv->np_qfirst[t], priv->np_qlast[t]); break; case NR_REG_SW: @@ -1837,7 +1837,7 @@ netmap_interp_ringid(struct netmap_priv_d *priv, uint32_t nr_mode, priv->np_qfirst[t] = (nr_mode == NR_REG_SW ? nma_get_nrings(na, t) : 0); priv->np_qlast[t] = netmap_all_rings(na, t); - ND("%s: %s %d %d", nr_mode == NR_REG_SW ? "SW" : "NIC+SW", + nm_prdis("%s: %s %d %d", nr_mode == NR_REG_SW ? "SW" : "NIC+SW", nm_txrx2str(t), priv->np_qfirst[t], priv->np_qlast[t]); break; @@ -1853,7 +1853,7 @@ netmap_interp_ringid(struct netmap_priv_d *priv, uint32_t nr_mode, j = 0; priv->np_qfirst[t] = j; priv->np_qlast[t] = j + 1; - ND("ONE_NIC: %s %d %d", nm_txrx2str(t), + nm_prdis("ONE_NIC: %s %d %d", nm_txrx2str(t), priv->np_qfirst[t], priv->np_qlast[t]); break; default: @@ -1962,7 +1962,7 @@ netmap_krings_get(struct netmap_priv_d *priv) if ((kring->nr_kflags & NKR_EXCLUSIVE) || (kring->users && excl)) { - ND("ring %s busy", kring->name); + nm_prdis("ring %s busy", kring->name); return EBUSY; } } @@ -1997,7 +1997,7 @@ netmap_krings_put(struct netmap_priv_d *priv) int excl = (priv->np_flags & NR_EXCLUSIVE); enum txrx t; - ND("%s: releasing tx [%d, %d) rx [%d, %d)", + nm_prdis("%s: releasing tx [%d, %d) rx [%d, %d)", na->name, priv->np_qfirst[NR_TX], priv->np_qlast[NR_TX], @@ -2262,7 +2262,7 @@ netmap_do_regif(struct netmap_priv_d *priv, struct netmap_adapter *na, error = netmap_mem_get_lut(na->nm_mem, &na->na_lut); if (error) goto err_drop_mem; - ND("lut %p bufs %u size %u", na->na_lut.lut, na->na_lut.objtotal, + nm_prdis("lut %p bufs %u size %u", na->na_lut.lut, na->na_lut.objtotal, na->na_lut.objsize); /* ring configuration may have changed, fetch from the card */ @@ -2284,7 +2284,7 @@ netmap_do_regif(struct netmap_priv_d *priv, struct netmap_adapter *na, /* This netmap adapter is attached to an ifnet. */ unsigned mtu = nm_os_ifnet_mtu(na->ifp); - ND("%s: mtu %d rx_buf_maxsize %d netmap_buf_size %d", + nm_prdis("%s: mtu %d rx_buf_maxsize %d netmap_buf_size %d", na->name, mtu, na->rx_buf_maxsize, NETMAP_BUF_SIZE(na)); if (na->rx_buf_maxsize == 0) { @@ -2381,7 +2381,7 @@ nm_sync_finalize(struct netmap_kring *kring) */ kring->ring->tail = kring->rtail = kring->nr_hwtail; - ND(5, "%s now hwcur %d hwtail %d head %d cur %d tail %d", + nm_prdis(5, "%s now hwcur %d hwtail %d head %d cur %d tail %d", kring->name, kring->nr_hwcur, kring->nr_hwtail, kring->rhead, kring->rcur, kring->rtail); } @@ -3711,7 +3711,8 @@ netmap_attach_ext(struct netmap_adapter *arg, size_t size, int override_reg) hwna->up.nm_dtor = netmap_hw_dtor; } - if_printf(ifp, "netmap queues/slots: TX %d/%d, RX %d/%d\n", + nm_prinf("%s: netmap queues/slots: TX %d/%d, RX %d/%d\n", + hwna->up.name, hwna->up.num_tx_rings, hwna->up.num_tx_desc, hwna->up.num_rx_rings, hwna->up.num_rx_desc); return 0; @@ -3779,7 +3780,7 @@ netmap_hw_krings_create(struct netmap_adapter *na) for (i = na->num_rx_rings; i < lim; i++) { mbq_safe_init(&NMR(na, NR_RX)[i]->rx_queue); } - ND("initialized sw rx queue %d", na->num_rx_rings); + nm_prdis("initialized sw rx queue %d", na->num_rx_rings); } return ret; } @@ -3880,13 +3881,13 @@ netmap_transmit(struct ifnet *ifp, struct mbuf *m) if (!netmap_generic_hwcsum) { if (nm_os_mbuf_has_csum_offld(m)) { - RD(1, "%s drop mbuf that needs checksum offload", na->name); + nm_prlim(1, "%s drop mbuf that needs checksum offload", na->name); goto done; } } if (nm_os_mbuf_has_seg_offld(m)) { - RD(1, "%s drop mbuf that needs generic segmentation offload", na->name); + nm_prlim(1, "%s drop mbuf that needs generic segmentation offload", na->name); goto done; } @@ -3906,11 +3907,11 @@ netmap_transmit(struct ifnet *ifp, struct mbuf *m) if (busy < 0) busy += kring->nkr_num_slots; if (busy + mbq_len(q) >= kring->nkr_num_slots - 1) { - RD(2, "%s full hwcur %d hwtail %d qlen %d", na->name, + nm_prlim(2, "%s full hwcur %d hwtail %d qlen %d", na->name, kring->nr_hwcur, kring->nr_hwtail, mbq_len(q)); } else { mbq_enqueue(q, m); - ND(2, "%s %d bufs in queue", na->name, mbq_len(q)); + nm_prdis(2, "%s %d bufs in queue", na->name, mbq_len(q)); /* notify outside the lock */ m = NULL; error = 0; @@ -3946,7 +3947,7 @@ netmap_reset(struct netmap_adapter *na, enum txrx tx, u_int n, int new_hwofs, lim; if (!nm_native_on(na)) { - ND("interface not in native netmap mode"); + nm_prdis("interface not in native netmap mode"); return NULL; /* nothing to reinitialize */ } @@ -4088,7 +4089,7 @@ netmap_rx_irq(struct ifnet *ifp, u_int q, u_int *work_done) return NM_IRQ_PASS; if (na->na_flags & NAF_SKIP_INTR) { - ND("use regular interrupt"); + nm_prdis("use regular interrupt"); return NM_IRQ_PASS; } @@ -4129,6 +4130,25 @@ nm_clear_native_flags(struct netmap_adapter *na) na->na_flags &= ~NAF_NETMAP_ON; } +void +netmap_krings_mode_commit(struct netmap_adapter *na, int onoff) +{ + enum txrx t; + + for_rx_tx(t) { + int i; + + for (i = 0; i < netmap_real_rings(na, t); i++) { + struct netmap_kring *kring = NMR(na, t)[i]; + + if (onoff && nm_kring_pending_on(kring)) + kring->nr_mode = NKR_NETMAP_ON; + else if (!onoff && nm_kring_pending_off(kring)) + kring->nr_mode = NKR_NETMAP_OFF; + } + } +} + /* * Module loader and unloader * diff --git a/sys/dev/netmap/netmap_bdg.c b/sys/dev/netmap/netmap_bdg.c index 1ad57f31654a..41faa1b5b56f 100644 --- a/sys/dev/netmap/netmap_bdg.c +++ b/sys/dev/netmap/netmap_bdg.c @@ -203,14 +203,14 @@ nm_find_bridge(const char *name, int create, struct netmap_bdg_ops *ops) } else if (x->bdg_namelen != namelen) { continue; } else if (strncmp(name, x->bdg_basename, namelen) == 0) { - ND("found '%.*s' at %d", namelen, name, i); + nm_prdis("found '%.*s' at %d", namelen, name, i); b = x; break; } } if (i == num_bridges && b) { /* name not found, can create entry */ /* initialize the bridge */ - ND("create new bridge %s with ports %d", b->bdg_basename, + nm_prdis("create new bridge %s with ports %d", b->bdg_basename, b->bdg_active_ports); b->ht = nm_os_malloc(sizeof(struct nm_hash_ent) * NM_BDG_HASH); if (b->ht == NULL) { @@ -239,7 +239,7 @@ netmap_bdg_free(struct nm_bridge *b) return EBUSY; } - ND("marking bridge %s as free", b->bdg_basename); + nm_prdis("marking bridge %s as free", b->bdg_basename); nm_os_free(b->ht); memset(&b->bdg_ops, 0, sizeof(b->bdg_ops)); memset(&b->bdg_saved_ops, 0, sizeof(b->bdg_saved_ops)); @@ -312,13 +312,13 @@ netmap_bdg_detach_common(struct nm_bridge *b, int hw, int sw) memcpy(b->tmp_bdg_port_index, b->bdg_port_index, sizeof(b->tmp_bdg_port_index)); for (i = 0; (hw >= 0 || sw >= 0) && i < lim; ) { if (hw >= 0 && tmp[i] == hw) { - ND("detach hw %d at %d", hw, i); + nm_prdis("detach hw %d at %d", hw, i); lim--; /* point to last active port */ tmp[i] = tmp[lim]; /* swap with i */ tmp[lim] = hw; /* now this is inactive */ hw = -1; } else if (sw >= 0 && tmp[i] == sw) { - ND("detach sw %d at %d", sw, i); + nm_prdis("detach sw %d at %d", sw, i); lim--; tmp[i] = tmp[lim]; tmp[lim] = sw; @@ -342,7 +342,7 @@ netmap_bdg_detach_common(struct nm_bridge *b, int hw, int sw) b->bdg_active_ports = lim; BDG_WUNLOCK(b); - ND("now %d active ports", lim); + nm_prdis("now %d active ports", lim); netmap_bdg_free(b); } @@ -408,7 +408,7 @@ netmap_get_bdg_na(struct nmreq_header *hdr, struct netmap_adapter **na, b = nm_find_bridge(nr_name, create, ops); if (b == NULL) { - ND("no bridges available for '%s'", nr_name); + nm_prdis("no bridges available for '%s'", nr_name); return (create ? ENOMEM : ENXIO); } if (strlen(nr_name) < b->bdg_namelen) /* impossible */ @@ -425,10 +425,10 @@ netmap_get_bdg_na(struct nmreq_header *hdr, struct netmap_adapter **na, for (j = 0; j < b->bdg_active_ports; j++) { i = b->bdg_port_index[j]; vpna = b->bdg_ports[i]; - ND("checking %s", vpna->up.name); + nm_prdis("checking %s", vpna->up.name); if (!strcmp(vpna->up.name, nr_name)) { netmap_adapter_get(&vpna->up); - ND("found existing if %s refs %d", nr_name) + nm_prdis("found existing if %s refs %d", nr_name) *na = &vpna->up; return 0; } @@ -445,7 +445,7 @@ netmap_get_bdg_na(struct nmreq_header *hdr, struct netmap_adapter **na, /* record the next two ports available, but do not allocate yet */ cand = b->bdg_port_index[b->bdg_active_ports]; cand2 = b->bdg_port_index[b->bdg_active_ports + 1]; - ND("+++ bridge %s port %s used %d avail %d %d", + nm_prdis("+++ bridge %s port %s used %d avail %d %d", b->bdg_basename, ifname, b->bdg_active_ports, cand, cand2); /* @@ -515,7 +515,7 @@ netmap_get_bdg_na(struct nmreq_header *hdr, struct netmap_adapter **na, BDG_WLOCK(b); vpna->bdg_port = cand; - ND("NIC %p to bridge port %d", vpna, cand); + nm_prdis("NIC %p to bridge port %d", vpna, cand); /* bind the port to the bridge (virtual ports are not active) */ b->bdg_ports[cand] = vpna; vpna->na_bdg = b; @@ -526,9 +526,9 @@ netmap_get_bdg_na(struct nmreq_header *hdr, struct netmap_adapter **na, hostna->bdg_port = cand2; hostna->na_bdg = b; b->bdg_active_ports++; - ND("host %p to bridge port %d", hostna, cand2); + nm_prdis("host %p to bridge port %d", hostna, cand2); } - ND("if %s refs %d", ifname, vpna->up.na_refcount); + nm_prdis("if %s refs %d", ifname, vpna->up.na_refcount); BDG_WUNLOCK(b); *na = &vpna->up; netmap_adapter_get(*na); @@ -920,8 +920,6 @@ netmap_vp_reg(struct netmap_adapter *na, int onoff) { struct netmap_vp_adapter *vpna = (struct netmap_vp_adapter*)na; - enum txrx t; - int i; /* persistent ports may be put in netmap mode * before being attached to a bridge @@ -929,14 +927,7 @@ netmap_vp_reg(struct netmap_adapter *na, int onoff) if (vpna->na_bdg) BDG_WLOCK(vpna->na_bdg); if (onoff) { - for_rx_tx(t) { - for (i = 0; i < netmap_real_rings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_on(kring)) - kring->nr_mode = NKR_NETMAP_ON; - } - } + netmap_krings_mode_commit(na, onoff); if (na->active_fds == 0) na->na_flags |= NAF_NETMAP_ON; /* XXX on FreeBSD, persistent VALE ports should also @@ -945,14 +936,7 @@ netmap_vp_reg(struct netmap_adapter *na, int onoff) } else { if (na->active_fds == 0) na->na_flags &= ~NAF_NETMAP_ON; - for_rx_tx(t) { - for (i = 0; i < netmap_real_rings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_off(kring)) - kring->nr_mode = NKR_NETMAP_OFF; - } - } + netmap_krings_mode_commit(na, onoff); } if (vpna->na_bdg) BDG_WUNLOCK(vpna->na_bdg); @@ -1077,7 +1061,7 @@ netmap_bwrap_dtor(struct netmap_adapter *na) (bh ? bna->host.bdg_port : -1)); } - ND("na %p", na); + nm_prdis("na %p", na); na->ifp = NULL; bna->host.up.ifp = NULL; hwna->na_vp = bna->saved_na_vp; @@ -1182,7 +1166,7 @@ netmap_bwrap_reg(struct netmap_adapter *na, int onoff) int error, i; enum txrx t; - ND("%s %s", na->name, onoff ? "on" : "off"); + nm_prdis("%s %s", na->name, onoff ? "on" : "off"); if (onoff) { /* netmap_do_regif has been called on the bwrap na. @@ -1387,7 +1371,7 @@ netmap_bwrap_krings_delete_common(struct netmap_adapter *na) enum txrx t; int i; - ND("%s", na->name); + nm_prdis("%s", na->name); /* decrement the usage counter for all the hwna krings */ for_rx_tx(t) { @@ -1414,7 +1398,7 @@ netmap_bwrap_notify(struct netmap_kring *kring, int flags) struct netmap_kring *hw_kring; int error; - ND("%s: na %s hwna %s", + nm_prdis("%s: na %s hwna %s", (kring ? kring->name : "NULL!"), (na ? na->name : "NULL!"), (hwna ? hwna->name : "NULL!")); @@ -1426,7 +1410,7 @@ netmap_bwrap_notify(struct netmap_kring *kring, int flags) /* first step: simulate a user wakeup on the rx ring */ netmap_vp_rxsync(kring, flags); - ND("%s[%d] PRE rx(c%3d t%3d l%3d) ring(h%3d c%3d t%3d) tx(c%3d ht%3d t%3d)", + nm_prdis("%s[%d] PRE rx(c%3d t%3d l%3d) ring(h%3d c%3d t%3d) tx(c%3d ht%3d t%3d)", na->name, ring_n, kring->nr_hwcur, kring->nr_hwtail, kring->nkr_hwlease, kring->rhead, kring->rcur, kring->rtail, @@ -1445,7 +1429,7 @@ netmap_bwrap_notify(struct netmap_kring *kring, int flags) /* fourth step: the user goes to sleep again, causing another rxsync */ netmap_vp_rxsync(kring, flags); - ND("%s[%d] PST rx(c%3d t%3d l%3d) ring(h%3d c%3d t%3d) tx(c%3d ht%3d t%3d)", + nm_prdis("%s[%d] PST rx(c%3d t%3d l%3d) ring(h%3d c%3d t%3d) tx(c%3d ht%3d t%3d)", na->name, ring_n, kring->nr_hwcur, kring->nr_hwtail, kring->nkr_hwlease, kring->rhead, kring->rcur, kring->rtail, @@ -1595,7 +1579,7 @@ netmap_bwrap_attach_common(struct netmap_adapter *na, if (hwna->na_flags & NAF_MOREFRAG) na->na_flags |= NAF_MOREFRAG; - ND("%s<->%s txr %d txd %d rxr %d rxd %d", + nm_prdis("%s<->%s txr %d txd %d rxr %d rxd %d", na->name, ifp->if_xname, na->num_tx_rings, na->num_tx_desc, na->num_rx_rings, na->num_rx_desc); diff --git a/sys/dev/netmap/netmap_freebsd.c b/sys/dev/netmap/netmap_freebsd.c index f94083f7d044..d99e526f3d10 100644 --- a/sys/dev/netmap/netmap_freebsd.c +++ b/sys/dev/netmap/netmap_freebsd.c @@ -1350,8 +1350,6 @@ nm_os_kctx_destroy(struct nm_kctx *nmk) void nm_os_selwakeup(struct nm_selinfo *si) { - if (netmap_verbose) - nm_prinf("on knote %p", &si->si.si_note); selwakeuppri(&si->si, PI_NET); taskqueue_enqueue(si->ntfytq, &si->ntfytask); } diff --git a/sys/dev/netmap/netmap_generic.c b/sys/dev/netmap/netmap_generic.c index dd90734b9458..e5a2499a595d 100644 --- a/sys/dev/netmap/netmap_generic.c +++ b/sys/dev/netmap/netmap_generic.c @@ -237,18 +237,7 @@ generic_netmap_unregister(struct netmap_adapter *na) nm_os_catch_tx(gna, 0); } - for_each_rx_kring_h(r, kring, na) { - if (nm_kring_pending_off(kring)) { - nm_prinf("Emulated adapter: ring '%s' deactivated", kring->name); - kring->nr_mode = NKR_NETMAP_OFF; - } - } - for_each_tx_kring_h(r, kring, na) { - if (nm_kring_pending_off(kring)) { - kring->nr_mode = NKR_NETMAP_OFF; - nm_prinf("Emulated adapter: ring '%s' deactivated", kring->name); - } - } + netmap_krings_mode_commit(na, /*onoff=*/0); for_each_rx_kring(r, kring, na) { /* Free the mbufs still pending in the RX queues, @@ -371,19 +360,7 @@ generic_netmap_register(struct netmap_adapter *na, int enable) } } - for_each_rx_kring_h(r, kring, na) { - if (nm_kring_pending_on(kring)) { - nm_prinf("Emulated adapter: ring '%s' activated", kring->name); - kring->nr_mode = NKR_NETMAP_ON; - } - - } - for_each_tx_kring_h(r, kring, na) { - if (nm_kring_pending_on(kring)) { - nm_prinf("Emulated adapter: ring '%s' activated", kring->name); - kring->nr_mode = NKR_NETMAP_ON; - } - } + netmap_krings_mode_commit(na, /*onoff=*/1); for_each_tx_kring(r, kring, na) { /* Initialize tx_pool and tx_event. */ diff --git a/sys/dev/netmap/netmap_kern.h b/sys/dev/netmap/netmap_kern.h index 3f4b00d814f4..f8db7a38ac9c 100644 --- a/sys/dev/netmap/netmap_kern.h +++ b/sys/dev/netmap/netmap_kern.h @@ -271,7 +271,7 @@ typedef struct hrtimer{ __LINE__, __FUNCTION__, ##__VA_ARGS__); \ } while (0) -/* Disabled printf (used to be ND). */ +/* Disabled printf (used to be nm_prdis). */ #define nm_prdis(format, ...) /* Rate limited, lps indicates how many per second. */ @@ -286,11 +286,6 @@ typedef struct hrtimer{ nm_prinf(format, ##__VA_ARGS__); \ } while (0) -/* Old macros. */ -#define ND nm_prdis -#define D nm_prerr -#define RD nm_prlim - struct netmap_adapter; struct nm_bdg_fwd; struct nm_bridge; @@ -1149,7 +1144,7 @@ nm_kr_rxspace(struct netmap_kring *k) int space = k->nr_hwtail - k->nr_hwcur; if (space < 0) space += k->nkr_num_slots; - ND("preserving %d rx slots %d -> %d", space, k->nr_hwcur, k->nr_hwtail); + nm_prdis("preserving %d rx slots %d -> %d", space, k->nr_hwcur, k->nr_hwtail); return space; } @@ -1375,6 +1370,8 @@ nm_update_hostrings_mode(struct netmap_adapter *na) void nm_set_native_flags(struct netmap_adapter *); void nm_clear_native_flags(struct netmap_adapter *); +void netmap_krings_mode_commit(struct netmap_adapter *na, int onoff); + /* * nm_*sync_prologue() functions are used in ioctl/poll and ptnetmap * kthreads. @@ -1402,7 +1399,7 @@ uint32_t nm_rxsync_prologue(struct netmap_kring *, struct netmap_ring *); #if 1 /* debug version */ #define NM_CHECK_ADDR_LEN(_na, _a, _l) do { \ if (_a == NETMAP_BUF_BASE(_na) || _l > NETMAP_BUF_SIZE(_na)) { \ - RD(5, "bad addr/len ring %d slot %d idx %d len %d", \ + nm_prlim(5, "bad addr/len ring %d slot %d idx %d len %d", \ kring->ring_id, nm_i, slot->buf_idx, len); \ if (_l > NETMAP_BUF_SIZE(_na)) \ _l = NETMAP_BUF_SIZE(_na); \ @@ -1564,7 +1561,7 @@ void __netmap_adapter_get(struct netmap_adapter *na); #define netmap_adapter_get(na) \ do { \ struct netmap_adapter *__na = na; \ - D("getting %p:%s (%d)", __na, (__na)->name, (__na)->na_refcount); \ + nm_prinf("getting %p:%s (%d)", __na, (__na)->name, (__na)->na_refcount); \ __netmap_adapter_get(__na); \ } while (0) @@ -1573,7 +1570,7 @@ int __netmap_adapter_put(struct netmap_adapter *na); #define netmap_adapter_put(na) \ ({ \ struct netmap_adapter *__na = na; \ - D("putting %p:%s (%d)", __na, (__na)->name, (__na)->na_refcount); \ + nm_prinf("putting %p:%s (%d)", __na, (__na)->name, (__na)->na_refcount); \ __netmap_adapter_put(__na); \ }) @@ -1735,7 +1732,7 @@ int nm_iommu_group_id(bus_dma_tag_t dev); addr, NETMAP_BUF_SIZE, DMA_TO_DEVICE); if (dma_mapping_error(&adapter->pdev->dev, buffer_info->dma)) { - D("dma mapping error"); + nm_prerr("dma mapping error"); /* goto dma_error; See e1000_put_txbuf() */ /* XXX reset */ } @@ -1994,6 +1991,12 @@ nm_si_user(struct netmap_priv_d *priv, enum txrx t) #ifdef WITH_PIPES int netmap_pipe_txsync(struct netmap_kring *txkring, int flags); int netmap_pipe_rxsync(struct netmap_kring *rxkring, int flags); +int netmap_pipe_krings_create_both(struct netmap_adapter *na, + struct netmap_adapter *ona); +void netmap_pipe_krings_delete_both(struct netmap_adapter *na, + struct netmap_adapter *ona); +int netmap_pipe_reg_both(struct netmap_adapter *na, + struct netmap_adapter *ona); #endif /* WITH_PIPES */ #ifdef WITH_MONITOR @@ -2328,7 +2331,7 @@ nm_os_get_mbuf(struct ifnet *ifp, int len) m->m_ext.ext_arg1 = m->m_ext.ext_buf; // XXX save m->m_ext.ext_free = (void *)void_mbuf_dtor; m->m_ext.ext_type = EXT_EXTREF; - ND(5, "create m %p refcnt %d", m, MBUF_REFCNT(m)); + nm_prdis(5, "create m %p refcnt %d", m, MBUF_REFCNT(m)); } return m; } diff --git a/sys/dev/netmap/netmap_legacy.c b/sys/dev/netmap/netmap_legacy.c index 9159c1bce4c8..afbd5ced8510 100644 --- a/sys/dev/netmap/netmap_legacy.c +++ b/sys/dev/netmap/netmap_legacy.c @@ -365,7 +365,14 @@ netmap_ioctl_legacy(struct netmap_priv_d *priv, u_long cmd, caddr_t data, /* Request for the legacy control API. Convert it to a * NIOCCTRL request. */ struct nmreq *nmr = (struct nmreq *) data; - struct nmreq_header *hdr = nmreq_from_legacy(nmr, cmd); + struct nmreq_header *hdr; + + if (nmr->nr_version < 11) { + nm_prerr("Minimum supported API is 11 (requested %u)", + nmr->nr_version); + return EINVAL; + } + hdr = nmreq_from_legacy(nmr, cmd); if (hdr == NULL) { /* out of memory */ return ENOMEM; } @@ -390,14 +397,14 @@ netmap_ioctl_legacy(struct netmap_priv_d *priv, u_long cmd, caddr_t data, #ifdef __FreeBSD__ case FIONBIO: case FIOASYNC: - ND("FIONBIO/FIOASYNC are no-ops"); + /* FIONBIO/FIOASYNC are no-ops. */ break; case BIOCIMMEDIATE: case BIOCGHDRCMPLT: case BIOCSHDRCMPLT: case BIOCSSEESENT: - D("ignore BIOCIMMEDIATE/BIOCSHDRCMPLT/BIOCSHDRCMPLT/BIOCSSEESENT"); + /* Ignore these commands. */ break; default: /* allow device-specific ioctls */ diff --git a/sys/dev/netmap/netmap_mem2.c b/sys/dev/netmap/netmap_mem2.c index f504525cee02..8aa7e3f46409 100644 --- a/sys/dev/netmap/netmap_mem2.c +++ b/sys/dev/netmap/netmap_mem2.c @@ -979,7 +979,7 @@ netmap_obj_offset(struct netmap_obj_pool *p, const void *vaddr) continue; ofs = ofs + relofs; - ND("%s: return offset %d (cluster %d) for pointer %p", + nm_prdis("%s: return offset %d (cluster %d) for pointer %p", p->name, ofs, i, vaddr); return ofs; } @@ -1043,7 +1043,7 @@ netmap_obj_malloc(struct netmap_obj_pool *p, u_int len, uint32_t *start, uint32_ if (index) *index = i * 32 + j; } - ND("%s allocator: allocated object @ [%d][%d]: vaddr %p",p->name, i, j, vaddr); + nm_prdis("%s allocator: allocated object @ [%d][%d]: vaddr %p",p->name, i, j, vaddr); if (start) *start = i; @@ -1143,7 +1143,7 @@ netmap_extra_alloc(struct netmap_adapter *na, uint32_t *head, uint32_t n) *head = cur; /* restore */ break; } - ND(5, "allocate buffer %d -> %d", *head, cur); + nm_prdis(5, "allocate buffer %d -> %d", *head, cur); *p = cur; /* link to previous head */ } @@ -1160,7 +1160,7 @@ netmap_extra_free(struct netmap_adapter *na, uint32_t head) struct netmap_obj_pool *p = &nmd->pools[NETMAP_BUF_POOL]; uint32_t i, cur, *buf; - ND("freeing the extra list"); + nm_prdis("freeing the extra list"); for (i = 0; head >=2 && head < p->objtotal; i++) { cur = head; buf = lut[head].vaddr; @@ -1197,7 +1197,7 @@ netmap_new_bufs(struct netmap_mem_d *nmd, struct netmap_slot *slot, u_int n) slot[i].ptr = 0; } - ND("%s: allocated %d buffers, %d available, first at %d", p->name, n, p->objfree, pos); + nm_prdis("%s: allocated %d buffers, %d available, first at %d", p->name, n, p->objfree, pos); return (0); cleanup: @@ -1245,7 +1245,7 @@ netmap_free_bufs(struct netmap_mem_d *nmd, struct netmap_slot *slot, u_int n) if (slot[i].buf_idx > 1) netmap_free_buf(nmd, slot[i].buf_idx); } - ND("%s: released some buffers, available: %u", + nm_prdis("%s: released some buffers, available: %u", p->name, p->objfree); } @@ -1539,7 +1539,7 @@ netmap_mem_unmap(struct netmap_obj_pool *p, struct netmap_adapter *na) (void)lut; nm_prerr("unsupported on Windows"); #else /* linux */ - ND("unmapping and freeing plut for %s", na->name); + nm_prdis("unmapping and freeing plut for %s", na->name); if (lut->plut == NULL) return 0; for (i = 0; i < lim; i += p->_clustentries) { @@ -1577,11 +1577,11 @@ netmap_mem_map(struct netmap_obj_pool *p, struct netmap_adapter *na) #else /* linux */ if (lut->plut != NULL) { - ND("plut already allocated for %s", na->name); + nm_prdis("plut already allocated for %s", na->name); return 0; } - ND("allocating physical lut for %s", na->name); + nm_prdis("allocating physical lut for %s", na->name); lut->plut = nm_alloc_plut(lim); if (lut->plut == NULL) { nm_prerr("Failed to allocate physical lut for %s", na->name); @@ -1775,7 +1775,7 @@ netmap_mem2_config(struct netmap_mem_d *nmd) if (!netmap_mem_params_changed(nmd->params)) goto out; - ND("reconfiguring"); + nm_prdis("reconfiguring"); if (nmd->flags & NETMAP_MEM_FINALIZED) { /* reset previous allocation */ @@ -1870,10 +1870,10 @@ netmap_free_rings(struct netmap_adapter *na) if (netmap_debug & NM_DEBUG_MEM) nm_prinf("deleting ring %s", kring->name); if (!(kring->nr_kflags & NKR_FAKERING)) { - ND("freeing bufs for %s", kring->name); + nm_prdis("freeing bufs for %s", kring->name); netmap_free_bufs(na->nm_mem, ring->slot, kring->nkr_num_slots); } else { - ND("NOT freeing bufs for %s", kring->name); + nm_prdis("NOT freeing bufs for %s", kring->name); } netmap_ring_free(na->nm_mem, ring); kring->ring = NULL; @@ -1918,7 +1918,7 @@ netmap_mem2_rings_create(struct netmap_adapter *na) nm_prerr("Cannot allocate %s_ring", nm_txrx2str(t)); goto cleanup; } - ND("txring at %p", ring); + nm_prdis("txring at %p", ring); kring->ring = ring; *(uint32_t *)(uintptr_t)&ring->num_slots = ndesc; *(int64_t *)(uintptr_t)&ring->buf_ofs = @@ -1932,9 +1932,9 @@ netmap_mem2_rings_create(struct netmap_adapter *na) ring->tail = kring->rtail; *(uint32_t *)(uintptr_t)&ring->nr_buf_size = netmap_mem_bufsize(na->nm_mem); - ND("%s h %d c %d t %d", kring->name, + nm_prdis("%s h %d c %d t %d", kring->name, ring->head, ring->cur, ring->tail); - ND("initializing slots for %s_ring", nm_txrx2str(t)); + nm_prdis("initializing slots for %s_ring", nm_txrx2str(t)); if (!(kring->nr_kflags & NKR_FAKERING)) { /* this is a real ring */ if (netmap_debug & NM_DEBUG_MEM) @@ -2306,19 +2306,19 @@ netmap_mem_ext_create(uint64_t usrptr, struct nmreq_pools_info *pi, int *perror) #if !defined(linux) && !defined(_WIN32) p->lut[j].paddr = vtophys(p->lut[j].vaddr); #endif - ND("%s %d at %p", p->name, j, p->lut[j].vaddr); + nm_prdis("%s %d at %p", p->name, j, p->lut[j].vaddr); noff = off + p->_objsize; if (noff < PAGE_SIZE) { off = noff; continue; } - ND("too big, recomputing offset..."); + nm_prdis("too big, recomputing offset..."); while (noff >= PAGE_SIZE) { char *old_clust = clust; noff -= PAGE_SIZE; clust = nm_os_extmem_nextpage(nme->os); nr_pages--; - ND("noff %zu page %p nr_pages %d", noff, + nm_prdis("noff %zu page %p nr_pages %d", noff, page_to_virt(*pages), nr_pages); if (noff > 0 && !nm_isset(p->invalid_bitmap, j) && (nr_pages == 0 || @@ -2328,7 +2328,7 @@ netmap_mem_ext_create(uint64_t usrptr, struct nmreq_pools_info *pi, int *perror) * drop this object * */ p->invalid_bitmap[ (j>>5) ] |= 1U << (j & 31U); - ND("non contiguous at off %zu, drop", noff); + nm_prdis("non contiguous at off %zu, drop", noff); } if (nr_pages == 0) break; @@ -2338,7 +2338,7 @@ netmap_mem_ext_create(uint64_t usrptr, struct nmreq_pools_info *pi, int *perror) p->objtotal = j; p->numclusters = p->objtotal; p->memtotal = j * p->_objsize; - ND("%d memtotal %u", j, p->memtotal); + nm_prdis("%d memtotal %u", j, p->memtotal); } netmap_mem_ext_register(nme); @@ -2442,7 +2442,7 @@ netmap_mem_pt_guest_ifp_del(struct netmap_mem_d *nmd, struct ifnet *ifp) } else { ptnmd->pt_ifs = curr->next; } - D("removed (ifp=%p,nifp_offset=%u)", + nm_prinf("removed (ifp=%p,nifp_offset=%u)", curr->ifp, curr->nifp_offset); nm_os_free(curr); ret = 0; @@ -2498,7 +2498,7 @@ netmap_mem_pt_guest_ofstophys(struct netmap_mem_d *nmd, vm_ooffset_t off) vm_paddr_t paddr; /* if the offset is valid, just return csb->base_addr + off */ paddr = (vm_paddr_t)(ptnmd->nm_paddr + off); - ND("off %lx padr %lx", off, (unsigned long)paddr); + nm_prdis("off %lx padr %lx", off, (unsigned long)paddr); return paddr; } @@ -2528,7 +2528,7 @@ netmap_mem_pt_guest_finalize(struct netmap_mem_d *nmd) goto out; if (ptnmd->ptn_dev == NULL) { - D("ptnetmap memdev not attached"); + nm_prerr("ptnetmap memdev not attached"); error = ENOMEM; goto out; } @@ -2547,10 +2547,10 @@ netmap_mem_pt_guest_finalize(struct netmap_mem_d *nmd) /* allocate the lut */ if (ptnmd->buf_lut.lut == NULL) { - D("allocating lut"); + nm_prinf("allocating lut"); ptnmd->buf_lut.lut = nm_alloc_lut(nbuffers); if (ptnmd->buf_lut.lut == NULL) { - D("lut allocation failed"); + nm_prerr("lut allocation failed"); return ENOMEM; } } @@ -2615,11 +2615,11 @@ netmap_mem_pt_guest_delete(struct netmap_mem_d *nmd) if (nmd == NULL) return; if (netmap_verbose) - D("deleting %p", nmd); + nm_prinf("deleting %p", nmd); if (nmd->active > 0) - D("bug: deleting mem allocator with active=%d!", nmd->active); + nm_prerr("bug: deleting mem allocator with active=%d!", nmd->active); if (netmap_verbose) - D("done deleting %p", nmd); + nm_prinf("done deleting %p", nmd); NMA_LOCK_DESTROY(nmd); nm_os_free(nmd); } @@ -2633,7 +2633,7 @@ netmap_mem_pt_guest_if_new(struct netmap_adapter *na, struct netmap_priv_d *priv ptif = netmap_mem_pt_guest_ifp_lookup(na->nm_mem, na->ifp); if (ptif == NULL) { - D("Error: interface %p is not in passthrough", na->ifp); + nm_prerr("interface %s is not in passthrough", na->name); goto out; } @@ -2650,7 +2650,7 @@ netmap_mem_pt_guest_if_delete(struct netmap_adapter *na, struct netmap_if *nifp) ptif = netmap_mem_pt_guest_ifp_lookup(na->nm_mem, na->ifp); if (ptif == NULL) { - D("Error: interface %p is not in passthrough", na->ifp); + nm_prerr("interface %s is not in passthrough", na->name); } } @@ -2664,7 +2664,7 @@ netmap_mem_pt_guest_rings_create(struct netmap_adapter *na) ptif = netmap_mem_pt_guest_ifp_lookup(na->nm_mem, na->ifp); if (ptif == NULL) { - D("Error: interface %p is not in passthrough", na->ifp); + nm_prerr("interface %s is not in passthrough", na->name); goto out; } diff --git a/sys/dev/netmap/netmap_monitor.c b/sys/dev/netmap/netmap_monitor.c index 5297c0cb9123..f30abcc4b39a 100644 --- a/sys/dev/netmap/netmap_monitor.c +++ b/sys/dev/netmap/netmap_monitor.c @@ -139,7 +139,7 @@ nm_is_zmon(struct netmap_adapter *na) static int netmap_monitor_txsync(struct netmap_kring *kring, int flags) { - RD(1, "%s %x", kring->name, flags); + nm_prlim(1, "%s %x", kring->name, flags); return EIO; } @@ -158,7 +158,7 @@ netmap_monitor_rxsync(struct netmap_kring *kring, int flags) /* parent left netmap mode */ return EIO; } - ND("%s %x", kring->name, flags); + nm_prdis("%s %x", kring->name, flags); kring->nr_hwcur = kring->rhead; mb(); return 0; @@ -230,8 +230,8 @@ nm_monitor_dealloc(struct netmap_kring *kring) { if (kring->monitors) { if (kring->n_monitors > 0) { - D("freeing not empty monitor array for %s (%d dangling monitors)!", kring->name, - kring->n_monitors); + nm_prerr("freeing not empty monitor array for %s (%d dangling monitors)!", + kring->name, kring->n_monitors); } nm_os_free(kring->monitors); kring->monitors = NULL; @@ -270,7 +270,7 @@ nm_monitor_dummycb(struct netmap_kring *kring, int flags) static void nm_monitor_intercept_callbacks(struct netmap_kring *kring) { - ND("intercept callbacks on %s", kring->name); + nm_prdis("intercept callbacks on %s", kring->name); kring->mon_sync = kring->nm_sync != NULL ? kring->nm_sync : nm_monitor_dummycb; kring->mon_notify = kring->nm_notify; @@ -286,7 +286,7 @@ nm_monitor_intercept_callbacks(struct netmap_kring *kring) static void nm_monitor_restore_callbacks(struct netmap_kring *kring) { - ND("restoring callbacks on %s", kring->name); + nm_prdis("restoring callbacks on %s", kring->name); kring->nm_sync = kring->mon_sync; kring->mon_sync = NULL; if (kring->tx == NR_RX) { @@ -333,7 +333,7 @@ netmap_monitor_add(struct netmap_kring *mkring, struct netmap_kring *kring, int if (nm_monitor_none(ikring)) { /* this is the first monitor, intercept the callbacks */ - ND("%s: intercept callbacks on %s", mkring->name, ikring->name); + nm_prdis("%s: intercept callbacks on %s", mkring->name, ikring->name); nm_monitor_intercept_callbacks(ikring); } @@ -513,11 +513,11 @@ netmap_monitor_reg_common(struct netmap_adapter *na, int onoff, int zmon) int i; enum txrx t, s; - ND("%p: onoff %d", na, onoff); + nm_prdis("%p: onoff %d", na, onoff); if (onoff) { if (pna == NULL) { /* parent left netmap mode, fatal */ - D("%s: internal error", na->name); + nm_prerr("%s: parent left netmap mode", na->name); return ENXIO; } for_rx_tx(t) { @@ -592,7 +592,7 @@ netmap_zmon_parent_sync(struct netmap_kring *kring, int flags, enum txrx tx) mlim; // = mkring->nkr_num_slots - 1; if (mkring == NULL) { - RD(5, "NULL monitor on %s", kring->name); + nm_prlim(5, "NULL monitor on %s", kring->name); return 0; } mring = mkring->ring; @@ -653,7 +653,7 @@ netmap_zmon_parent_sync(struct netmap_kring *kring, int flags, enum txrx tx) tmp = ms->buf_idx; ms->buf_idx = s->buf_idx; s->buf_idx = tmp; - ND(5, "beg %d buf_idx %d", beg, tmp); + nm_prdis(5, "beg %d buf_idx %d", beg, tmp); tmp = ms->len; ms->len = s->len; @@ -770,7 +770,7 @@ netmap_monitor_parent_sync(struct netmap_kring *kring, u_int first_new, int new_ *dst = NMB(mkring->na, ms); if (unlikely(copy_len > max_len)) { - RD(5, "%s->%s: truncating %d to %d", kring->name, + nm_prlim(5, "%s->%s: truncating %d to %d", kring->name, mkring->name, copy_len, max_len); copy_len = max_len; } @@ -849,7 +849,7 @@ static int netmap_monitor_parent_notify(struct netmap_kring *kring, int flags) { int (*notify)(struct netmap_kring*, int); - ND(5, "%s %x", kring->name, flags); + nm_prdis(5, "%s %x", kring->name, flags); /* ?xsync callbacks have tryget called by their callers * (NIOCREGIF and poll()), but here we have to call it * by ourself @@ -909,12 +909,12 @@ netmap_get_monitor_na(struct nmreq_header *hdr, struct netmap_adapter **na, req->nr_flags |= (NR_MONITOR_TX | NR_MONITOR_RX); } if ((req->nr_flags & (NR_MONITOR_TX | NR_MONITOR_RX)) == 0) { - ND("not a monitor"); + nm_prdis("not a monitor"); return 0; } /* this is a request for a monitor adapter */ - ND("flags %lx", req->nr_flags); + nm_prdis("flags %lx", req->nr_flags); /* First, try to find the adapter that we want to monitor. * We use the same req, after we have turned off the monitor flags. @@ -927,24 +927,23 @@ netmap_get_monitor_na(struct nmreq_header *hdr, struct netmap_adapter **na, error = netmap_get_na(hdr, &pna, &ifp, nmd, create); hdr->nr_body = (uintptr_t)req; if (error) { - D("parent lookup failed: %d", error); + nm_prerr("parent lookup failed: %d", error); return error; } - ND("found parent: %s", pna->name); + nm_prdis("found parent: %s", pna->name); if (!nm_netmap_on(pna)) { /* parent not in netmap mode */ /* XXX we can wait for the parent to enter netmap mode, * by intercepting its nm_register callback (2014-03-16) */ - D("%s not in netmap mode", pna->name); + nm_prerr("%s not in netmap mode", pna->name); error = EINVAL; goto put_out; } mna = nm_os_malloc(sizeof(*mna)); if (mna == NULL) { - D("memory error"); error = ENOMEM; goto put_out; } @@ -954,7 +953,7 @@ netmap_get_monitor_na(struct nmreq_header *hdr, struct netmap_adapter **na, error = netmap_interp_ringid(&mna->priv, req->nr_mode, req->nr_ringid, req->nr_flags); if (error) { - D("ringid error"); + nm_prerr("ringid error"); goto free_out; } snprintf(mna->up.name, sizeof(mna->up.name), "%s/%s%s%s#%lu", pna->name, @@ -1013,7 +1012,7 @@ netmap_get_monitor_na(struct nmreq_header *hdr, struct netmap_adapter **na, error = netmap_attach_common(&mna->up); if (error) { - D("attach_common error"); + nm_prerr("netmap_attach_common failed"); goto mem_put_out; } @@ -1024,7 +1023,7 @@ netmap_get_monitor_na(struct nmreq_header *hdr, struct netmap_adapter **na, netmap_adapter_get(*na); /* keep the reference to the parent */ - ND("monitor ok"); + nm_prdis("monitor ok"); /* drop the reference to the ifp, if any */ if (ifp) diff --git a/sys/dev/netmap/netmap_null.c b/sys/dev/netmap/netmap_null.c index b769ae7ed6e8..e880304e7379 100644 --- a/sys/dev/netmap/netmap_null.c +++ b/sys/dev/netmap/netmap_null.c @@ -74,15 +74,7 @@ #ifdef WITH_NMNULL static int -netmap_null_txsync(struct netmap_kring *kring, int flags) -{ - (void)kring; - (void)flags; - return 0; -} - -static int -netmap_null_rxsync(struct netmap_kring *kring, int flags) +netmap_null_sync(struct netmap_kring *kring, int flags) { (void)kring; (void)flags; @@ -95,12 +87,6 @@ netmap_null_krings_create(struct netmap_adapter *na) return netmap_krings_create(na, 0); } -static void -netmap_null_krings_delete(struct netmap_adapter *na) -{ - netmap_krings_delete(na); -} - static int netmap_null_reg(struct netmap_adapter *na, int onoff) { @@ -153,11 +139,11 @@ netmap_get_null_na(struct nmreq_header *hdr, struct netmap_adapter **na, } snprintf(nna->up.name, sizeof(nna->up.name), "null:%s", hdr->nr_name); - nna->up.nm_txsync = netmap_null_txsync; - nna->up.nm_rxsync = netmap_null_rxsync; + nna->up.nm_txsync = netmap_null_sync; + nna->up.nm_rxsync = netmap_null_sync; nna->up.nm_register = netmap_null_reg; nna->up.nm_krings_create = netmap_null_krings_create; - nna->up.nm_krings_delete = netmap_null_krings_delete; + nna->up.nm_krings_delete = netmap_krings_delete; nna->up.nm_bdg_attach = netmap_null_bdg_attach; nna->up.nm_mem = netmap_mem_get(nmd); diff --git a/sys/dev/netmap/netmap_offloadings.c b/sys/dev/netmap/netmap_offloadings.c index e0b96a8e52a2..a6ff8b00a402 100644 --- a/sys/dev/netmap/netmap_offloadings.c +++ b/sys/dev/netmap/netmap_offloadings.c @@ -82,16 +82,16 @@ gso_fix_segment(uint8_t *pkt, size_t len, u_int ipv4, u_int iphlen, u_int tcp, if (ipv4) { /* Set the IPv4 "Total Length" field. */ iph->tot_len = htobe16(len); - ND("ip total length %u", be16toh(ip->tot_len)); + nm_prdis("ip total length %u", be16toh(ip->tot_len)); /* Set the IPv4 "Identification" field. */ iph->id = htobe16(be16toh(iph->id) + idx); - ND("ip identification %u", be16toh(iph->id)); + nm_prdis("ip identification %u", be16toh(iph->id)); /* Compute and insert the IPv4 header checksum. */ iph->check = 0; iph->check = nm_os_csum_ipv4(iph); - ND("IP csum %x", be16toh(iph->check)); + nm_prdis("IP csum %x", be16toh(iph->check)); } else { /* Set the IPv6 "Payload Len" field. */ ip6h->payload_len = htobe16(len-iphlen); @@ -102,13 +102,13 @@ gso_fix_segment(uint8_t *pkt, size_t len, u_int ipv4, u_int iphlen, u_int tcp, /* Set the TCP sequence number. */ tcph->seq = htobe32(be32toh(tcph->seq) + segmented_bytes); - ND("tcp seq %u", be32toh(tcph->seq)); + nm_prdis("tcp seq %u", be32toh(tcph->seq)); /* Zero the PSH and FIN TCP flags if this is not the last segment. */ if (!last_segment) tcph->flags &= ~(0x8 | 0x1); - ND("last_segment %u", last_segment); + nm_prdis("last_segment %u", last_segment); check = &tcph->check; check_data = (uint8_t *)tcph; @@ -129,7 +129,7 @@ gso_fix_segment(uint8_t *pkt, size_t len, u_int ipv4, u_int iphlen, u_int tcp, else nm_os_csum_tcpudp_ipv6(ip6h, check_data, len-iphlen, check); - ND("TCP/UDP csum %x", be16toh(*check)); + nm_prdis("TCP/UDP csum %x", be16toh(*check)); } static inline int @@ -170,7 +170,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, u_int dst_slots = 0; if (unlikely(ft_p == ft_end)) { - RD(1, "No source slots to process"); + nm_prlim(1, "No source slots to process"); return; } @@ -189,11 +189,11 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, /* Initial sanity check on the source virtio-net header. If * something seems wrong, just drop the packet. */ if (src_len < na->up.virt_hdr_len) { - RD(1, "Short src vnet header, dropping"); + nm_prlim(1, "Short src vnet header, dropping"); return; } if (unlikely(vnet_hdr_is_bad(vh))) { - RD(1, "Bad src vnet header, dropping"); + nm_prlim(1, "Bad src vnet header, dropping"); return; } } @@ -266,7 +266,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, if (dst_slots >= *howmany) { /* We still have work to do, but we've run out of * dst slots, so we have to drop the packet. */ - ND(1, "Not enough slots, dropping GSO packet"); + nm_prdis(1, "Not enough slots, dropping GSO packet"); return; } @@ -281,7 +281,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, * encapsulation. */ for (;;) { if (src_len < ethhlen) { - RD(1, "Short GSO fragment [eth], dropping"); + nm_prlim(1, "Short GSO fragment [eth], dropping"); return; } ethertype = be16toh(*((uint16_t *) @@ -297,7 +297,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, (gso_hdr + ethhlen); if (src_len < ethhlen + 20) { - RD(1, "Short GSO fragment " + nm_prlim(1, "Short GSO fragment " "[IPv4], dropping"); return; } @@ -310,14 +310,14 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, iphlen = 40; break; default: - RD(1, "Unsupported ethertype, " + nm_prlim(1, "Unsupported ethertype, " "dropping GSO packet"); return; } - ND(3, "type=%04x", ethertype); + nm_prdis(3, "type=%04x", ethertype); if (src_len < ethhlen + iphlen) { - RD(1, "Short GSO fragment [IP], dropping"); + nm_prlim(1, "Short GSO fragment [IP], dropping"); return; } @@ -329,7 +329,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, (gso_hdr + ethhlen + iphlen); if (src_len < ethhlen + iphlen + 20) { - RD(1, "Short GSO fragment " + nm_prlim(1, "Short GSO fragment " "[TCP], dropping"); return; } @@ -340,11 +340,11 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, } if (src_len < gso_hdr_len) { - RD(1, "Short GSO fragment [TCP/UDP], dropping"); + nm_prlim(1, "Short GSO fragment [TCP/UDP], dropping"); return; } - ND(3, "gso_hdr_len %u gso_mtu %d", gso_hdr_len, + nm_prdis(3, "gso_hdr_len %u gso_mtu %d", gso_hdr_len, dst_na->mfs); /* Advance source pointers. */ @@ -386,7 +386,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, gso_idx, segmented_bytes, src_len == 0 && ft_p + 1 == ft_end); - ND("frame %u completed with %d bytes", gso_idx, (int)gso_bytes); + nm_prdis("frame %u completed with %d bytes", gso_idx, (int)gso_bytes); dst_slot->len = gso_bytes; dst_slot->flags = 0; dst_slots++; @@ -410,7 +410,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, src_len = ft_p->ft_len; } } - ND(3, "%d bytes segmented", segmented_bytes); + nm_prdis(3, "%d bytes segmented", segmented_bytes); } else { /* Address of a checksum field into a destination slot. */ @@ -423,7 +423,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, /* Init 'check' if necessary. */ if (vh && (vh->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM)) { if (unlikely(vh->csum_offset + vh->csum_start > src_len)) - D("invalid checksum request"); + nm_prerr("invalid checksum request"); else check = (uint16_t *)(dst + vh->csum_start + vh->csum_offset); @@ -468,7 +468,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, if (check && vh && (vh->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM)) { *check = nm_os_csum_fold(csum); } - ND(3, "using %u dst_slots", dst_slots); + nm_prdis(3, "using %u dst_slots", dst_slots); /* A second pass on the destination slots to set the slot flags, * using the right number of destination slots. @@ -485,7 +485,7 @@ bdg_mismatch_datapath(struct netmap_vp_adapter *na, /* Update howmany and j. This is to commit the use of * those slots in the destination ring. */ if (unlikely(dst_slots > *howmany)) { - D("Slot allocation error: This is a bug"); + nm_prerr("bug: slot allocation error"); } *j = j_cur; *howmany -= dst_slots; diff --git a/sys/dev/netmap/netmap_pipe.c b/sys/dev/netmap/netmap_pipe.c index 999b45f4c371..09261ca4c273 100644 --- a/sys/dev/netmap/netmap_pipe.c +++ b/sys/dev/netmap/netmap_pipe.c @@ -118,8 +118,8 @@ netmap_pipe_dealloc(struct netmap_adapter *na) { if (na->na_pipes) { if (na->na_next_pipe > 0) { - D("freeing not empty pipe array for %s (%d dangling pipes)!", na->name, - na->na_next_pipe); + nm_prerr("freeing not empty pipe array for %s (%d dangling pipes)!", + na->name, na->na_next_pipe); } nm_os_free(na->na_pipes); na->na_pipes = NULL; @@ -190,8 +190,8 @@ netmap_pipe_txsync(struct netmap_kring *txkring, int flags) int complete; /* did we see a complete packet ? */ struct netmap_ring *txring = txkring->ring, *rxring = rxkring->ring; - ND("%p: %s %x -> %s", txkring, txkring->name, flags, rxkring->name); - ND(20, "TX before: hwcur %d hwtail %d cur %d head %d tail %d", + nm_prdis("%p: %s %x -> %s", txkring, txkring->name, flags, rxkring->name); + nm_prdis(20, "TX before: hwcur %d hwtail %d cur %d head %d tail %d", txkring->nr_hwcur, txkring->nr_hwtail, txkring->rcur, txkring->rhead, txkring->rtail); @@ -221,7 +221,7 @@ netmap_pipe_txsync(struct netmap_kring *txkring, int flags) txkring->nr_hwcur = k; - ND(20, "TX after : hwcur %d hwtail %d cur %d head %d tail %d k %d", + nm_prdis(20, "TX after : hwcur %d hwtail %d cur %d head %d tail %d k %d", txkring->nr_hwcur, txkring->nr_hwtail, txkring->rcur, txkring->rhead, txkring->rtail, k); @@ -242,8 +242,8 @@ netmap_pipe_rxsync(struct netmap_kring *rxkring, int flags) int m; /* slots to release */ struct netmap_ring *txring = txkring->ring, *rxring = rxkring->ring; - ND("%p: %s %x -> %s", txkring, txkring->name, flags, rxkring->name); - ND(20, "RX before: hwcur %d hwtail %d cur %d head %d tail %d", + nm_prdis("%p: %s %x -> %s", txkring, txkring->name, flags, rxkring->name); + nm_prdis(20, "RX before: hwcur %d hwtail %d cur %d head %d tail %d", rxkring->nr_hwcur, rxkring->nr_hwtail, rxkring->rcur, rxkring->rhead, rxkring->rtail); @@ -274,7 +274,7 @@ netmap_pipe_rxsync(struct netmap_kring *rxkring, int flags) txkring->pipe_tail = nm_prev(k, lim); rxkring->nr_hwcur = k; - ND(20, "RX after : hwcur %d hwtail %d cur %d head %d tail %d k %d", + nm_prdis(20, "RX after : hwcur %d hwtail %d cur %d head %d tail %d k %d", rxkring->nr_hwcur, rxkring->nr_hwtail, rxkring->rcur, rxkring->rhead, rxkring->rtail, k); @@ -312,6 +312,47 @@ netmap_pipe_rxsync(struct netmap_kring *rxkring, int flags) */ +int netmap_pipe_krings_create_both(struct netmap_adapter *na, + struct netmap_adapter *ona) +{ + enum txrx t; + int error; + int i; + + /* case 1) below */ + nm_prdis("%p: case 1, create both ends", na); + error = netmap_krings_create(na, 0); + if (error) + return error; + + /* create the krings of the other end */ + error = netmap_krings_create(ona, 0); + if (error) + goto del_krings1; + + /* cross link the krings and initialize the pipe_tails */ + for_rx_tx(t) { + enum txrx r = nm_txrx_swap(t); /* swap NR_TX <-> NR_RX */ + for (i = 0; i < nma_get_nrings(na, t); i++) { + struct netmap_kring *k1 = NMR(na, t)[i], + *k2 = NMR(ona, r)[i]; + k1->pipe = k2; + k2->pipe = k1; + /* mark all peer-adapter rings as fake */ + k2->nr_kflags |= NKR_FAKERING; + /* init tails */ + k1->pipe_tail = k1->nr_hwtail; + k2->pipe_tail = k2->nr_hwtail; + } + } + + return 0; + +del_krings1: + netmap_krings_delete(na); + return error; +} + /* netmap_pipe_krings_create. * * There are two cases: @@ -336,46 +377,83 @@ netmap_pipe_krings_create(struct netmap_adapter *na) struct netmap_pipe_adapter *pna = (struct netmap_pipe_adapter *)na; struct netmap_adapter *ona = &pna->peer->up; - int error = 0; + + if (pna->peer_ref) + return netmap_pipe_krings_create_both(na, ona); + + return 0; +} + +int +netmap_pipe_reg_both(struct netmap_adapter *na, struct netmap_adapter *ona) +{ + int i, error = 0; enum txrx t; - if (pna->peer_ref) { - int i; + for_rx_tx(t) { + for (i = 0; i < nma_get_nrings(na, t); i++) { + struct netmap_kring *kring = NMR(na, t)[i]; - /* case 1) above */ - ND("%p: case 1, create both ends", na); - error = netmap_krings_create(na, 0); - if (error) - goto err; - - /* create the krings of the other end */ - error = netmap_krings_create(ona, 0); - if (error) - goto del_krings1; - - /* cross link the krings and initialize the pipe_tails */ - for_rx_tx(t) { - enum txrx r = nm_txrx_swap(t); /* swap NR_TX <-> NR_RX */ - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *k1 = NMR(na, t)[i], - *k2 = NMR(ona, r)[i]; - k1->pipe = k2; - k2->pipe = k1; - /* mark all peer-adapter rings as fake */ - k2->nr_kflags |= NKR_FAKERING; - /* init tails */ - k1->pipe_tail = k1->nr_hwtail; - k2->pipe_tail = k2->nr_hwtail; + if (nm_kring_pending_on(kring)) { + /* mark the peer ring as needed */ + kring->pipe->nr_kflags |= NKR_NEEDRING; } } - } - return 0; -del_krings1: - netmap_krings_delete(na); -err: - return error; + /* create all missing needed rings on the other end. + * Either our end, or the other, has been marked as + * fake, so the allocation will not be done twice. + */ + error = netmap_mem_rings_create(ona); + if (error) + return error; + + /* In case of no error we put our rings in netmap mode */ + for_rx_tx(t) { + for (i = 0; i < nma_get_nrings(na, t); i++) { + struct netmap_kring *kring = NMR(na, t)[i]; + if (nm_kring_pending_on(kring)) { + struct netmap_kring *sring, *dring; + + kring->nr_mode = NKR_NETMAP_ON; + if ((kring->nr_kflags & NKR_FAKERING) && + (kring->pipe->nr_kflags & NKR_FAKERING)) { + /* this is a re-open of a pipe + * end-point kept alive by the other end. + * We need to leave everything as it is + */ + continue; + } + + /* copy the buffers from the non-fake ring */ + if (kring->nr_kflags & NKR_FAKERING) { + sring = kring->pipe; + dring = kring; + } else { + sring = kring; + dring = kring->pipe; + } + memcpy(dring->ring->slot, + sring->ring->slot, + sizeof(struct netmap_slot) * + sring->nkr_num_slots); + /* mark both rings as fake and needed, + * so that buffers will not be + * deleted by the standard machinery + * (we will delete them by ourselves in + * netmap_pipe_krings_delete) + */ + sring->nr_kflags |= + (NKR_FAKERING | NKR_NEEDRING); + dring->nr_kflags |= + (NKR_FAKERING | NKR_NEEDRING); + kring->nr_mode = NKR_NETMAP_ON; + } + } + } + + return 0; } /* netmap_pipe_reg. @@ -417,110 +495,105 @@ netmap_pipe_reg(struct netmap_adapter *na, int onoff) struct netmap_pipe_adapter *pna = (struct netmap_pipe_adapter *)na; struct netmap_adapter *ona = &pna->peer->up; - int i, error = 0; - enum txrx t; + int error = 0; - ND("%p: onoff %d", na, onoff); + nm_prdis("%p: onoff %d", na, onoff); if (onoff) { - for_rx_tx(t) { - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_on(kring)) { - /* mark the peer ring as needed */ - kring->pipe->nr_kflags |= NKR_NEEDRING; - } - } - } - - /* create all missing needed rings on the other end. - * Either our end, or the other, has been marked as - * fake, so the allocation will not be done twice. - */ - error = netmap_mem_rings_create(ona); - if (error) + error = netmap_pipe_reg_both(na, ona); + if (error) { return error; - - /* In case of no error we put our rings in netmap mode */ - for_rx_tx(t) { - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - if (nm_kring_pending_on(kring)) { - struct netmap_kring *sring, *dring; - - kring->nr_mode = NKR_NETMAP_ON; - if ((kring->nr_kflags & NKR_FAKERING) && - (kring->pipe->nr_kflags & NKR_FAKERING)) { - /* this is a re-open of a pipe - * end-point kept alive by the other end. - * We need to leave everything as it is - */ - continue; - } - - /* copy the buffers from the non-fake ring */ - if (kring->nr_kflags & NKR_FAKERING) { - sring = kring->pipe; - dring = kring; - } else { - sring = kring; - dring = kring->pipe; - } - memcpy(dring->ring->slot, - sring->ring->slot, - sizeof(struct netmap_slot) * - sring->nkr_num_slots); - /* mark both rings as fake and needed, - * so that buffers will not be - * deleted by the standard machinery - * (we will delete them by ourselves in - * netmap_pipe_krings_delete) - */ - sring->nr_kflags |= - (NKR_FAKERING | NKR_NEEDRING); - dring->nr_kflags |= - (NKR_FAKERING | NKR_NEEDRING); - kring->nr_mode = NKR_NETMAP_ON; - } - } } if (na->active_fds == 0) na->na_flags |= NAF_NETMAP_ON; } else { if (na->active_fds == 0) na->na_flags &= ~NAF_NETMAP_ON; - for_rx_tx(t) { - for (i = 0; i < nma_get_nrings(na, t); i++) { - struct netmap_kring *kring = NMR(na, t)[i]; - - if (nm_kring_pending_off(kring)) { - kring->nr_mode = NKR_NETMAP_OFF; - } - } - } + netmap_krings_mode_commit(na, onoff); } if (na->active_fds) { - ND("active_fds %d", na->active_fds); + nm_prdis("active_fds %d", na->active_fds); return 0; } if (pna->peer_ref) { - ND("%p: case 1.a or 2.a, nothing to do", na); + nm_prdis("%p: case 1.a or 2.a, nothing to do", na); return 0; } if (onoff) { - ND("%p: case 1.b, drop peer", na); + nm_prdis("%p: case 1.b, drop peer", na); pna->peer->peer_ref = 0; netmap_adapter_put(na); } else { - ND("%p: case 2.b, grab peer", na); + nm_prdis("%p: case 2.b, grab peer", na); netmap_adapter_get(na); pna->peer->peer_ref = 1; } return error; } +void +netmap_pipe_krings_delete_both(struct netmap_adapter *na, + struct netmap_adapter *ona) +{ + struct netmap_adapter *sna; + enum txrx t; + int i; + + /* case 1) below */ + nm_prdis("%p: case 1, deleting everything", na); + /* To avoid double-frees we zero-out all the buffers in the kernel part + * of each ring. The reason is this: If the user is behaving correctly, + * all buffers are found in exactly one slot in the userspace part of + * some ring. If the user is not behaving correctly, we cannot release + * buffers cleanly anyway. In the latter case, the allocator will + * return to a clean state only when all its users will close. + */ + sna = na; +cleanup: + for_rx_tx(t) { + for (i = 0; i < nma_get_nrings(sna, t); i++) { + struct netmap_kring *kring = NMR(sna, t)[i]; + struct netmap_ring *ring = kring->ring; + uint32_t j, lim = kring->nkr_num_slots - 1; + + nm_prdis("%s ring %p hwtail %u hwcur %u", + kring->name, ring, kring->nr_hwtail, kring->nr_hwcur); + + if (ring == NULL) + continue; + + if (kring->tx == NR_RX) + ring->slot[kring->pipe_tail].buf_idx = 0; + + for (j = nm_next(kring->pipe_tail, lim); + j != kring->nr_hwcur; + j = nm_next(j, lim)) + { + nm_prdis("%s[%d] %u", kring->name, j, ring->slot[j].buf_idx); + ring->slot[j].buf_idx = 0; + } + kring->nr_kflags &= ~(NKR_FAKERING | NKR_NEEDRING); + } + + } + if (sna != ona && ona->tx_rings) { + sna = ona; + goto cleanup; + } + + netmap_mem_rings_delete(na); + netmap_krings_delete(na); /* also zeroes tx_rings etc. */ + + if (ona->tx_rings == NULL) { + /* already deleted, we must be on an + * cleanup-after-error path */ + return; + } + netmap_mem_rings_delete(ona); + netmap_krings_delete(ona); +} + /* netmap_pipe_krings_delete. * * There are two cases: @@ -546,67 +619,14 @@ netmap_pipe_krings_delete(struct netmap_adapter *na) { struct netmap_pipe_adapter *pna = (struct netmap_pipe_adapter *)na; - struct netmap_adapter *sna, *ona; /* na of the other end */ - enum txrx t; - int i; + struct netmap_adapter *ona; /* na of the other end */ if (!pna->peer_ref) { - ND("%p: case 2, kept alive by peer", na); + nm_prdis("%p: case 2, kept alive by peer", na); return; } ona = &pna->peer->up; - /* case 1) above */ - ND("%p: case 1, deleting everything", na); - /* To avoid double-frees we zero-out all the buffers in the kernel part - * of each ring. The reason is this: If the user is behaving correctly, - * all buffers are found in exactly one slot in the userspace part of - * some ring. If the user is not behaving correctly, we cannot release - * buffers cleanly anyway. In the latter case, the allocator will - * return to a clean state only when all its users will close. - */ - sna = na; -cleanup: - for_rx_tx(t) { - for (i = 0; i < nma_get_nrings(sna, t); i++) { - struct netmap_kring *kring = NMR(sna, t)[i]; - struct netmap_ring *ring = kring->ring; - uint32_t j, lim = kring->nkr_num_slots - 1; - - ND("%s ring %p hwtail %u hwcur %u", - kring->name, ring, kring->nr_hwtail, kring->nr_hwcur); - - if (ring == NULL) - continue; - - if (kring->tx == NR_RX) - ring->slot[kring->pipe_tail].buf_idx = 0; - - for (j = nm_next(kring->pipe_tail, lim); - j != kring->nr_hwcur; - j = nm_next(j, lim)) - { - ND("%s[%d] %u", kring->name, j, ring->slot[j].buf_idx); - ring->slot[j].buf_idx = 0; - } - kring->nr_kflags &= ~(NKR_FAKERING | NKR_NEEDRING); - } - - } - if (sna != ona && ona->tx_rings) { - sna = ona; - goto cleanup; - } - - netmap_mem_rings_delete(na); - netmap_krings_delete(na); /* also zeroes tx_rings etc. */ - - if (ona->tx_rings == NULL) { - /* already deleted, we must be on an - * cleanup-after-error path */ - return; - } - netmap_mem_rings_delete(ona); - netmap_krings_delete(ona); + netmap_pipe_krings_delete_both(na, ona); } @@ -615,9 +635,9 @@ netmap_pipe_dtor(struct netmap_adapter *na) { struct netmap_pipe_adapter *pna = (struct netmap_pipe_adapter *)na; - ND("%p %p", na, pna->parent_ifp); + nm_prdis("%p %p", na, pna->parent_ifp); if (pna->peer_ref) { - ND("%p: clean up peer", na); + nm_prdis("%p: clean up peer", na); pna->peer_ref = 0; netmap_adapter_put(&pna->peer->up); } @@ -651,7 +671,7 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, if (cbra != NULL) { role = NM_PIPE_ROLE_SLAVE; } else { - ND("not a pipe"); + nm_prdis("not a pipe"); return 0; } } @@ -682,10 +702,10 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, if (!error) break; if (error != ENXIO || retries++) { - ND("parent lookup failed: %d", error); + nm_prdis("parent lookup failed: %d", error); return error; } - ND("try to create a persistent vale port"); + nm_prdis("try to create a persistent vale port"); /* create a persistent vale port and try again */ *cbra = '\0'; NMG_UNLOCK(); @@ -694,14 +714,15 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, strlcpy(hdr->nr_name, nr_name_orig, sizeof(hdr->nr_name)); if (create_error && create_error != EEXIST) { if (create_error != EOPNOTSUPP) { - D("failed to create a persistent vale port: %d", create_error); + nm_prerr("failed to create a persistent vale port: %d", + create_error); } return error; } } if (NETMAP_OWNED_BY_KERN(pna)) { - ND("parent busy"); + nm_prdis("parent busy"); error = EBUSY; goto put_out; } @@ -711,10 +732,10 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, mna = netmap_pipe_find(pna, pipe_id); if (mna) { if (mna->role == role) { - ND("found %s directly at %d", pipe_id, mna->parent_slot); + nm_prdis("found %s directly at %d", pipe_id, mna->parent_slot); reqna = mna; } else { - ND("found %s indirectly at %d", pipe_id, mna->parent_slot); + nm_prdis("found %s indirectly at %d", pipe_id, mna->parent_slot); reqna = mna->peer; } /* the pipe we have found already holds a ref to the parent, @@ -723,7 +744,7 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, netmap_unget_na(pna, ifp); goto found; } - ND("pipe %s not found, create %d", pipe_id, create); + nm_prdis("pipe %s not found, create %d", pipe_id, create); if (!create) { error = ENODEV; goto put_out; @@ -814,10 +835,10 @@ netmap_get_pipe_na(struct nmreq_header *hdr, struct netmap_adapter **na, sna->peer_ref = 1; netmap_adapter_get(&mna->up); } - ND("created master %p and slave %p", mna, sna); + nm_prdis("created master %p and slave %p", mna, sna); found: - ND("pipe %s %s at %p", pipe_id, + nm_prdis("pipe %s %s at %p", pipe_id, (reqna->role == NM_PIPE_ROLE_MASTER ? "master" : "slave"), reqna); *na = &reqna->up; netmap_adapter_get(*na); diff --git a/sys/dev/netmap/netmap_vale.c b/sys/dev/netmap/netmap_vale.c index 0d0232e3d2da..50f44e410477 100644 --- a/sys/dev/netmap/netmap_vale.c +++ b/sys/dev/netmap/netmap_vale.c @@ -445,7 +445,7 @@ netmap_vale_attach(struct nmreq_header *hdr, void *auth_token) error = na->nm_bdg_ctl(hdr, na); if (error) goto unref_exit; - ND("registered %s to netmap-mode", na->name); + nm_prdis("registered %s to netmap-mode", na->name); } vpna = (struct netmap_vp_adapter *)na; req->port_index = vpna->bdg_port; @@ -533,7 +533,7 @@ netmap_vale_vp_dtor(struct netmap_adapter *na) struct netmap_vp_adapter *vpna = (struct netmap_vp_adapter*)na; struct nm_bridge *b = vpna->na_bdg; - ND("%s has %d references", na->name, na->na_refcount); + nm_prdis("%s has %d references", na->name, na->na_refcount); if (b) { netmap_bdg_detach_common(b, vpna->bdg_port, -1); @@ -542,7 +542,7 @@ netmap_vale_vp_dtor(struct netmap_adapter *na) if (na->ifp != NULL && !nm_iszombie(na)) { NM_DETACH_NA(na->ifp); if (vpna->autodelete) { - ND("releasing %s", na->ifp->if_xname); + nm_prdis("releasing %s", na->ifp->if_xname); NMG_UNLOCK(); nm_os_vi_detach(na->ifp); NMG_LOCK(); @@ -628,12 +628,12 @@ nm_vale_preflush(struct netmap_kring *kring, u_int end) * shared lock, waiting if we can sleep (if the source port is * attached to a user process) or with a trylock otherwise (NICs). */ - ND("wait rlock for %d packets", ((j > end ? lim+1 : 0) + end) - j); + nm_prdis("wait rlock for %d packets", ((j > end ? lim+1 : 0) + end) - j); if (na->up.na_flags & NAF_BDG_MAYSLEEP) BDG_RLOCK(b); else if (!BDG_RTRYLOCK(b)) return j; - ND(5, "rlock acquired for %d packets", ((j > end ? lim+1 : 0) + end) - j); + nm_prdis(5, "rlock acquired for %d packets", ((j > end ? lim+1 : 0) + end) - j); ft = kring->nkr_ft; for (; likely(j != end); j = nm_next(j, lim)) { @@ -644,7 +644,7 @@ nm_vale_preflush(struct netmap_kring *kring, u_int end) ft[ft_i].ft_flags = slot->flags; ft[ft_i].ft_offset = 0; - ND("flags is 0x%x", slot->flags); + nm_prdis("flags is 0x%x", slot->flags); /* we do not use the buf changed flag, but we still need to reset it */ slot->flags &= ~NS_BUF_CHANGED; @@ -667,7 +667,7 @@ nm_vale_preflush(struct netmap_kring *kring, u_int end) continue; } if (unlikely(netmap_verbose && frags > 1)) - RD(5, "%d frags at %d", frags, ft_i - frags); + nm_prlim(5, "%d frags at %d", frags, ft_i - frags); ft[ft_i - frags].ft_frags = frags; frags = 1; if (unlikely((int)ft_i >= bridge_batch)) @@ -815,8 +815,9 @@ nm_kr_space(struct netmap_kring *k, int is_rx) k->nr_tail >= k->nkr_num_slots || busy < 0 || busy >= k->nkr_num_slots) { - D("invalid kring, cur %d tail %d lease %d lease_idx %d lim %d", k->nr_hwcur, k->nr_hwtail, k->nkr_hwlease, - k->nkr_lease_idx, k->nkr_num_slots); + nm_prerr("invalid kring, cur %d tail %d lease %d lease_idx %d lim %d", + k->nr_hwcur, k->nr_hwtail, k->nkr_hwlease, + k->nkr_lease_idx, k->nkr_num_slots); } #endif return space; @@ -893,7 +894,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, struct nm_vale_q *d; struct nm_bdg_fwd *start_ft = NULL; - ND("slot %d frags %d", i, ft[i].ft_frags); + nm_prdis("slot %d frags %d", i, ft[i].ft_frags); if (na->up.virt_hdr_len < ft[i].ft_len) { ft[i].ft_offset = na->up.virt_hdr_len; @@ -909,7 +910,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, } dst_port = b->bdg_ops.lookup(start_ft, &dst_ring, na, b->private_data); if (netmap_verbose > 255) - RD(5, "slot %d port %d -> %d", i, me, dst_port); + nm_prlim(5, "slot %d port %d -> %d", i, me, dst_port); if (dst_port >= NM_BDG_NOPORT) continue; /* this packet is identified to be dropped */ else if (dst_port == NM_BDG_BROADCAST) @@ -956,7 +957,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, } } - ND(5, "pass 1 done %d pkts %d dsts", n, num_dsts); + nm_prdis(5, "pass 1 done %d pkts %d dsts", n, num_dsts); /* second pass: scan destinations */ for (i = 0; i < num_dsts; i++) { struct netmap_vp_adapter *dst_na; @@ -971,7 +972,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, int virt_hdr_mismatch = 0; d_i = dsts[i]; - ND("second pass %d port %d", i, d_i); + nm_prdis("second pass %d port %d", i, d_i); d = dst_ents + d_i; // XXX fix the division dst_na = b->bdg_ports[d_i/NM_BDG_MAXRINGS]; @@ -988,7 +989,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, * - when na is being deactivated but is still attached. */ if (unlikely(!nm_netmap_on(&dst_na->up))) { - ND("not in netmap mode!"); + nm_prdis("not in netmap mode!"); goto cleanup; } @@ -1006,7 +1007,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, if (unlikely(dst_na->up.virt_hdr_len != na->up.virt_hdr_len)) { if (netmap_verbose) { - RD(3, "virt_hdr_mismatch, src %d dst %d", na->up.virt_hdr_len, + nm_prlim(3, "virt_hdr_mismatch, src %d dst %d", na->up.virt_hdr_len, dst_na->up.virt_hdr_len); } /* There is a virtio-net header/offloadings mismatch between @@ -1028,11 +1029,11 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, KASSERT(dst_na->mfs > 0, ("vpna->mfs is 0")); needed = (needed * na->mfs) / (dst_na->mfs - WORST_CASE_GSO_HEADER) + 1; - ND(3, "srcmtu=%u, dstmtu=%u, x=%u", na->mfs, dst_na->mfs, needed); + nm_prdis(3, "srcmtu=%u, dstmtu=%u, x=%u", na->mfs, dst_na->mfs, needed); } } - ND(5, "pass 2 dst %d is %x %s", + nm_prdis(5, "pass 2 dst %d is %x %s", i, d_i, is_vp ? "virtual" : "nic/host"); dst_nr = d_i & (NM_BDG_MAXRINGS-1); nrings = dst_na->up.num_rx_rings; @@ -1098,7 +1099,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, if (unlikely(cnt > howmany)) break; /* no more space */ if (netmap_verbose && cnt > 1) - RD(5, "rx %d frags to %d", cnt, j); + nm_prlim(5, "rx %d frags to %d", cnt, j); ft_end = ft_p + cnt; if (unlikely(virt_hdr_mismatch)) { bdg_mismatch_datapath(na, dst_na, ft_p, ring, &j, lim, &howmany); @@ -1111,7 +1112,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, slot = &ring->slot[j]; dst = NMB(&dst_na->up, slot); - ND("send [%d] %d(%d) bytes at %s:%d", + nm_prdis("send [%d] %d(%d) bytes at %s:%d", i, (int)copy_len, (int)dst_len, NM_IFPNAME(dst_ifp), j); /* round to a multiple of 64 */ @@ -1119,7 +1120,7 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, if (unlikely(copy_len > NETMAP_BUF_SIZE(&dst_na->up) || copy_len > NETMAP_BUF_SIZE(&na->up))) { - RD(5, "invalid len %d, down to 64", (int)copy_len); + nm_prlim(5, "invalid len %d, down to 64", (int)copy_len); copy_len = dst_len = 64; // XXX } if (ft_p->ft_flags & NS_INDIRECT) { @@ -1155,10 +1156,10 @@ nm_vale_flush(struct nm_bdg_fwd *ft, u_int n, struct netmap_vp_adapter *na, * i can recover the slots, otherwise must * fill them with 0 to mark empty packets. */ - ND("leftover %d bufs", howmany); + nm_prdis("leftover %d bufs", howmany); if (nm_next(lease_idx, lim) == kring->nkr_lease_idx) { /* yes i am the last one */ - ND("roll back nkr_hwlease to %d", j); + nm_prdis("roll back nkr_hwlease to %d", j); kring->nkr_hwlease = j; } else { while (howmany-- > 0) { @@ -1323,7 +1324,7 @@ netmap_vale_vp_create(struct nmreq_header *hdr, struct ifnet *ifp, na->nm_krings_create = netmap_vale_vp_krings_create; na->nm_krings_delete = netmap_vale_vp_krings_delete; na->nm_dtor = netmap_vale_vp_dtor; - ND("nr_mem_id %d", req->nr_mem_id); + nm_prdis("nr_mem_id %d", req->nr_mem_id); na->nm_mem = nmd ? netmap_mem_get(nmd): netmap_mem_private_new( @@ -1594,11 +1595,11 @@ netmap_vi_create(struct nmreq_header *hdr, int autodelete) if (error) { goto err_2; } - ND("returning nr_mem_id %d", req->nr_mem_id); + nm_prdis("returning nr_mem_id %d", req->nr_mem_id); if (nmd) netmap_mem_put(nmd); NMG_UNLOCK(); - ND("created %s", ifp->if_xname); + nm_prdis("created %s", ifp->if_xname); return 0; err_2: From 6fd2dcd428e13914a1f9a6cbd457befcc655675a Mon Sep 17 00:00:00 2001 From: Bruce Evans Date: Tue, 5 Feb 2019 15:34:55 +0000 Subject: [PATCH 31/36] Fix zapping of static hints and env in init_static_kenv(). Environments are terminated by 2 NULs, but only 1 NUL was zapped. Zapping only 1 NUL just splits the first string into an empty string and a corrupted string. All other strings in static hints and env remained live early in the boot when they were supposed to be disabled. Support calling init_static_kenv() very early in the boot, so as to use the env very early in the boot. Then the pointer to the loader env may change after the first call due to enabling paging or otherwise remapping the pointer. Another call is needed to register the change. Don't use the previous pointer in this (or any) later call. Reviewed by: kib --- sys/kern/kern_environment.c | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/sys/kern/kern_environment.c b/sys/kern/kern_environment.c index a2480c3d689e..af3449f2b0bd 100644 --- a/sys/kern/kern_environment.c +++ b/sys/kern/kern_environment.c @@ -250,6 +250,23 @@ init_static_kenv(char *buf, size_t len) char *eval; KASSERT(!dynamic_kenv, ("kenv: dynamic_kenv already initialized")); + + /* + * We may be called twice, with the second call needed to relocate + * md_envp after enabling paging. md_envp is then garbage if it is + * not null and the relocation will move it. Discard it so as to + * not crash using its old value in our first call to kern_getenv(). + * + * The second call gives the same environment as the first except + * in silly configurations where the static env disables itself. + * + * Other env calls don't handle possibly-garbage pointers, so must + * not be made between enabling paging and calling here. + */ + md_envp = NULL; + md_env_len = 0; + md_env_pos = 0; + /* * Give the static environment a chance to disable the loader(8) * environment first. This is done with loader_env.disabled=1. @@ -275,12 +292,16 @@ init_static_kenv(char *buf, size_t len) md_env_pos = 0; eval = kern_getenv("static_env.disabled"); - if (eval != NULL && strcmp(eval, "1") == 0) - *kern_envp = '\0'; + if (eval != NULL && strcmp(eval, "1") == 0) { + kern_envp[0] = '\0'; + kern_envp[1] = '\0'; + } } eval = kern_getenv("static_hints.disabled"); - if (eval != NULL && strcmp(eval, "1") == 0) - *static_hints = '\0'; + if (eval != NULL && strcmp(eval, "1") == 0) { + static_hints[0] = '\0'; + static_hints[1] = '\0'; + } } static void From 3a19918442bf0cb5c41ac7f7d1217c462a09813f Mon Sep 17 00:00:00 2001 From: Bruce Evans Date: Tue, 5 Feb 2019 16:59:29 +0000 Subject: [PATCH 32/36] My recent fix for programmable function keys in syscons only worked when TEKEN_CONS25 is configured. Fix this by adding a function to set the flag that enables the fix and always calling this function for syscons. Expand the man page for teken_set_cons25(). This function is not very useful since it can only set but not clear 1 flag. In practice, it is only used when TEKEN_CONS25 is configured and all that does is choose the the default emulation for syscons at compile time. --- sys/dev/syscons/scterm-teken.c | 1 + sys/teken/libteken/teken.3 | 19 +++++++++++++++++-- sys/teken/teken.c | 9 ++++++++- sys/teken/teken.h | 1 + 4 files changed, 27 insertions(+), 3 deletions(-) diff --git a/sys/dev/syscons/scterm-teken.c b/sys/dev/syscons/scterm-teken.c index 290e836f91fb..ae231f01d294 100644 --- a/sys/dev/syscons/scterm-teken.c +++ b/sys/dev/syscons/scterm-teken.c @@ -144,6 +144,7 @@ scteken_init(scr_stat *scp, void **softc, int code) #ifdef TEKEN_CONS25 teken_set_cons25(&ts->ts_teken); #endif /* TEKEN_CONS25 */ + teken_set_cons25keys(&ts->ts_teken); scteken_sync_internal(scp, ts); break; } diff --git a/sys/teken/libteken/teken.3 b/sys/teken/libteken/teken.3 index 3e954470bdd7..2f4a0d8eaf75 100644 --- a/sys/teken/libteken/teken.3 +++ b/sys/teken/libteken/teken.3 @@ -66,6 +66,8 @@ .Fn teken_set_8bit "teken_t *t" .Ft void .Fn teken_set_cons25 "teken_t *t" +.Ft void +.Fn teken_set_cons25keys "teken_t *t" .Sh DESCRIPTION The .Nm @@ -194,11 +196,24 @@ which can be used to support character sets like CP437 and ISO-8859-1. .Pp The .Fn teken_set_cons25 -function switches terminal emulation to +function sets the terminal emulation to .Dv cons25 , -which is used by versions of +which was the default for +.Xr syscons 4 +in versions of .Fx prior to 9.0. +This function is only useful for initialization. +The emulation can be changed at any time using an escape sequence, +and this function is not used then. +.Pp +The +.Fn teken_set_cons25keys +function tells the +.Fn teken_get_sequence +function to not interpret special keys in +.Dv cons25 +mode. .Sh SEE ALSO .Xr ncurses 3 , .Xr termcap 3 , diff --git a/sys/teken/teken.c b/sys/teken/teken.c index f4e4c8a57a2d..64fd42622b5f 100644 --- a/sys/teken/teken.c +++ b/sys/teken/teken.c @@ -412,7 +412,14 @@ void teken_set_cons25(teken_t *t) { - t->t_stateflags |= TS_CONS25 | TS_CONS25KEYS; + t->t_stateflags |= TS_CONS25; +} + +void +teken_set_cons25keys(teken_t *t) +{ + + t->t_stateflags |= TS_CONS25KEYS; } /* diff --git a/sys/teken/teken.h b/sys/teken/teken.h index 5ee2474ed455..0a3928a9ffd1 100644 --- a/sys/teken/teken.h +++ b/sys/teken/teken.h @@ -212,6 +212,7 @@ const char *teken_get_sequence(const teken_t *, unsigned int); /* Legacy features. */ void teken_set_8bit(teken_t *); void teken_set_cons25(teken_t *); +void teken_set_cons25keys(teken_t *); /* Color conversion. */ teken_color_t teken_256to16(teken_color_t); From 78223db29ce64f175c8a886d71fdccce82f32211 Mon Sep 17 00:00:00 2001 From: Bruce Evans Date: Tue, 5 Feb 2019 17:17:12 +0000 Subject: [PATCH 33/36] Fix missing translation of old ioctls for KDSETMODE, KDSBORDER and CONS_SETWINORG. After translation, the last 2 are not supported, but the first one has incomplete support that is enough to run old versions of X. --- sys/dev/vt/vt_core.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/sys/dev/vt/vt_core.c b/sys/dev/vt/vt_core.c index 053da082c2fe..2f9413aaffd2 100644 --- a/sys/dev/vt/vt_core.c +++ b/sys/dev/vt/vt_core.c @@ -2114,12 +2114,21 @@ vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data, case _IO('K', 8): cmd = KDMKTONE; break; + case _IO('K', 10): + cmd = KDSETMODE; + break; + case _IO('K', 13): + cmd = KDSBORDER; + break; case _IO('K', 63): cmd = KIOCSOUND; break; case _IO('K', 66): cmd = KDSETLED; break; + case _IO('c', 104): + cmd = CONS_SETWINORG; + break; case _IO('c', 110): cmd = CONS_SETKBD; break; From 762138f78f0661ae77b7913a28b69d01f7c69b2a Mon Sep 17 00:00:00 2001 From: Konstantin Belousov Date: Tue, 5 Feb 2019 17:49:27 +0000 Subject: [PATCH 34/36] amd64: clear callee-preserved registers on syscall exit. %r8, %r10, and on non-KPTI configuration %r9 were not restored on fast return from a syscall. Reviewed by: markj Approved by: so Security: CVE-2019-5595 Sponsored by: The FreeBSD Foundation MFC after: 0 minutes --- sys/amd64/amd64/exception.S | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sys/amd64/amd64/exception.S b/sys/amd64/amd64/exception.S index 91767094954b..c0f57ad4babc 100644 --- a/sys/amd64/amd64/exception.S +++ b/sys/amd64/amd64/exception.S @@ -521,12 +521,14 @@ fast_syscall_common: movq TF_RFLAGS(%rsp),%r11 /* original %rflags */ movq TF_RIP(%rsp),%rcx /* original %rip */ movq TF_RSP(%rsp),%rsp /* user stack pointer */ + xorl %r8d,%r8d /* zero the rest of GPRs */ + xorl %r10d,%r10d cmpq $~0,PCPU(UCR3) je 2f movq PCPU(UCR3),%r9 movq %r9,%cr3 - xorl %r9d,%r9d -2: swapgs +2: xorl %r9d,%r9d + swapgs sysretq 3: /* AST scheduled. */ From 401ca034cdb6cc418a461ce70ab28f92d83d51fb Mon Sep 17 00:00:00 2001 From: Mark Johnston Date: Tue, 5 Feb 2019 17:55:08 +0000 Subject: [PATCH 35/36] Avoid leaking fp references when truncating SCM_RIGHTS control messages. Reported by: pho Approved by: so MFC after: 0 minutes Security: CVE-2019-5596 Sponsored by: The FreeBSD Foundation --- sys/kern/uipc_syscalls.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c index b86f041c54ef..0f0c8888a147 100644 --- a/sys/kern/uipc_syscalls.c +++ b/sys/kern/uipc_syscalls.c @@ -1605,8 +1605,10 @@ m_dispose_extcontrolm(struct mbuf *m) fd = *fds++; error = fget(td, fd, &cap_no_rights, &fp); - if (error == 0) + if (error == 0) { fdclose(td, fp, fd); + fdrop(fp, td); + } } } clen -= datalen; From 4a8450ceff3860a601101fcb6db6a5433b9737ce Mon Sep 17 00:00:00 2001 From: Leandro Lupori Date: Tue, 5 Feb 2019 18:16:14 +0000 Subject: [PATCH 36/36] [ppc64] llan: fix fatal kernel trap when system is low on memory When running several builders in parallel, on QEMU, with 8GB of memory, a fatal kernel trap (0x300 (data storage interrupt)) caused by llan driver is sometimes observed, when the system starts to run out of swap space. This happens because, at llan_intr(), a phyp call to add a logical LAN buffer is always made when llan_add_rxbuf() fails, even if it fails to allocate a new buffer. PR: 235489 Reviewed by: jhibbits Differential Revision: https://reviews.freebsd.org/D19084 --- sys/powerpc/pseries/phyp_llan.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/sys/powerpc/pseries/phyp_llan.c b/sys/powerpc/pseries/phyp_llan.c index b21515e1d3da..58333214ba06 100644 --- a/sys/powerpc/pseries/phyp_llan.c +++ b/sys/powerpc/pseries/phyp_llan.c @@ -386,8 +386,6 @@ llan_intr(void *xsc) /* llan_add_rxbuf does DMA sync and unload as well as requeue */ if (llan_add_rxbuf(sc, rx) != 0) { if_inc_counter(sc->ifp, IFCOUNTER_IERRORS, 1); - phyp_hcall(H_ADD_LOGICAL_LAN_BUFFER, sc->unit, - rx->rx_bufdesc); continue; }