Lines Matching defs:rings
187 * this by using generation numbers for rings and freeing the mac rings only
189 * must not expose underlying driver rings or driver data structures/pointers
272 * For information on the datapath, the world of soft rings, hardware rings, how
1457 * and rings. In this case, the aggr driver has exclusive control of the
1458 * underlying HW Rx group/rings, it calls the following functions to
1459 * start/stop the HW Rx rings, disable/enable polling, add/remove mac'
1481 * This function is called to get the list of HW rings that are reserved by
1484 * Return value: the number of HW rings.
1530 * This function is called to get info about Tx/Rx rings.
1671 * that does not expose Tx rings, aggr_ring_tx() entry point needs
1691 * from the group. In those cases, all of the rings will be torn down because
1693 * rings can still exist such that it may be able to continue to send LACP PDUs
1698 * MAC does about the rings and can't know that it's not quite ready for use
1752 * so that SRSs get to turn on/off individual rings they's
1765 * Set all rings of this group to software classified.
1850 * of rings between clients
1896 * mac, then the SRS, and then the soft rings. There are 2 use cases of this
1906 * rings as CONDEMNED or QUIESCE as appropriate. This prevents the mr_refcnt
3246 uint_t rings;
3316 rings = id == MAC_PROP_MAX_RX_RINGS_AVAIL ?
3318 bcopy(&rings, val, sizeof (uint_t));
3410 * Currently, we support range for RX and TX rings properties.
3413 * There is no default value for RX or TX rings.
3418 * We don't support setting rings for a VLAN
3439 * rings
3445 * but not rings
3454 * rings
3460 * but not rings
3472 * rings
3649 * we maintain a cache of rings in the mac_impl_t after they get free'd up.
3650 * When packets are received on free'd up rings, MAC (through the generation
3840 * The interrupt handle could be shared among multiple rings.
3841 * Thus if there is a bunch of rings that are sharing an
3854 * of a group of rings sharing an
3873 * Rx rings get registered first. So if this is a Tx ring,
3874 * then go through all the Rx rings and see if there is a
3953 * If we have multiple TX rings, but only one TX group, we can
3956 * one group with all the rings (for all its ports), going
3964 * with all the rings in it.
4027 * rings, and the following groups must
4028 * have zero rings.
4048 * All TX ring groups must have zero rings.
4115 * If there are ungrouped rings, allocate a continuous buffer for
4172 * later when pseudo Tx rings are added after
4179 * rings to the group later.
4184 * Even though there are no rings at this time
4185 * (rings will come later), set the group
4224 * The ddi interrupt handle could be shared amoung rings. If so, compare
4314 /* Free all the cached rings */
4482 * Insert the ring ahead existing rings.
4562 * If the rings are being moved to a group that has
4563 * clients using it, then add the new rings to the
4576 * If we are growing from 1 to multiple rings.
4689 * the pseudo Tx rings that it exposed gets removed.
4692 * rings are already quiesced.
4749 * If we are here when removing rings from the
5857 * RX and TX rings are reserved according to different semantics depending
5858 * on the requests from the MAC clients and type of rings:
5860 * On the Tx side, by default we reserve individual rings, independently from
5864 * of rings, and used for v12n level 1 only. It has a special case for the
5868 * RX group to the client, and assign TX rings and RX rings to these
5872 * The foreseable evolution of Rx rings will handle v12n level 2 and higher
5873 * to allocate individual rings out of a group and program the hw classifier
5887 * function swaps it with a new ring from the group of unassigned rings.
5901 * The unassigned rings are at the end of the mi_tx_groups
5956 * replacement ring. If there aren't any replacement rings, this
5961 mac_ring_t *ring, mac_ring_t **rings, int nrings)
5995 if (rings[j] == tring)
6024 * the default group, thereby freeing some rings.
6041 * rings asked by the share we cannot
6045 if (rings[j] == tgrp->mrg_rings)
6060 * All the rings are reserved, can't give up the
6072 * If this ring is part of the rings asked by the
6076 if (rings[j] == tring)
6111 * If this ring is part of the rings asked by the
6115 if (rings[j] == tring)
6141 * Populate a zero-ring group with rings. If the share is non-NULL,
6142 * the rings are chosen according to that share.
6152 mac_ring_t **rings, *ring;
6162 * First find the rings to allocate to the group.
6165 /* get rings through ms_squery() */
6168 rings = kmem_alloc(nrings * sizeof (mac_ring_handle_t),
6171 (mac_ring_handle_t *)rings, &nrings);
6178 ring = rings[i];
6182 ring, rings, nrings) != 0) {
6198 rings = kmem_alloc(ringcnt * sizeof (mac_ring_handle_t),
6210 rings[i++] = ring;
6216 /* Not enough rings as required */
6226 /* we ran out of rings */
6231 /* move receive rings to new group */
6233 rv = mac_group_mov_ring(mip, new_group, rings[i]);
6235 /* move rings back on failure */
6238 src_group, rings[j]);
6248 /* move the TX rings to the new group */
6251 tmp_ring = mac_reserve_tx_ring(mip, rings[i]);
6256 ASSERT(tmp_ring == rings[i]);
6257 rv = mac_group_mov_ring(mip, new_group, rings[i]);
6263 rings[j]);
6277 /* free temporary array of rings */
6278 kmem_free(rings, nrings * sizeof (mac_ring_handle_t));
6326 * largest number of rings, otherwise the default ring when available.
6377 * For static grouping we allow only specifying rings=0 and
6402 * mip and we have not asked for any rings, we give
6404 * use all the rings.
6409 /* The group that can donate rings */
6413 * The number of rings that the default group can donate.
6423 * it all the rings from the donor group, except the default ring
6427 * rings, if available.
6443 * one and it has enough rings (combined with what
6451 * If we don't have enough rings we will check
6497 * enough rings for this, unless we already have
6506 * the rings from the driver, let's populate
6575 * Now give this group with the required rings
6593 * the rings from the driver, let's populate
6624 * all rings are assigned back to default group.
6669 * Move rings back to default group.
6943 * For static grouping we allow only specifying rings=0 and
6968 * The number of rings that the default group can donate.
6976 * to (i.e. rings > 0).
6990 * one and it has enough rings (combined with what
7013 * enough rings for this.
7048 * of rings to this MAC client.
7065 * the rings from the driver, let's populate
7099 * For a share i_mac_group_allocate_rings gets the rings from the
7149 * Disassociate a MAC client from a group, i.e go through the rings in the
7150 * group and delete all the soft rings tied to them.
7163 /* Single ring case we haven't created any soft rings */
7168 /* Fanout case, where we have to dismantle the soft rings */
7247 * the rings in the default group, except
7250 * the default group, so the rings won't
7451 * Walk the primary VLAN clients whenever the primary's rings property
7455 * follow the primary w.r.t the rings property;
7498 * rings is the default group. The destination for giving rings back is
7511 mac_ring_t **rings;
7523 * the specified number of rings.
7533 /* don't allow modifying rings for a share for now. */
7550 rings = kmem_alloc(modify * sizeof (mac_ring_handle_t),
7560 rings[j]);
7564 rings[j++] = ring;
7567 kmem_free(rings, modify * sizeof (mac_ring_handle_t));
7581 * rings. Default group now gets to be the donor
7591 * If the default doesn't have any rings, lets see if we can
7592 * take rings given to an h/w client that doesn't need it.
7594 * all the required rings.
7897 * Set effective rings property. This could be called from datapath_setup/
7899 * If the group is reserved we just go ahead and set the effective rings.
7901 * some rings, so if the default group is reserved, we need to adjust the
7902 * effective rings for the default group clients. For RX, if we are working
7921 * If we have reserved a group, set the effective rings
7999 * the group, will lose exclusive access to the rings, hence
8015 * group OR set the RX rings property, return.