From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR02-AM5-obe.outbound.protection.outlook.com (mail-eopbgr00061.outbound.protection.outlook.com [40.107.0.61]) by dpdk.org (Postfix) with ESMTP id 80CF410B7 for ; Tue, 24 Apr 2018 03:39:12 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=tKU6yikT6feVdl+6LJ6TCl/mDHcdr0IWpUxBze7l2Fo=; b=CAfixLWpckoA1VEfaBn5Su0gmVerW9uz+hTd7J/gGVFfJSco6qkk8ZjUAf2RshE0AdEY3Pa/N4aBGqpRc8H9Vdnt5pCFDGSCgpremEA3u4l48DELK6rYkB89dVIBbokaIwj5JliK1Vnj0q7YZnNgtpm9j5x5X7ByieX7wdnfeTU= Authentication-Results: intel.com; dkim=none (message not signed) header.d=none;intel.com; dmarc=none action=none header.from=mellanox.com; Received: from mellanox.com (209.116.155.178) by AM5PR0501MB2035.eurprd05.prod.outlook.com (2603:10a6:203:1a::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.696.13; Tue, 24 Apr 2018 01:39:08 +0000 From: Yongseok Koh To: wenzhuo.lu@intel.com, jingjing.wu@intel.com, olivier.matz@6wind.com Cc: dev@dpdk.org, konstantin.ananyev@intel.com, adrien.mazarguil@6wind.com, nelio.laranjeiro@6wind.com, Yongseok Koh Date: Mon, 23 Apr 2018 18:38:53 -0700 Message-Id: <20180424013854.33749-1-yskoh@mellanox.com> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20180310012532.15809-1-yskoh@mellanox.com> References: <20180310012532.15809-1-yskoh@mellanox.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [209.116.155.178] X-ClientProxiedBy: CY4PR04CA0073.namprd04.prod.outlook.com (2603:10b6:910:4f::38) To AM5PR0501MB2035.eurprd05.prod.outlook.com (2603:10a6:203:1a::21) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:AM5PR0501MB2035; X-Microsoft-Exchange-Diagnostics: 1; AM5PR0501MB2035; 3:z1EULxuZ5jwqdQTmJnw42mt//Vhl60DdBAvIAJe+JTttlLwqO9nJf4ZuNI3tLZFqJ6tYDmsRpmEJfTXavFc6Cj/4wnMTJqpfNgGv0ZEvWC5aHCc15Pz896ko4dGPqmFBys/F4JvZDL48BC5tVCG5BuUej16NNvfiFm6eBcdlFQrKyvCzhSskaUdtq+mRaTiW8bCOWkpkfkSJ5TDvL5oWFvRLA5yjKhmp/LC6CWoUcpp6BNp/+nUuAbjuJKPiX4pt; 25:TUts7qL7YVECpgLRQnYr7tK98dp2liKhgL7j7KP9nFzwPKLPXION6ZvXfPHC35R74Cx5UJVCAm09vhPYc9gfcbMdZBPbkuJj8pREDmw7ejK2cOgymoz+vcDGOBsah9XAIpJDJLe3DoqEowW4qhNixbili+cEi0J5mfgoAKDhTm2RpjCzHomuc/wkS6dExZn8tXjaik4Vl1DBXNb0L8AoXpQOFRvEyoaeP3vtO0Lkjcw6csHValyIuOuQ+I/0jnUjXtKRgf0gvdQn1ZWmc4/84gRWLLxmyTCt6AVcUBlp6hWTtZ5wVszJKsI8XfJzru1yT+t0KKZqdxwHo8sj9+igZw==; 31:zJQq4MIlg5SB0ufEP/md802d4lDMzugDP5SzSMdn1ZAKpI0qLlZiTEyWVP3nv2uu49ygZFyVqw1jB6hxT+73JhxmOaTWGrUoYL43cEpWXVoULKwr5JP1I36MUVOftc2vxuXodI8CKap//J5epyMgukYrYT04lcJnv2wIhPn6nvVfjQSUcIXO6wiLxBrlbDJ/oJG4jZHy+iwgqwaZnew6rTel1TIp/7WriGc+edp8CoU= X-MS-TrafficTypeDiagnostic: AM5PR0501MB2035: X-LD-Processed: a652971c-7d2e-4d9b-a6a4-d149256f461b,ExtAddr X-Microsoft-Exchange-Diagnostics: 1; AM5PR0501MB2035; 20:KQK9IRFTu99dnjEcKjEOBtmrCbiX1VAFpdg6HyuTLibWhGSydLncDHzHyhbD/Qju+4JTJKYXN+VlhIpTemmLgTvevodPwXzTV+GOSJPtQK+XULuKJAfUoa7ZW7ZP7L8+gtGuxAtvycqABiJnPaHTgBc90DFvm9gwmp84THtglU4ke3IXYyTzZy8G/Csd1mjbEW1ZWoomEUj/bn2miD/wIGaRzoHpHfYDv1YcbByi6n4/FYiezSpUHY+5/2Pw6e5bAv4Vx/eBjsI6uuBVsYaoLo7pEYLQvTikvEFofUG6klIsS4xgkwLZ0wAKxjofveMXlI2igb4VEamXq/m0ukWmalAoTUkO+r9dUSB3bViXnlju1V5YcTz1BKTPFl80RPz3/RlMq6gOLFONlOrFnPpDTEzDt/iyIjcntIbkNkK6NINIF46CnWDCyvX0dtp4EkmI2TYjTkzzavUD1Nv5lFrdrnCw7Wm2ArFfDVTbo0iQJVVxe88VbTOInJ8aJZxGLJa8; 4:Fc70S2pW5hd+vdY3tYUkWMpKkZuKuvoYowPJ+NP32uWfY+8V+1VN8zZK6qkbdCf33u66Z1jP5aIM64y+6tX092OZbhnAVFCTvMO7rqV6x153DtrtSyYAlyTfV+PFv62YlMg7fm8QjPMdaNzynazcMYbfFh8M5L4oEUli9quEXNc6gSZWYCAINWxFv9rWViJ968K4GIw9B1HVPt3rlU5qzKL29sQ+27s9UgP+83/2jFy+i2Hoiv20jVwBaPxhrveoJnE26rPlluohbXTlEAKsng== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(3231232)(944501410)(52105095)(3002001)(10201501046)(93006095)(93001095)(6055026)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123564045)(20161123560045)(20161123558120)(6072148)(201708071742011); SRVR:AM5PR0501MB2035; BCL:0; PCL:0; RULEID:; SRVR:AM5PR0501MB2035; X-Forefront-PRVS: 0652EA5565 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(39860400002)(366004)(376002)(39380400002)(396003)(346002)(50466002)(48376002)(16526019)(2906002)(386003)(6116002)(478600001)(1076002)(26005)(4326008)(186003)(6666003)(305945005)(3846002)(52116002)(7736002)(956004)(7696005)(11346002)(76176011)(55016002)(86362001)(446003)(316002)(59450400001)(476003)(8936002)(5660300001)(81166006)(8676002)(36756003)(107886003)(50226002)(2616005)(53936002)(47776003)(16586007)(66066001)(25786009)(5890100001); DIR:OUT; SFP:1101; SCL:1; SRVR:AM5PR0501MB2035; H:mellanox.com; FPR:; SPF:None; LANG:en; MLV:sfv; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; AM5PR0501MB2035; 23:D/FMRhWunE+MerqablGu/GcwRUANIKZgni3jCPh?= =?us-ascii?Q?23xrsJnGsbLdrZLkZg3fTELcCsiet2vZ7Csc6YoJgSdfICF2lAx/qU365Oj6?= =?us-ascii?Q?b82B4cqe6GNqP1WxVD1BsJKuYmAnsmOIpzpjGmqwbPNbBxb+OzjJ8uhLvhJy?= =?us-ascii?Q?8ROLflEcafpvev2eEbHuOSCNxxVnPKCs6rK1y6+bVFQYsf899pND5cqUxeOj?= =?us-ascii?Q?3wh1yW3UiPYgIJWxeXh+QIiI/+dqwy42dwQF/o1OUnmaY000WXshaiMNuqP+?= =?us-ascii?Q?+FrpZh2QeRWOaMQ9ym8OS/N/ZY5SIxAcl26P1YNSOZC+sopkoUF7WeaQfB7N?= =?us-ascii?Q?xpxHi65JIUGRFSJiCml1OKNw2+iGvBtKjsmFreqYJMhWtyL/X/Oo7whVG27Z?= =?us-ascii?Q?VPQonj3efIKyXwLHXuay4b6qJ5sPZ8X2YvcwWprD47FG5ocL9jn6E+OJAIZN?= =?us-ascii?Q?dnv38aTMI/hfTu+5sbteyS9glje+kV2SlbBGZ7t2R8W/kytBWtb5PgeDOr6l?= =?us-ascii?Q?R+uT6PkdX7VudWtNipq4Kf5fryNHCahhwFq741kQHa03uW80Rmp6RUgJ+PS6?= =?us-ascii?Q?Q8iu1sxNadZoB+rohJiMK0A5qBGAYQysAHkc9k9Xm3o8zRwyPfUuCRvPrG0+?= =?us-ascii?Q?iFdGnsdFhCLmaZL4NQRltQ/PUcxggoJEhKS1GGnDVwpETz+Hd2ixUWyVCPP5?= =?us-ascii?Q?z8u1pjCsW1xsosidM93vEsOVvtjR5eroQrbQiuPcBduBYHTGgEweud93M4Zr?= =?us-ascii?Q?JdZkx7E7LzGzPdCNQhUWHigk0xIcw1G+hhoCq/hoFabNd/GT7u0C8PD3ybNo?= =?us-ascii?Q?3DHHRFH+ylLbKIR3OgsJ3ilkpDRub5/NqY9x8aaOC7AuOn59P35B0jDcnAy/?= =?us-ascii?Q?a9lldpnhGZcruX6Ne6Xvv5/gvXedjXar3hx+jAm1qGuQvWsxuMZOAuJ+DeW1?= =?us-ascii?Q?V0279WhtFkY7nnir5Zfz13PhjFAvJnZZsp3mLh5uueIE9t64mHVM+b5mcJUG?= =?us-ascii?Q?V88ePEET5tc9KNwb1wkCqpxd1EqMXumc5WLf9nv1fa6LYbUbztHTm4aSKypE?= =?us-ascii?Q?gmbUCnow=3D?= X-Microsoft-Antispam-Message-Info: hjoFnJJf5LW+U8g/dmNVi7+fqs2lzvu335cP4pOjm1HOOI5uy+C57tUrJRigajlsPhWsICicOHUvqzdOzvHli3qLNUI0r4sgAB2diWzLi3GdJJ62h39BFehq8u4P4mGt2mGmPll/1f6/dx1TA0UEJqg6ZvCWUC8gyC92/gp/wsxlOLH/P9k32lphGAzH54Mv X-Microsoft-Exchange-Diagnostics: 1; AM5PR0501MB2035; 6:aZJcxFibypbBE7aykK8UqR9tERq1/oXXZLzzGh4VH8fgiIaulspvxy+FfxUDV5huB26ctV3JJDQLEgzImtTWEzASY8f7EUsbpqae+qTdMbgrA4EIFWoonJHtNwbZumG8ofwyloLLKJn2la/SJ2IiMVL3qMkrdeDdl8d8y3rzix1FAlKBYFcRwR8+et7E+lyxFLSJQR9+Dl7FnZWoj1Iu/rEqYPH8Z2QFhrkShD53qXSmejZQU0MB7o7bOyXCIMvX8QMMDLsb4ZD19xtia97f9m7ch7rmfAt8Y2mNQ/3QRoygI/Le9ydxQpHHpELjECtE8I/fE56nqb1ZGd2h+6DyIYXKonlFyGWocVU0vk70m7WTlvS77cII8hRw99B9DYKTW4qz0F850FHCydctKRvO8IAWOERGdKkYjYt3Ztg0RKhSFgF3NJnKQsyifCah2qc/TrCstONVfkqdNZu7Hx88Vg==; 5:N/MgpSFOf8sruWGTRk/iYHcnTslHeUUZtNNSXduEYGh1ju+Y5CEzNGl/ZBgE8Jk/IT2RezFW2UcFBJmM/McbirTegp8dhWW0E1NA4NQ3e85/RPyWwvBWwqdA+E56XjARIY7mW3ChtRRtWjgj4Y7Y3pocKSp9WyPHQVhyWV5GQ4o=; 24:DwzCnBrwk/tH1KzXncOReLM8v9sbIsCw7wF9+gf3orDTqeuwtTpfMd2ZkHsDUnEQlbxyx1fqZH6yCmIyV9LiHGyteI5EQ6aCsgrD1/Tx+P8= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; AM5PR0501MB2035; 7:qSQjiFM1kDoUGGroBok/bmZFqCpSZblGecDgJKi8bahhwHptbENLcoI0wgwtazc2CeTPjRDMJPoYoJcGt3OEYfWfFWFHHPhhCP6vOo1nDu958f7bO0e/wktLAkOiA44HNrxwVMm2xZn6ybgRLB2j+Ua80w69UN1ifKa5NquoUggL7kyzTs+DVwAd2hI/xyTNXpvo8/AgK9koQcLUqOqmqVkgCZQlAb+14dKisdLU/76Zd6uRxLBp0m/hfs9/Fcs/ X-MS-Office365-Filtering-Correlation-Id: df6ba371-70de-47a8-61cf-08d5a9842ce8 X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Apr 2018 01:39:08.0746 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: df6ba371-70de-47a8-61cf-08d5a9842ce8 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM5PR0501MB2035 Subject: [dpdk-dev] [PATCH v4 1/2] mbuf: support attaching external buffer to mbuf X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 24 Apr 2018 01:39:12 -0000 This patch introduces a new way of attaching an external buffer to a mbuf. Attaching an external buffer is quite similar to mbuf indirection in replacing buffer addresses and length of a mbuf, but a few differences: - When an indirect mbuf is attached, refcnt of the direct mbuf would be 2 as long as the direct mbuf itself isn't freed after the attachment. In such cases, the buffer area of a direct mbuf must be read-only. But external buffer has its own refcnt and it starts from 1. Unless multiple mbufs are attached to a mbuf having an external buffer, the external buffer is writable. - There's no need to allocate buffer from a mempool. Any buffer can be attached with appropriate free callback. - Smaller metadata is required to maintain shared data such as refcnt. Signed-off-by: Yongseok Koh --- ** This patch can pass the mbuf_autotest. ** Submitting only non-mlx5 patches to meet deadline for RC1. mlx5 patches will be submitted separately rebased on a differnet patchset which accommodates new memory hotplug design to mlx PMDs. v4: * rte_pktmbuf_attach_extbuf() takes new arguments - buf_iova and shinfo. user can pass memory for shared data via shinfo argument. * minor changes from review. v3: * implement external buffer attachment instead of introducing buf_off for mbuf indirection. lib/librte_mbuf/rte_mbuf.h | 289 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 260 insertions(+), 29 deletions(-) diff --git a/lib/librte_mbuf/rte_mbuf.h b/lib/librte_mbuf/rte_mbuf.h index 06eceba37..7f6507a66 100644 --- a/lib/librte_mbuf/rte_mbuf.h +++ b/lib/librte_mbuf/rte_mbuf.h @@ -326,7 +326,7 @@ extern "C" { PKT_TX_MACSEC | \ PKT_TX_SEC_OFFLOAD) -#define __RESERVED (1ULL << 61) /**< reserved for future mbuf use */ +#define EXT_ATTACHED_MBUF (1ULL << 61) /**< Mbuf having external buffer */ #define IND_ATTACHED_MBUF (1ULL << 62) /**< Indirect attached mbuf */ @@ -566,8 +566,24 @@ struct rte_mbuf { /** Sequence number. See also rte_reorder_insert(). */ uint32_t seqn; + struct rte_mbuf_ext_shared_info *shinfo; + } __rte_cache_aligned; +/** + * Function typedef of callback to free externally attached buffer. + */ +typedef void (*rte_mbuf_extbuf_free_callback_t)(void *addr, void *opaque); + +/** + * Shared data at the end of an external buffer. + */ +struct rte_mbuf_ext_shared_info { + rte_mbuf_extbuf_free_callback_t free_cb; /**< Free callback function */ + void *fcb_opaque; /**< Free callback argument */ + rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */ +}; + /**< Maximum number of nb_segs allowed. */ #define RTE_MBUF_MAX_NB_SEGS UINT16_MAX @@ -688,14 +704,33 @@ rte_mbuf_to_baddr(struct rte_mbuf *md) } /** + * Returns TRUE if given mbuf is cloned by mbuf indirection, or FALSE + * otherwise. + * + * If a mbuf has its data in another mbuf and references it by mbuf + * indirection, this mbuf can be defined as a cloned mbuf. + */ +#define RTE_MBUF_CLONED(mb) ((mb)->ol_flags & IND_ATTACHED_MBUF) + +/** * Returns TRUE if given mbuf is indirect, or FALSE otherwise. */ -#define RTE_MBUF_INDIRECT(mb) ((mb)->ol_flags & IND_ATTACHED_MBUF) +#define RTE_MBUF_INDIRECT(mb) RTE_MBUF_CLONED(mb) + +/** + * Returns TRUE if given mbuf has an external buffer, or FALSE otherwise. + * + * External buffer is a user-provided anonymous buffer. + */ +#define RTE_MBUF_HAS_EXTBUF(mb) ((mb)->ol_flags & EXT_ATTACHED_MBUF) /** * Returns TRUE if given mbuf is direct, or FALSE otherwise. + * + * If a mbuf embeds its own data after the rte_mbuf structure, this mbuf + * can be defined as a direct mbuf. */ -#define RTE_MBUF_DIRECT(mb) (!RTE_MBUF_INDIRECT(mb)) +#define RTE_MBUF_DIRECT(mb) (!(RTE_MBUF_CLONED(mb) || RTE_MBUF_HAS_EXTBUF(mb))) /** * Private data in case of pktmbuf pool. @@ -821,6 +856,58 @@ rte_mbuf_refcnt_set(struct rte_mbuf *m, uint16_t new_value) #endif /* RTE_MBUF_REFCNT_ATOMIC */ +/** + * Reads the refcnt of an external buffer. + * + * @param shinfo + * Shared data of the external buffer. + * @return + * Reference count number. + */ +static inline uint16_t +rte_mbuf_ext_refcnt_read(const struct rte_mbuf_ext_shared_info *shinfo) +{ + return (uint16_t)(rte_atomic16_read(&shinfo->refcnt_atomic)); +} + +/** + * Set refcnt of an external buffer. + * + * @param shinfo + * Shared data of the external buffer. + * @param new_value + * Value set + */ +static inline void +rte_mbuf_ext_refcnt_set(struct rte_mbuf_ext_shared_info *shinfo, + uint16_t new_value) +{ + rte_atomic16_set(&shinfo->refcnt_atomic, new_value); +} + +/** + * Add given value to refcnt of an external buffer and return its new + * value. + * + * @param shinfo + * Shared data of the external buffer. + * @param value + * Value to add/subtract + * @return + * Updated value + */ +static inline uint16_t +rte_mbuf_ext_refcnt_update(struct rte_mbuf_ext_shared_info *shinfo, + int16_t value) +{ + if (likely(rte_mbuf_ext_refcnt_read(shinfo) == 1)) { + rte_mbuf_ext_refcnt_set(shinfo, 1 + value); + return 1 + value; + } + + return (uint16_t)rte_atomic16_add_return(&shinfo->refcnt_atomic, value); +} + /** Mbuf prefetch */ #define RTE_MBUF_PREFETCH_TO_FREE(m) do { \ if ((m) != NULL) \ @@ -1195,11 +1282,122 @@ static inline int rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, } /** + * Attach an external buffer to a mbuf. + * + * User-managed anonymous buffer can be attached to an mbuf. When attaching + * it, corresponding free callback function and its argument should be + * provided. This callback function will be called once all the mbufs are + * detached from the buffer. + * + * More mbufs can be attached to the same external buffer by + * ``rte_pktmbuf_attach()`` once the external buffer has been attached by + * this API. + * + * Detachment can be done by either ``rte_pktmbuf_detach_extbuf()`` or + * ``rte_pktmbuf_detach()``. + * + * Memory for shared data can be provided by shinfo argument. If shinfo is NULL, + * a few bytes in the trailer of the provided buffer will be dedicated for + * shared data (``struct rte_mbuf_ext_shared_info``) to store refcnt, callback + * function and so on. The pointer of shared data will be stored in m->shinfo. + * + * Attaching an external buffer is quite similar to mbuf indirection in + * replacing buffer addresses and length of a mbuf, but a few differences: + * - When an indirect mbuf is attached, refcnt of the direct mbuf would be + * 2 as long as the direct mbuf itself isn't freed after the attachment. + * In such cases, the buffer area of a direct mbuf must be read-only. But + * external buffer has its own refcnt and it starts from 1. Unless + * multiple mbufs are attached to a mbuf having an external buffer, the + * external buffer is writable. + * - There's no need to allocate buffer from a mempool. Any buffer can be + * attached with appropriate free callback and its IO address. + * - Smaller metadata is required to maintain shared data such as refcnt. + * + * @warning + * @b EXPERIMENTAL: This API may change without prior notice. + * Once external buffer is enabled by allowing experimental API, + * ``RTE_MBUF_DIRECT()`` and ``RTE_MBUF_INDIRECT()`` are no longer + * exclusive. A mbuf can be considered direct if it is neither indirect nor + * having external buffer. + * + * @param m + * The pointer to the mbuf. + * @param buf_addr + * The pointer to the external buffer we're attaching to. + * @param buf_iova + * IO address of the external buffer we're attaching to. + * @param buf_len + * The size of the external buffer we're attaching to. If memory for + * shared data is not provided, buf_len must be larger than the size of + * ``struct rte_mbuf_ext_shared_info`` and padding for alignment. If not + * enough, this function will return NULL. + * @param shinfo + * User-provided memory for shared data. If NULL, a few bytes in the + * trailer of the provided buffer will be dedicated for shared data. + * @param free_cb + * Free callback function to call when the external buffer needs to be + * freed. + * @param fcb_opaque + * Argument for the free callback function. + * + * @return + * A pointer to the new start of the data on success, return NULL + * otherwise. + */ +static inline char * __rte_experimental +rte_pktmbuf_attach_extbuf(struct rte_mbuf *m, void *buf_addr, + rte_iova_t buf_iova, uint16_t buf_len, + struct rte_mbuf_ext_shared_info *shinfo, + rte_mbuf_extbuf_free_callback_t free_cb, void *fcb_opaque) +{ + void *buf_end = RTE_PTR_ADD(buf_addr, buf_len); + + m->buf_addr = buf_addr; + m->buf_iova = buf_iova; + + if (shinfo == NULL) { + shinfo = RTE_PTR_ALIGN_FLOOR(RTE_PTR_SUB(buf_end, + sizeof(*shinfo)), sizeof(uintptr_t)); + if ((void *)shinfo <= buf_addr) + return NULL; + + m->buf_len = RTE_PTR_DIFF(shinfo, buf_addr); + } else { + m->buf_len = buf_len; + } + + m->data_len = 0; + + rte_pktmbuf_reset_headroom(m); + m->ol_flags |= EXT_ATTACHED_MBUF; + m->shinfo = shinfo; + + rte_mbuf_ext_refcnt_set(shinfo, 1); + shinfo->free_cb = free_cb; + shinfo->fcb_opaque = fcb_opaque; + + return (char *)m->buf_addr + m->data_off; +} + +/** + * Detach the external buffer attached to a mbuf, same as + * ``rte_pktmbuf_detach()`` + * + * @param m + * The mbuf having external buffer. + */ +#define rte_pktmbuf_detach_extbuf(m) rte_pktmbuf_detach(m) + +/** * Attach packet mbuf to another packet mbuf. * - * After attachment we refer the mbuf we attached as 'indirect', - * while mbuf we attached to as 'direct'. - * The direct mbuf's reference counter is incremented. + * If the mbuf we are attaching to isn't a direct buffer and is attached to + * an external buffer, the mbuf being attached will be attached to the + * external buffer instead of mbuf indirection. + * + * Otherwise, the mbuf will be indirectly attached. After attachment we + * refer the mbuf we attached as 'indirect', while mbuf we attached to as + * 'direct'. The direct mbuf's reference counter is incremented. * * Right now, not supported: * - attachment for already indirect mbuf (e.g. - mi has to be direct). @@ -1213,19 +1411,18 @@ static inline int rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, */ static inline void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *m) { - struct rte_mbuf *md; - RTE_ASSERT(RTE_MBUF_DIRECT(mi) && rte_mbuf_refcnt_read(mi) == 1); - /* if m is not direct, get the mbuf that embeds the data */ - if (RTE_MBUF_DIRECT(m)) - md = m; - else - md = rte_mbuf_from_indirect(m); + if (RTE_MBUF_HAS_EXTBUF(m)) { + rte_mbuf_ext_refcnt_update(m->shinfo, 1); + mi->ol_flags = m->ol_flags; + } else { + rte_mbuf_refcnt_update(rte_mbuf_from_indirect(m), 1); + mi->priv_size = m->priv_size; + mi->ol_flags = m->ol_flags | IND_ATTACHED_MBUF; + } - rte_mbuf_refcnt_update(md, 1); - mi->priv_size = m->priv_size; mi->buf_iova = m->buf_iova; mi->buf_addr = m->buf_addr; mi->buf_len = m->buf_len; @@ -1241,7 +1438,6 @@ static inline void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *m) mi->next = NULL; mi->pkt_len = mi->data_len; mi->nb_segs = 1; - mi->ol_flags = m->ol_flags | IND_ATTACHED_MBUF; mi->packet_type = m->packet_type; mi->timestamp = m->timestamp; @@ -1250,12 +1446,50 @@ static inline void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *m) } /** - * Detach an indirect packet mbuf. + * @internal used by rte_pktmbuf_detach(). + * + * Decrement the reference counter of the external buffer. When the + * reference counter becomes 0, the buffer is freed by pre-registered + * callback. + */ +static inline void +__rte_pktmbuf_free_extbuf(struct rte_mbuf *m) +{ + RTE_ASSERT(RTE_MBUF_HAS_EXTBUF(m)); + RTE_ASSERT(m->shinfo != NULL); + + if (rte_mbuf_ext_refcnt_update(m->shinfo, -1) == 0) + m->shinfo->free_cb(m->buf_addr, m->shinfo->fcb_opaque); +} + +/** + * @internal used by rte_pktmbuf_detach(). + * + * Decrement the direct mbuf's reference counter. When the reference + * counter becomes 0, the direct mbuf is freed. + */ +static inline void +__rte_pktmbuf_free_direct(struct rte_mbuf *m) +{ + struct rte_mbuf *md = rte_mbuf_from_indirect(m); + + RTE_ASSERT(RTE_MBUF_INDIRECT(m)); + + if (rte_mbuf_refcnt_update(md, -1) == 0) { + md->next = NULL; + md->nb_segs = 1; + rte_mbuf_refcnt_set(md, 1); + rte_mbuf_raw_free(md); + } +} + +/** + * Detach a packet mbuf from external buffer or direct buffer. * + * - decrement refcnt and free the external/direct buffer if refcnt + * becomes zero. * - restore original mbuf address and length values. * - reset pktmbuf data and data_len to their default values. - * - decrement the direct mbuf's reference counter. When the - * reference counter becomes 0, the direct mbuf is freed. * * All other fields of the given packet mbuf will be left intact. * @@ -1264,10 +1498,14 @@ static inline void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *m) */ static inline void rte_pktmbuf_detach(struct rte_mbuf *m) { - struct rte_mbuf *md = rte_mbuf_from_indirect(m); struct rte_mempool *mp = m->pool; uint32_t mbuf_size, buf_len, priv_size; + if (RTE_MBUF_HAS_EXTBUF(m)) + __rte_pktmbuf_free_extbuf(m); + else + __rte_pktmbuf_free_direct(m); + priv_size = rte_pktmbuf_priv_size(mp); mbuf_size = sizeof(struct rte_mbuf) + priv_size; buf_len = rte_pktmbuf_data_room_size(mp); @@ -1279,13 +1517,6 @@ static inline void rte_pktmbuf_detach(struct rte_mbuf *m) rte_pktmbuf_reset_headroom(m); m->data_len = 0; m->ol_flags = 0; - - if (rte_mbuf_refcnt_update(md, -1) == 0) { - md->next = NULL; - md->nb_segs = 1; - rte_mbuf_refcnt_set(md, 1); - rte_mbuf_raw_free(md); - } } /** @@ -1309,7 +1540,7 @@ rte_pktmbuf_prefree_seg(struct rte_mbuf *m) if (likely(rte_mbuf_refcnt_read(m) == 1)) { - if (RTE_MBUF_INDIRECT(m)) + if (!RTE_MBUF_DIRECT(m)) rte_pktmbuf_detach(m); if (m->next != NULL) { @@ -1321,7 +1552,7 @@ rte_pktmbuf_prefree_seg(struct rte_mbuf *m) } else if (__rte_mbuf_refcnt_update(m, -1) == 0) { - if (RTE_MBUF_INDIRECT(m)) + if (!RTE_MBUF_DIRECT(m)) rte_pktmbuf_detach(m); if (m->next != NULL) { -- 2.11.0