locale: more output fixes

[yuripv]

Summary

• make abday, day, abmon, mon, am_pm output quoting match linux
• workaround localeconv() issue for mon_grouping and grouping (PR172215)
• for other values not available in default locale, output -1 instead of 127 (CHAR_MAX) as returned by localeconv()

With these changes, output of locale and locale -k for all keywords
specified by POSIX exactly matches the linux one.

P.S. Baptiste, if I should include anyone else interested in reviewing locale stuff, please let me know.

Test Plan

New test cases provided, existing ones updated.

Compare the output of locale and locale -k for all POSIX specified keywords against linux.

[bapt]

This looks fine to me, tested locally with success.

Note that I am fine with reviewing the locale patches and I am not sure anyone else is really interested into locale stuff :(

head/usr.bin/locale/locale.c

struct its_col {
         uint64_t        col_id;         /* Collection ID */
 };
 
 struct gicv3_its_irqsrc {
         struct intr_irqsrc      gi_isrc;
         u_int                   gi_id;
         u_int                   gi_lpi;
         struct its_dev          *gi_its_dev;
+        TAILQ_ENTRY(gicv3_its_irqsrc) gi_link;
 };
 
 struct gicv3_its_softc {
         device_t        dev;
         struct intr_pic *sc_pic;
         struct resource *sc_its_res;
 
         cpuset_t        sc_cpus;
struct gicv3_its_softc {
         vm_offset_t sc_pend_base[MAXCPU];
 
         /* Command handling */
         struct mtx sc_its_cmd_lock;
         struct its_cmd *sc_its_cmd_base; /* Command circular buffer address */
         size_t sc_its_cmd_next_idx;
 
         vmem_t *sc_irq_alloc;
-        struct gicv3_its_irqsrc *sc_irqs;
+        struct gicv3_its_irqsrc **sc_irqs;
         u_int   sc_irq_base;
         u_int   sc_irq_length;
+        u_int   sc_irq_count;
 
         struct mtx sc_its_dev_lock;
         TAILQ_HEAD(its_dev_list, its_dev) sc_its_dev_list;
+        TAILQ_HEAD(free_irqs, gicv3_its_irqsrc) sc_free_irqs;
 
 #define ITS_FLAGS_CMDQ_FLUSH            0x00000001
 #define ITS_FLAGS_LPI_CONF_FLUSH        0x00000002
 #define ITS_FLAGS_ERRATA_CAVIUM_22375   0x00000004
         u_int sc_its_flags;
         bool    trace_enable;
 };
 
gicv3_its_init_sysctl(struct gicv3_its_softc *sc)
 
         return (0);
 }
 
 static int
 gicv3_its_attach(device_t dev)
 {
         struct gicv3_its_softc *sc;
-        const char *name;
         uint32_t iidr;
         int domain, err, i, rid;
 
         sc = device_get_softc(dev);
 
         sc->sc_irq_length = gicv3_get_nirqs(dev);
         sc->sc_irq_base = GIC_FIRST_LPI;
         sc->sc_irq_base += device_get_unit(dev) * sc->sc_irq_length;
gicv3_its_attach(device_t dev)
 
         /* And the pending tebles */
         gicv3_its_pendtables_init(sc);
 
         /* Enable LPIs on this CPU */
         its_init_cpu(dev, sc);
 
         TAILQ_INIT(&sc->sc_its_dev_list);
+        TAILQ_INIT(&sc->sc_free_irqs);
 
         /*
          * Create the vmem object to allocate INTRNG IRQs from. We try to
          * use all IRQs not already used by the GICv3.
          * XXX: This assumes there are no other interrupt controllers in the
          * system.
          */
         sc->sc_irq_alloc = vmem_create(device_get_nameunit(dev), 0,
             gicv3_get_nirqs(dev), 1, 0, M_FIRSTFIT | M_WAITOK);
 
         sc->sc_irqs = malloc(sizeof(*sc->sc_irqs) * sc->sc_irq_length,
             M_GICV3_ITS, M_WAITOK | M_ZERO);
-        name = device_get_nameunit(dev);
-        for (i = 0; i < sc->sc_irq_length; i++) {
-                sc->sc_irqs[i].gi_id = -1;
-                sc->sc_irqs[i].gi_lpi = i + sc->sc_irq_base - GIC_FIRST_LPI;
-                err = intr_isrc_register(&sc->sc_irqs[i].gi_isrc, dev, 0,
-                    "%s,%u", name, i);
-        }
 
         /* For GIC-500 install tracking sysctls. */
         if ((iidr & (GITS_IIDR_PRODUCT_MASK | GITS_IIDR_IMPLEMENTOR_MASK)) ==
             GITS_IIDR_RAW(GITS_IIDR_IMPL_ARM, GITS_IIDR_PROD_GIC500, 0, 0))
                 gicv3_its_init_sysctl(sc);
 
         return (0);
 }

 static int
 gicv3_its_intr(void *arg, uintptr_t irq)
 {
         struct gicv3_its_softc *sc = arg;
         struct gicv3_its_irqsrc *girq;
         struct trapframe *tf;
 
         irq -= sc->sc_irq_base;
-        girq = &sc->sc_irqs[irq];
+        girq = sc->sc_irqs[irq];
         if (girq == NULL)
                 panic("gicv3_its_intr: Invalid interrupt %ld",
                     irq + sc->sc_irq_base);
 
         tf = curthread->td_intr_frame;
         intr_isrc_dispatch(&girq->gi_isrc, tf);
         return (FILTER_HANDLED);
 }
its_device_release(device_t dev, struct its_dev *its_dev)
 
         /* Free the IRQ allocation */
         vmem_free(sc->sc_irq_alloc, its_dev->lpis.lpi_base,
             its_dev->lpis.lpi_num);
 
         free(its_dev, M_GICV3_ITS);
 }
 
