From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR01-HE1-obe.outbound.protection.outlook.com (mail-he1eur01on0057.outbound.protection.outlook.com [104.47.0.57]) by dpdk.org (Postfix) with ESMTP id 3C23A58C6 for ; Thu, 19 Apr 2018 03:11:21 +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=UATJecbxujodWw7pPiVJZ8sxx7ZfZvZ8tHf0FLE9pd0=; b=kbRDHkTEL8kVRnkAkZkfQwr40YTvvzynn90F5HIEN8UYXo9RQG1IrCHzUT0KXfY/UMf4L6qIGDVtKNAqvIsh7TtXoJxRo1uEtEUqx6o6QrWoyEySDdBC159ytTq1Ew1CfQ/d1sQMHl3gm8Lab5LP92tMEUkwMatN0nL73sMxjhQ= Received: from mellanox.com (209.116.155.178) by DB6PR0501MB2040.eurprd05.prod.outlook.com (2603:10a6:4:6::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.675.14; Thu, 19 Apr 2018 01:11:18 +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: Wed, 18 Apr 2018 18:11:04 -0700 Message-Id: <20180419011105.9694-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: BN6PR11CA0042.namprd11.prod.outlook.com (2603:10b6:404:4b::28) To DB6PR0501MB2040.eurprd05.prod.outlook.com (2603:10a6:4:6::22) 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:DB6PR0501MB2040; X-Microsoft-Exchange-Diagnostics: 1; DB6PR0501MB2040; 3:fYpTdg0ZZX9nFc5D7+FawIE1yS1T4qLbu8YgFSW1mwW+nW4XVdTi5PMwlyEeri4kD+PxqGJtN4C3G8Tev61jBBFrJahINFjuLAi7ZfTsffcUzRVwGDXxzAHqLTpX7c/xOJNLvxMlkcIb1KAZe+DxcsTOYxwQlovKxtp0+vjEraRWEM4ugbcpj6it/TR+gSjD/UL2+cZ3W9pthvWVQB+F386RsWl1NsS1VrPfuAgUyiSpz2jGhKZc0Ywww44uGtU3; 25:pnD60I9z1A0FW65/EE8krp1M6VvIt7E+s7XwUKsRMv0KI+Z9BNAisRtzuKDe/hL3jIFoqILRsnoJmt5qFUUwMRex5XeQgfMtCIp1bEas6imFaCbQYD3HyI1lrKu29DpZlZrwrjYtclMXrINaApUtpoSkwAfn6jfgoIAYN4HyH9hMrSyz2JaAnMPY22+5T8Ym/6masd0tzo+7MmGQ0sEHxzfSffncBhmtmiD4jbgwvCnmuhVgPg77N2ucPseDTIqi8oR4yzv1EQjGr2G9Uvpx3FpoBA4a6T+uuq5lgVeboxheU61g1gCaU9Cl293bQ3OLOhNi9HdwUUmxx3YBgl+KLg==; 31:SNBAwu92+NksaaZbza1I1e1xK/JgTr1kXQyS9Mc1aet2SeegJ/VrshG3g1qMqIaNr35k9tjssAf8TG/x8K+7P+wERMYjDHM54C4DMZycv83SmT/bbgZFufQLQrSCGTP0ju4J8JM+iQtuDeChNwflK0ZJ6BNJfOFqcKUSn9wKnI6Xuypvl5rrg6AlhLKb23dZdb3bLD4lbnb0tvizzTXIsUau2fT7PWxM3F/2l9PdOo8= X-MS-TrafficTypeDiagnostic: DB6PR0501MB2040: Authentication-Results: outbound.protection.outlook.com; spf=skipped (originating message); dkim=none (message not signed) header.d=none; dmarc=none action=none header.from=mellanox.com; X-LD-Processed: a652971c-7d2e-4d9b-a6a4-d149256f461b,ExtAddr X-Microsoft-Exchange-Diagnostics: 1; DB6PR0501MB2040; 20:vqdUp6qJebT20GginEcjXFPD6QvmAfTEoJ9qqcQ4QgV/xe05unEgtFb1PwycN952Qsw2tgDBbgsy6B2zaeKPfLeL5cbYoSMCHnLkklQy06fdxcLTlkAAPhd4SHwD76x81vRL6hm99X7fs/CE1LKoX69cXW9pjtPQrYAa4bgjmhopBwBVYfKAEDnWNr5uO4OnDHdhexjkrZYciLITjMwCNOXPX3SgSDSFbzyuTJpNyfOofIMdy5w+04Xe1jggPTqPQD4QaeFwy/bCD6U3cXreMIB8LhnlGZejA4QHLBeFFXr0ffMupFkO3F9vJxrBsrhn6oXZaMxw5C28O5a8FwHQNAgv/0rBSb7lBj48mDhnVgwHSwFBzUnNzZyacsddn7ff+jMAiL5Fn92FxPhiDWZ6dBZVHXxvtLoZgHW2x/CMXacM3BGlQYVdnQbZGlWFV5H2X6T9KDr0ezoo3VjqaA8rk9Du0FRAdBBTjHS/RwFdcv2jKGk7UPYEYCft1bDPNkLS; 4:Y6xENekG5DpsZ0x01ueFxY1VCYU7csb8Om9UruunwaZ0l/mlk2qaU12Ry7OUepA9O6fpyIMnQxXhodxJJnkyv3fkLz8ePKsDGG0IlQLwhJRVopm71i9iLPiDY0/75rCve2G9kiHsofEOgPRMS2BFEJNtxy8gaFh6NpT3RPZ5IWUNgCo/NXUT6SYaYnhVZsV8Z7teZKkZCf2as6A00B9YZp5ZURjhYSnUQYZ+jrLtSy6CZx0+E64yzIu/SywO2QinNG6NuStjLAbuLJkldbpINw== 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)(3002001)(93006095)(93001095)(10201501046)(3231232)(944501372)(52105095)(6055026)(6041310)(20161123560045)(20161123558120)(20161123562045)(20161123564045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011); SRVR:DB6PR0501MB2040; BCL:0; PCL:0; RULEID:; SRVR:DB6PR0501MB2040; X-Forefront-PRVS: 0647963F84 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(346002)(376002)(366004)(39380400002)(39860400002)(186003)(956004)(6666003)(52116002)(446003)(386003)(66066001)(1076002)(107886003)(86362001)(47776003)(59450400001)(11346002)(50466002)(26005)(16586007)(3846002)(36756003)(476003)(316002)(2616005)(76176011)(7696005)(51416003)(16526019)(8936002)(50226002)(478600001)(305945005)(8676002)(81166006)(55016002)(53936002)(6116002)(5890100001)(7736002)(5660300001)(2906002)(25786009)(4326008); DIR:OUT; SFP:1101; SCL:1; SRVR:DB6PR0501MB2040; H:mellanox.com; FPR:; SPF:None; LANG:en; MLV:sfv; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DB6PR0501MB2040; 23:ZYXrxQ03Kfvhz11IAC3dnFtHviMdzHmltsT+kwP?= =?us-ascii?Q?RcCD24a8puQXjMQ3h3S2YMIlPnNGdp34yoPw/HKrnNbQI9C8ZjZfl4xhmQon?= =?us-ascii?Q?o51Mq8FlZXJf+qHEC1aMVhUZGXLbb88uyEImIsmHRJrS1GHf+h8DefVEoUKl?= =?us-ascii?Q?DVXW/AfXsRBJ1NgdERBsus/fp7sDfXnxWdEqkkw4DyX7kehCGlzBskVVe7Rt?= =?us-ascii?Q?gD0AFCYTqKB3NKxA+PrW31Gfxxc/yx7WY8aOs1lbV3zpfmc2QWvO/WST6R4i?= =?us-ascii?Q?KHYMrpP2yJCqKX6ywH2+KvMYmw+t7LTBv7a8c5xWUpDn6Ru/Q/BYBYn1W8Mk?= =?us-ascii?Q?A3GT2eNu8cfT+pxWX5sqyebL+026hDLsP0+V+0VtkHIFiKh14dT2ADnitMLK?= =?us-ascii?Q?/fg0gVM3W5UseLHtFqggnTdH50cGGXkCwmWajAtWarrvSJ14rEOLSzwXwe/8?= =?us-ascii?Q?brwPXCAk/40cDJ+ZVf1KXhPm663tiwGZAxrmHSTipyPlFcuLKDy/BKGMNn9m?= =?us-ascii?Q?hr0JoHdfQq62H9nkVi2jo6q+Rco1k/sgdSmI6C3eIiyZjpdCQYGmYYJUCCz4?= =?us-ascii?Q?f/34XAeo5gt6AtyXzz2mPAzagewmMR65KixTPDthd6WoW3cNHl36ry4Hx9Bu?= =?us-ascii?Q?EcQOsGTBFxnQxtdl44TJYhIPrK8JPf567tn3NiUCM4ICuYcHB5lBoue2UoyK?= =?us-ascii?Q?v+l+cmcy+lF2TJPXod4wty1ILsUISktx6XagqYauZ5aC6K/mgUXHjvbo20kZ?= =?us-ascii?Q?HbTyaH8BBn7YrVn9wrlAPdjNgRosteBKS3g1ZAzXBpisCtnLbKQmoxc6YOSZ?= =?us-ascii?Q?EL6dl5pkhJ3BxhwCssI4w38Nzy7+dTtOZg6h9VKQCLnL8vZ7e5uPjQpnbP3i?= =?us-ascii?Q?3oy9+2+bf0NvKsgpt7RmTTinxB0o4eWATd0/5eXDnOXOs3aL/GjUgmOY9MfK?= =?us-ascii?Q?0zO7BkwqxKKkxDw2ikoU3ZDLSTfHpofThxv/FAhsR/rZCDsSYf1IebDj2zwK?= =?us-ascii?Q?sio+d6drt0X3Z6mrPZRDxjtpSehHcVRjhGHwVGSZsK41acA=3D=3D?= X-Microsoft-Antispam-Message-Info: RHtv2ISnn69dYzq1u9643wo2EF/PE+snsO+5qqwV6DtS/hM3eaYTMeoGRNKvtG/s51CuEZjNOeb3iZnzcbKoakcFExbcFpt+4tE8GKwlALgCgHF78qN2MS2s3sZemPFarhxkRUlc8W9bgibP2tXAFTPTPeULsU7ohV1TMlAnL7A7MALy+R6+GHH1k5dlbKx6 X-Microsoft-Exchange-Diagnostics: 1; DB6PR0501MB2040; 6:MgWOmgNuUAx/BfPa8hrteIr8LQbx9KOgs9ucsa2xk8vyO8onTdz2VgnLvd1KyET9Jv2Ry+d0H1E1kXJ5y9MeHrefGBwnLb5nf1ntAPow3QJFcQTAqGfk1/JVwL9nmtxE/IhmVw34xoOSRpVGKeqSMD4YHpIF6trkjHyd2ruhCuUtu/qM85pW/6DqWjGV0xuyF8FSmqGl/tQb3ofHQBQHWX7UitQa0LU+0oMempxRcdGro9LOJHlsCYPC8juFLofSao/AMjHiJ4/0LrBrm6SdSaQBhc+U4vdiMJ4F66YxwV/FLQzTl6SaSMmIBtB/mw+r4zQNh8Y4dZDS1t73n1eFNbp86QpUmR5eAN/SqrgAUzaAE/TYzpT8HeJ3uXSlUeUM2ZQEd6jHhJNGABejrQ6j+zssaJfgC/s3COk5sVz6K5AqO/epoqzI3Kr9XwCklDH8wFS9ZIj7sZUCvI22WvnwzQ==; 5:3g2HG1NjMIpZRHUwji0QhhdadLCFchn2OIW3ECjKW5ZNuOGO/x/dT4xeTflwSu1vFlFcvMrxUGzQ2uqPw3Hb1+mWdzYzxMvHSXNjT532Z43XTc7/jRe2fQWTJF+cYdR+yoWXJP48i6xMOzjcI6bRu+CzBmyusIVQGUUIoyo68QI=; 24:nLqNPx0V73UaaFwWwhcqHNpoS6dR/xhWDHQAy1aPrhx0vNgGIich7pAfp17BSL2Eb/9mCBF1K5BElaIbbzNHlI48TxGRjSsIGWCngURKnu8= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DB6PR0501MB2040; 7:K5PlnenTSbYZmgEqS1R4H5xmF8mdipvff20G7PcXvpIRGh2mAODegnOY0ZQQt1duXTB5Zq5a+bUpwXSeDRy+TuB1t9uJGiVQRP8T1xpJVU5I+KMejSIRmf+OiVmhATBXiVdMTNY62WvHYNJ9gFG5QwLfqD3kdsXAethytZ4alkY1hLY24sr8dZKooFVkiYdb7yDnkLtPfePbn/lKUsrN1OU1AqdfTC5HWvIfIJU70V4byat2lNXuLdzaj5ROhTeX X-MS-Office365-Filtering-Correlation-Id: 2dbcb61c-ebb5-412b-ec0f-08d5a592757e X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Apr 2018 01:11:18.2228 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 2dbcb61c-ebb5-412b-ec0f-08d5a592757e X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB6PR0501MB2040 Subject: [dpdk-dev] [PATCH v3 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: Thu, 19 Apr 2018 01:11:21 -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: - As refcnt of a direct mbuf is at least 2, 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 --- 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. v3: * implement external buffer attachment instead of introducing buf_off for mbuf indirection. lib/librte_mbuf/rte_mbuf.h | 276 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 248 insertions(+), 28 deletions(-) diff --git a/lib/librte_mbuf/rte_mbuf.h b/lib/librte_mbuf/rte_mbuf.h index 06eceba37..e64160c81 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 */ @@ -568,6 +568,24 @@ struct rte_mbuf { } __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_STD_C11 + union { + rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */ + uint16_t refcnt; /**< Non-atomically accessed refcnt */ + }; +}; + /**< Maximum number of nb_segs allowed. */ #define RTE_MBUF_MAX_NB_SEGS UINT16_MAX @@ -693,9 +711,14 @@ rte_mbuf_to_baddr(struct rte_mbuf *md) #define RTE_MBUF_INDIRECT(mb) ((mb)->ol_flags & IND_ATTACHED_MBUF) /** + * Returns TRUE if given mbuf has external buffer, or FALSE otherwise. + */ +#define RTE_MBUF_HAS_EXTBUF(mb) ((mb)->ol_flags & EXT_ATTACHED_MBUF) + +/** * Returns TRUE if given mbuf is direct, or FALSE otherwise. */ -#define RTE_MBUF_DIRECT(mb) (!RTE_MBUF_INDIRECT(mb)) +#define RTE_MBUF_DIRECT(mb) (!RTE_MBUF_INDIRECT(mb) && !RTE_MBUF_HAS_EXTBUF(mb)) /** * Private data in case of pktmbuf pool. @@ -821,6 +844,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_extbuf_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_extbuf_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_extbuf_refcnt_update(struct rte_mbuf_ext_shared_info *shinfo, + int16_t value) +{ + if (likely(rte_extbuf_refcnt_read(shinfo) == 1)) { + rte_extbuf_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 +1270,120 @@ static inline int rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, } /** + * Return shared data of external buffer of a mbuf. + * + * @param m + * The pointer to the mbuf. + * @return + * The address of the shared data. + */ +static inline struct rte_mbuf_ext_shared_info * +rte_mbuf_ext_shinfo(struct rte_mbuf *m) +{ + return (struct rte_mbuf_ext_shared_info *) + RTE_PTR_ADD(m->buf_addr, m->buf_len); +} + +/** + * 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()``. + * + * 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 shared data can be referenced by + * ``rte_mbuf_ext_shinfo()`` + * + * Attaching an external buffer is quite similar to mbuf indirection in + * replacing buffer addresses and length of a mbuf, but a few differences: + * - As refcnt of a direct mbuf is at least 2, 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. + * + * @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 consiered 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_len + * The size of the external buffer we're attaching to. This 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 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, + uint16_t buf_len, rte_mbuf_extbuf_free_callback_t free_cb, + void *fcb_opaque) +{ + void *buf_end = RTE_PTR_ADD(buf_addr, buf_len); + struct rte_mbuf_ext_shared_info *shinfo; + + shinfo = RTE_PTR_ALIGN_FLOOR(RTE_PTR_SUB(buf_end, sizeof(*shinfo)), + sizeof(uintptr_t)); + + if ((void *)shinfo <= buf_addr) + return NULL; + + m->buf_addr = buf_addr; + m->buf_iova = rte_mempool_virt2iova(buf_addr); + m->buf_len = RTE_PTR_DIFF(shinfo, buf_addr); + m->data_len = 0; + + rte_pktmbuf_reset_headroom(m); + m->ol_flags |= EXT_ATTACHED_MBUF; + + rte_extbuf_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 +1397,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_extbuf_refcnt_update(rte_mbuf_ext_shinfo(m), 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 +1424,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 +1432,53 @@ 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) +{ + struct rte_mbuf_ext_shared_info *shinfo; + + RTE_ASSERT(RTE_MBUF_HAS_EXTBUF(m)); + + shinfo = rte_mbuf_ext_shinfo(m); + + if (rte_extbuf_refcnt_update(shinfo, -1) == 0) + shinfo->free_cb(m->buf_addr, 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 +1487,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 +1506,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 +1529,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 +1541,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