1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1982, 1986, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #ifndef _NET_IFQ_H_ 33 #define _NET_IFQ_H_ 34 35 #ifdef _KERNEL 36 #include <sys/mbuf.h> /* ifqueue only? */ 37 #include <sys/buf_ring.h> 38 #include <net/vnet.h> 39 #endif /* _KERNEL */ 40 #include <sys/lock.h> /* XXX */ 41 #include <sys/mutex.h> /* struct ifqueue */ 42 43 /* 44 * Couple of ugly extra definitions that are required since ifq.h 45 * is splitted from if_var.h. 46 */ 47 #define IF_DUNIT_NONE -1 48 49 #include <net/altq/if_altq.h> 50 51 /* 52 * Structure defining a queue for a network interface. 53 */ 54 struct ifqueue { 55 struct mbuf *ifq_head; 56 struct mbuf *ifq_tail; 57 int ifq_len; 58 int ifq_maxlen; 59 struct mtx ifq_mtx; 60 }; 61 62 #ifdef _KERNEL 63 /* 64 * Output queues (ifp->if_snd) and slow device input queues (*ifp->if_slowq) 65 * are queues of messages stored on ifqueue structures 66 * (defined above). Entries are added to and deleted from these structures 67 * by these macros. 68 */ 69 #define IF_LOCK(ifq) mtx_lock(&(ifq)->ifq_mtx) 70 #define IF_UNLOCK(ifq) mtx_unlock(&(ifq)->ifq_mtx) 71 #define IF_LOCK_ASSERT(ifq) mtx_assert(&(ifq)->ifq_mtx, MA_OWNED) 72 #define _IF_QFULL(ifq) ((ifq)->ifq_len >= (ifq)->ifq_maxlen) 73 #define _IF_QLEN(ifq) ((ifq)->ifq_len) 74 75 #define _IF_ENQUEUE(ifq, m) do { \ 76 (m)->m_nextpkt = NULL; \ 77 if ((ifq)->ifq_tail == NULL) \ 78 (ifq)->ifq_head = m; \ 79 else \ 80 (ifq)->ifq_tail->m_nextpkt = m; \ 81 (ifq)->ifq_tail = m; \ 82 (ifq)->ifq_len++; \ 83 } while (0) 84 85 #define IF_ENQUEUE(ifq, m) do { \ 86 IF_LOCK(ifq); \ 87 _IF_ENQUEUE(ifq, m); \ 88 IF_UNLOCK(ifq); \ 89 } while (0) 90 91 #define _IF_PREPEND(ifq, m) do { \ 92 (m)->m_nextpkt = (ifq)->ifq_head; \ 93 if ((ifq)->ifq_tail == NULL) \ 94 (ifq)->ifq_tail = (m); \ 95 (ifq)->ifq_head = (m); \ 96 (ifq)->ifq_len++; \ 97 } while (0) 98 99 #define IF_PREPEND(ifq, m) do { \ 100 IF_LOCK(ifq); \ 101 _IF_PREPEND(ifq, m); \ 102 IF_UNLOCK(ifq); \ 103 } while (0) 104 105 #define _IF_DEQUEUE(ifq, m) do { \ 106 (m) = (ifq)->ifq_head; \ 107 if (m) { \ 108 if (((ifq)->ifq_head = (m)->m_nextpkt) == NULL) \ 109 (ifq)->ifq_tail = NULL; \ 110 (m)->m_nextpkt = NULL; \ 111 (ifq)->ifq_len--; \ 112 } \ 113 } while (0) 114 115 #define IF_DEQUEUE(ifq, m) do { \ 116 IF_LOCK(ifq); \ 117 _IF_DEQUEUE(ifq, m); \ 118 IF_UNLOCK(ifq); \ 119 } while (0) 120 121 #define _IF_DEQUEUE_ALL(ifq, m) do { \ 122 (m) = (ifq)->ifq_head; \ 123 (ifq)->ifq_head = (ifq)->ifq_tail = NULL; \ 124 (ifq)->ifq_len = 0; \ 125 } while (0) 126 127 #define IF_DEQUEUE_ALL(ifq, m) do { \ 128 IF_LOCK(ifq); \ 129 _IF_DEQUEUE_ALL(ifq, m); \ 130 IF_UNLOCK(ifq); \ 131 } while (0) 132 133 #define _IF_POLL(ifq, m) ((m) = (ifq)->ifq_head) 134 #define IF_POLL(ifq, m) _IF_POLL(ifq, m) 135 136 #define _IF_DRAIN(ifq) do { \ 137 struct mbuf *m; \ 138 for (;;) { \ 139 _IF_DEQUEUE(ifq, m); \ 140 if (m == NULL) \ 141 break; \ 142 m_freem(m); \ 143 } \ 144 } while (0) 145 146 #define IF_DRAIN(ifq) do { \ 147 IF_LOCK(ifq); \ 148 _IF_DRAIN(ifq); \ 149 IF_UNLOCK(ifq); \ 150 } while(0) 151 152 int if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp, 153 int adjust); 154 #define IF_HANDOFF(ifq, m, ifp) \ 155 if_handoff((struct ifqueue *)ifq, m, ifp, 0) 156 #define IF_HANDOFF_ADJ(ifq, m, ifp, adj) \ 157 if_handoff((struct ifqueue *)ifq, m, ifp, adj) 158 159 void if_start(struct ifnet *); 160 161 #define IFQ_ENQUEUE(ifq, m, err) \ 162 do { \ 163 IF_LOCK(ifq); \ 164 if (ALTQ_IS_ENABLED(ifq)) \ 165 ALTQ_ENQUEUE(ifq, m, NULL, err); \ 166 else { \ 167 if (_IF_QFULL(ifq)) { \ 168 m_freem(m); \ 169 (err) = ENOBUFS; \ 170 } else { \ 171 _IF_ENQUEUE(ifq, m); \ 172 (err) = 0; \ 173 } \ 174 } \ 175 IF_UNLOCK(ifq); \ 176 } while (0) 177 178 #define IFQ_DEQUEUE_NOLOCK(ifq, m) \ 179 do { \ 180 if (TBR_IS_ENABLED(ifq)) \ 181 (m) = tbr_dequeue_ptr(ifq, ALTDQ_REMOVE); \ 182 else if (ALTQ_IS_ENABLED(ifq)) \ 183 ALTQ_DEQUEUE(ifq, m); \ 184 else \ 185 _IF_DEQUEUE(ifq, m); \ 186 } while (0) 187 188 #define IFQ_DEQUEUE(ifq, m) \ 189 do { \ 190 IF_LOCK(ifq); \ 191 IFQ_DEQUEUE_NOLOCK(ifq, m); \ 192 IF_UNLOCK(ifq); \ 193 } while (0) 194 195 #define IFQ_POLL_NOLOCK(ifq, m) \ 196 do { \ 197 if (TBR_IS_ENABLED(ifq)) \ 198 (m) = tbr_dequeue_ptr(ifq, ALTDQ_POLL); \ 199 else if (ALTQ_IS_ENABLED(ifq)) \ 200 ALTQ_POLL(ifq, m); \ 201 else \ 202 _IF_POLL(ifq, m); \ 203 } while (0) 204 205 #define IFQ_POLL(ifq, m) \ 206 do { \ 207 IF_LOCK(ifq); \ 208 IFQ_POLL_NOLOCK(ifq, m); \ 209 IF_UNLOCK(ifq); \ 210 } while (0) 211 212 #define IFQ_PURGE_NOLOCK(ifq) \ 213 do { \ 214 if (ALTQ_IS_ENABLED(ifq)) { \ 215 ALTQ_PURGE(ifq); \ 216 } else \ 217 _IF_DRAIN(ifq); \ 218 } while (0) 219 220 #define IFQ_PURGE(ifq) \ 221 do { \ 222 IF_LOCK(ifq); \ 223 IFQ_PURGE_NOLOCK(ifq); \ 224 IF_UNLOCK(ifq); \ 225 } while (0) 226 227 #define IFQ_SET_READY(ifq) \ 228 do { ((ifq)->altq_flags |= ALTQF_READY); } while (0) 229 230 #define IFQ_LOCK(ifq) IF_LOCK(ifq) 231 #define IFQ_UNLOCK(ifq) IF_UNLOCK(ifq) 232 #define IFQ_LOCK_ASSERT(ifq) IF_LOCK_ASSERT(ifq) 233 #define IFQ_IS_EMPTY(ifq) ((ifq)->ifq_len == 0) 234 #define IFQ_INC_LEN(ifq) ((ifq)->ifq_len++) 235 #define IFQ_DEC_LEN(ifq) (--(ifq)->ifq_len) 236 #define IFQ_SET_MAXLEN(ifq, len) ((ifq)->ifq_maxlen = (len)) 237 238 /* 239 * The IFF_DRV_OACTIVE test should really occur in the device driver, not in 240 * the handoff logic, as that flag is locked by the device driver. 241 */ 242 #define IFQ_HANDOFF_ADJ(ifp, m, adj, err) \ 243 do { \ 244 int len; \ 245 short mflags; \ 246 \ 247 len = (m)->m_pkthdr.len; \ 248 mflags = (m)->m_flags; \ 249 IFQ_ENQUEUE(&(ifp)->if_snd, m, err); \ 250 if ((err) == 0) { \ 251 if_inc_counter((ifp), IFCOUNTER_OBYTES, len + (adj)); \ 252 if (mflags & M_MCAST) \ 253 if_inc_counter((ifp), IFCOUNTER_OMCASTS, 1); \ 254 if (((ifp)->if_drv_flags & IFF_DRV_OACTIVE) == 0) \ 255 if_start(ifp); \ 256 } else \ 257 if_inc_counter((ifp), IFCOUNTER_OQDROPS, 1); \ 258 } while (0) 259 260 #define IFQ_HANDOFF(ifp, m, err) \ 261 IFQ_HANDOFF_ADJ(ifp, m, 0, err) 262 263 #define IFQ_DRV_DEQUEUE(ifq, m) \ 264 do { \ 265 (m) = (ifq)->ifq_drv_head; \ 266 if (m) { \ 267 if (((ifq)->ifq_drv_head = (m)->m_nextpkt) == NULL) \ 268 (ifq)->ifq_drv_tail = NULL; \ 269 (m)->m_nextpkt = NULL; \ 270 (ifq)->ifq_drv_len--; \ 271 } else { \ 272 IFQ_LOCK(ifq); \ 273 IFQ_DEQUEUE_NOLOCK(ifq, m); \ 274 while ((ifq)->ifq_drv_len < (ifq)->ifq_drv_maxlen) { \ 275 struct mbuf *m0; \ 276 IFQ_DEQUEUE_NOLOCK(ifq, m0); \ 277 if (m0 == NULL) \ 278 break; \ 279 m0->m_nextpkt = NULL; \ 280 if ((ifq)->ifq_drv_tail == NULL) \ 281 (ifq)->ifq_drv_head = m0; \ 282 else \ 283 (ifq)->ifq_drv_tail->m_nextpkt = m0; \ 284 (ifq)->ifq_drv_tail = m0; \ 285 (ifq)->ifq_drv_len++; \ 286 } \ 287 IFQ_UNLOCK(ifq); \ 288 } \ 289 } while (0) 290 291 #define IFQ_DRV_PREPEND(ifq, m) \ 292 do { \ 293 (m)->m_nextpkt = (ifq)->ifq_drv_head; \ 294 if ((ifq)->ifq_drv_tail == NULL) \ 295 (ifq)->ifq_drv_tail = (m); \ 296 (ifq)->ifq_drv_head = (m); \ 297 (ifq)->ifq_drv_len++; \ 298 } while (0) 299 300 #define IFQ_DRV_IS_EMPTY(ifq) \ 301 (((ifq)->ifq_drv_len == 0) && ((ifq)->ifq_len == 0)) 302 303 #define IFQ_DRV_PURGE(ifq) \ 304 do { \ 305 struct mbuf *m, *n = (ifq)->ifq_drv_head; \ 306 while((m = n) != NULL) { \ 307 n = m->m_nextpkt; \ 308 m_freem(m); \ 309 } \ 310 (ifq)->ifq_drv_head = (ifq)->ifq_drv_tail = NULL; \ 311 (ifq)->ifq_drv_len = 0; \ 312 IFQ_PURGE(ifq); \ 313 } while (0) 314 315 #ifdef ALTQ 316 int drbr_enqueue(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m); 317 void drbr_putback(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m_new); 318 struct mbuf *drbr_peek(struct ifnet *ifp, struct buf_ring *br); 319 void drbr_flush(struct ifnet *ifp, struct buf_ring *br); 320 struct mbuf *drbr_dequeue(struct ifnet *ifp, struct buf_ring *br); 321 void drbr_advance(struct ifnet *ifp, struct buf_ring *br); 322 struct mbuf *drbr_dequeue_cond(struct ifnet *ifp, struct buf_ring *br, 323 int (*func) (struct mbuf *, void *), void *arg); 324 int drbr_empty(struct ifnet *ifp, struct buf_ring *br); 325 int drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br); 326 int drbr_inuse(struct ifnet *ifp, struct buf_ring *br); 327 328 #else /* !ALTQ */ 329 static __inline int 330 drbr_enqueue(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m) 331 { 332 int error = 0; 333 334 error = buf_ring_enqueue(br, m); 335 if (error) 336 m_freem(m); 337 338 return (error); 339 } 340 341 static __inline void 342 drbr_putback(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m_new) 343 { 344 /* 345 * The top of the list needs to be swapped 346 * for this one. 347 */ 348 buf_ring_putback_sc(br, m_new); 349 } 350 351 static __inline struct mbuf * 352 drbr_peek(struct ifnet *ifp, struct buf_ring *br) 353 { 354 return ((struct mbuf *)buf_ring_peek_clear_sc(br)); 355 } 356 357 static __inline void 358 drbr_flush(struct ifnet *ifp, struct buf_ring *br) 359 { 360 struct mbuf *m; 361 362 while ((m = (struct mbuf *)buf_ring_dequeue_sc(br)) != NULL) 363 m_freem(m); 364 } 365 366 static __inline struct mbuf * 367 drbr_dequeue(struct ifnet *ifp, struct buf_ring *br) 368 { 369 return ((struct mbuf *)buf_ring_dequeue_sc(br)); 370 } 371 372 static __inline void 373 drbr_advance(struct ifnet *ifp, struct buf_ring *br) 374 { 375 return (buf_ring_advance_sc(br)); 376 } 377 378 static __inline struct mbuf * 379 drbr_dequeue_cond(struct ifnet *ifp, struct buf_ring *br, 380 int (*func) (struct mbuf *, void *), void *arg) 381 { 382 struct mbuf *m; 383 m = (struct mbuf *)buf_ring_peek(br); 384 if (m == NULL || func(m, arg) == 0) 385 return (NULL); 386 387 return ((struct mbuf *)buf_ring_dequeue_sc(br)); 388 } 389 390 static __inline int 391 drbr_empty(struct ifnet *ifp, struct buf_ring *br) 392 { 393 return (buf_ring_empty(br)); 394 } 395 396 static __inline int 397 drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br) 398 { 399 return (!buf_ring_empty(br)); 400 } 401 402 static __inline int 403 drbr_inuse(struct ifnet *ifp, struct buf_ring *br) 404 { 405 return (buf_ring_count(br)); 406 } 407 #endif /* ALTQ */ 408 409 static __inline void 410 drbr_free(struct buf_ring *br, struct malloc_type *type) 411 { 412 413 drbr_flush(NULL, br); 414 buf_ring_free(br, type); 415 } 416 417 extern int ifqmaxlen; 418 419 void if_qflush(struct ifnet *); 420 void ifq_init(struct ifaltq *, struct ifnet *ifp); 421 void ifq_delete(struct ifaltq *); 422 423 #endif /* _KERNEL */ 424 #endif /* !_NET_IFQ_H_ */ 425