From patchwork Wed Aug 28 21:03:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154864 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="gF5RmwXp"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdX019pWz9sMr for ; Thu, 29 Aug 2019 07:04:00 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726840AbfH1VD7 (ORCPT ); Wed, 28 Aug 2019 17:03:59 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:24310 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726583AbfH1VD6 (ORCPT ); Wed, 28 Aug 2019 17:03:58 -0400 Received: from pps.filterd (m0089730.ppops.net [127.0.0.1]) by m0089730.ppops.net (8.16.0.42/8.16.0.42) with SMTP id x7SKxnaQ030450 for ; Wed, 28 Aug 2019 14:03:57 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=iPq7cHxWDw+ax28E2LpaitvRSxJaxf2/KfQM8ivfW8E=; b=gF5RmwXp0Ez/AChRy1q6sLElJwG/h2G0LVFPEyRSnL7UpSRGMoU69YNPrQqh/gRCU6S+ jOsdl18697ElyCerdkVMCOOu8OKBySw0UaGHPpMETLxhjHzqynEHqBe3VXI5dz6dd6L2 z+rTg96uxyQvKJHyrTK0ZJ4DanDTgv6sSkk= Received: from maileast.thefacebook.com ([163.114.130.16]) by m0089730.ppops.net with ESMTP id 2un62cf2q1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:03:57 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:82::c) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:03:56 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id C7EB8A25D5D7; Wed, 28 Aug 2019 14:03:55 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 01/10] bpf: introduce __MAX_BPF_PROG_TYPE and __MAX_BPF_MAP_TYPE enum values Date: Wed, 28 Aug 2019 14:03:04 -0700 Message-ID: <43989d37be938b7d284028481e63df0a0471e29f.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 lowpriorityscore=0 malwarescore=0 spamscore=0 priorityscore=1501 phishscore=0 impostorscore=0 bulkscore=0 adultscore=0 mlxlogscore=999 mlxscore=0 suspectscore=0 clxscore=1015 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Similar to __MAX_BPF_ATTACH_TYPE identifying the number of elements in bpf_attach_type enum, add tailing enum values __MAX_BPF_PROG_TYPE and __MAX_BPF_MAP_TYPE to simplify e.g. iteration over enums values in the case when new values are added. Signed-off-by: Julia Kartseva --- include/uapi/linux/bpf.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 5d2fb183ee2d..9b681bb82211 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -136,8 +136,11 @@ enum bpf_map_type { BPF_MAP_TYPE_STACK, BPF_MAP_TYPE_SK_STORAGE, BPF_MAP_TYPE_DEVMAP_HASH, + __MAX_BPF_MAP_TYPE }; +#define MAX_BPF_MAP_TYPE __MAX_BPF_MAP_TYPE + /* Note that tracing related programs such as * BPF_PROG_TYPE_{KPROBE,TRACEPOINT,PERF_EVENT,RAW_TRACEPOINT} * are not subject to a stable API since kernel internal data @@ -173,8 +176,11 @@ enum bpf_prog_type { BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, BPF_PROG_TYPE_CGROUP_SOCKOPT, + __MAX_BPF_PROG_TYPE }; +#define MAX_BPF_PROG_TYPE __MAX_BPF_PROG_TYPE + enum bpf_attach_type { BPF_CGROUP_INET_INGRESS, BPF_CGROUP_INET_EGRESS, From patchwork Wed Aug 28 21:03:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154865 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="iRt8sbma"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdX74gzBz9sDB for ; Thu, 29 Aug 2019 07:04:07 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726944AbfH1VEE (ORCPT ); Wed, 28 Aug 2019 17:04:04 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:65252 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726583AbfH1VEE (ORCPT ); Wed, 28 Aug 2019 17:04:04 -0400 Received: from pps.filterd (m0109331.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7SL3DLG027737 for ; Wed, 28 Aug 2019 14:04:03 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=luB/P6B7Bs6XQoDFTkWB3eskeA3/FPdPWOldlXkrQkA=; b=iRt8sbmasKH8mHgNGfrxSipPx6c33u39tNIx/hv98L+dHZ3Qcfy3qvWwnqk+JJ8IDRuO shXq/tCrx2hzZv0B62smfuPqTFul/IjvbU25LAxTznwAL7vuH8zFl1xJOEDGkAd2RkD/ uVtTArbkyGrVq3BmmluLfx9FEYo36xiWES0= Received: from mail.thefacebook.com (mailout.thefacebook.com [199.201.64.23]) by mx0a-00082601.pphosted.com with ESMTP id 2untb0j7fq-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Wed, 28 Aug 2019 14:04:02 -0700 Received: from mx-out.facebook.com (2620:10d:c081:10::13) by mail.thefacebook.com (2620:10d:c081:35::127) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:00 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id 8BAF2A25D5E1; Wed, 28 Aug 2019 14:03:59 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 02/10] tools/bpf: sync bpf.h to tools/ Date: Wed, 28 Aug 2019 14:03:05 -0700 Message-ID: <6c3d8803a29cf7147242dfe43af101ecb9f40f99.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 clxscore=1015 priorityscore=1501 phishscore=0 bulkscore=0 lowpriorityscore=0 mlxlogscore=951 suspectscore=0 spamscore=0 adultscore=0 mlxscore=0 impostorscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Introduce __MAX_BPF_MAP_TYPE and __MAX_BPF_MAP_TYPE enum values. Signed-off-by: Julia Kartseva --- tools/include/uapi/linux/bpf.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 5d2fb183ee2d..9b681bb82211 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -136,8 +136,11 @@ enum bpf_map_type { BPF_MAP_TYPE_STACK, BPF_MAP_TYPE_SK_STORAGE, BPF_MAP_TYPE_DEVMAP_HASH, + __MAX_BPF_MAP_TYPE }; +#define MAX_BPF_MAP_TYPE __MAX_BPF_MAP_TYPE + /* Note that tracing related programs such as * BPF_PROG_TYPE_{KPROBE,TRACEPOINT,PERF_EVENT,RAW_TRACEPOINT} * are not subject to a stable API since kernel internal data @@ -173,8 +176,11 @@ enum bpf_prog_type { BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, BPF_PROG_TYPE_CGROUP_SOCKOPT, + __MAX_BPF_PROG_TYPE }; +#define MAX_BPF_PROG_TYPE __MAX_BPF_PROG_TYPE + enum bpf_attach_type { BPF_CGROUP_INET_INGRESS, BPF_CGROUP_INET_EGRESS, From patchwork Wed Aug 28 21:03:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154867 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="Pc8RQXM9"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXB4z4Jz9sDB for ; Thu, 29 Aug 2019 07:04:10 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726894AbfH1VEK (ORCPT ); Wed, 28 Aug 2019 17:04:10 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:31714 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726864AbfH1VEK (ORCPT ); Wed, 28 Aug 2019 17:04:10 -0400 Received: from pps.filterd (m0001303.ppops.net [127.0.0.1]) by m0001303.ppops.net (8.16.0.42/8.16.0.42) with SMTP id x7SL2O2R023022 for ; Wed, 28 Aug 2019 14:04:08 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=YrAxoIc+gtSqaMELjDilDkdqQog0vQqu8ICAlVzdfbU=; b=Pc8RQXM9Hs8FIV8o24Pd0xzu6BC0t4PKfgAs5ufwjgtK4J795AsfX1Jr5JhnjYYSJ2bp njemN0zan43R6mZCFcaahJkmWDyEc1KOrPJB+xDTmddk26j/Xt2qr0tSo7bBP7xxc8W8 NPWaodVhpC80P9Ks9t+NSyVVBzQYXGldn4g= Received: from mail.thefacebook.com (mailout.thefacebook.com [199.201.64.23]) by m0001303.ppops.net with ESMTP id 2unuwq9r05-5 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Wed, 28 Aug 2019 14:04:08 -0700 Received: from mx-out.facebook.com (2620:10d:c081:10::13) by mail.thefacebook.com (2620:10d:c081:35::126) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:06 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id A1A92A25D5E3; Wed, 28 Aug 2019 14:04:04 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 03/10] tools/bpf: handle __MAX_BPF_(PROG|MAP)_TYPE in switch statements Date: Wed, 28 Aug 2019 14:03:06 -0700 Message-ID: <1895f7dfe2a8067f6397ff565edf20130a28aa91.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 clxscore=1015 priorityscore=1501 mlxscore=0 phishscore=0 mlxlogscore=999 impostorscore=0 adultscore=0 lowpriorityscore=0 suspectscore=0 malwarescore=0 bulkscore=0 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Add cases to switch statements in probe_load, bpf_prog_type__needs_kver bpf_probe_map_type to fix enumeration value not handled in switch compilation error. prog_type_name array in bpftool/main.h doesn't have __MAX_BPF_PROG_TYPE entity, same for map, so probe won't be called. Signed-off-by: Julia Kartseva --- tools/lib/bpf/libbpf.c | 1 + tools/lib/bpf/libbpf_probes.c | 2 ++ 2 files changed, 3 insertions(+) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 2233f919dd88..72e6e5eb397f 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -3580,6 +3580,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type) case BPF_PROG_TYPE_PERF_EVENT: case BPF_PROG_TYPE_CGROUP_SYSCTL: case BPF_PROG_TYPE_CGROUP_SOCKOPT: + case __MAX_BPF_PROG_TYPE: return false; case BPF_PROG_TYPE_KPROBE: default: diff --git a/tools/lib/bpf/libbpf_probes.c b/tools/lib/bpf/libbpf_probes.c index 4b0b0364f5fc..8f2ba6a457ac 100644 --- a/tools/lib/bpf/libbpf_probes.c +++ b/tools/lib/bpf/libbpf_probes.c @@ -102,6 +102,7 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, case BPF_PROG_TYPE_FLOW_DISSECTOR: case BPF_PROG_TYPE_CGROUP_SYSCTL: case BPF_PROG_TYPE_CGROUP_SOCKOPT: + case __MAX_BPF_PROG_TYPE: default: break; } @@ -250,6 +251,7 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) case BPF_MAP_TYPE_XSKMAP: case BPF_MAP_TYPE_SOCKHASH: case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: + case __MAX_BPF_MAP_TYPE: default: break; } From patchwork Wed Aug 28 21:03:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154869 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="ibzzvTi5"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXG6YCkz9sDB for ; Thu, 29 Aug 2019 07:04:14 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727018AbfH1VEN (ORCPT ); Wed, 28 Aug 2019 17:04:13 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:8480 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726980AbfH1VEN (ORCPT ); Wed, 28 Aug 2019 17:04:13 -0400 Received: from pps.filterd (m0001303.ppops.net [127.0.0.1]) by m0001303.ppops.net (8.16.0.42/8.16.0.42) with SMTP id x7SL2O2U023022 for ; Wed, 28 Aug 2019 14:04:11 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=FtOhHeFUusg5zoqho3Xg0nJRXc/5dplrdyaCMp4MQ8A=; b=ibzzvTi5v/j09a1BgJvKtrDNP1AW8rtY1AM1jRHQkPNTgpBtSkidjmxg1Famh2JTXMwe fSkq1aoEle3HU50ZCOift2JrOm3vbX8zrAncxmaJomrdia+V8ijzgVpHab19G8rH8Kmp 8yUaBlXFfjyzmr92llyYx3gkMxbpdd0Q8kQ= Received: from mail.thefacebook.com (mailout.thefacebook.com [199.201.64.23]) by m0001303.ppops.net with ESMTP id 2unuwq9r0d-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Wed, 28 Aug 2019 14:04:11 -0700 Received: from mx-out.facebook.com (2620:10d:c081:10::13) by mail.thefacebook.com (2620:10d:c081:35::126) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:10 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id ED8ADA25D5F1; Wed, 28 Aug 2019 14:04:07 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 04/10] tools/bpf: add libbpf_prog_type_(from|to)_str helpers Date: Wed, 28 Aug 2019 14:03:07 -0700 Message-ID: <467620c966825173dbd65b37a3f9bd7dd4fb8184.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 clxscore=1015 priorityscore=1501 mlxscore=0 phishscore=0 mlxlogscore=999 impostorscore=0 adultscore=0 lowpriorityscore=0 suspectscore=0 malwarescore=0 bulkscore=0 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Standardize string representation of prog types by putting commonly used names to libbpf. The prog_type to string mapping is taken from bpftool: tools/bpf/bpftool/main.h Signed-off-by: Julia Kartseva --- tools/lib/bpf/libbpf.c | 51 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 8 +++++++ tools/lib/bpf/libbpf.map | 2 ++ 3 files changed, 61 insertions(+) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 72e6e5eb397f..946a4d41f223 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -296,6 +296,35 @@ struct bpf_object { }; #define obj_elf_valid(o) ((o)->efile.elf) +static const char *const prog_type_strs[] = { + [BPF_PROG_TYPE_UNSPEC] = "unspec", + [BPF_PROG_TYPE_SOCKET_FILTER] = "socket_filter", + [BPF_PROG_TYPE_KPROBE] = "kprobe", + [BPF_PROG_TYPE_SCHED_CLS] = "sched_cls", + [BPF_PROG_TYPE_SCHED_ACT] = "sched_act", + [BPF_PROG_TYPE_TRACEPOINT] = "tracepoint", + [BPF_PROG_TYPE_XDP] = "xdp", + [BPF_PROG_TYPE_PERF_EVENT] = "perf_event", + [BPF_PROG_TYPE_CGROUP_SKB] = "cgroup_skb", + [BPF_PROG_TYPE_CGROUP_SOCK] = "cgroup_sock", + [BPF_PROG_TYPE_LWT_IN] = "lwt_in", + [BPF_PROG_TYPE_LWT_OUT] = "lwt_out", + [BPF_PROG_TYPE_LWT_XMIT] = "lwt_xmit", + [BPF_PROG_TYPE_SOCK_OPS] = "sock_ops", + [BPF_PROG_TYPE_SK_SKB] = "sk_skb", + [BPF_PROG_TYPE_CGROUP_DEVICE] = "cgroup_device", + [BPF_PROG_TYPE_SK_MSG] = "sk_msg", + [BPF_PROG_TYPE_RAW_TRACEPOINT] = "raw_tracepoint", + [BPF_PROG_TYPE_CGROUP_SOCK_ADDR] = "cgroup_sock_addr", + [BPF_PROG_TYPE_LWT_SEG6LOCAL] = "lwt_seg6local", + [BPF_PROG_TYPE_LIRC_MODE2] = "lirc_mode2", + [BPF_PROG_TYPE_SK_REUSEPORT] = "sk_reuseport", + [BPF_PROG_TYPE_FLOW_DISSECTOR] = "flow_dissector", + [BPF_PROG_TYPE_CGROUP_SYSCTL] = "cgroup_sysctl", + [BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE] = "raw_tracepoint_writable", + [BPF_PROG_TYPE_CGROUP_SOCKOPT] = "cgroup_sockopt", +}; + void bpf_program__unload(struct bpf_program *prog) { int i; @@ -4632,6 +4661,28 @@ int libbpf_attach_type_by_name(const char *name, return -EINVAL; } +int libbpf_prog_type_from_str(const char *str, enum bpf_prog_type *type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(prog_type_strs); i++) + if (prog_type_strs[i] && strcmp(prog_type_strs[i], str) == 0) { + *type = i; + return 0; + } + + return -EINVAL; +} + +int libbpf_prog_type_to_str(enum bpf_prog_type type, const char **str) +{ + if (type < BPF_PROG_TYPE_UNSPEC || type >= ARRAY_SIZE(prog_type_strs)) + return -EINVAL; + + *str = prog_type_strs[type]; + return 0; +} + static int bpf_program__identify_section(struct bpf_program *prog, enum bpf_prog_type *prog_type, diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index e8f70977d137..6846c488d8a2 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -122,12 +122,20 @@ LIBBPF_API int bpf_object__set_priv(struct bpf_object *obj, void *priv, bpf_object_clear_priv_t clear_priv); LIBBPF_API void *bpf_object__priv(const struct bpf_object *prog); +/* Program and expected attach types by section name */ LIBBPF_API int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type, enum bpf_attach_type *expected_attach_type); +/* Attach type by section name */ LIBBPF_API int libbpf_attach_type_by_name(const char *name, enum bpf_attach_type *attach_type); +/* String representation of program type */ +LIBBPF_API int libbpf_prog_type_from_str(const char *str, + enum bpf_prog_type *type); +LIBBPF_API int libbpf_prog_type_to_str(enum bpf_prog_type type, + const char **str); + /* Accessors of bpf_program */ struct bpf_program; LIBBPF_API struct bpf_program *bpf_program__next(struct bpf_program *prog, diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 664ce8e7a60e..2ea7c99f1579 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -188,4 +188,6 @@ LIBBPF_0.0.4 { LIBBPF_0.0.5 { global: bpf_btf_get_next_id; + libbpf_prog_type_from_str; + libbpf_prog_type_to_str; } LIBBPF_0.0.4; From patchwork Wed Aug 28 21:03:08 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154871 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="mL2GMu/z"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXJ0hYVz9sN6 for ; Thu, 29 Aug 2019 07:04:16 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727040AbfH1VEO (ORCPT ); Wed, 28 Aug 2019 17:04:14 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:56818 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726986AbfH1VEN (ORCPT ); Wed, 28 Aug 2019 17:04:13 -0400 Received: from pps.filterd (m0109331.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7SL3DFi027742 for ; Wed, 28 Aug 2019 14:04:11 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=JpHIeNTQH+w3VCO646ycX4US8fdIIjlenyDOATzHzFw=; b=mL2GMu/zv1hobWa5C4UM7phpe90ooZ2Qz+yKd3kuFEnOLRSgoZ3iNPki8tfX+QxDSh4z PR3JrBH8ODFyEDuzV4vTI/k2WplxyBqEO3g87IASt9xKtMMT18oSi+aYSVQqqWGWwWe7 IVKzYzPIsoRTzvSR8UKb2O/1MeNjl+jdhMk= Received: from maileast.thefacebook.com ([163.114.130.16]) by mx0a-00082601.pphosted.com with ESMTP id 2untb0j7g9-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:04:11 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:11 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id 6833DA25D60B; Wed, 28 Aug 2019 14:04:10 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 05/10] tools/bpf: add libbpf_map_type_(from|to)_str helpers Date: Wed, 28 Aug 2019 14:03:08 -0700 Message-ID: <5ddd6d7579770845dee4e9261f4eb9f8020d9765.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 clxscore=1015 priorityscore=1501 phishscore=0 bulkscore=0 lowpriorityscore=0 mlxlogscore=999 suspectscore=0 spamscore=0 adultscore=0 mlxscore=0 impostorscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Similar to prog_type to string mapping, standardize string representation of map types by putting commonly used names to libbpf. The map_type to string mapping is taken from bpftool: tools/bpf/bpftool/map.c Signed-off-by: Julia Kartseva --- tools/lib/bpf/libbpf.c | 51 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 4 ++++ tools/lib/bpf/libbpf.map | 2 ++ 3 files changed, 57 insertions(+) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 946a4d41f223..9c531256888b 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -325,6 +325,35 @@ static const char *const prog_type_strs[] = { [BPF_PROG_TYPE_CGROUP_SOCKOPT] = "cgroup_sockopt", }; +static const char *const map_type_strs[] = { + [BPF_MAP_TYPE_UNSPEC] = "unspec", + [BPF_MAP_TYPE_HASH] = "hash", + [BPF_MAP_TYPE_ARRAY] = "array", + [BPF_MAP_TYPE_PROG_ARRAY] = "prog_array", + [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf_event_array", + [BPF_MAP_TYPE_PERCPU_HASH] = "percpu_hash", + [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu_array", + [BPF_MAP_TYPE_STACK_TRACE] = "stack_trace", + [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup_array", + [BPF_MAP_TYPE_LRU_HASH] = "lru_hash", + [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru_percpu_hash", + [BPF_MAP_TYPE_LPM_TRIE] = "lpm_trie", + [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array_of_maps", + [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash_of_maps", + [BPF_MAP_TYPE_DEVMAP] = "devmap", + [BPF_MAP_TYPE_SOCKMAP] = "sockmap", + [BPF_MAP_TYPE_CPUMAP] = "cpumap", + [BPF_MAP_TYPE_XSKMAP] = "xskmap", + [BPF_MAP_TYPE_SOCKHASH] = "sockhash", + [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage", + [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray", + [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "percpu_cgroup_storage", + [BPF_MAP_TYPE_QUEUE] = "queue", + [BPF_MAP_TYPE_STACK] = "stack", + [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage", + [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash" +}; + void bpf_program__unload(struct bpf_program *prog) { int i; @@ -4683,6 +4712,28 @@ int libbpf_prog_type_to_str(enum bpf_prog_type type, const char **str) return 0; } +int libbpf_map_type_from_str(const char *str, enum bpf_map_type *type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(map_type_strs); i++) + if (map_type_strs[i] && strcmp(map_type_strs[i], str) == 0) { + *type = i; + return 0; + } + + return -EINVAL; +} + +int libbpf_map_type_to_str(enum bpf_map_type type, const char **str) +{ + if (type < BPF_MAP_TYPE_UNSPEC || type >= ARRAY_SIZE(map_type_strs)) + return -EINVAL; + + *str = map_type_strs[type]; + return 0; +} + static int bpf_program__identify_section(struct bpf_program *prog, enum bpf_prog_type *prog_type, diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index 6846c488d8a2..90daeb2cdefb 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -135,6 +135,10 @@ LIBBPF_API int libbpf_prog_type_from_str(const char *str, enum bpf_prog_type *type); LIBBPF_API int libbpf_prog_type_to_str(enum bpf_prog_type type, const char **str); +/* String representation of map type */ +LIBBPF_API int libbpf_map_type_from_str(const char *str, + enum bpf_map_type *type); +LIBBPF_API int libbpf_map_type_to_str(enum bpf_map_type type, const char **str); /* Accessors of bpf_program */ struct bpf_program; diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 2ea7c99f1579..e4ecf5414bb7 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -190,4 +190,6 @@ LIBBPF_0.0.5 { bpf_btf_get_next_id; libbpf_prog_type_from_str; libbpf_prog_type_to_str; + libbpf_map_type_from_str; + libbpf_map_type_to_str; } LIBBPF_0.0.4; From patchwork Wed Aug 28 21:03:09 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154875 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="jnKHszvc"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXQ2t6hz9sMr for ; Thu, 29 Aug 2019 07:04:22 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727096AbfH1VEU (ORCPT ); Wed, 28 Aug 2019 17:04:20 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:5932 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727024AbfH1VET (ORCPT ); Wed, 28 Aug 2019 17:04:19 -0400 Received: from pps.filterd (m0044012.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7SKxveG025668 for ; Wed, 28 Aug 2019 14:04:18 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=hGNB+Ir5jkBVB/3Ds+4h1CKVWEctBOogQTO+Yiul1gE=; b=jnKHszvcvDzVrXVsbXPLxF2R/HGEatpnvOSWRqrPXKExu327YNeFZrO07Ta9kxzPXTzB 84/N4Z83dDnm6iIMy4h88ieqhUmamLVedZ6oNkB+ZZfnUas36ONud6CzJKXBRj4EBiaR y7EOUC5uOBl7ABg+DCH4+29+5YDydin70To= Received: from maileast.thefacebook.com ([163.114.130.16]) by mx0a-00082601.pphosted.com with ESMTP id 2une6kmtmn-4 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:04:18 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:13 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id 635D9A25D62C; Wed, 28 Aug 2019 14:04:13 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 06/10] tools/bpf: add libbpf_attach_type_(from|to)_str Date: Wed, 28 Aug 2019 14:03:09 -0700 Message-ID: <5af82a599a3e886b48e89a47579ad331b7954ee0.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 suspectscore=0 impostorscore=0 mlxscore=0 bulkscore=0 malwarescore=0 clxscore=1015 spamscore=0 phishscore=0 lowpriorityscore=0 mlxlogscore=999 adultscore=0 priorityscore=1501 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Standardize string representation of attach types by putting commonly used names to libbpf. The attach_type to string mapping is taken from bpftool: tools/bpf/bpftool/cgroup.c tools/bpf/bpftool/prog.c Signed-off-by: Julia Kartseva --- tools/lib/bpf/libbpf.c | 50 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 5 ++++ tools/lib/bpf/libbpf.map | 2 ++ 3 files changed, 57 insertions(+) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 9c531256888b..b5b07493655f 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -354,6 +354,32 @@ static const char *const map_type_strs[] = { [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash" }; +static const char *const attach_type_strs[] = { + [BPF_CGROUP_INET_INGRESS] = "ingress", + [BPF_CGROUP_INET_EGRESS] = "egress", + [BPF_CGROUP_INET_SOCK_CREATE] = "sock_create", + [BPF_CGROUP_SOCK_OPS] = "sock_ops", + [BPF_SK_SKB_STREAM_PARSER] = "stream_parser", + [BPF_SK_SKB_STREAM_VERDICT] = "stream_verdict", + [BPF_CGROUP_DEVICE] = "device", + [BPF_SK_MSG_VERDICT] = "msg_verdict", + [BPF_CGROUP_INET4_BIND] = "bind4", + [BPF_CGROUP_INET6_BIND] = "bind6", + [BPF_CGROUP_INET4_CONNECT] = "connect4", + [BPF_CGROUP_INET6_CONNECT] = "connect6", + [BPF_CGROUP_INET4_POST_BIND] = "post_bind4", + [BPF_CGROUP_INET6_POST_BIND] = "post_bind6", + [BPF_CGROUP_UDP4_SENDMSG] = "sendmsg4", + [BPF_CGROUP_UDP6_SENDMSG] = "sendmsg6", + [BPF_LIRC_MODE2] = "lirc_mode2", + [BPF_FLOW_DISSECTOR] = "flow_dissector", + [BPF_CGROUP_SYSCTL] = "sysctl", + [BPF_CGROUP_UDP4_RECVMSG] = "recvmsg4", + [BPF_CGROUP_UDP6_RECVMSG] = "recvmsg6", + [BPF_CGROUP_GETSOCKOPT] = "getsockopt", + [BPF_CGROUP_SETSOCKOPT] = "setsockopt" +}; + void bpf_program__unload(struct bpf_program *prog) { int i; @@ -4734,6 +4760,30 @@ int libbpf_map_type_to_str(enum bpf_map_type type, const char **str) return 0; } +int libbpf_attach_type_from_str(const char *str, enum bpf_attach_type *type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(attach_type_strs); i++) + if (attach_type_strs[i] && + strcmp(attach_type_strs[i], str) == 0) { + *type = i; + return 0; + } + + return -EINVAL; +} + +int libbpf_attach_type_to_str(enum bpf_attach_type type, const char **str) +{ + if (type < BPF_CGROUP_INET_INGRESS || + type >= ARRAY_SIZE(attach_type_strs)) + return -EINVAL; + + *str = attach_type_strs[type]; + return 0; +} + static int bpf_program__identify_section(struct bpf_program *prog, enum bpf_prog_type *prog_type, diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index 90daeb2cdefb..0ad941951b0d 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -139,6 +139,11 @@ LIBBPF_API int libbpf_prog_type_to_str(enum bpf_prog_type type, LIBBPF_API int libbpf_map_type_from_str(const char *str, enum bpf_map_type *type); LIBBPF_API int libbpf_map_type_to_str(enum bpf_map_type type, const char **str); +/* String representation of attach type */ +LIBBPF_API int libbpf_attach_type_from_str(const char *str, + enum bpf_attach_type *type); +LIBBPF_API int libbpf_attach_type_to_str(enum bpf_attach_type type, + const char **str); /* Accessors of bpf_program */ struct bpf_program; diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index e4ecf5414bb7..d87a6dc8a71f 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -192,4 +192,6 @@ LIBBPF_0.0.5 { libbpf_prog_type_to_str; libbpf_map_type_from_str; libbpf_map_type_to_str; + libbpf_attach_type_from_str; + libbpf_attach_type_to_str; } LIBBPF_0.0.4; From patchwork Wed Aug 28 21:03:10 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154878 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="RziBnKbx"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXS4rPbz9sMr for ; Thu, 29 Aug 2019 07:04:24 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727108AbfH1VEW (ORCPT ); Wed, 28 Aug 2019 17:04:22 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:4526 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727087AbfH1VEU (ORCPT ); Wed, 28 Aug 2019 17:04:20 -0400 Received: from pps.filterd (m0148460.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7SL47FH028834 for ; Wed, 28 Aug 2019 14:04:18 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=txtomiOXWxacCT7/7yJQhGvyYNbKMak5FyK2wGSFu24=; b=RziBnKbxYXl1+9k+245zzDaUjmyZGviE3ijst19LV7va8hJvIeSOX8nw8nOC4lmuPXqT vhxXW4siVbVVGeaDgJzqjDujWbd3nevsNQEmmROe/Fh/CIfAOJjGZlJgfKoQattopgis sPN9w8hC3U+iapEEmgoRxMHnDGhgH8tqL38= Received: from maileast.thefacebook.com ([163.114.130.16]) by mx0a-00082601.pphosted.com with ESMTP id 2unvfyhhpy-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:04:18 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::4) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:17 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id A6CA6A25D668; Wed, 28 Aug 2019 14:04:16 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 07/10] selftests/bpf: extend test_section_names with type_(from|to)_str Date: Wed, 28 Aug 2019 14:03:10 -0700 Message-ID: X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 adultscore=0 priorityscore=1501 mlxscore=0 mlxlogscore=999 clxscore=1015 malwarescore=0 spamscore=0 lowpriorityscore=0 bulkscore=0 phishscore=0 impostorscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280206 X-FB-Internal: deliver Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Test bpf enum stringification helpers: libbpf_(prog|map|attach)_type_(from|to)_str Signed-off-by: Julia Kartseva --- .../selftests/bpf/test_section_names.c | 149 +++++++++++++++++- 1 file changed, 147 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/bpf/test_section_names.c b/tools/testing/selftests/bpf/test_section_names.c index 29833aeaf0de..564585a07592 100644 --- a/tools/testing/selftests/bpf/test_section_names.c +++ b/tools/testing/selftests/bpf/test_section_names.c @@ -202,7 +202,137 @@ static int test_attach_type_by_name(const struct sec_name_test *test) return 0; } -static int run_test_case(const struct sec_name_test *test) +static int test_prog_type_from_to_str(void) +{ + enum bpf_prog_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_PROG_TYPE_UNSPEC; type < __MAX_BPF_PROG_TYPE; type++) { + rc = libbpf_prog_type_to_str(type, &str); + if (rc) { + warnx("prog_type_to_str: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_prog_type_from_str(str, &actual_type); + if (rc) { + warnx("prog_type_from_str: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("prog: unexpected prog_type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_prog_type_to_str(__MAX_BPF_PROG_TYPE, &str); + if (!rc) { + warnx("prog: unexpected result for __MAX_BPF_PROG_TYPE"); + return -EINVAL; + } + + rc = libbpf_prog_type_from_str("NonExistent", &type); + if (!rc) { + warnx("prog: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int test_map_type_from_to_str(void) +{ + enum bpf_map_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_MAP_TYPE_UNSPEC; type < __MAX_BPF_MAP_TYPE; type++) { + rc = libbpf_map_type_to_str(type, &str); + if (rc) { + warnx("map_type_to_str: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_map_type_from_str(str, &actual_type); + if (rc) { + warnx("map_type_from_str: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("map: unexpected map_type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_map_type_to_str(__MAX_BPF_MAP_TYPE, &str); + if (!rc) { + warnx("map: unexpected result for __MAX_BPF_MAP_TYPE"); + return -EINVAL; + } + + rc = libbpf_map_type_from_str("NonExistent", &type); + if (!rc) { + warnx("map: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int test_attach_type_from_to_str(void) +{ + enum bpf_attach_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_CGROUP_INET_INGRESS; type < __MAX_BPF_ATTACH_TYPE; + type++) { + rc = libbpf_attach_type_to_str(type, &str); + if (rc) { + warnx("attach: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_attach_type_from_str(str, &actual_type); + if (rc) { + warnx("attach: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("attach: unexpected type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_attach_type_to_str(__MAX_BPF_ATTACH_TYPE, &str); + if (!rc) { + warnx("attach: unexpected result for __MAX_BPF_ATTACH_TYPE"); + return -EINVAL; + } + + rc = libbpf_attach_type_from_str("NonExistent", &type); + if (!rc) { + warnx("attach: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int run_sec_name_test_case(const struct sec_name_test *test) { if (test_prog_type_by_name(test)) return -1; @@ -218,11 +348,26 @@ static int run_tests(void) int i; for (i = 0; i < ARRAY_SIZE(tests); ++i) { - if (run_test_case(&tests[i])) + if (run_sec_name_test_case(&tests[i])) ++fails; else ++passes; } + + if (test_prog_type_from_to_str()) + ++fails; + else + ++passes; + + if (test_map_type_from_to_str()) + ++fails; + else + ++passes; + + if (test_attach_type_from_to_str()) + ++fails; + else + ++passes; printf("Summary: %d PASSED, %d FAILED\n", passes, fails); return fails ? -1 : 0; } From patchwork Wed Aug 28 21:03:11 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154877 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="NyDKAhPc"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXR5gPGz9sDB for ; Thu, 29 Aug 2019 07:04:23 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727109AbfH1VEW (ORCPT ); Wed, 28 Aug 2019 17:04:22 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:14542 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727097AbfH1VEV (ORCPT ); Wed, 28 Aug 2019 17:04:21 -0400 Received: from pps.filterd (m0001303.ppops.net [127.0.0.1]) by m0001303.ppops.net (8.16.0.42/8.16.0.42) with SMTP id x7SL2Rit023116 for ; Wed, 28 Aug 2019 14:04:20 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=zevRuexbdAc20lx0nPT3/bJlFv43H54UMmH42cLDnGg=; b=NyDKAhPcAdnbI2bxDkuZ6qYqfsYlbw6VmwepmLdCroX5iTdd1g9HiOp9o4LyoT2rTwFX voqmAdW0zejDBezsCFbpIxs/tEfq1e4ZpCfCt8PLaqtI9NlLbV099k5ATGksNrV/em8n RgMb4G7AOMnqkvWhpIG3rOBVsZCq/JyafWI= Received: from maileast.thefacebook.com ([163.114.130.16]) by m0001303.ppops.net with ESMTP id 2unuwq9r14-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:04:19 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:19 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id C24EBA25D697; Wed, 28 Aug 2019 14:04:18 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 08/10] selftests/bpf: rename test_section_names to test_section_and_type_names Date: Wed, 28 Aug 2019 14:03:11 -0700 Message-ID: X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 clxscore=1015 priorityscore=1501 mlxscore=0 phishscore=0 mlxlogscore=999 impostorscore=0 adultscore=0 lowpriorityscore=0 suspectscore=0 malwarescore=0 bulkscore=0 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Change the test name after extending it with enum stringification helpers. Signed-off-by: Julia Kartseva --- tools/testing/selftests/bpf/Makefile | 2 +- .../bpf/test_section_and_type_names.c | 378 ++++++++++++++++++ .../selftests/bpf/test_section_names.c | 378 ------------------ 3 files changed, 379 insertions(+), 379 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_section_and_type_names.c delete mode 100644 tools/testing/selftests/bpf/test_section_names.c diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile index 1faad0c3c3c9..8212a6240297 100644 --- a/tools/testing/selftests/bpf/Makefile +++ b/tools/testing/selftests/bpf/Makefile @@ -26,7 +26,7 @@ LDLIBS += -lcap -lelf -lrt -lpthread TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \ test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \ test_sock test_btf test_sockmap get_cgroup_id_user test_socket_cookie \ - test_cgroup_storage test_select_reuseport test_section_names \ + test_cgroup_storage test_select_reuseport test_section_and_type_names \ test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \ test_btf_dump test_cgroup_attach xdping test_sockopt test_sockopt_sk \ test_sockopt_multi test_sockopt_inherit test_tcp_rtt diff --git a/tools/testing/selftests/bpf/test_section_and_type_names.c b/tools/testing/selftests/bpf/test_section_and_type_names.c new file mode 100644 index 000000000000..564585a07592 --- /dev/null +++ b/tools/testing/selftests/bpf/test_section_and_type_names.c @@ -0,0 +1,378 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2018 Facebook + +#include +#include + +#include "bpf_util.h" + +struct sec_name_test { + const char sec_name[32]; + struct { + int rc; + enum bpf_prog_type prog_type; + enum bpf_attach_type expected_attach_type; + } expected_load; + struct { + int rc; + enum bpf_attach_type attach_type; + } expected_attach; +}; + +static struct sec_name_test tests[] = { + {"InvAliD", {-EINVAL, 0, 0}, {-EINVAL, 0} }, + {"cgroup", {-EINVAL, 0, 0}, {-EINVAL, 0} }, + {"socket", {0, BPF_PROG_TYPE_SOCKET_FILTER, 0}, {-EINVAL, 0} }, + {"kprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} }, + {"kretprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} }, + {"classifier", {0, BPF_PROG_TYPE_SCHED_CLS, 0}, {-EINVAL, 0} }, + {"action", {0, BPF_PROG_TYPE_SCHED_ACT, 0}, {-EINVAL, 0} }, + {"tracepoint/", {0, BPF_PROG_TYPE_TRACEPOINT, 0}, {-EINVAL, 0} }, + { + "raw_tracepoint/", + {0, BPF_PROG_TYPE_RAW_TRACEPOINT, 0}, + {-EINVAL, 0}, + }, + {"xdp", {0, BPF_PROG_TYPE_XDP, 0}, {-EINVAL, 0} }, + {"perf_event", {0, BPF_PROG_TYPE_PERF_EVENT, 0}, {-EINVAL, 0} }, + {"lwt_in", {0, BPF_PROG_TYPE_LWT_IN, 0}, {-EINVAL, 0} }, + {"lwt_out", {0, BPF_PROG_TYPE_LWT_OUT, 0}, {-EINVAL, 0} }, + {"lwt_xmit", {0, BPF_PROG_TYPE_LWT_XMIT, 0}, {-EINVAL, 0} }, + {"lwt_seg6local", {0, BPF_PROG_TYPE_LWT_SEG6LOCAL, 0}, {-EINVAL, 0} }, + { + "cgroup_skb/ingress", + {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, + {0, BPF_CGROUP_INET_INGRESS}, + }, + { + "cgroup_skb/egress", + {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, + {0, BPF_CGROUP_INET_EGRESS}, + }, + {"cgroup/skb", {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, {-EINVAL, 0} }, + { + "cgroup/sock", + {0, BPF_PROG_TYPE_CGROUP_SOCK, 0}, + {0, BPF_CGROUP_INET_SOCK_CREATE}, + }, + { + "cgroup/post_bind4", + {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET4_POST_BIND}, + {0, BPF_CGROUP_INET4_POST_BIND}, + }, + { + "cgroup/post_bind6", + {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET6_POST_BIND}, + {0, BPF_CGROUP_INET6_POST_BIND}, + }, + { + "cgroup/dev", + {0, BPF_PROG_TYPE_CGROUP_DEVICE, 0}, + {0, BPF_CGROUP_DEVICE}, + }, + {"sockops", {0, BPF_PROG_TYPE_SOCK_OPS, 0}, {0, BPF_CGROUP_SOCK_OPS} }, + { + "sk_skb/stream_parser", + {0, BPF_PROG_TYPE_SK_SKB, 0}, + {0, BPF_SK_SKB_STREAM_PARSER}, + }, + { + "sk_skb/stream_verdict", + {0, BPF_PROG_TYPE_SK_SKB, 0}, + {0, BPF_SK_SKB_STREAM_VERDICT}, + }, + {"sk_skb", {0, BPF_PROG_TYPE_SK_SKB, 0}, {-EINVAL, 0} }, + {"sk_msg", {0, BPF_PROG_TYPE_SK_MSG, 0}, {0, BPF_SK_MSG_VERDICT} }, + {"lirc_mode2", {0, BPF_PROG_TYPE_LIRC_MODE2, 0}, {0, BPF_LIRC_MODE2} }, + { + "flow_dissector", + {0, BPF_PROG_TYPE_FLOW_DISSECTOR, 0}, + {0, BPF_FLOW_DISSECTOR}, + }, + { + "cgroup/bind4", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_BIND}, + {0, BPF_CGROUP_INET4_BIND}, + }, + { + "cgroup/bind6", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_BIND}, + {0, BPF_CGROUP_INET6_BIND}, + }, + { + "cgroup/connect4", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_CONNECT}, + {0, BPF_CGROUP_INET4_CONNECT}, + }, + { + "cgroup/connect6", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_CONNECT}, + {0, BPF_CGROUP_INET6_CONNECT}, + }, + { + "cgroup/sendmsg4", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_SENDMSG}, + {0, BPF_CGROUP_UDP4_SENDMSG}, + }, + { + "cgroup/sendmsg6", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_SENDMSG}, + {0, BPF_CGROUP_UDP6_SENDMSG}, + }, + { + "cgroup/recvmsg4", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_RECVMSG}, + {0, BPF_CGROUP_UDP4_RECVMSG}, + }, + { + "cgroup/recvmsg6", + {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_RECVMSG}, + {0, BPF_CGROUP_UDP6_RECVMSG}, + }, + { + "cgroup/sysctl", + {0, BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_CGROUP_SYSCTL}, + {0, BPF_CGROUP_SYSCTL}, + }, + { + "cgroup/getsockopt", + {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_GETSOCKOPT}, + {0, BPF_CGROUP_GETSOCKOPT}, + }, + { + "cgroup/setsockopt", + {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_SETSOCKOPT}, + {0, BPF_CGROUP_SETSOCKOPT}, + }, +}; + +static int test_prog_type_by_name(const struct sec_name_test *test) +{ + enum bpf_attach_type expected_attach_type; + enum bpf_prog_type prog_type; + int rc; + + rc = libbpf_prog_type_by_name(test->sec_name, &prog_type, + &expected_attach_type); + + if (rc != test->expected_load.rc) { + warnx("prog: unexpected rc=%d for %s", rc, test->sec_name); + return -1; + } + + if (rc) + return 0; + + if (prog_type != test->expected_load.prog_type) { + warnx("prog: unexpected prog_type=%d for %s", prog_type, + test->sec_name); + return -1; + } + + if (expected_attach_type != test->expected_load.expected_attach_type) { + warnx("prog: unexpected expected_attach_type=%d for %s", + expected_attach_type, test->sec_name); + return -1; + } + + return 0; +} + +static int test_attach_type_by_name(const struct sec_name_test *test) +{ + enum bpf_attach_type attach_type; + int rc; + + rc = libbpf_attach_type_by_name(test->sec_name, &attach_type); + + if (rc != test->expected_attach.rc) { + warnx("attach: unexpected rc=%d for %s", rc, test->sec_name); + return -1; + } + + if (rc) + return 0; + + if (attach_type != test->expected_attach.attach_type) { + warnx("attach: unexpected attach_type=%d for %s", attach_type, + test->sec_name); + return -1; + } + + return 0; +} + +static int test_prog_type_from_to_str(void) +{ + enum bpf_prog_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_PROG_TYPE_UNSPEC; type < __MAX_BPF_PROG_TYPE; type++) { + rc = libbpf_prog_type_to_str(type, &str); + if (rc) { + warnx("prog_type_to_str: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_prog_type_from_str(str, &actual_type); + if (rc) { + warnx("prog_type_from_str: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("prog: unexpected prog_type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_prog_type_to_str(__MAX_BPF_PROG_TYPE, &str); + if (!rc) { + warnx("prog: unexpected result for __MAX_BPF_PROG_TYPE"); + return -EINVAL; + } + + rc = libbpf_prog_type_from_str("NonExistent", &type); + if (!rc) { + warnx("prog: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int test_map_type_from_to_str(void) +{ + enum bpf_map_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_MAP_TYPE_UNSPEC; type < __MAX_BPF_MAP_TYPE; type++) { + rc = libbpf_map_type_to_str(type, &str); + if (rc) { + warnx("map_type_to_str: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_map_type_from_str(str, &actual_type); + if (rc) { + warnx("map_type_from_str: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("map: unexpected map_type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_map_type_to_str(__MAX_BPF_MAP_TYPE, &str); + if (!rc) { + warnx("map: unexpected result for __MAX_BPF_MAP_TYPE"); + return -EINVAL; + } + + rc = libbpf_map_type_from_str("NonExistent", &type); + if (!rc) { + warnx("map: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int test_attach_type_from_to_str(void) +{ + enum bpf_attach_type type, actual_type; + const char *str; + int rc; + + for (type = BPF_CGROUP_INET_INGRESS; type < __MAX_BPF_ATTACH_TYPE; + type++) { + rc = libbpf_attach_type_to_str(type, &str); + if (rc) { + warnx("attach: unexpected rc=%d for type %d", + rc, type); + return rc; + } + + rc = libbpf_attach_type_from_str(str, &actual_type); + if (rc) { + warnx("attach: unexpected rc=%d for str %s", + rc, str); + return rc; + } + + if (actual_type != type) { + warnx("attach: unexpected type for str %s, %d != %d", + str, actual_type, type); + return -EINVAL; + } + } + + rc = libbpf_attach_type_to_str(__MAX_BPF_ATTACH_TYPE, &str); + if (!rc) { + warnx("attach: unexpected result for __MAX_BPF_ATTACH_TYPE"); + return -EINVAL; + } + + rc = libbpf_attach_type_from_str("NonExistent", &type); + if (!rc) { + warnx("attach: unexpected result for non existent key"); + return -EINVAL; + } + + return 0; +} + +static int run_sec_name_test_case(const struct sec_name_test *test) +{ + if (test_prog_type_by_name(test)) + return -1; + if (test_attach_type_by_name(test)) + return -1; + return 0; +} + +static int run_tests(void) +{ + int passes = 0; + int fails = 0; + int i; + + for (i = 0; i < ARRAY_SIZE(tests); ++i) { + if (run_sec_name_test_case(&tests[i])) + ++fails; + else + ++passes; + } + + if (test_prog_type_from_to_str()) + ++fails; + else + ++passes; + + if (test_map_type_from_to_str()) + ++fails; + else + ++passes; + + if (test_attach_type_from_to_str()) + ++fails; + else + ++passes; + printf("Summary: %d PASSED, %d FAILED\n", passes, fails); + return fails ? -1 : 0; +} + +int main(int argc, char **argv) +{ + return run_tests(); +} diff --git a/tools/testing/selftests/bpf/test_section_names.c b/tools/testing/selftests/bpf/test_section_names.c deleted file mode 100644 index 564585a07592..000000000000 --- a/tools/testing/selftests/bpf/test_section_names.c +++ /dev/null @@ -1,378 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -// Copyright (c) 2018 Facebook - -#include -#include - -#include "bpf_util.h" - -struct sec_name_test { - const char sec_name[32]; - struct { - int rc; - enum bpf_prog_type prog_type; - enum bpf_attach_type expected_attach_type; - } expected_load; - struct { - int rc; - enum bpf_attach_type attach_type; - } expected_attach; -}; - -static struct sec_name_test tests[] = { - {"InvAliD", {-EINVAL, 0, 0}, {-EINVAL, 0} }, - {"cgroup", {-EINVAL, 0, 0}, {-EINVAL, 0} }, - {"socket", {0, BPF_PROG_TYPE_SOCKET_FILTER, 0}, {-EINVAL, 0} }, - {"kprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} }, - {"kretprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} }, - {"classifier", {0, BPF_PROG_TYPE_SCHED_CLS, 0}, {-EINVAL, 0} }, - {"action", {0, BPF_PROG_TYPE_SCHED_ACT, 0}, {-EINVAL, 0} }, - {"tracepoint/", {0, BPF_PROG_TYPE_TRACEPOINT, 0}, {-EINVAL, 0} }, - { - "raw_tracepoint/", - {0, BPF_PROG_TYPE_RAW_TRACEPOINT, 0}, - {-EINVAL, 0}, - }, - {"xdp", {0, BPF_PROG_TYPE_XDP, 0}, {-EINVAL, 0} }, - {"perf_event", {0, BPF_PROG_TYPE_PERF_EVENT, 0}, {-EINVAL, 0} }, - {"lwt_in", {0, BPF_PROG_TYPE_LWT_IN, 0}, {-EINVAL, 0} }, - {"lwt_out", {0, BPF_PROG_TYPE_LWT_OUT, 0}, {-EINVAL, 0} }, - {"lwt_xmit", {0, BPF_PROG_TYPE_LWT_XMIT, 0}, {-EINVAL, 0} }, - {"lwt_seg6local", {0, BPF_PROG_TYPE_LWT_SEG6LOCAL, 0}, {-EINVAL, 0} }, - { - "cgroup_skb/ingress", - {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, - {0, BPF_CGROUP_INET_INGRESS}, - }, - { - "cgroup_skb/egress", - {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, - {0, BPF_CGROUP_INET_EGRESS}, - }, - {"cgroup/skb", {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, {-EINVAL, 0} }, - { - "cgroup/sock", - {0, BPF_PROG_TYPE_CGROUP_SOCK, 0}, - {0, BPF_CGROUP_INET_SOCK_CREATE}, - }, - { - "cgroup/post_bind4", - {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET4_POST_BIND}, - {0, BPF_CGROUP_INET4_POST_BIND}, - }, - { - "cgroup/post_bind6", - {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET6_POST_BIND}, - {0, BPF_CGROUP_INET6_POST_BIND}, - }, - { - "cgroup/dev", - {0, BPF_PROG_TYPE_CGROUP_DEVICE, 0}, - {0, BPF_CGROUP_DEVICE}, - }, - {"sockops", {0, BPF_PROG_TYPE_SOCK_OPS, 0}, {0, BPF_CGROUP_SOCK_OPS} }, - { - "sk_skb/stream_parser", - {0, BPF_PROG_TYPE_SK_SKB, 0}, - {0, BPF_SK_SKB_STREAM_PARSER}, - }, - { - "sk_skb/stream_verdict", - {0, BPF_PROG_TYPE_SK_SKB, 0}, - {0, BPF_SK_SKB_STREAM_VERDICT}, - }, - {"sk_skb", {0, BPF_PROG_TYPE_SK_SKB, 0}, {-EINVAL, 0} }, - {"sk_msg", {0, BPF_PROG_TYPE_SK_MSG, 0}, {0, BPF_SK_MSG_VERDICT} }, - {"lirc_mode2", {0, BPF_PROG_TYPE_LIRC_MODE2, 0}, {0, BPF_LIRC_MODE2} }, - { - "flow_dissector", - {0, BPF_PROG_TYPE_FLOW_DISSECTOR, 0}, - {0, BPF_FLOW_DISSECTOR}, - }, - { - "cgroup/bind4", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_BIND}, - {0, BPF_CGROUP_INET4_BIND}, - }, - { - "cgroup/bind6", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_BIND}, - {0, BPF_CGROUP_INET6_BIND}, - }, - { - "cgroup/connect4", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_CONNECT}, - {0, BPF_CGROUP_INET4_CONNECT}, - }, - { - "cgroup/connect6", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_CONNECT}, - {0, BPF_CGROUP_INET6_CONNECT}, - }, - { - "cgroup/sendmsg4", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_SENDMSG}, - {0, BPF_CGROUP_UDP4_SENDMSG}, - }, - { - "cgroup/sendmsg6", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_SENDMSG}, - {0, BPF_CGROUP_UDP6_SENDMSG}, - }, - { - "cgroup/recvmsg4", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_RECVMSG}, - {0, BPF_CGROUP_UDP4_RECVMSG}, - }, - { - "cgroup/recvmsg6", - {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_RECVMSG}, - {0, BPF_CGROUP_UDP6_RECVMSG}, - }, - { - "cgroup/sysctl", - {0, BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_CGROUP_SYSCTL}, - {0, BPF_CGROUP_SYSCTL}, - }, - { - "cgroup/getsockopt", - {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_GETSOCKOPT}, - {0, BPF_CGROUP_GETSOCKOPT}, - }, - { - "cgroup/setsockopt", - {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_SETSOCKOPT}, - {0, BPF_CGROUP_SETSOCKOPT}, - }, -}; - -static int test_prog_type_by_name(const struct sec_name_test *test) -{ - enum bpf_attach_type expected_attach_type; - enum bpf_prog_type prog_type; - int rc; - - rc = libbpf_prog_type_by_name(test->sec_name, &prog_type, - &expected_attach_type); - - if (rc != test->expected_load.rc) { - warnx("prog: unexpected rc=%d for %s", rc, test->sec_name); - return -1; - } - - if (rc) - return 0; - - if (prog_type != test->expected_load.prog_type) { - warnx("prog: unexpected prog_type=%d for %s", prog_type, - test->sec_name); - return -1; - } - - if (expected_attach_type != test->expected_load.expected_attach_type) { - warnx("prog: unexpected expected_attach_type=%d for %s", - expected_attach_type, test->sec_name); - return -1; - } - - return 0; -} - -static int test_attach_type_by_name(const struct sec_name_test *test) -{ - enum bpf_attach_type attach_type; - int rc; - - rc = libbpf_attach_type_by_name(test->sec_name, &attach_type); - - if (rc != test->expected_attach.rc) { - warnx("attach: unexpected rc=%d for %s", rc, test->sec_name); - return -1; - } - - if (rc) - return 0; - - if (attach_type != test->expected_attach.attach_type) { - warnx("attach: unexpected attach_type=%d for %s", attach_type, - test->sec_name); - return -1; - } - - return 0; -} - -static int test_prog_type_from_to_str(void) -{ - enum bpf_prog_type type, actual_type; - const char *str; - int rc; - - for (type = BPF_PROG_TYPE_UNSPEC; type < __MAX_BPF_PROG_TYPE; type++) { - rc = libbpf_prog_type_to_str(type, &str); - if (rc) { - warnx("prog_type_to_str: unexpected rc=%d for type %d", - rc, type); - return rc; - } - - rc = libbpf_prog_type_from_str(str, &actual_type); - if (rc) { - warnx("prog_type_from_str: unexpected rc=%d for str %s", - rc, str); - return rc; - } - - if (actual_type != type) { - warnx("prog: unexpected prog_type for str %s, %d != %d", - str, actual_type, type); - return -EINVAL; - } - } - - rc = libbpf_prog_type_to_str(__MAX_BPF_PROG_TYPE, &str); - if (!rc) { - warnx("prog: unexpected result for __MAX_BPF_PROG_TYPE"); - return -EINVAL; - } - - rc = libbpf_prog_type_from_str("NonExistent", &type); - if (!rc) { - warnx("prog: unexpected result for non existent key"); - return -EINVAL; - } - - return 0; -} - -static int test_map_type_from_to_str(void) -{ - enum bpf_map_type type, actual_type; - const char *str; - int rc; - - for (type = BPF_MAP_TYPE_UNSPEC; type < __MAX_BPF_MAP_TYPE; type++) { - rc = libbpf_map_type_to_str(type, &str); - if (rc) { - warnx("map_type_to_str: unexpected rc=%d for type %d", - rc, type); - return rc; - } - - rc = libbpf_map_type_from_str(str, &actual_type); - if (rc) { - warnx("map_type_from_str: unexpected rc=%d for str %s", - rc, str); - return rc; - } - - if (actual_type != type) { - warnx("map: unexpected map_type for str %s, %d != %d", - str, actual_type, type); - return -EINVAL; - } - } - - rc = libbpf_map_type_to_str(__MAX_BPF_MAP_TYPE, &str); - if (!rc) { - warnx("map: unexpected result for __MAX_BPF_MAP_TYPE"); - return -EINVAL; - } - - rc = libbpf_map_type_from_str("NonExistent", &type); - if (!rc) { - warnx("map: unexpected result for non existent key"); - return -EINVAL; - } - - return 0; -} - -static int test_attach_type_from_to_str(void) -{ - enum bpf_attach_type type, actual_type; - const char *str; - int rc; - - for (type = BPF_CGROUP_INET_INGRESS; type < __MAX_BPF_ATTACH_TYPE; - type++) { - rc = libbpf_attach_type_to_str(type, &str); - if (rc) { - warnx("attach: unexpected rc=%d for type %d", - rc, type); - return rc; - } - - rc = libbpf_attach_type_from_str(str, &actual_type); - if (rc) { - warnx("attach: unexpected rc=%d for str %s", - rc, str); - return rc; - } - - if (actual_type != type) { - warnx("attach: unexpected type for str %s, %d != %d", - str, actual_type, type); - return -EINVAL; - } - } - - rc = libbpf_attach_type_to_str(__MAX_BPF_ATTACH_TYPE, &str); - if (!rc) { - warnx("attach: unexpected result for __MAX_BPF_ATTACH_TYPE"); - return -EINVAL; - } - - rc = libbpf_attach_type_from_str("NonExistent", &type); - if (!rc) { - warnx("attach: unexpected result for non existent key"); - return -EINVAL; - } - - return 0; -} - -static int run_sec_name_test_case(const struct sec_name_test *test) -{ - if (test_prog_type_by_name(test)) - return -1; - if (test_attach_type_by_name(test)) - return -1; - return 0; -} - -static int run_tests(void) -{ - int passes = 0; - int fails = 0; - int i; - - for (i = 0; i < ARRAY_SIZE(tests); ++i) { - if (run_sec_name_test_case(&tests[i])) - ++fails; - else - ++passes; - } - - if (test_prog_type_from_to_str()) - ++fails; - else - ++passes; - - if (test_map_type_from_to_str()) - ++fails; - else - ++passes; - - if (test_attach_type_from_to_str()) - ++fails; - else - ++passes; - printf("Summary: %d PASSED, %d FAILED\n", passes, fails); - return fails ? -1 : 0; -} - -int main(int argc, char **argv) -{ - return run_tests(); -} From patchwork Wed Aug 28 21:03:12 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154883 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="QmMZBGOh"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdY870QMz9sDB for ; Thu, 29 Aug 2019 07:05:00 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726787AbfH1VE7 (ORCPT ); Wed, 28 Aug 2019 17:04:59 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:51240 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726583AbfH1VE7 (ORCPT ); Wed, 28 Aug 2019 17:04:59 -0400 Received: from pps.filterd (m0089730.ppops.net [127.0.0.1]) by m0089730.ppops.net (8.16.0.42/8.16.0.42) with SMTP id x7SL4s2b002548 for ; Wed, 28 Aug 2019 14:04:57 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=YMi7ATQez7af44Q6sVNFWtVib+PyV/1XudXukZNgIYg=; b=QmMZBGOhoOfFDnmjfl1ORhYt0GEeMT8sT1mT8kK4tmDqU+Qr6BQYa8Nc3QmgdiD6TsCU gF/3TybOuapY17OCwnTwx3vxXZKZnRFzhzjAQuYIAij8bNjLN3pOlmbDzY5N9Te1ycC9 hkkMZHd7KWnk0J9md9elbjPtWN/es9rkBqk= Received: from maileast.thefacebook.com ([163.114.130.16]) by m0089730.ppops.net with ESMTP id 2un62cf2qu-6 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Wed, 28 Aug 2019 14:04:57 -0700 Received: from mx-out.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:23 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id A41DDA25D6A2; Wed, 28 Aug 2019 14:04:22 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 09/10] tools/bpftool: use libbpf_(prog|map)_type_to_str helpers Date: Wed, 28 Aug 2019 14:03:12 -0700 Message-ID: <6dbed87425cb14e32002c7b596fdcfec7dfca732.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 lowpriorityscore=0 malwarescore=0 spamscore=0 priorityscore=1501 phishscore=0 impostorscore=0 bulkscore=0 adultscore=0 mlxlogscore=999 mlxscore=0 suspectscore=2 clxscore=1015 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280206 X-FB-Internal: deliver Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Replace lookup in (prog|map)_type_name arrays with libbpf_(prog|map)_type_to_str helpers. Use __MAX_BPF_(PROG|MAP)_TYPE enum values as loop bounds. Signed-off-by: Julia Kartseva --- tools/bpf/bpftool/feature.c | 47 ++++++++++++++-------- tools/bpf/bpftool/main.h | 33 --------------- tools/bpf/bpftool/map.c | 80 ++++++++++--------------------------- tools/bpf/bpftool/prog.c | 11 ++--- 4 files changed, 59 insertions(+), 112 deletions(-) diff --git a/tools/bpf/bpftool/feature.c b/tools/bpf/bpftool/feature.c index 03bdc5b3ac49..e9416005e721 100644 --- a/tools/bpf/bpftool/feature.c +++ b/tools/bpf/bpftool/feature.c @@ -462,7 +462,7 @@ probe_prog_type(enum bpf_prog_type prog_type, bool *supported_types, const char *define_prefix, __u32 ifindex) { char feat_name[128], plain_desc[128], define_name[128]; - const char *plain_comment = "eBPF program_type "; + const char *ptype_name, *plain_comment = "eBPF program_type "; size_t maxlen; bool res; @@ -480,16 +480,21 @@ probe_prog_type(enum bpf_prog_type prog_type, bool *supported_types, supported_types[prog_type] |= res; + if (libbpf_prog_type_to_str(prog_type, &ptype_name)) { + p_info("program type name does not exist"); + return; + } + maxlen = sizeof(plain_desc) - strlen(plain_comment) - 1; - if (strlen(prog_type_name[prog_type]) > maxlen) { + if (strlen(ptype_name) > maxlen) { p_info("program type name too long"); return; } - sprintf(feat_name, "have_%s_prog_type", prog_type_name[prog_type]); - sprintf(define_name, "%s_prog_type", prog_type_name[prog_type]); + sprintf(feat_name, "have_%s_prog_type", ptype_name); + sprintf(define_name, "%s_prog_type", ptype_name); uppercase(define_name, sizeof(define_name)); - sprintf(plain_desc, "%s%s", plain_comment, prog_type_name[prog_type]); + sprintf(plain_desc, "%s%s", plain_comment, ptype_name); print_bool_feature(feat_name, plain_desc, define_name, res, define_prefix); } @@ -499,22 +504,27 @@ probe_map_type(enum bpf_map_type map_type, const char *define_prefix, __u32 ifindex) { char feat_name[128], plain_desc[128], define_name[128]; - const char *plain_comment = "eBPF map_type "; + const char *mtype_name, *plain_comment = "eBPF map_type "; size_t maxlen; bool res; res = bpf_probe_map_type(map_type, ifindex); + if (libbpf_map_type_to_str(map_type, &mtype_name)) { + p_info("map type name does not exist"); + return; + } + maxlen = sizeof(plain_desc) - strlen(plain_comment) - 1; - if (strlen(map_type_name[map_type]) > maxlen) { + if (strlen(mtype_name) > maxlen) { p_info("map type name too long"); return; } - sprintf(feat_name, "have_%s_map_type", map_type_name[map_type]); - sprintf(define_name, "%s_map_type", map_type_name[map_type]); + sprintf(feat_name, "have_%s_map_type", mtype_name); + sprintf(define_name, "%s_map_type", mtype_name); uppercase(define_name, sizeof(define_name)); - sprintf(plain_desc, "%s%s", plain_comment, map_type_name[map_type]); + sprintf(plain_desc, "%s%s", plain_comment, mtype_name); print_bool_feature(feat_name, plain_desc, define_name, res, define_prefix); } @@ -523,11 +533,16 @@ static void probe_helpers_for_progtype(enum bpf_prog_type prog_type, bool supported_type, const char *define_prefix, __u32 ifindex) { - const char *ptype_name = prog_type_name[prog_type]; + const char *ptype_name; char feat_name[128]; unsigned int id; bool res; + if (libbpf_prog_type_to_str(prog_type, &ptype_name)) { + p_info("map type name does not exist"); + return; + } + if (ifindex) /* Only test helpers for offload-able program types */ switch (prog_type) { @@ -689,7 +704,7 @@ static int do_probe(int argc, char **argv) "/*** eBPF program types ***/", define_prefix); - for (i = BPF_PROG_TYPE_UNSPEC + 1; i < ARRAY_SIZE(prog_type_name); i++) + for (i = BPF_PROG_TYPE_UNSPEC + 1; i < __MAX_BPF_PROG_TYPE; i++) probe_prog_type(i, supported_types, define_prefix, ifindex); print_end_then_start_section("map_types", @@ -697,7 +712,7 @@ static int do_probe(int argc, char **argv) "/*** eBPF map types ***/", define_prefix); - for (i = BPF_MAP_TYPE_UNSPEC + 1; i < map_type_name_size; i++) + for (i = BPF_MAP_TYPE_UNSPEC + 1; i < __MAX_BPF_MAP_TYPE; i++) probe_map_type(i, define_prefix, ifindex); print_end_then_start_section("helpers", @@ -720,9 +735,9 @@ static int do_probe(int argc, char **argv) " %sBPF__PROG_TYPE_ ## prog_type ## __HELPER_ ## helper\n", define_prefix, define_prefix, define_prefix, define_prefix); - for (i = BPF_PROG_TYPE_UNSPEC + 1; i < ARRAY_SIZE(prog_type_name); i++) - probe_helpers_for_progtype(i, supported_types[i], - define_prefix, ifindex); + for (i = BPF_PROG_TYPE_UNSPEC + 1; i <= __MAX_BPF_PROG_TYPE; i++) + probe_helpers_for_progtype(i, supported_types[i], define_prefix, + ifindex); exit_close_json: if (json_output) { diff --git a/tools/bpf/bpftool/main.h b/tools/bpf/bpftool/main.h index af9ad56c303a..bb840d900fb4 100644 --- a/tools/bpf/bpftool/main.h +++ b/tools/bpf/bpftool/main.h @@ -48,39 +48,6 @@ "\t {-m|--mapcompat} | {-n|--nomount} }" #define HELP_SPEC_MAP \ "MAP := { id MAP_ID | pinned FILE }" - -static const char * const prog_type_name[] = { - [BPF_PROG_TYPE_UNSPEC] = "unspec", - [BPF_PROG_TYPE_SOCKET_FILTER] = "socket_filter", - [BPF_PROG_TYPE_KPROBE] = "kprobe", - [BPF_PROG_TYPE_SCHED_CLS] = "sched_cls", - [BPF_PROG_TYPE_SCHED_ACT] = "sched_act", - [BPF_PROG_TYPE_TRACEPOINT] = "tracepoint", - [BPF_PROG_TYPE_XDP] = "xdp", - [BPF_PROG_TYPE_PERF_EVENT] = "perf_event", - [BPF_PROG_TYPE_CGROUP_SKB] = "cgroup_skb", - [BPF_PROG_TYPE_CGROUP_SOCK] = "cgroup_sock", - [BPF_PROG_TYPE_LWT_IN] = "lwt_in", - [BPF_PROG_TYPE_LWT_OUT] = "lwt_out", - [BPF_PROG_TYPE_LWT_XMIT] = "lwt_xmit", - [BPF_PROG_TYPE_SOCK_OPS] = "sock_ops", - [BPF_PROG_TYPE_SK_SKB] = "sk_skb", - [BPF_PROG_TYPE_CGROUP_DEVICE] = "cgroup_device", - [BPF_PROG_TYPE_SK_MSG] = "sk_msg", - [BPF_PROG_TYPE_RAW_TRACEPOINT] = "raw_tracepoint", - [BPF_PROG_TYPE_CGROUP_SOCK_ADDR] = "cgroup_sock_addr", - [BPF_PROG_TYPE_LWT_SEG6LOCAL] = "lwt_seg6local", - [BPF_PROG_TYPE_LIRC_MODE2] = "lirc_mode2", - [BPF_PROG_TYPE_SK_REUSEPORT] = "sk_reuseport", - [BPF_PROG_TYPE_FLOW_DISSECTOR] = "flow_dissector", - [BPF_PROG_TYPE_CGROUP_SYSCTL] = "cgroup_sysctl", - [BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE] = "raw_tracepoint_writable", - [BPF_PROG_TYPE_CGROUP_SOCKOPT] = "cgroup_sockopt", -}; - -extern const char * const map_type_name[]; -extern const size_t map_type_name_size; - enum bpf_obj_type { BPF_OBJ_UNKNOWN, BPF_OBJ_PROG, diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c index de61d73b9030..ca3760b5c33e 100644 --- a/tools/bpf/bpftool/map.c +++ b/tools/bpf/bpftool/map.c @@ -16,42 +16,12 @@ #include #include +#include #include "btf.h" #include "json_writer.h" #include "main.h" -const char * const map_type_name[] = { - [BPF_MAP_TYPE_UNSPEC] = "unspec", - [BPF_MAP_TYPE_HASH] = "hash", - [BPF_MAP_TYPE_ARRAY] = "array", - [BPF_MAP_TYPE_PROG_ARRAY] = "prog_array", - [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf_event_array", - [BPF_MAP_TYPE_PERCPU_HASH] = "percpu_hash", - [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu_array", - [BPF_MAP_TYPE_STACK_TRACE] = "stack_trace", - [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup_array", - [BPF_MAP_TYPE_LRU_HASH] = "lru_hash", - [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru_percpu_hash", - [BPF_MAP_TYPE_LPM_TRIE] = "lpm_trie", - [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array_of_maps", - [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash_of_maps", - [BPF_MAP_TYPE_DEVMAP] = "devmap", - [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash", - [BPF_MAP_TYPE_SOCKMAP] = "sockmap", - [BPF_MAP_TYPE_CPUMAP] = "cpumap", - [BPF_MAP_TYPE_XSKMAP] = "xskmap", - [BPF_MAP_TYPE_SOCKHASH] = "sockhash", - [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage", - [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray", - [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "percpu_cgroup_storage", - [BPF_MAP_TYPE_QUEUE] = "queue", - [BPF_MAP_TYPE_STACK] = "stack", - [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage", -}; - -const size_t map_type_name_size = ARRAY_SIZE(map_type_name); - static bool map_is_per_cpu(__u32 type) { return type == BPF_MAP_TYPE_PERCPU_HASH || @@ -71,17 +41,6 @@ static bool map_is_map_of_progs(__u32 type) return type == BPF_MAP_TYPE_PROG_ARRAY; } -static int map_type_from_str(const char *type) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(map_type_name); i++) - /* Don't allow prefixing in case of possible future shadowing */ - if (map_type_name[i] && !strcmp(map_type_name[i], type)) - return i; - return -1; -} - static void *alloc_value(struct bpf_map_info *info) { if (map_is_per_cpu(info->type)) @@ -481,6 +440,8 @@ static int parse_elem(char **argv, struct bpf_map_info *info, static int show_map_close_json(int fd, struct bpf_map_info *info) { + const char *ptype_name, *mtype_name; + enum bpf_prog_type prog_type; char *memlock, *frozen_str; int frozen = 0; @@ -488,11 +449,10 @@ static int show_map_close_json(int fd, struct bpf_map_info *info) frozen_str = get_fdinfo(fd, "frozen"); jsonw_start_object(json_wtr); - jsonw_uint_field(json_wtr, "id", info->id); - if (info->type < ARRAY_SIZE(map_type_name)) - jsonw_string_field(json_wtr, "type", - map_type_name[info->type]); + + if (!libbpf_map_type_to_str(info->type, &mtype_name)) + jsonw_string_field(json_wtr, "type", mtype_name); else jsonw_uint_field(json_wtr, "type", info->type); @@ -517,11 +477,11 @@ static int show_map_close_json(int fd, struct bpf_map_info *info) char *owner_jited = get_fdinfo(fd, "owner_jited"); if (owner_prog_type) { - unsigned int prog_type = atoi(owner_prog_type); + prog_type = atoi(owner_prog_type); - if (prog_type < ARRAY_SIZE(prog_type_name)) + if (!libbpf_prog_type_to_str(prog_type, &ptype_name)) jsonw_string_field(json_wtr, "owner_prog_type", - prog_type_name[prog_type]); + ptype_name); else jsonw_uint_field(json_wtr, "owner_prog_type", prog_type); @@ -563,6 +523,7 @@ static int show_map_close_json(int fd, struct bpf_map_info *info) static int show_map_close_plain(int fd, struct bpf_map_info *info) { + const char *mtype_name, *ptype_name; char *memlock, *frozen_str; int frozen = 0; @@ -570,8 +531,9 @@ static int show_map_close_plain(int fd, struct bpf_map_info *info) frozen_str = get_fdinfo(fd, "frozen"); printf("%u: ", info->id); - if (info->type < ARRAY_SIZE(map_type_name)) - printf("%s ", map_type_name[info->type]); + + if (!libbpf_map_type_to_str(info->type, &mtype_name)) + printf("%s ", mtype_name); else printf("type %u ", info->type); @@ -596,10 +558,8 @@ static int show_map_close_plain(int fd, struct bpf_map_info *info) printf("\n\t"); if (owner_prog_type) { unsigned int prog_type = atoi(owner_prog_type); - - if (prog_type < ARRAY_SIZE(prog_type_name)) - printf("owner_prog_type %s ", - prog_type_name[prog_type]); + if (!libbpf_prog_type_to_str(prog_type, &ptype_name)) + printf("owner_prog_type %s ", ptype_name); else printf("owner_prog_type %d ", prog_type); } @@ -772,6 +732,7 @@ static int do_dump(int argc, char **argv) unsigned int num_elems = 0; __u32 len = sizeof(info); json_writer_t *btf_wtr; + const char *mtype_name; struct btf *btf = NULL; int err; int fd; @@ -813,10 +774,14 @@ static int do_dump(int argc, char **argv) } } + if (libbpf_map_type_to_str(info.type, &mtype_name)) { + p_info("map type name does not exist"); + goto exit_free; + } if (info.type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY && info.value_size != 8) p_info("Warning: cannot read values from %s map with value_size != 8", - map_type_name[info.type]); + mtype_name); while (true) { err = bpf_map_get_next_key(fd, prev_key, key); if (err) { @@ -1150,8 +1115,7 @@ static int do_create(int argc, char **argv) return -1; } - attr.map_type = map_type_from_str(*argv); - if ((int)attr.map_type < 0) { + if (libbpf_map_type_from_str(*argv, &attr.map_type)) { p_err("unrecognized map type: %s", *argv); return -1; } diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c index 66f04a4846a5..8bbb24339a52 100644 --- a/tools/bpf/bpftool/prog.c +++ b/tools/bpf/bpftool/prog.c @@ -196,13 +196,13 @@ static void show_prog_maps(int fd, u32 num_maps) static void print_prog_json(struct bpf_prog_info *info, int fd) { + const char *ptype_name; char *memlock; jsonw_start_object(json_wtr); jsonw_uint_field(json_wtr, "id", info->id); - if (info->type < ARRAY_SIZE(prog_type_name)) - jsonw_string_field(json_wtr, "type", - prog_type_name[info->type]); + if (!libbpf_prog_type_to_str(info->type, &ptype_name)) + jsonw_string_field(json_wtr, "type", ptype_name); else jsonw_uint_field(json_wtr, "type", info->type); @@ -270,11 +270,12 @@ static void print_prog_json(struct bpf_prog_info *info, int fd) static void print_prog_plain(struct bpf_prog_info *info, int fd) { + const char *ptype_name; char *memlock; printf("%u: ", info->id); - if (info->type < ARRAY_SIZE(prog_type_name)) - printf("%s ", prog_type_name[info->type]); + if (!libbpf_prog_type_to_str(info->type, &ptype_name)) + printf("%s ", ptype_name); else printf("type %u ", info->type); From patchwork Wed Aug 28 21:03:13 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yulia Kartseva X-Patchwork-Id: 1154881 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=fb.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=fb.com header.i=@fb.com header.b="jkN1S4Dm"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 46JdXd0Rj3z9sDB for ; Thu, 29 Aug 2019 07:04:33 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727021AbfH1VEc (ORCPT ); Wed, 28 Aug 2019 17:04:32 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:39368 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726583AbfH1VEb (ORCPT ); Wed, 28 Aug 2019 17:04:31 -0400 Received: from pps.filterd (m0109333.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7SL0d6h015726 for ; Wed, 28 Aug 2019 14:04:30 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=i/oSHlRUjt3br9XtRGjcR+sgJQT/s8b1f3GoHBUMabs=; b=jkN1S4DmbobYOJiiXdMeBp3WFNsWj95B6Ie9YQtNTjW+n94HW9WdJQh6yFKi0yHvffpR ZAKJht34PUK9RjCfi6uKURdlzWxMo2D2wpvq7V6vvZOAhy1sYeM7OtRTIpqhlUILWrcd V9iJECrQ8UlJ8SNK2KX8OKDe5mB6cVsI8jE= Received: from mail.thefacebook.com (mailout.thefacebook.com [199.201.64.23]) by mx0a-00082601.pphosted.com with ESMTP id 2un3vjr1f3-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Wed, 28 Aug 2019 14:04:30 -0700 Received: from mx-out.facebook.com (2620:10d:c081:10::13) by mail.thefacebook.com (2620:10d:c081:35::128) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA) id 15.1.1713.5; Wed, 28 Aug 2019 14:04:29 -0700 Received: by devvm2868.prn3.facebook.com (Postfix, from userid 125878) id 37F5CA25D6B9; Wed, 28 Aug 2019 14:04:28 -0700 (PDT) Smtp-Origin-Hostprefix: devvm From: Julia Kartseva Smtp-Origin-Hostname: devvm2868.prn3.facebook.com To: , , , , , CC: Julia Kartseva Smtp-Origin-Cluster: prn3c11 Subject: [PATCH bpf-next 10/10] tools/bpftool: use libbpf_attach_type_to_str helper Date: Wed, 28 Aug 2019 14:03:13 -0700 Message-ID: <558d1511b255eb38974162674e7e1687fbedb8b7.1567024943.git.hex@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: X-FB-Internal: Safe MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.70,1.0.8 definitions=2019-08-28_11:2019-08-28,2019-08-28 signatures=0 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 priorityscore=1501 impostorscore=0 clxscore=1015 phishscore=0 mlxlogscore=682 adultscore=0 spamscore=0 mlxscore=0 suspectscore=0 malwarescore=0 bulkscore=0 lowpriorityscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-1906280000 definitions=main-1908280205 X-FB-Internal: deliver Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Replace lookup in `attach_type_strings` with libbpf_attach_type_to_str helper for cgroup (cgroup.c) and non-cgroup (prog.c) attach types. Signed-off-by: Julia Kartseva --- tools/bpf/bpftool/cgroup.c | 60 +++++++++++++++++++++----------------- tools/bpf/bpftool/prog.c | 20 +++++++------ 2 files changed, 45 insertions(+), 35 deletions(-) diff --git a/tools/bpf/bpftool/cgroup.c b/tools/bpf/bpftool/cgroup.c index 1ef45e55039e..1b53218b06e7 100644 --- a/tools/bpf/bpftool/cgroup.c +++ b/tools/bpf/bpftool/cgroup.c @@ -15,6 +15,7 @@ #include #include +#include #include "main.h" @@ -31,35 +32,37 @@ static unsigned int query_flags; -static const char * const attach_type_strings[] = { - [BPF_CGROUP_INET_INGRESS] = "ingress", - [BPF_CGROUP_INET_EGRESS] = "egress", - [BPF_CGROUP_INET_SOCK_CREATE] = "sock_create", - [BPF_CGROUP_SOCK_OPS] = "sock_ops", - [BPF_CGROUP_DEVICE] = "device", - [BPF_CGROUP_INET4_BIND] = "bind4", - [BPF_CGROUP_INET6_BIND] = "bind6", - [BPF_CGROUP_INET4_CONNECT] = "connect4", - [BPF_CGROUP_INET6_CONNECT] = "connect6", - [BPF_CGROUP_INET4_POST_BIND] = "post_bind4", - [BPF_CGROUP_INET6_POST_BIND] = "post_bind6", - [BPF_CGROUP_UDP4_SENDMSG] = "sendmsg4", - [BPF_CGROUP_UDP6_SENDMSG] = "sendmsg6", - [BPF_CGROUP_SYSCTL] = "sysctl", - [BPF_CGROUP_UDP4_RECVMSG] = "recvmsg4", - [BPF_CGROUP_UDP6_RECVMSG] = "recvmsg6", - [BPF_CGROUP_GETSOCKOPT] = "getsockopt", - [BPF_CGROUP_SETSOCKOPT] = "setsockopt", - [__MAX_BPF_ATTACH_TYPE] = NULL, +static const enum bpf_attach_type cgroup_attach_types[] = { + BPF_CGROUP_INET_INGRESS, + BPF_CGROUP_INET_EGRESS, + BPF_CGROUP_INET_SOCK_CREATE, + BPF_CGROUP_SOCK_OPS, + BPF_CGROUP_DEVICE, + BPF_CGROUP_INET4_BIND, + BPF_CGROUP_INET6_BIND, + BPF_CGROUP_INET4_CONNECT, + BPF_CGROUP_INET6_CONNECT, + BPF_CGROUP_INET4_POST_BIND, + BPF_CGROUP_INET6_POST_BIND, + BPF_CGROUP_UDP4_SENDMSG, + BPF_CGROUP_UDP6_SENDMSG, + BPF_CGROUP_SYSCTL, + BPF_CGROUP_UDP4_RECVMSG, + BPF_CGROUP_UDP6_RECVMSG, + BPF_CGROUP_GETSOCKOPT, + BPF_CGROUP_SETSOCKOPT, }; static enum bpf_attach_type parse_attach_type(const char *str) { enum bpf_attach_type type; + const char *atype_str; + unsigned int i; - for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) { - if (attach_type_strings[type] && - is_prefix(str, attach_type_strings[type])) + for (i = 0; i < ARRAY_SIZE(cgroup_attach_types); i++) { + type = cgroup_attach_types[i]; + if (!libbpf_attach_type_to_str(type, &atype_str) && + is_prefix(str, atype_str)) return type; } @@ -120,7 +123,7 @@ static int count_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type) static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type, int level) { - const char *attach_flags_str; + const char *attach_flags_str, *atype_str; __u32 prog_ids[1024] = {0}; __u32 prog_cnt, iter; __u32 attach_flags; @@ -136,6 +139,11 @@ static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type, if (prog_cnt == 0) return 0; + ret = libbpf_attach_type_to_str(type, &atype_str); + + if (ret) + return 0; + switch (attach_flags) { case BPF_F_ALLOW_MULTI: attach_flags_str = "multi"; @@ -152,8 +160,8 @@ static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type, } for (iter = 0; iter < prog_cnt; iter++) - show_bpf_prog(prog_ids[iter], attach_type_strings[type], - attach_flags_str, level); + show_bpf_prog(prog_ids[iter], atype_str, attach_flags_str, + level); return 0; } diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c index 8bbb24339a52..4dfec67e22fa 100644 --- a/tools/bpf/bpftool/prog.c +++ b/tools/bpf/bpftool/prog.c @@ -25,21 +25,23 @@ #include "main.h" #include "xlated_dumper.h" -static const char * const attach_type_strings[] = { - [BPF_SK_SKB_STREAM_PARSER] = "stream_parser", - [BPF_SK_SKB_STREAM_VERDICT] = "stream_verdict", - [BPF_SK_MSG_VERDICT] = "msg_verdict", - [BPF_FLOW_DISSECTOR] = "flow_dissector", - [__MAX_BPF_ATTACH_TYPE] = NULL, +static const enum bpf_attach_type attach_types[] = { + BPF_SK_SKB_STREAM_PARSER, + BPF_SK_SKB_STREAM_VERDICT, + BPF_SK_MSG_VERDICT, + BPF_FLOW_DISSECTOR, }; static enum bpf_attach_type parse_attach_type(const char *str) { enum bpf_attach_type type; + const char *atype_str; + unsigned int i; - for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) { - if (attach_type_strings[type] && - is_prefix(str, attach_type_strings[type])) + for (i = 0; type < ARRAY_SIZE(attach_types); i++) { + type = attach_types[i]; + if (!libbpf_attach_type_to_str(type, &atype_str) && + is_prefix(str, atype_str)) return type; }