From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by dpdk.space (Postfix) with ESMTP id 36009A0679 for ; Thu, 28 Mar 2019 20:30:29 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 04D6D4C8D; Thu, 28 Mar 2019 20:30:29 +0100 (CET) Received: from NAM03-DM3-obe.outbound.protection.outlook.com (mail-eopbgr800093.outbound.protection.outlook.com [40.107.80.93]) by dpdk.org (Postfix) with ESMTP id D4A55324D for ; Thu, 28 Mar 2019 20:30:27 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=WPtvsV+GHK91H8O3bT4tAl1M4/gki2+V14mxaUWg9lk=; b=mUjbfGoq1KMxjGpnCI7Otc2WZK/pv6CbX6Qs/ZRvvAMSG44chL7cUeFAuwuFjhLv33dLabpr6LF+2yr6f+P6plc6U2RUQIfeyfiOvBkO411Yc9aL4M5zu6RaqKjU2DlFyhUBl/+lDZHv6q3eOCM+QJONtmo8AABt+pkikj0csAk= ARC-Seal: i=1; a=rsa-sha256; s=testarcselector01; d=microsoft.com; cv=none; b=RaBWpDh4BPeP/wODn2iywPG/IDO33hQ3NEUocm5bpcdsNV2msb1rWagjcL3DC75Sry1CrrB6DK1sshMXBVLFfDggJaYdvWFZVfhDDtOYDoYfIc0NExOv99nHzVA4qoxf2ELYrOmW8ZJ87pyvtkb5Ix8xnPGp9vh0xdiJ00Tl9W8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=testarcselector01; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=WPtvsV+GHK91H8O3bT4tAl1M4/gki2+V14mxaUWg9lk=; b=iN1G9WEry644dDKE4Ngap1qFKuuBzSlxVdTADxaY7ieb+eiTbyhuKQCQoS7+bQwMzx/kqdha/qOkwBMQ0YA0y5SuFXHy5uyhSWT7olQnNXJ0+rk3SUxqwQICjg0dHjnE5CFspTLyQfk4cthCL6bWvgHDAgiN9vWwXgr9+dHh+Ho= ARC-Authentication-Results: =?us-ascii?Q?i=3D1; _test.office365.com_1; =0D=0A=09=09dmarc=3Dnone_action?= =?us-ascii?Q?=3Dnone_header.from=3Dmicrosoft.com;=0D=0A=09=09arc=3Dnone?= Received: from MWHPR21MB0638.namprd21.prod.outlook.com (10.175.141.139) by MWHPR21MB0175.namprd21.prod.outlook.com (10.173.52.21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1771.3; Thu, 28 Mar 2019 19:30:26 +0000 Received: from MWHPR21MB0638.namprd21.prod.outlook.com ([fe80::c4e7:ece1:887e:b983]) by MWHPR21MB0638.namprd21.prod.outlook.com ([fe80::c4e7:ece1:887e:b983%3]) with mapi id 15.20.1771.002; Thu, 28 Mar 2019 19:30:26 +0000 From: Harini Ramakrishnan To: Anand Rawat , "dev@dpdk.org" CC: "pallavi.kadam@intel.com" , "ranjit.menon@intel.com" , "jeffrey.b.shaw@intel.com" , "bruce.richardson@intel.com" , "thomas@monjalon.net" Thread-Topic: [dpdk-dev] [PATCH v6 4/8] eal: sys/queue.h implementation for windows Thread-Index: AQHU5Q0QsHvzr49epEyiUVIGkRzpF6YhbyNA Date: Thu, 28 Mar 2019 19:30:26 +0000 Message-ID: References: <20190306041634.12976-1-anand.rawat@intel.com> <20190328022115.4660-1-anand.rawat@intel.com> <20190328022115.4660-5-anand.rawat@intel.com> In-Reply-To: <20190328022115.4660-5-anand.rawat@intel.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: msip_labels: MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Enabled=True; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_SiteId=72f988bf-86f1-41af-91ab-2d7cd011db47; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Owner=haramakr@microsoft.com; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_SetDate=2019-03-28T19:30:24.2776662Z; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Name=General; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Application=Microsoft Azure Information Protection; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_ActionId=d324e3e9-15bd-4681-adb4-49bcc5521f8f; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Extended_MSFT_Method=Automatic x-originating-ip: [2001:4898:80e8:a:84e2:1334:627:d48e] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: d12ea6cf-d285-4fbb-c139-08d6b3b3d46c x-ms-office365-filtering-ht: Tenant x-microsoft-antispam: BCL:0; PCL:0; RULEID:(2390118)(7020095)(4652040)(8989299)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(5600127)(711020)(4605104)(4618075)(2017052603328)(7193020); SRVR:MWHPR21MB0175; x-ms-traffictypediagnostic: MWHPR21MB0175: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:10000; x-forefront-prvs: 0990C54589 x-forefront-antispam-report: SFV:NSPM; SFS:(10019020)(39860400002)(346002)(136003)(396003)(376002)(366004)(189003)(199004)(13464003)(186003)(68736007)(72206003)(6246003)(256004)(25786009)(106356001)(71200400001)(105586002)(446003)(81156014)(5660300002)(71190400001)(53546011)(4326008)(110136005)(22452003)(8990500004)(14444005)(316002)(10090500001)(81166006)(86362001)(486006)(476003)(30864003)(86612001)(55016002)(11346002)(8936002)(53936002)(9686003)(6116002)(99286004)(14454004)(2501003)(33656002)(478600001)(6506007)(54906003)(229853002)(76176011)(74316002)(102836004)(97736004)(305945005)(7736002)(7696005)(52536014)(46003)(6346003)(2906002)(6436002)(10290500003); DIR:OUT; SFP:1102; SCL:1; SRVR:MWHPR21MB0175; H:MWHPR21MB0638.namprd21.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; received-spf: None (protection.outlook.com: microsoft.com does not designate permitted sender hosts) authentication-results: spf=none (sender IP is ) smtp.mailfrom=Harini.Ramakrishnan@microsoft.com; x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: vj2jRXuHgYkTaquMjsYerO8KVhnaV2wuXTSXxrx0yHVMymoS+u8DCHnBpwXKZN5JOV7p+o2Je511tAhlH2PA8iVAxgTyJYztemTgbp5rALs7L7T+FbMV+Tx+GM+2IXaVmW5mx56vc74bq+C7lOSJkBls2sGDdG/pUY5OJYmEoJQ7KGVBMQZ8MKIyaLhsgD9Z7XECrEcSGfyB+otthUH6+/qpm/qRTFzacXvi8rz9EkIhZkZHYWDINRTPTVR8DoQvQbsfwqGSKHQg6jGbXOVS0ViHjCj75+omwIAO4y0NWeBs5lLZhv+X29FGXjDxlMhwMCrNdO9mXw24uKHHq1GpBzvAwXYNR0sNIU4KZFcSqMIbnXSexnzUhd7HV14K3RVBQR7KL+GO9GupwaIrc1F0C8dIc9Pe0EXodaf8810s26I= Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: microsoft.com X-MS-Exchange-CrossTenant-Network-Message-Id: d12ea6cf-d285-4fbb-c139-08d6b3b3d46c X-MS-Exchange-CrossTenant-originalarrivaltime: 28 Mar 2019 19:30:26.3088 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 72f988bf-86f1-41af-91ab-2d7cd011db47 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR21MB0175 Subject: Re: [dpdk-dev] [PATCH v6 4/8] eal: sys/queue.h implementation for windows 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Message-ID: <20190328193026.lw9BYhgaFV9A8ZTFFWFXpGit8REaGRcH4bCDLV3RRbg@z> Acked-by: Harini Ramakrishnan -----Original Message----- From: dev On Behalf Of Anand Rawat Sent: Wednesday, March 27, 2019 7:21 PM To: dev@dpdk.org Cc: anand.rawat@intel.com; pallavi.kadam@intel.com; ranjit.menon@intel.com;= jeffrey.b.shaw@intel.com; bruce.richardson@intel.com; thomas@monjalon.net Subject: [dpdk-dev] [PATCH v6 4/8] eal: sys/queue.h implementation for wind= ows Adding sys/queue.h on windows for supporting common code. This is implementation has BSD-3-Clause licensing. Signed-off-by: Ranjit Menon Signed-off-by: Anand Rawat Reviewed-by: Jeff Shaw --- .../windows/eal/include/sys/queue.h | 320 ++++++++++++++++++ 1 file changed, 320 insertions(+) create mode 100644 lib/librte_eal/windows/eal/include/sys/queue.h diff --git a/lib/librte_eal/windows/eal/include/sys/queue.h b/lib/librte_ea= l/windows/eal/include/sys/queue.h new file mode 100644 index 000000000..5ee4916ad --- /dev/null +++ b/lib/librte_eal/windows/eal/include/sys/queue.h @@ -0,0 +1,320 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this softwar= e + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 PURP= OSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABL= E + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENT= IAL + * 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, STR= ICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY W= AY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#ifndef _SYS_QUEUE_H_ +#define _SYS_QUEUE_H_ + +/* + * This file defines tail queues. + * + * A tail queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or + * after an existing element, at the head of the list, or at the end of + * the list. A tail queue may be traversed in either direction. + * + * Below is a summary of implemented functions where: + * + means the macro is available + * - means the macro is not available + * s means the macro is available but is slow (runs in O(n) time) + * + * TAILQ + * _HEAD + + * _CLASS_HEAD + + * _HEAD_INITIALIZER + + * _ENTRY + + * _CLASS_ENTRY + + * _INIT + + * _EMPTY + + * _FIRST + + * _NEXT + + * _PREV + + * _LAST + + * _LAST_FAST + + * _FOREACH + + * _FOREACH_FROM + + * _FOREACH_SAFE + + * _FOREACH_FROM_SAFE + + * _FOREACH_REVERSE + + * _FOREACH_REVERSE_FROM + + * _FOREACH_REVERSE_SAFE + + * _FOREACH_REVERSE_FROM_SAFE + + * _INSERT_HEAD + + * _INSERT_BEFORE + + * _INSERT_AFTER + + * _INSERT_TAIL + + * _CONCAT + + * _REMOVE_AFTER - + * _REMOVE_HEAD - + * _REMOVE + + * _SWAP + + * + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#define QMD_TRACE_ELEM(elem) +#define QMD_TRACE_HEAD(head) +#define TRACEBUF +#define TRACEBUF_INITIALIZER + +#define TRASHIT(x) +#define QMD_IS_TRASHED(x) 0 + +#define QMD_SAVELINK(name, link) + +#ifdef __cplusplus +/* + * In C++ there can be structure lists and class lists: + */ +#define QUEUE_TYPEOF(type) type +#else +#define QUEUE_TYPEOF(type) struct type +#endif + +/* + * Tail queue declarations. + */ +#define TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_HEAD(name, type) \ +struct name { \ + class type *tqh_first; /* first element */ \ + class type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER } + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_ENTRY(type) \ +struct { \ + class type *tqe_next; /* next element */ \ + class type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +/* + * Tail queue functions. + */ +#define QMD_TAILQ_CHECK_HEAD(head, field) +#define QMD_TAILQ_CHECK_TAIL(head, headname) +#define QMD_TAILQ_CHECK_NEXT(elm, field) +#define QMD_TAILQ_CHECK_PREV(elm, field) + +#define TAILQ_CONCAT(head1, head2, field) do { \ + if (!TAILQ_EMPTY(head2)) { \ + *(head1)->tqh_last =3D (head2)->tqh_first; \ + (head2)->tqh_first->field.tqe_prev =3D (head1)->tqh_last; \ + (head1)->tqh_last =3D (head2)->tqh_last; \ + TAILQ_INIT((head2)); \ + QMD_TRACE_HEAD(head1); \ + QMD_TRACE_HEAD(head2); \ + } \ +} while (0) + +#define TAILQ_EMPTY(head) ((head)->tqh_first =3D=3D NULL) + +#define TAILQ_FIRST(head) ((head)->tqh_first) + +#define TAILQ_FOREACH(var, head, field) \ + for ((var) =3D TAILQ_FIRST((head)); \ + (var); \ + (var) =3D TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_FROM(var, head, field) \ + for ((var) =3D ((var) ? (var) : TAILQ_FIRST((head))); \ + (var); \ + (var) =3D TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) =3D TAILQ_FIRST((head)); \ + (var) && ((tvar) =3D TAILQ_NEXT((var), field), 1); \ + (var) =3D (tvar)) + +#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) =3D ((var) ? (var) : TAILQ_FIRST((head))); \ + (var) && ((tvar) =3D TAILQ_NEXT((var), field), 1); \ + (var) =3D (tvar)) + +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for ((var) =3D TAILQ_LAST((head), headname); \ + (var); \ + (var) =3D TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ + for ((var) =3D ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var); \ + (var) =3D TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ + for ((var) =3D TAILQ_LAST((head), headname); \ + (var) && ((tvar) =3D TAILQ_PREV((var), headname, field), 1); \ + (var) =3D (tvar)) + +#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) = \ + for ((var) =3D ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var) && ((tvar) =3D TAILQ_PREV((var), headname, field), 1); \ + (var) =3D (tvar)) + +#define TAILQ_INIT(head) do { \ + TAILQ_FIRST((head)) =3D NULL; \ + (head)->tqh_last =3D &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ +} while (0) + +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + QMD_TAILQ_CHECK_NEXT(listelm, field); \ + TAILQ_NEXT((elm), field) =3D TAILQ_NEXT((listelm), field); \ + if (TAILQ_NEXT((listelm), field) !=3D NULL) \ + TAILQ_NEXT((elm), field)->field.tqe_prev =3D \ + &TAILQ_NEXT((elm), field); \ + else { \ + (head)->tqh_last =3D &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + } \ + TAILQ_NEXT((listelm), field) =3D (elm); \ + (elm)->field.tqe_prev =3D &TAILQ_NEXT((listelm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + QMD_TAILQ_CHECK_PREV(listelm, field); \ + (elm)->field.tqe_prev =3D (listelm)->field.tqe_prev; \ + TAILQ_NEXT((elm), field) =3D (listelm); \ + *(listelm)->field.tqe_prev =3D (elm); \ + (listelm)->field.tqe_prev =3D &TAILQ_NEXT((elm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ + QMD_TAILQ_CHECK_HEAD(head, field); \ + TAILQ_NEXT((elm), field) =3D TAILQ_FIRST((head)); \ + if (TAILQ_FIRST((head)) !=3D NULL) \ + TAILQ_FIRST((head))->field.tqe_prev =3D \ + &TAILQ_NEXT((elm), field); \ + else \ + (head)->tqh_last =3D &TAILQ_NEXT((elm), field); \ + TAILQ_FIRST((head)) =3D (elm); \ + (elm)->field.tqe_prev =3D &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ + QMD_TAILQ_CHECK_TAIL(head, field); \ + TAILQ_NEXT((elm), field) =3D NULL; \ + (elm)->field.tqe_prev =3D (head)->tqh_last; \ + *(head)->tqh_last =3D (elm); \ + (head)->tqh_last =3D &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) + +/* + * The FAST function is fast in that it causes no data access other + * then the access to the head. The standard LAST function above + * will cause a data access of both the element you want and + * the previous element. FAST is very useful for instances when + * you may want to prefetch the last data element. + */ +#define TAILQ_LAST_FAST(head, type, field) \ + (TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, \ + QUEUE_TYPEOF(type), field.tqe_next)) + +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) + +#define TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) + +#define TAILQ_REMOVE(head, elm, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ + QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ + QMD_TAILQ_CHECK_NEXT(elm, field); \ + QMD_TAILQ_CHECK_PREV(elm, field); \ + if ((TAILQ_NEXT((elm), field)) !=3D NULL) \ + TAILQ_NEXT((elm), field)->field.tqe_prev =3D \ + (elm)->field.tqe_prev; \ + else { \ + (head)->tqh_last =3D (elm)->field.tqe_prev; \ + QMD_TRACE_HEAD(head); \ + } \ + *(elm)->field.tqe_prev =3D TAILQ_NEXT((elm), field); \ + TRASHIT(*oldnext); \ + TRASHIT(*oldprev); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_SWAP(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) * swap_first =3D (head1)->tqh_first; \ + QUEUE_TYPEOF(type) * *swap_last =3D (head1)->tqh_last; \ + (head1)->tqh_first =3D (head2)->tqh_first; \ + (head1)->tqh_last =3D (head2)->tqh_last; \ + (head2)->tqh_first =3D swap_first; \ + (head2)->tqh_last =3D swap_last; \ + swap_first =3D (head1)->tqh_first; \ + if (swap_first !=3D NULL) \ + swap_first->field.tqe_prev =3D &(head1)->tqh_first; \ + else \ + (head1)->tqh_last =3D &(head1)->tqh_first; \ + swap_first =3D (head2)->tqh_first; \ + if (swap_first !=3D NULL) \ + swap_first->field.tqe_prev =3D &(head2)->tqh_first; \ + else \ + (head2)->tqh_last =3D &(head2)->tqh_first; \ +} while (0) + +#ifdef __cplusplus +} +#endif + +#endif /* _SYS_QUEUE_H_ */ --=20 2.17.1.windows.2