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 67AFCA05D3 for ; Tue, 26 Mar 2019 17:31:48 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 1D2321B295; Tue, 26 Mar 2019 17:31:48 +0100 (CET) Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-eopbgr740101.outbound.protection.outlook.com [40.107.74.101]) by dpdk.org (Postfix) with ESMTP id 500171B209 for ; Tue, 26 Mar 2019 17:31:46 +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=z//AlwA0NCuz310a7iJpPP//aL2yXZtBhrNkgEwHrpA=; b=P9A3CIImaLc9CrUZW1+zVZIkDYxJ+bHnOVyXKJVnkwAK31xgKVf9KWaGn0gJfGHtVlhRqyCRYhbiFnp9Ha5RRQpE5O6fhf2/54M5xk6SCzQKizX4+hgE9glkIiuLfv3ffCnbvWIp5J5zRcLtVJsWk9s6qqFtHFXwPlyw+0gcN2Y= Received: from MWHPR21MB0638.namprd21.prod.outlook.com (10.175.141.139) by MWHPR21MB0144.namprd21.prod.outlook.com (10.173.52.14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1771.2; Tue, 26 Mar 2019 16:31:44 +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; Tue, 26 Mar 2019 16:31:44 +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 v5 4/8] eal: sys/queue.h implementation for windows Thread-Index: AQHU45mjavHWR574PE2isPD3edyL0aYeG2vw Date: Tue, 26 Mar 2019 16:31:44 +0000 Message-ID: References: <20190306041634.12976-1-anand.rawat@intel.com> <20190326060238.9884-1-anand.rawat@intel.com> <20190326060238.9884-5-anand.rawat@intel.com> In-Reply-To: <20190326060238.9884-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-26T16:31:39.0298134Z; 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=03dfb89a-2e15-401e-b8b4-e3aee850bfb6; MSIP_Label_f42aa342-8706-4288-bd11-ebb85995028c_Extended_MSFT_Method=Automatic x-originating-ip: [131.107.147.44] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: b49a52b3-97d7-4b3b-3fa3-08d6b20888e3 x-ms-office365-filtering-ht: Tenant x-microsoft-antispam: BCL:0; PCL:0; RULEID:(2390118)(7020095)(4652040)(8989299)(5600127)(711020)(4605104)(4618075)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(2017052603328)(7193020); SRVR:MWHPR21MB0144; x-ms-traffictypediagnostic: MWHPR21MB0144: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:10000; x-forefront-prvs: 09888BC01D x-forefront-antispam-report: SFV:NSPM; SFS:(10019020)(366004)(39860400002)(136003)(346002)(376002)(396003)(189003)(199004)(13464003)(105586002)(14454004)(71200400001)(2906002)(7696005)(6346003)(52536014)(10290500003)(8936002)(14444005)(476003)(5660300002)(11346002)(53936002)(97736004)(478600001)(53546011)(186003)(2501003)(74316002)(3846002)(33656002)(229853002)(71190400001)(81166006)(6116002)(26005)(68736007)(4326008)(106356001)(102836004)(72206003)(66066001)(25786009)(99286004)(7736002)(54906003)(316002)(10090500001)(305945005)(6246003)(110136005)(76176011)(81156014)(22452003)(86612001)(30864003)(446003)(6506007)(6436002)(8990500004)(86362001)(55016002)(486006)(256004)(9686003); DIR:OUT; SFP:1102; SCL:1; SRVR:MWHPR21MB0144; 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: /U0GiC7VVRlhlno4GQsDCJTXmivEzt0wMhh871M6HvbEn/E2RY+WOM/9CXV32M6KKagnuuUNUcJ7COIQM/X+9c6lyG58eEii1bwEtag1QzoE3hqubR618UBUAIx09Si/BZhiXmvd+svkW3Qw1RbGg/OIR9+bDWugDJzK3buTCvlGUsKr6bI5cMeSdZuPbJMsn3XwzVAzUflMTIBJ+n78kJWGocSudJ+cxHCkMlNNRvd+4lbjlTZDZ3+5I9WQ/jcwxJgqiKnx+nwv+K7dnhom92fo0pkwT/WWcoTeevYaiIPgn+DVgjvHPoebx0k3n7j4tGG2O/mrxThTaEa/jxkYgElTO+GFmp+ofV3GfGYYf6E44Laac4n0orYBizIO7h1jfcigHV2YtyskvgY/YpnjaAdQmXD8jHF5V+bA/Lq5Jsg= 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: b49a52b3-97d7-4b3b-3fa3-08d6b20888e3 X-MS-Exchange-CrossTenant-originalarrivaltime: 26 Mar 2019 16:31:44.3378 (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: MWHPR21MB0144 Subject: Re: [dpdk-dev] [PATCH v5 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: <20190326163144.Kpkk1aX_nkM72c54vjwIUoFVUJ595gBQ65QHW78d6vU@z> -----Original Message----- From: dev On Behalf Of Anand Rawat Sent: Monday, March 25, 2019 11:03 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 v5 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 Acked-by: Harini Ramakrishnan --- .../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