+static struct gicv3_its_irqsrc *
+gicv3_its_alloc_irqsrc(device_t dev, struct gicv3_its_softc *sc, u_int irq)
+{
+        struct gicv3_its_irqsrc *girq = NULL;
+
+        KASSERT(sc->sc_irqs[irq] == NULL,
+            ("%s: Interrupt %u already allocated", __func__, irq));
+        mtx_lock_spin(&sc->sc_its_dev_lock);
+        if (!TAILQ_EMPTY(&sc->sc_free_irqs)) {
+                girq = TAILQ_FIRST(&sc->sc_free_irqs);
+                TAILQ_REMOVE(&sc->sc_free_irqs, girq, gi_link);
+        }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
+        if (girq == NULL) {
+                girq = malloc(sizeof(*girq), M_GICV3_ITS,
+                    M_NOWAIT | M_ZERO);
+                if (girq == NULL)
+                        return (NULL);
+                girq->gi_id = -1;
+                if (intr_isrc_register(&girq->gi_isrc, dev, 0,
+                    "%s,%u", device_get_nameunit(dev), irq) != 0) {
+                        free(girq, M_GICV3_ITS);
+                        return (NULL);
+                }
+        }
+        girq->gi_lpi = irq + sc->sc_irq_base - GIC_FIRST_LPI;
+        sc->sc_irqs[irq] = girq;
+
+        return (girq);
+}
+
+static void
+gicv3_its_release_irqsrc(struct gicv3_its_softc *sc,
+    struct gicv3_its_irqsrc *girq)
+{
+        u_int irq;
+
+        mtx_assert(&sc->sc_its_dev_lock, MA_OWNED);
+
+        irq = girq->gi_lpi + GIC_FIRST_LPI - sc->sc_irq_base;
+        sc->sc_irqs[irq] = NULL;
+
+        girq->gi_id = -1;
+        girq->gi_its_dev = NULL;
+        TAILQ_INSERT_TAIL(&sc->sc_free_irqs, girq, gi_link);
+}
+
 static int
 gicv3_its_alloc_msi(device_t dev, device_t child, int count, int maxcount,
     device_t *pic, struct intr_irqsrc **srcs)
 {
         struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         u_int irq;
         int i;
 
         its_dev = its_device_get(dev, child, count);
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free >= count,
             ("gicv3_its_alloc_msi: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
+
+        /* Allocate the irqsrc for each MSI */
         for (i = 0; i < count; i++, irq++) {
                 its_dev->lpis.lpi_free--;
-                girq = &sc->sc_irqs[irq];
+                srcs[i] = (struct intr_irqsrc *)gicv3_its_alloc_irqsrc(dev,
+                    sc, irq);
+                if (srcs[i] == NULL)
+                        break;
+        }
+
+        /* The allocation failed, release them */
+        if (i != count) {
+                mtx_lock_spin(&sc->sc_its_dev_lock);
+                for (i = 0; i < count; i++) {
+                        girq = (struct gicv3_its_irqsrc *)srcs[i];
+                        if (girq == NULL)
+                                break;
+                        gicv3_its_release_irqsrc(sc, girq);
+                        srcs[i] = NULL;
+                }
+                mtx_unlock_spin(&sc->sc_its_dev_lock);
+                return (ENXIO);
+        }
+
+        /* Finish the allocation now we have all MSI irqsrcs */
+        for (i = 0; i < count; i++) {
+                girq = (struct gicv3_its_irqsrc *)srcs[i];
                 girq->gi_id = i;
                 girq->gi_its_dev = its_dev;
-                srcs[i] = (struct intr_irqsrc *)girq;
 
                 /* Map the message to the given IRQ */
                 gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
                 its_cmd_mapti(dev, girq);
         }
         its_dev->lpis.lpi_busy += count;
         *pic = dev;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msi(device_t dev, device_t child, int count,
     struct intr_irqsrc **isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         int i;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msi: Releasing a MSI interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy >= count,
             ("gicv3_its_release_msi: Releasing more interrupts than "
              "were allocated: releasing %d, allocated %d", count,
              its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
+        mtx_lock_spin(&sc->sc_its_dev_lock);
         for (i = 0; i < count; i++) {
                 girq = (struct gicv3_its_irqsrc *)isrc[i];
-                girq->gi_id = -1;
-                girq->gi_its_dev = NULL;
+                gicv3_its_release_irqsrc(sc, girq);
         }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
         its_dev->lpis.lpi_busy -= count;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 
gicv3_its_alloc_msix(device_t dev, device_t child, device_t *pic,
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free > 0,
             ("gicv3_its_alloc_msix: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
-        girq = &sc->sc_irqs[irq];
+
+        girq = gicv3_its_alloc_irqsrc(dev, sc, irq);
+        if (girq == NULL)
+                return (ENXIO);
         girq->gi_id = its_dev->lpis.lpi_busy;
         girq->gi_its_dev = its_dev;
 
         its_dev->lpis.lpi_free--;
         its_dev->lpis.lpi_busy++;
 
         /* Map the message to the given IRQ */
         gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
         its_cmd_mapti(dev, girq);
 
         *pic = dev;
         *isrcp = (struct intr_irqsrc *)girq;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msix(device_t dev, device_t child, struct intr_irqsrc *isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msix: Releasing a MSI-X interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy > 0,
             ("gicv3_its_release_msix: Releasing more interrupts than "
              "were allocated: allocated %d", its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
         girq = (struct gicv3_its_irqsrc *)isrc;
-        girq->gi_its_dev = NULL;
-        girq->gi_id = -1;
+        gicv3_its_release_irqsrc(sc, girq);
         its_dev->lpis.lpi_busy--;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 

head/usr.bin/locale/tests/Makefile

struct its_col {
         uint64_t        col_id;         /* Collection ID */
 };
 
 struct gicv3_its_irqsrc {
         struct intr_irqsrc      gi_isrc;
         u_int                   gi_id;
         u_int                   gi_lpi;
         struct its_dev          *gi_its_dev;
+        TAILQ_ENTRY(gicv3_its_irqsrc) gi_link;
 };
 
 struct gicv3_its_softc {
         device_t        dev;
         struct intr_pic *sc_pic;
         struct resource *sc_its_res;
 
         cpuset_t        sc_cpus;
struct gicv3_its_softc {
         vm_offset_t sc_pend_base[MAXCPU];
 
         /* Command handling */
         struct mtx sc_its_cmd_lock;
         struct its_cmd *sc_its_cmd_base; /* Command circular buffer address */
         size_t sc_its_cmd_next_idx;
 
         vmem_t *sc_irq_alloc;
-        struct gicv3_its_irqsrc *sc_irqs;
+        struct gicv3_its_irqsrc **sc_irqs;
         u_int   sc_irq_base;
         u_int   sc_irq_length;
+        u_int   sc_irq_count;
 
         struct mtx sc_its_dev_lock;
         TAILQ_HEAD(its_dev_list, its_dev) sc_its_dev_list;
+        TAILQ_HEAD(free_irqs, gicv3_its_irqsrc) sc_free_irqs;
 
 #define ITS_FLAGS_CMDQ_FLUSH            0x00000001
 #define ITS_FLAGS_LPI_CONF_FLUSH        0x00000002
 #define ITS_FLAGS_ERRATA_CAVIUM_22375   0x00000004
         u_int sc_its_flags;
         bool    trace_enable;
 };
 
gicv3_its_init_sysctl(struct gicv3_its_softc *sc)
 
         return (0);
 }
 
 static int
 gicv3_its_attach(device_t dev)
 {
         struct gicv3_its_softc *sc;
-        const char *name;
         uint32_t iidr;
         int domain, err, i, rid;
 
         sc = device_get_softc(dev);
 
         sc->sc_irq_length = gicv3_get_nirqs(dev);
         sc->sc_irq_base = GIC_FIRST_LPI;
         sc->sc_irq_base += device_get_unit(dev) * sc->sc_irq_length;
gicv3_its_attach(device_t dev)
 
         /* And the pending tebles */
         gicv3_its_pendtables_init(sc);
 
         /* Enable LPIs on this CPU */
         its_init_cpu(dev, sc);
 
         TAILQ_INIT(&sc->sc_its_dev_list);
+        TAILQ_INIT(&sc->sc_free_irqs);
 
         /*
          * Create the vmem object to allocate INTRNG IRQs from. We try to
          * use all IRQs not already used by the GICv3.
          * XXX: This assumes there are no other interrupt controllers in the
          * system.
          */
         sc->sc_irq_alloc = vmem_create(device_get_nameunit(dev), 0,
             gicv3_get_nirqs(dev), 1, 0, M_FIRSTFIT | M_WAITOK);
 
         sc->sc_irqs = malloc(sizeof(*sc->sc_irqs) * sc->sc_irq_length,
             M_GICV3_ITS, M_WAITOK | M_ZERO);
-        name = device_get_nameunit(dev);
-        for (i = 0; i < sc->sc_irq_length; i++) {
-                sc->sc_irqs[i].gi_id = -1;
-                sc->sc_irqs[i].gi_lpi = i + sc->sc_irq_base - GIC_FIRST_LPI;
-                err = intr_isrc_register(&sc->sc_irqs[i].gi_isrc, dev, 0,
-                    "%s,%u", name, i);
-        }
 
         /* For GIC-500 install tracking sysctls. */
         if ((iidr & (GITS_IIDR_PRODUCT_MASK | GITS_IIDR_IMPLEMENTOR_MASK)) ==
             GITS_IIDR_RAW(GITS_IIDR_IMPL_ARM, GITS_IIDR_PROD_GIC500, 0, 0))
                 gicv3_its_init_sysctl(sc);
 
         return (0);
 }

 static int
 gicv3_its_intr(void *arg, uintptr_t irq)
 {
         struct gicv3_its_softc *sc = arg;
         struct gicv3_its_irqsrc *girq;
         struct trapframe *tf;
 
         irq -= sc->sc_irq_base;
-        girq = &sc->sc_irqs[irq];
+        girq = sc->sc_irqs[irq];
         if (girq == NULL)
                 panic("gicv3_its_intr: Invalid interrupt %ld",
                     irq + sc->sc_irq_base);
 
         tf = curthread->td_intr_frame;
         intr_isrc_dispatch(&girq->gi_isrc, tf);
         return (FILTER_HANDLED);
 }
its_device_release(device_t dev, struct its_dev *its_dev)
 
         /* Free the IRQ allocation */
         vmem_free(sc->sc_irq_alloc, its_dev->lpis.lpi_base,
             its_dev->lpis.lpi_num);
 
         free(its_dev, M_GICV3_ITS);
 }
 
+static struct gicv3_its_irqsrc *
+gicv3_its_alloc_irqsrc(device_t dev, struct gicv3_its_softc *sc, u_int irq)
+{
+        struct gicv3_its_irqsrc *girq = NULL;
+
+        KASSERT(sc->sc_irqs[irq] == NULL,
+            ("%s: Interrupt %u already allocated", __func__, irq));
+        mtx_lock_spin(&sc->sc_its_dev_lock);
+        if (!TAILQ_EMPTY(&sc->sc_free_irqs)) {
+                girq = TAILQ_FIRST(&sc->sc_free_irqs);
+                TAILQ_REMOVE(&sc->sc_free_irqs, girq, gi_link);
+        }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
+        if (girq == NULL) {
+                girq = malloc(sizeof(*girq), M_GICV3_ITS,
+                    M_NOWAIT | M_ZERO);
+                if (girq == NULL)
+                        return (NULL);
+                girq->gi_id = -1;
+                if (intr_isrc_register(&girq->gi_isrc, dev, 0,
+                    "%s,%u", device_get_nameunit(dev), irq) != 0) {
+                        free(girq, M_GICV3_ITS);
+                        return (NULL);
+                }
+        }
+        girq->gi_lpi = irq + sc->sc_irq_base - GIC_FIRST_LPI;
+        sc->sc_irqs[irq] = girq;
+
+        return (girq);
+}
+
+static void
+gicv3_its_release_irqsrc(struct gicv3_its_softc *sc,
+    struct gicv3_its_irqsrc *girq)
+{
+        u_int irq;
+
+        mtx_assert(&sc->sc_its_dev_lock, MA_OWNED);
+
+        irq = girq->gi_lpi + GIC_FIRST_LPI - sc->sc_irq_base;
+        sc->sc_irqs[irq] = NULL;
+
+        girq->gi_id = -1;
+        girq->gi_its_dev = NULL;
+        TAILQ_INSERT_TAIL(&sc->sc_free_irqs, girq, gi_link);
+}
+
 static int
 gicv3_its_alloc_msi(device_t dev, device_t child, int count, int maxcount,
     device_t *pic, struct intr_irqsrc **srcs)
 {
         struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         u_int irq;
         int i;
 
         its_dev = its_device_get(dev, child, count);
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free >= count,
             ("gicv3_its_alloc_msi: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
+
+        /* Allocate the irqsrc for each MSI */
         for (i = 0; i < count; i++, irq++) {
                 its_dev->lpis.lpi_free--;
-                girq = &sc->sc_irqs[irq];
+                srcs[i] = (struct intr_irqsrc *)gicv3_its_alloc_irqsrc(dev,
+                    sc, irq);
+                if (srcs[i] == NULL)
+                        break;
+        }
+
+        /* The allocation failed, release them */
+        if (i != count) {
+                mtx_lock_spin(&sc->sc_its_dev_lock);
+                for (i = 0; i < count; i++) {
+                        girq = (struct gicv3_its_irqsrc *)srcs[i];
+                        if (girq == NULL)
+                                break;
+                        gicv3_its_release_irqsrc(sc, girq);
+                        srcs[i] = NULL;
+                }
+                mtx_unlock_spin(&sc->sc_its_dev_lock);
+                return (ENXIO);
+        }
+
+        /* Finish the allocation now we have all MSI irqsrcs */
+        for (i = 0; i < count; i++) {
+                girq = (struct gicv3_its_irqsrc *)srcs[i];
                 girq->gi_id = i;
                 girq->gi_its_dev = its_dev;
-                srcs[i] = (struct intr_irqsrc *)girq;
 
                 /* Map the message to the given IRQ */
                 gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
                 its_cmd_mapti(dev, girq);
         }
         its_dev->lpis.lpi_busy += count;
         *pic = dev;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msi(device_t dev, device_t child, int count,
     struct intr_irqsrc **isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         int i;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msi: Releasing a MSI interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy >= count,
             ("gicv3_its_release_msi: Releasing more interrupts than "
              "were allocated: releasing %d, allocated %d", count,
              its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
+        mtx_lock_spin(&sc->sc_its_dev_lock);
         for (i = 0; i < count; i++) {
                 girq = (struct gicv3_its_irqsrc *)isrc[i];
-                girq->gi_id = -1;
-                girq->gi_its_dev = NULL;
+                gicv3_its_release_irqsrc(sc, girq);
         }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
         its_dev->lpis.lpi_busy -= count;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 
gicv3_its_alloc_msix(device_t dev, device_t child, device_t *pic,
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free > 0,
             ("gicv3_its_alloc_msix: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
-        girq = &sc->sc_irqs[irq];
+
+        girq = gicv3_its_alloc_irqsrc(dev, sc, irq);
+        if (girq == NULL)
+                return (ENXIO);
         girq->gi_id = its_dev->lpis.lpi_busy;
         girq->gi_its_dev = its_dev;
 
         its_dev->lpis.lpi_free--;
         its_dev->lpis.lpi_busy++;
 
         /* Map the message to the given IRQ */
         gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
         its_cmd_mapti(dev, girq);
 
         *pic = dev;
         *isrcp = (struct intr_irqsrc *)girq;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msix(device_t dev, device_t child, struct intr_irqsrc *isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msix: Releasing a MSI-X interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy > 0,
             ("gicv3_its_release_msix: Releasing more interrupts than "
              "were allocated: allocated %d", its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
         girq = (struct gicv3_its_irqsrc *)isrc;
-        girq->gi_its_dev = NULL;
-        girq->gi_id = -1;
+        gicv3_its_release_irqsrc(sc, girq);
         its_dev->lpis.lpi_busy--;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 

head/usr.bin/locale/tests/k_flag_posix_monetary.out

struct its_col {
         uint64_t        col_id;         /* Collection ID */
 };
 
 struct gicv3_its_irqsrc {
         struct intr_irqsrc      gi_isrc;
         u_int                   gi_id;
         u_int                   gi_lpi;
         struct its_dev          *gi_its_dev;
+        TAILQ_ENTRY(gicv3_its_irqsrc) gi_link;
 };
 
 struct gicv3_its_softc {
         device_t        dev;
         struct intr_pic *sc_pic;
         struct resource *sc_its_res;
 
         cpuset_t        sc_cpus;
struct gicv3_its_softc {
         vm_offset_t sc_pend_base[MAXCPU];
 
         /* Command handling */
         struct mtx sc_its_cmd_lock;
         struct its_cmd *sc_its_cmd_base; /* Command circular buffer address */
         size_t sc_its_cmd_next_idx;
 
         vmem_t *sc_irq_alloc;
-        struct gicv3_its_irqsrc *sc_irqs;
+        struct gicv3_its_irqsrc **sc_irqs;
         u_int   sc_irq_base;
         u_int   sc_irq_length;
+        u_int   sc_irq_count;
 
         struct mtx sc_its_dev_lock;
         TAILQ_HEAD(its_dev_list, its_dev) sc_its_dev_list;
+        TAILQ_HEAD(free_irqs, gicv3_its_irqsrc) sc_free_irqs;
 
 #define ITS_FLAGS_CMDQ_FLUSH            0x00000001
 #define ITS_FLAGS_LPI_CONF_FLUSH        0x00000002
 #define ITS_FLAGS_ERRATA_CAVIUM_22375   0x00000004
         u_int sc_its_flags;
         bool    trace_enable;
 };
 
gicv3_its_init_sysctl(struct gicv3_its_softc *sc)
 
         return (0);
 }
 
 static int
 gicv3_its_attach(device_t dev)
 {
         struct gicv3_its_softc *sc;
-        const char *name;
         uint32_t iidr;
         int domain, err, i, rid;
 
         sc = device_get_softc(dev);
 
         sc->sc_irq_length = gicv3_get_nirqs(dev);
         sc->sc_irq_base = GIC_FIRST_LPI;
         sc->sc_irq_base += device_get_unit(dev) * sc->sc_irq_length;
gicv3_its_attach(device_t dev)
 
         /* And the pending tebles */
         gicv3_its_pendtables_init(sc);
 
         /* Enable LPIs on this CPU */
         its_init_cpu(dev, sc);
 
         TAILQ_INIT(&sc->sc_its_dev_list);
+        TAILQ_INIT(&sc->sc_free_irqs);
 
         /*
          * Create the vmem object to allocate INTRNG IRQs from. We try to
          * use all IRQs not already used by the GICv3.
          * XXX: This assumes there are no other interrupt controllers in the
          * system.
          */
         sc->sc_irq_alloc = vmem_create(device_get_nameunit(dev), 0,
             gicv3_get_nirqs(dev), 1, 0, M_FIRSTFIT | M_WAITOK);
 
         sc->sc_irqs = malloc(sizeof(*sc->sc_irqs) * sc->sc_irq_length,
             M_GICV3_ITS, M_WAITOK | M_ZERO);
-        name = device_get_nameunit(dev);
-        for (i = 0; i < sc->sc_irq_length; i++) {
-                sc->sc_irqs[i].gi_id = -1;
-                sc->sc_irqs[i].gi_lpi = i + sc->sc_irq_base - GIC_FIRST_LPI;
-                err = intr_isrc_register(&sc->sc_irqs[i].gi_isrc, dev, 0,
-                    "%s,%u", name, i);
-        }
 
         /* For GIC-500 install tracking sysctls. */
         if ((iidr & (GITS_IIDR_PRODUCT_MASK | GITS_IIDR_IMPLEMENTOR_MASK)) ==
             GITS_IIDR_RAW(GITS_IIDR_IMPL_ARM, GITS_IIDR_PROD_GIC500, 0, 0))
                 gicv3_its_init_sysctl(sc);
 
         return (0);
 }

 static int
 gicv3_its_intr(void *arg, uintptr_t irq)
 {
         struct gicv3_its_softc *sc = arg;
         struct gicv3_its_irqsrc *girq;
         struct trapframe *tf;
 
         irq -= sc->sc_irq_base;
-        girq = &sc->sc_irqs[irq];
+        girq = sc->sc_irqs[irq];
         if (girq == NULL)
                 panic("gicv3_its_intr: Invalid interrupt %ld",
                     irq + sc->sc_irq_base);
 
         tf = curthread->td_intr_frame;
         intr_isrc_dispatch(&girq->gi_isrc, tf);
         return (FILTER_HANDLED);
 }
its_device_release(device_t dev, struct its_dev *its_dev)
 
         /* Free the IRQ allocation */
         vmem_free(sc->sc_irq_alloc, its_dev->lpis.lpi_base,
             its_dev->lpis.lpi_num);
 
         free(its_dev, M_GICV3_ITS);
 }
 
+static struct gicv3_its_irqsrc *
+gicv3_its_alloc_irqsrc(device_t dev, struct gicv3_its_softc *sc, u_int irq)
+{
+        struct gicv3_its_irqsrc *girq = NULL;
+
+        KASSERT(sc->sc_irqs[irq] == NULL,
+            ("%s: Interrupt %u already allocated", __func__, irq));
+        mtx_lock_spin(&sc->sc_its_dev_lock);
+        if (!TAILQ_EMPTY(&sc->sc_free_irqs)) {
+                girq = TAILQ_FIRST(&sc->sc_free_irqs);
+                TAILQ_REMOVE(&sc->sc_free_irqs, girq, gi_link);
+        }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
+        if (girq == NULL) {
+                girq = malloc(sizeof(*girq), M_GICV3_ITS,
+                    M_NOWAIT | M_ZERO);
+                if (girq == NULL)
+                        return (NULL);
+                girq->gi_id = -1;
+                if (intr_isrc_register(&girq->gi_isrc, dev, 0,
+                    "%s,%u", device_get_nameunit(dev), irq) != 0) {
+                        free(girq, M_GICV3_ITS);
+                        return (NULL);
+                }
+        }
+        girq->gi_lpi = irq + sc->sc_irq_base - GIC_FIRST_LPI;
+        sc->sc_irqs[irq] = girq;
+
+        return (girq);
+}
+
+static void
+gicv3_its_release_irqsrc(struct gicv3_its_softc *sc,
+    struct gicv3_its_irqsrc *girq)
+{
+        u_int irq;
+
+        mtx_assert(&sc->sc_its_dev_lock, MA_OWNED);
+
+        irq = girq->gi_lpi + GIC_FIRST_LPI - sc->sc_irq_base;
+        sc->sc_irqs[irq] = NULL;
+
+        girq->gi_id = -1;
+        girq->gi_its_dev = NULL;
+        TAILQ_INSERT_TAIL(&sc->sc_free_irqs, girq, gi_link);
+}
+
 static int
 gicv3_its_alloc_msi(device_t dev, device_t child, int count, int maxcount,
     device_t *pic, struct intr_irqsrc **srcs)
 {
         struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         u_int irq;
         int i;
 
         its_dev = its_device_get(dev, child, count);
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free >= count,
             ("gicv3_its_alloc_msi: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
+
+        /* Allocate the irqsrc for each MSI */
         for (i = 0; i < count; i++, irq++) {
                 its_dev->lpis.lpi_free--;
-                girq = &sc->sc_irqs[irq];
+                srcs[i] = (struct intr_irqsrc *)gicv3_its_alloc_irqsrc(dev,
+                    sc, irq);
+                if (srcs[i] == NULL)
+                        break;
+        }
+
+        /* The allocation failed, release them */
+        if (i != count) {
+                mtx_lock_spin(&sc->sc_its_dev_lock);
+                for (i = 0; i < count; i++) {
+                        girq = (struct gicv3_its_irqsrc *)srcs[i];
+                        if (girq == NULL)
+                                break;
+                        gicv3_its_release_irqsrc(sc, girq);
+                        srcs[i] = NULL;
+                }
+                mtx_unlock_spin(&sc->sc_its_dev_lock);
+                return (ENXIO);
+        }
+
+        /* Finish the allocation now we have all MSI irqsrcs */
+        for (i = 0; i < count; i++) {
+                girq = (struct gicv3_its_irqsrc *)srcs[i];
                 girq->gi_id = i;
                 girq->gi_its_dev = its_dev;
-                srcs[i] = (struct intr_irqsrc *)girq;
 
                 /* Map the message to the given IRQ */
                 gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
                 its_cmd_mapti(dev, girq);
         }
         its_dev->lpis.lpi_busy += count;
         *pic = dev;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msi(device_t dev, device_t child, int count,
     struct intr_irqsrc **isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         int i;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msi: Releasing a MSI interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy >= count,
             ("gicv3_its_release_msi: Releasing more interrupts than "
              "were allocated: releasing %d, allocated %d", count,
              its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
+        mtx_lock_spin(&sc->sc_its_dev_lock);
         for (i = 0; i < count; i++) {
                 girq = (struct gicv3_its_irqsrc *)isrc[i];
-                girq->gi_id = -1;
-                girq->gi_its_dev = NULL;
+                gicv3_its_release_irqsrc(sc, girq);
         }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
         its_dev->lpis.lpi_busy -= count;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 
gicv3_its_alloc_msix(device_t dev, device_t child, device_t *pic,
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free > 0,
             ("gicv3_its_alloc_msix: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
-        girq = &sc->sc_irqs[irq];
+
+        girq = gicv3_its_alloc_irqsrc(dev, sc, irq);
+        if (girq == NULL)
+                return (ENXIO);
         girq->gi_id = its_dev->lpis.lpi_busy;
         girq->gi_its_dev = its_dev;
 
         its_dev->lpis.lpi_free--;
         its_dev->lpis.lpi_busy++;
 
         /* Map the message to the given IRQ */
         gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
         its_cmd_mapti(dev, girq);
 
         *pic = dev;
         *isrcp = (struct intr_irqsrc *)girq;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msix(device_t dev, device_t child, struct intr_irqsrc *isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msix: Releasing a MSI-X interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy > 0,
             ("gicv3_its_release_msix: Releasing more interrupts than "
              "were allocated: allocated %d", its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
         girq = (struct gicv3_its_irqsrc *)isrc;
-        girq->gi_its_dev = NULL;
-        girq->gi_id = -1;
+        gicv3_its_release_irqsrc(sc, girq);
         its_dev->lpis.lpi_busy--;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 

head/usr.bin/locale/tests/k_flag_posix_numeric.out

struct its_col {
         uint64_t        col_id;         /* Collection ID */
 };
 
 struct gicv3_its_irqsrc {
         struct intr_irqsrc      gi_isrc;
         u_int                   gi_id;
         u_int                   gi_lpi;
         struct its_dev          *gi_its_dev;
+        TAILQ_ENTRY(gicv3_its_irqsrc) gi_link;
 };
 
 struct gicv3_its_softc {
         device_t        dev;
         struct intr_pic *sc_pic;
         struct resource *sc_its_res;
 
         cpuset_t        sc_cpus;
struct gicv3_its_softc {
         vm_offset_t sc_pend_base[MAXCPU];
 
         /* Command handling */
         struct mtx sc_its_cmd_lock;
         struct its_cmd *sc_its_cmd_base; /* Command circular buffer address */
         size_t sc_its_cmd_next_idx;
 
         vmem_t *sc_irq_alloc;
-        struct gicv3_its_irqsrc *sc_irqs;
+        struct gicv3_its_irqsrc **sc_irqs;
         u_int   sc_irq_base;
         u_int   sc_irq_length;
+        u_int   sc_irq_count;
 
         struct mtx sc_its_dev_lock;
         TAILQ_HEAD(its_dev_list, its_dev) sc_its_dev_list;
+        TAILQ_HEAD(free_irqs, gicv3_its_irqsrc) sc_free_irqs;
 
 #define ITS_FLAGS_CMDQ_FLUSH            0x00000001
 #define ITS_FLAGS_LPI_CONF_FLUSH        0x00000002
 #define ITS_FLAGS_ERRATA_CAVIUM_22375   0x00000004
         u_int sc_its_flags;
         bool    trace_enable;
 };
 
gicv3_its_init_sysctl(struct gicv3_its_softc *sc)
 
         return (0);
 }
 
 static int
 gicv3_its_attach(device_t dev)
 {
         struct gicv3_its_softc *sc;
-        const char *name;
         uint32_t iidr;
         int domain, err, i, rid;
 
         sc = device_get_softc(dev);
 
         sc->sc_irq_length = gicv3_get_nirqs(dev);
         sc->sc_irq_base = GIC_FIRST_LPI;
         sc->sc_irq_base += device_get_unit(dev) * sc->sc_irq_length;
gicv3_its_attach(device_t dev)
 
         /* And the pending tebles */
         gicv3_its_pendtables_init(sc);
 
         /* Enable LPIs on this CPU */
         its_init_cpu(dev, sc);
 
         TAILQ_INIT(&sc->sc_its_dev_list);
+        TAILQ_INIT(&sc->sc_free_irqs);
 
         /*
          * Create the vmem object to allocate INTRNG IRQs from. We try to
          * use all IRQs not already used by the GICv3.
          * XXX: This assumes there are no other interrupt controllers in the
          * system.
          */
         sc->sc_irq_alloc = vmem_create(device_get_nameunit(dev), 0,
             gicv3_get_nirqs(dev), 1, 0, M_FIRSTFIT | M_WAITOK);
 
         sc->sc_irqs = malloc(sizeof(*sc->sc_irqs) * sc->sc_irq_length,
             M_GICV3_ITS, M_WAITOK | M_ZERO);
-        name = device_get_nameunit(dev);
-        for (i = 0; i < sc->sc_irq_length; i++) {
-                sc->sc_irqs[i].gi_id = -1;
-                sc->sc_irqs[i].gi_lpi = i + sc->sc_irq_base - GIC_FIRST_LPI;
-                err = intr_isrc_register(&sc->sc_irqs[i].gi_isrc, dev, 0,
-                    "%s,%u", name, i);
-        }
 
         /* For GIC-500 install tracking sysctls. */
         if ((iidr & (GITS_IIDR_PRODUCT_MASK | GITS_IIDR_IMPLEMENTOR_MASK)) ==
             GITS_IIDR_RAW(GITS_IIDR_IMPL_ARM, GITS_IIDR_PROD_GIC500, 0, 0))
                 gicv3_its_init_sysctl(sc);
 
         return (0);
 }

 static int
 gicv3_its_intr(void *arg, uintptr_t irq)
 {
         struct gicv3_its_softc *sc = arg;
         struct gicv3_its_irqsrc *girq;
         struct trapframe *tf;
 
         irq -= sc->sc_irq_base;
-        girq = &sc->sc_irqs[irq];
+        girq = sc->sc_irqs[irq];
         if (girq == NULL)
                 panic("gicv3_its_intr: Invalid interrupt %ld",
                     irq + sc->sc_irq_base);
 
         tf = curthread->td_intr_frame;
         intr_isrc_dispatch(&girq->gi_isrc, tf);
         return (FILTER_HANDLED);
 }
its_device_release(device_t dev, struct its_dev *its_dev)
 
         /* Free the IRQ allocation */
         vmem_free(sc->sc_irq_alloc, its_dev->lpis.lpi_base,
             its_dev->lpis.lpi_num);
 
         free(its_dev, M_GICV3_ITS);
 }
 
+static struct gicv3_its_irqsrc *
+gicv3_its_alloc_irqsrc(device_t dev, struct gicv3_its_softc *sc, u_int irq)
+{
+        struct gicv3_its_irqsrc *girq = NULL;
+
+        KASSERT(sc->sc_irqs[irq] == NULL,
+            ("%s: Interrupt %u already allocated", __func__, irq));
+        mtx_lock_spin(&sc->sc_its_dev_lock);
+        if (!TAILQ_EMPTY(&sc->sc_free_irqs)) {
+                girq = TAILQ_FIRST(&sc->sc_free_irqs);
+                TAILQ_REMOVE(&sc->sc_free_irqs, girq, gi_link);
+        }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
+        if (girq == NULL) {
+                girq = malloc(sizeof(*girq), M_GICV3_ITS,
+                    M_NOWAIT | M_ZERO);
+                if (girq == NULL)
+                        return (NULL);
+                girq->gi_id = -1;
+                if (intr_isrc_register(&girq->gi_isrc, dev, 0,
+                    "%s,%u", device_get_nameunit(dev), irq) != 0) {
+                        free(girq, M_GICV3_ITS);
+                        return (NULL);
+                }
+        }
+        girq->gi_lpi = irq + sc->sc_irq_base - GIC_FIRST_LPI;
+        sc->sc_irqs[irq] = girq;
+
+        return (girq);
+}
+
+static void
+gicv3_its_release_irqsrc(struct gicv3_its_softc *sc,
+    struct gicv3_its_irqsrc *girq)
+{
+        u_int irq;
+
+        mtx_assert(&sc->sc_its_dev_lock, MA_OWNED);
+
+        irq = girq->gi_lpi + GIC_FIRST_LPI - sc->sc_irq_base;
+        sc->sc_irqs[irq] = NULL;
+
+        girq->gi_id = -1;
+        girq->gi_its_dev = NULL;
+        TAILQ_INSERT_TAIL(&sc->sc_free_irqs, girq, gi_link);
+}
+
 static int
 gicv3_its_alloc_msi(device_t dev, device_t child, int count, int maxcount,
     device_t *pic, struct intr_irqsrc **srcs)
 {
         struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         u_int irq;
         int i;
 
         its_dev = its_device_get(dev, child, count);
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free >= count,
             ("gicv3_its_alloc_msi: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
+
+        /* Allocate the irqsrc for each MSI */
         for (i = 0; i < count; i++, irq++) {
                 its_dev->lpis.lpi_free--;
-                girq = &sc->sc_irqs[irq];
+                srcs[i] = (struct intr_irqsrc *)gicv3_its_alloc_irqsrc(dev,
+                    sc, irq);
+                if (srcs[i] == NULL)
+                        break;
+        }
+
+        /* The allocation failed, release them */
+        if (i != count) {
+                mtx_lock_spin(&sc->sc_its_dev_lock);
+                for (i = 0; i < count; i++) {
+                        girq = (struct gicv3_its_irqsrc *)srcs[i];
+                        if (girq == NULL)
+                                break;
+                        gicv3_its_release_irqsrc(sc, girq);
+                        srcs[i] = NULL;
+                }
+                mtx_unlock_spin(&sc->sc_its_dev_lock);
+                return (ENXIO);
+        }
+
+        /* Finish the allocation now we have all MSI irqsrcs */
+        for (i = 0; i < count; i++) {
+                girq = (struct gicv3_its_irqsrc *)srcs[i];
                 girq->gi_id = i;
                 girq->gi_its_dev = its_dev;
-                srcs[i] = (struct intr_irqsrc *)girq;
 
                 /* Map the message to the given IRQ */
                 gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
                 its_cmd_mapti(dev, girq);
         }
         its_dev->lpis.lpi_busy += count;
         *pic = dev;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msi(device_t dev, device_t child, int count,
     struct intr_irqsrc **isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
         int i;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msi: Releasing a MSI interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy >= count,
             ("gicv3_its_release_msi: Releasing more interrupts than "
              "were allocated: releasing %d, allocated %d", count,
              its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
+        mtx_lock_spin(&sc->sc_its_dev_lock);
         for (i = 0; i < count; i++) {
                 girq = (struct gicv3_its_irqsrc *)isrc[i];
-                girq->gi_id = -1;
-                girq->gi_its_dev = NULL;
+                gicv3_its_release_irqsrc(sc, girq);
         }
+        mtx_unlock_spin(&sc->sc_its_dev_lock);
         its_dev->lpis.lpi_busy -= count;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }
 
gicv3_its_alloc_msix(device_t dev, device_t child, device_t *pic,
         if (its_dev == NULL)
                 return (ENXIO);
 
         KASSERT(its_dev->lpis.lpi_free > 0,
             ("gicv3_its_alloc_msix: No free LPIs"));
         sc = device_get_softc(dev);
         irq = its_dev->lpis.lpi_base + its_dev->lpis.lpi_num -
             its_dev->lpis.lpi_free;
-        girq = &sc->sc_irqs[irq];
+
+        girq = gicv3_its_alloc_irqsrc(dev, sc, irq);
+        if (girq == NULL)
+                return (ENXIO);
         girq->gi_id = its_dev->lpis.lpi_busy;
         girq->gi_its_dev = its_dev;
 
         its_dev->lpis.lpi_free--;
         its_dev->lpis.lpi_busy++;
 
         /* Map the message to the given IRQ */
         gicv3_its_select_cpu(dev, (struct intr_irqsrc *)girq);
         its_cmd_mapti(dev, girq);
 
         *pic = dev;
         *isrcp = (struct intr_irqsrc *)girq;
 
         return (0);
 }
 
 static int
 gicv3_its_release_msix(device_t dev, device_t child, struct intr_irqsrc *isrc)
 {
+        struct gicv3_its_softc *sc;
         struct gicv3_its_irqsrc *girq;
         struct its_dev *its_dev;
 
         its_dev = its_device_find(dev, child);
 
         KASSERT(its_dev != NULL,
             ("gicv3_its_release_msix: Releasing a MSI-X interrupt with "
              "no ITS device"));
         KASSERT(its_dev->lpis.lpi_busy > 0,
             ("gicv3_its_release_msix: Releasing more interrupts than "
              "were allocated: allocated %d", its_dev->lpis.lpi_busy));
+
+        sc = device_get_softc(dev);
         girq = (struct gicv3_its_irqsrc *)isrc;
-        girq->gi_its_dev = NULL;
-        girq->gi_id = -1;
+        gicv3_its_release_irqsrc(sc, girq);
         its_dev->lpis.lpi_busy--;
 
         if (its_dev->lpis.lpi_busy == 0)
                 its_device_release(dev, its_dev);
 
         return (0);
 }