syslogd: Always support recursive config includes

[jfree]

Summary

There is no external knob to disable config includes, so remove the
internal boolean option.

[markj]

I'm not sure this change is right, see my comment in D41358.

usr.sbin/syslogd/syslogd.c

 static int        unp_externalize(struct mbuf *, struct mbuf **, int);
 static int        unp_externalize_fp(struct file *);
 static struct mbuf        *unp_addsockcred(struct thread *, struct mbuf *);
 static void        unp_process_defers(void * __unused, int);
 
 static void
 unp_pcb_hold(struct unpcb *unp)
 {
-        MPASS(unp->unp_refcount);
-        refcount_acquire(&unp->unp_refcount);
+        u_int old __unused;
+
+        old = refcount_acquire(&unp->unp_refcount);
+        KASSERT(old > 0, ("%s: unpcb %p has no references", __func__, unp));
 }
 
-static int
+static __result_use_check bool
 unp_pcb_rele(struct unpcb *unp)
 {
-        int freed;
+        bool ret;
 
         UNP_PCB_LOCK_ASSERT(unp);
-        MPASS(unp->unp_refcount);
-        if ((freed = refcount_release(&unp->unp_refcount))) {
-                /* we got here with having detached? */
-                MPASS(unp->unp_socket == NULL);
+
+        if ((ret = refcount_release(&unp->unp_refcount))) {
                 UNP_PCB_UNLOCK(unp);
                 UNP_PCB_LOCK_DESTROY(unp);
                 uma_zfree(unp_zone, unp);
         }
-        return (freed);
+        return (ret);
 }
 
 static void
 unp_pcb_lock2(struct unpcb *unp, struct unpcb *unp2)
 {
         MPASS(unp != unp2);
         UNP_PCB_UNLOCK_ASSERT(unp);
         UNP_PCB_UNLOCK_ASSERT(unp2);
uipc_attach(struct socket *so, int proto, struct thread *td)
         }
         unp = uma_zalloc(unp_zone, M_NOWAIT | M_ZERO);
         if (unp == NULL)
                 return (ENOBUFS);
         LIST_INIT(&unp->unp_refs);
         UNP_PCB_LOCK_INIT(unp);
         unp->unp_socket = so;
         so->so_pcb = unp;
-        unp->unp_refcount = 1;
+        refcount_init(&unp->unp_refcount, 1);
 
         if ((locked = UNP_LINK_WOWNED()) == false)
                 UNP_LINK_WLOCK();
 
         unp->unp_gencnt = ++unp_gencnt;
         unp->unp_ino = ++unp_ino;
         unp_count++;
         switch (so->so_type) {

 unp_pcblist(SYSCTL_HANDLER_ARGS)
 {
         struct unpcb *unp, **unp_list;
         unp_gen_t gencnt;
         struct xunpgen *xug;
         struct unp_head *head;
         struct xunpcb *xu;
         u_int i;
-        int error, freeunp, n;
+        int error, n;
 
         switch ((intptr_t)arg1) {
         case SOCK_STREAM:
                 head = &unp_shead;
                 break;
 
         case SOCK_DGRAM:
                 head = &unp_dhead;
unp_pcblist(SYSCTL_HANDLER_ARGS)
         UNP_LINK_RUNLOCK();
         n = i;                        /* In case we lost some during malloc. */
 
         error = 0;
         xu = malloc(sizeof(*xu), M_TEMP, M_WAITOK | M_ZERO);
         for (i = 0; i < n; i++) {
                 unp = unp_list[i];
                 UNP_PCB_LOCK(unp);
-                freeunp = unp_pcb_rele(unp);
+                if (unp_pcb_rele(unp))
+                        continue;
 
-                if (freeunp == 0 && unp->unp_gencnt <= gencnt) {
+                if (unp->unp_gencnt <= gencnt) {
                         xu->xu_len = sizeof *xu;
                         xu->xu_unpp = (uintptr_t)unp;
                         /*
                          * XXX - need more locking here to protect against
                          * connect/disconnect races for SMP.
                          */
                         if (unp->unp_addr != NULL)
                                 bcopy(unp->unp_addr, &xu->xu_addr,
if (unp->unp_gencnt <= gencnt) {
                         xu->unp_vnode = (uintptr_t)unp->unp_vnode;
                         xu->unp_conn = (uintptr_t)unp->unp_conn;
                         xu->xu_firstref = (uintptr_t)LIST_FIRST(&unp->unp_refs);
                         xu->xu_nextref = (uintptr_t)LIST_NEXT(unp, unp_reflink);
                         xu->unp_gencnt = unp->unp_gencnt;
                         sotoxsocket(unp->unp_socket, &xu->xu_socket);
                         UNP_PCB_UNLOCK(unp);
                         error = SYSCTL_OUT(req, xu, sizeof *xu);
-                } else  if (freeunp == 0)
+                } else {
                         UNP_PCB_UNLOCK(unp);
                 }
+        }
         free(xu, M_TEMP);
         if (!error) {
                 /*
                  * Give the user an updated idea of our state.  If the
                  * generation differs from what we told her before, she knows
                  * that something happened while we were processing this
                  * request, and it might be necessary to retry.
                  */

 
 static void
 unp_zone_change(void *tag)
 {
 
         uma_zone_set_max(unp_zone, maxsockets);
 }
 
+#ifdef INVARIANTS
 static void
+unp_zdtor(void *mem, int size __unused, void *arg __unused)
+{
+        struct unpcb *unp;
+
+        unp = mem;
+
+        KASSERT(LIST_EMPTY(&unp->unp_refs),
+            ("%s: unpcb %p has lingering refs", __func__, unp));
+        KASSERT(unp->unp_socket == NULL,
+            ("%s: unpcb %p has socket backpointer", __func__, unp));
+        KASSERT(unp->unp_vnode == NULL,
+            ("%s: unpcb %p has vnode references", __func__, unp));
+        KASSERT(unp->unp_conn == NULL,
+            ("%s: unpcb %p is still connected", __func__, unp));
+        KASSERT(unp->unp_addr == NULL,
+            ("%s: unpcb %p has leaked addr", __func__, unp));
+}
+#endif
+
+static void
 unp_init(void)
 {
+        uma_dtor dtor;
 
 #ifdef VIMAGE
         if (!IS_DEFAULT_VNET(curvnet))
                 return;
 #endif
-        unp_zone = uma_zcreate("unpcb", sizeof(struct unpcb), NULL, NULL,
+
+#ifdef INVARIANTS
+        dtor = unp_zdtor;
+#else
+        dtor = NULL;
+#endif
+        unp_zone = uma_zcreate("unpcb", sizeof(struct unpcb), NULL, dtor,
             NULL, NULL, UMA_ALIGN_CACHE, 0);
-        if (unp_zone == NULL)
-                panic("unp_init");
         uma_zone_set_max(unp_zone, maxsockets);
         uma_zone_set_warning(unp_zone, "kern.ipc.maxsockets limit reached");
         EVENTHANDLER_REGISTER(maxsockets_change, unp_zone_change,
             NULL, EVENTHANDLER_PRI_ANY);
         LIST_INIT(&unp_dhead);
         LIST_INIT(&unp_shead);
         LIST_INIT(&unp_sphead);
         SLIST_INIT(&unp_defers);