hyperv/vmbus: Move channel map to vmbus_softc

head/sys/dev/hyperv/vmbus/hv_connection.c

if (hv_vmbus_g_connection.connect_state != HV_DISCONNECTED) {
                 return (-1);
         }
 
         /**
          * Initialize the vmbus connection
          */
         hv_vmbus_g_connection.connect_state = HV_CONNECTING;
 
-        hv_vmbus_g_connection.channels = malloc(sizeof(hv_vmbus_channel*) *
-            VMBUS_CHAN_MAX, M_DEVBUF, M_WAITOK | M_ZERO);
-
         hv_vmbus_g_connection.connect_state = HV_CONNECTED;
 
         return (0);
 }
 
 /**
  * Send a disconnect request on the partition service connection
  */
 int
 hv_vmbus_disconnect(void)
 {
 
-        free(hv_vmbus_g_connection.channels, M_DEVBUF);
         hv_vmbus_g_connection.connect_state = HV_DISCONNECTED;
 
         return (0);
 }
 
 static __inline void
-vmbus_event_flags_proc(volatile u_long *event_flags, int flag_cnt)
+vmbus_event_flags_proc(struct vmbus_softc *sc, volatile u_long *event_flags,
+    int flag_cnt)
 {
         int f;
 
         for (f = 0; f < flag_cnt; ++f) {
                 uint32_t rel_id_base;
                 u_long flags;
                 int bit;
 
                 if (event_flags[f] == 0)
                         continue;
 
                 flags = atomic_swap_long(&event_flags[f], 0);
                 rel_id_base = f << VMBUS_EVTFLAG_SHIFT;
 
                 while ((bit = ffsl(flags)) != 0) {
                         struct hv_vmbus_channel *channel;
                         uint32_t rel_id;
 
                         --bit;  /* NOTE: ffsl is 1-based */
                         flags &= ~(1UL << bit);
 
                         rel_id = rel_id_base + bit;
-                        channel = hv_vmbus_g_connection.channels[rel_id];
+                        channel = sc->vmbus_chmap[rel_id];
 
                         /* if channel is closed or closing */
                         if (channel == NULL || channel->rxq == NULL)
                                 continue;
 
                         if (channel->batched_reading)
                                 hv_ring_buffer_read_begin(&channel->inbound);
                         taskqueue_enqueue(channel->rxq, &channel->channel_task);
                 }
         }
 }
 
 void
 vmbus_event_proc(struct vmbus_softc *sc, int cpu)
 {
         struct vmbus_evtflags *eventf;
 
         /*
          * On Host with Win8 or above, the event page can be checked directly
          * to get the id of the channel that has the pending interrupt.
          */
         eventf = VMBUS_PCPU_GET(sc, event_flags, cpu) + VMBUS_SINT_MESSAGE;
-        vmbus_event_flags_proc(eventf->evt_flags,
+        vmbus_event_flags_proc(sc, eventf->evt_flags,
             VMBUS_PCPU_GET(sc, event_flags_cnt, cpu));
 }
 
 void
 vmbus_event_proc_compat(struct vmbus_softc *sc, int cpu)
 {
         struct vmbus_evtflags *eventf;
 
         eventf = VMBUS_PCPU_GET(sc, event_flags, cpu) + VMBUS_SINT_MESSAGE;
         if (atomic_testandclear_long(&eventf->evt_flags[0], 0)) {
-                vmbus_event_flags_proc(sc->vmbus_rx_evtflags,
+                vmbus_event_flags_proc(sc, sc->vmbus_rx_evtflags,
                     VMBUS_CHAN_MAX_COMPAT >> VMBUS_EVTFLAG_SHIFT);
         }
 }
 
 void
 vmbus_on_channel_open(const struct hv_vmbus_channel *chan)
 {
         volatile int *flag_cnt_ptr;