mbuf(9): unbreak m_fragment()
ClosedPublic
Actions

Authored by avos on Nov 5 2015, 10:29 PM.

Details

Reviewers

freebsd-net-list
glebius
adrian

Commits

rS331847: MFC r324673:
rS324673: mbuf(9): unbreak m_fragment()

Summary

Fix it by replacing m_cat() with m_prev->m_next = m_new;

(m_cat() will try to append data - as a result, now this function does nothing).

Move constants out of the loop.

Test Plan

Tested with D4077 (+ some output)

Diff Detail

Repository

rS FreeBSD src repository - subversion

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

avos updated this revision to Diff 9973.Nov 5 2015, 10:29 PM

avos retitled this revision from to mbuf(9): unbreak m_fragment().

avos updated this object.

avos edited the test plan for this revision. (Show Details)

avos added reviewers: adrian, glebius.

avos set the repository for this revision to rS FreeBSD src repository - subversion.

Herald added a subscriber: imp. · View Herald TranscriptNov 5 2015, 10:29 PM

adrian added a reviewer: freebsd-net-list.Jan 22 2016, 8:21 PM

Closed by commit rS324673: mbuf(9): unbreak m_fragment() (authored by avos). · Explain WhyOct 16 2017, 9:46 PM

This revision was automatically updated to reflect the committed changes.

Diffusion mentioned this in rS331847: MFC r324673:.Mar 31 2018, 5:28 PM

Revision Contents
Changeset List

Path

Size

head/

sys/

kern/

uipc_mbuf.c

57 lines

Diff 34038

View Options

head/sys/kern/uipc_mbuf.c

This file was added.

				/*-
				* Copyright (c) 2017 Ruslan Bukin <br@bsdpad.com>
				* All rights reserved.
				*
				* This software was developed by SRI International and the University of
				* Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237
				* ("CTSRD"), as part of the DARPA CRASH research programme.
				*
				* Redistribution and use in source and binary forms, with or without
				* modification, are permitted provided that the following conditions
				* are met:
				* 1. Redistributions of source code must retain the above copyright
				* notice, this list of conditions and the following disclaimer.
				* 2. Redistributions in binary form must reproduce the above copyright
				* notice, this list of conditions and the following disclaimer in the
				* documentation and/or other materials provided with the distribution.
				*
				* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
				* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
				* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
				* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
				* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
				* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
				* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
				* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
				* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
				* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
				* SUCH DAMAGE.
				*/

				#include <sys/cdefs.h>
				__FBSDID("$FreeBSD$");

				#include "opt_platform.h"
				#include <sys/param.h>
				#include <sys/conf.h>
				#include <sys/bus.h>
				#include <sys/kernel.h>
				#include <sys/queue.h>
				#include <sys/kobj.h>
				#include <sys/malloc.h>
				#include <sys/mutex.h>
				#include <sys/mbuf.h>
				#include <sys/limits.h>
				#include <sys/lock.h>
				#include <sys/sysctl.h>
				#include <sys/systm.h>
				#include <sys/sx.h>
				#include <sys/bus_dma.h>

				#include <machine/bus.h>

				#ifdef FDT
				#include <dev/fdt/fdt_common.h>
				#include <dev/ofw/ofw_bus.h>
				#include <dev/ofw/ofw_bus_subr.h>
				#endif

				#include <dev/xdma/xdma.h>

				int
				xdma_dequeue_mbuf(xdma_channel_t xchan, struct mbuf *mp,
				xdma_transfer_status_t *status)
				{
				struct xdma_request *xr;

				if (xchan->xr_tail == xchan->xr_processed) {
				return (-1);
				}

				xr = &xchan->xr[xchan->xr_tail];
				if (xr->done == 0) {
				return (-1);
				}

				*mp = xr->m;
				status->error = xr->status.error;
				status->transferred = xr->status.transferred;
				xchan->xr_tail = xchan_next_req(xchan, xchan->xr_tail);
				atomic_subtract_int(&xchan->xr_count, 1);

				return (0);
				}

				int
				xdma_enqueue_mbuf(xdma_channel_t xchan, struct mbuf *mp,
				uintptr_t addr, uint8_t src_width, uint8_t dst_width,
				enum xdma_direction dir)
				{
				struct xdma_request *xr;
				xdma_controller_t *xdma;

				xdma = xchan->xdma;

				if (xchan->xr_count >= (xchan->xr_num - 1)) {
				/* No space is available yet. */
				return (-1);
				}

				xr = &xchan->xr[xchan->xr_head];
				xr->direction = dir;
				xr->m = *mp;
				xr->type = XR_TYPE_MBUF;
				if (dir == XDMA_MEM_TO_DEV) {
				xr->dst_addr = addr;
				xr->src_addr = 0;
				} else {
				xr->src_addr = addr;
				xr->dst_addr = 0;
				}
				xr->src_width = src_width;
				xr->dst_width = dst_width;
				xr->done = 0;
				xchan->xr_head = xchan_next_req(xchan, xchan->xr_head);
				atomic_add_int(&xchan->xr_count, 1);

				return (0);
				}

				uint32_t
				xdma_mbuf_chain_count(struct mbuf *m0)
				{
				struct mbuf *m;
				uint32_t c;

				c = 0;

				for (m = m0; m != NULL; m = m->m_next) {
				c++;
				}

				return (c);
				}

				uint32_t
				xdma_mbuf_defrag(xdma_channel_t xchan, struct xdma_request xr)
				{
				xdma_controller_t *xdma;
				struct mbuf *m;
				uint32_t c;

				xdma = xchan->xdma;

				c = xdma_mbuf_chain_count(xr->m);
				if (c == 1) {
				/* Nothing to do. */
				return (c);
				}

				if (xchan->caps & XCHAN_CAP_BUSDMA) {
				if ((xchan->caps & XCHAN_CAP_BUSDMA_NOSEG) \|\| \
				(c > xchan->maxnsegs)) {
				if ((m = m_defrag(xr->m, M_NOWAIT)) == NULL) {
				device_printf(xdma->dma_dev,
				"%s: Can't defrag mbuf\n",
				__func__);
				return (c);
				}
				xr->m = m;
				c = 1;
				}
				}

				return (c);
				}

mbuf(9): unbreak m_fragment()ClosedPublicActions