11493 aggr needs support for multiple pseudo rx groups
Portions contributed by: Dan McDonald <danmcd@joyent.com>
Reviewed by: Patrick Mooney <patrick.mooney@joyent.com>
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Reviewed by: Robert Mustacchi <rm@joyent.com>

*** 697,707 ****
  {
          mac_impl_t              *mip = (mac_impl_t *)mh;
          mac_ring_t              *mr = (mac_ring_t *)mrh;
          mac_soft_ring_set_t     *mac_srs;
          mblk_t                  *bp = mp_chain;
-         boolean_t               hw_classified = B_FALSE;
  
          /*
           * If there are any promiscuous mode callbacks defined for
           * this MAC, pass them a copy if appropriate.
           */
--- 697,706 ----
*** 709,719 ****
                  mac_promisc_dispatch(mip, mp_chain, NULL);
  
          if (mr != NULL) {
                  /*
                   * If the SRS teardown has started, just return. The 'mr'
!                  * continues to be valid until the driver unregisters the mac.
                   * Hardware classified packets will not make their way up
                   * beyond this point once the teardown has started. The driver
                   * is never passed a pointer to a flow entry or SRS or any
                   * structure that can be freed much before mac_unregister.
                   */
--- 708,718 ----
                  mac_promisc_dispatch(mip, mp_chain, NULL);
  
          if (mr != NULL) {
                  /*
                   * If the SRS teardown has started, just return. The 'mr'
!                  * continues to be valid until the driver unregisters the MAC.
                   * Hardware classified packets will not make their way up
                   * beyond this point once the teardown has started. The driver
                   * is never passed a pointer to a flow entry or SRS or any
                   * structure that can be freed much before mac_unregister.
                   */
*** 722,756 ****
                      (MR_INCIPIENT | MR_CONDEMNED | MR_QUIESCE))) {
                          mutex_exit(&mr->mr_lock);
                          freemsgchain(mp_chain);
                          return;
                  }
!                 if (mr->mr_classify_type == MAC_HW_CLASSIFIER) {
!                         hw_classified = B_TRUE;
                          MR_REFHOLD_LOCKED(mr);
-                 }
                  mutex_exit(&mr->mr_lock);
  
                  /*
                   * We check if an SRS is controlling this ring.
                   * If so, we can directly call the srs_lower_proc
                   * routine otherwise we need to go through mac_rx_classify
                   * to reach the right place.
                   */
!                 if (hw_classified) {
                          mac_srs = mr->mr_srs;
                          /*
!                          * This is supposed to be the fast path.
!                          * All packets received though here were steered by
!                          * the hardware classifier, and share the same
!                          * MAC header info.
                           */
                          mac_srs->srs_rx.sr_lower_proc(mh,
                              (mac_resource_handle_t)mac_srs, mp_chain, B_FALSE);
                          MR_REFRELE(mr);
                          return;
                  }
                  /* We'll fall through to software classification */
          } else {
                  flow_entry_t *flent;
                  int err;
  
--- 721,774 ----
                      (MR_INCIPIENT | MR_CONDEMNED | MR_QUIESCE))) {
                          mutex_exit(&mr->mr_lock);
                          freemsgchain(mp_chain);
                          return;
                  }
! 
!                 /*
!                  * The ring is in passthru mode; pass the chain up to
!                  * the pseudo ring.
!                  */
!                 if (mr->mr_classify_type == MAC_PASSTHRU_CLASSIFIER) {
                          MR_REFHOLD_LOCKED(mr);
                          mutex_exit(&mr->mr_lock);
+                         mr->mr_pt_fn(mr->mr_pt_arg1, mr->mr_pt_arg2, mp_chain,
+                             B_FALSE);
+                         MR_REFRELE(mr);
+                         return;
+                 }
  
                  /*
+                  * The passthru callback should only be set when in
+                  * MAC_PASSTHRU_CLASSIFIER mode.
+                  */
+                 ASSERT3P(mr->mr_pt_fn, ==, NULL);
+ 
+                 /*
                   * We check if an SRS is controlling this ring.
                   * If so, we can directly call the srs_lower_proc
                   * routine otherwise we need to go through mac_rx_classify
                   * to reach the right place.
                   */
!                 if (mr->mr_classify_type == MAC_HW_CLASSIFIER) {
!                         MR_REFHOLD_LOCKED(mr);
!                         mutex_exit(&mr->mr_lock);
!                         ASSERT3P(mr->mr_srs, !=, NULL);
                          mac_srs = mr->mr_srs;
+ 
                          /*
!                          * This is the fast path. All packets received
!                          * on this ring are hardware classified and
!                          * share the same MAC header info.
                           */
                          mac_srs->srs_rx.sr_lower_proc(mh,
                              (mac_resource_handle_t)mac_srs, mp_chain, B_FALSE);
                          MR_REFRELE(mr);
                          return;
                  }
+ 
+                 mutex_exit(&mr->mr_lock);
                  /* We'll fall through to software classification */
          } else {
                  flow_entry_t *flent;
                  int err;