From patchwork Fri Jul 20 17:45:45 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947139 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="BdHMXtdf"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="cRii9boM"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJJR1pr2z9s9F for ; Sat, 21 Jul 2018 03:48:07 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388319AbeGTSgB (ORCPT ); Fri, 20 Jul 2018 14:36:01 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38240 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388155AbeGTSgA (ORCPT ); Fri, 20 Jul 2018 14:36:00 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhGR025819; Fri, 20 Jul 2018 10:46:19 -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=0kpv5DP9yxAfrm7uY1eU6H3FoEtW7FyEGUfBeySMrHM=; b=BdHMXtdflpauClUfGq+7lmOZQ+7uGmvSkOCHg629NxUnY9pVT7t/c+eUiXaajeIhnTXZ CmyH8bxbIpB0xfH/2iLr2INPaG4ChTcyUihJJnti4uHK5weFhMx+Hh6S9LRHijlELNgI QLZiATdK4vNR2f2bKGOvtu1uRX/SHG8qs9o= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dh-1 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:19 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.27) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:17 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=0kpv5DP9yxAfrm7uY1eU6H3FoEtW7FyEGUfBeySMrHM=; b=cRii9boML6EgxX6wTtsR0SttOGuIUutYikSeu46+YP2fOgYxRktkaohIdOZ363o9hGK48bfO2y3F6mgLk1xXG5F/WNSmz8IZZ+zr9RSeprVcHXvBh6/97cbqIiVp8RJmWZ7FaWdHTzx3eseKXijPZ3Z40CPh/rgQ0+bS9RKEQeo= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:14 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 01/14] bpf: add ability to charge bpf maps memory dynamically Date: Fri, 20 Jul 2018 10:45:45 -0700 Message-ID: <20180720174558.5829-2-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 31ab01c7-d082-4b7c-e697-08d5ee68b09f X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:+4ZUR1ODusJT8tKVLs+BvJ3V4tRZkJNqEga1hYEl9XUmAciEVe5cmZXqG3Yuq11vtEVKV+I50GDM+M6vFXbxiEj+L3AnZqmDdk1ibxz3LVQAtoyH9l0EpiXc7J/F7MBZq23cKKTTvoSsdEXwbZWPkGR7Is9oiiKXu+71eHJQCZHt/QOJ3JeXn7ldkkcxLNpowS+VroKX9u2e3fBTbp2UQsfhbe41s2p7z2MhxDkFsrSYXmzq9r4AmwJ2+vF05Xx4; 25:umqtOgEtf7IskUd7dl8jaR9jfNcOoAS7bpDTkb8xtV8HgaXb87uD+BYqPZ+uJQrBX02WXZW0y1/xr6JYQG/VRS87sMrbN/dESZ9kClr/Ff2gBy4NxbtZWpTMkGWb3oUWP4StycgbG64Zt598WuWUVCxyjxi+FkdkrxxtIngG1xL5r55wE9OAL8H026XIihzgGiRWDp1uwgATDL8nq5kYVYDHLIhPPvFrGgxoPFRo/1VqLtEDWI5473Vmvgsm42HtIAtmgCN9P4D/lsYgY90MWZ/gcX+3/2bBL0xAhT/UfBq8Zn5oWym9MFY3p6TCZILZhTXIZZ/phV82JI9UfOb9Cw==; 31:e57LqkF8f028Nky01NDncv73XXxtIRmVIbFPhqxU/UWeC13bCYhRTo8UqZadxf5h0LPCRrl1HaUW166QyljlTomlmpspb6YtJGlF5zL7MwNjiQmTRTbE+tNZxjAzNy9Vva0KmZRvqSC7FGn15Q90fXQKkipr6D4CrBjglxeSIt0z/ds+cjO9cKeLJJ0ianyqi7nU0UheRX6xckVzZEQkZj3QkuamSza0yCxQA9msPP0= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:i+dReEkDV/WRp+XNgO3fRwHQWA3rBUWeWCPesaSCR7FroWKFez2xHH2Oj1QfTTEZyqoeOiGpOb8ch7LjM23c+q1Y6oumJv6UF/+p6mUN1yfOkpV7/PqFwVwEp4dqP6jL2bsbIA2rIEZZ5UnHcwv5T8SnhmQm5nSvdFLfXpaug9wKNj431V1wxawUdM+69rRW8BYPcdJNAJAydswkilVNhTMfk3RaBF0ZFBRZnSfZIaHv/d+fCAyOV1uPoMX/GQ4SB8GA1crLzGhODkGYfgF8oe50G0zdkroP72/Sd4kamUF+VJlrkEWko5yi9xMcvjeCjAxocf1M50AiVo52GkilXEg3ErlvB1FwucaIm0Ip9afV1l6ZqR5DOt3D0z6i2ZLmj3BcwlufUlk3cEQRL0MAEM6mhYNxl7tq+ufkQ1zgg9SQP0ms2mtcAELivRIrKWlujb3/W9FCtYp2+eQxX0W8HGnYnZqWXlDPi1U5JE15kCFWvXDziFqVmTCe/kr36eCB; 4:LcE9qyiCfk0USeBZSdv/91R/zosxVSMxhlSVisxxdXToPMk6DJfCIHl9eyhek4uKB+3Ffa1JiLb99Hzb0cyizo3ABesYnGGVu3ajjyEWWSt2lwfZgv7RgfoOQNPXhCJqmS6doPCNP1svNeyBoIrfQ8GUBj6J3GiUY738Wo0vnvASE/7DIuUS1A9f/TH3kPhC7g+SEUryTaySuzMR95SqsDk4LxjNfxGj3Ozkyki7hOTQaqq77Y4+Dsl+PiwSji3EWe0zEyMthmlxS/LjhzADyKvi4WGuFm0ReRey46s/drcTOJ8RRnAokauWf79gpTGyz30qmyrMheUyTyuxrheom4KMMIq2dKmRSOZF7GTsMD4= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(192374486261705)(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:Qz80kxm2SXdUBRSTf+DqQKg3zuLuYyT1SPIjrhHyAuN0RxEUZ++soT3PlQAV8D12g30YAezfo9bdbjCxIWEdTgsaCWqLytd25UP6dMm/z+3lYlc6WW55q5zxjvdMmPxd0mVjypwdV5fz9kDQwzjI3y6w+fLea931syZRbhmnHPfjOG0tDEAb5Zln5otLmPzhagnz2FhQFrM3ZEtlNpCHsm/iQcO6ehJu5mBghYz5xJpVPhGrclPMLPlBXpsJaV4obSe1utVkMkHjUpFV62y3OzqGIbFH2u63TpfPKE9q4mpclU05mFbc8OmvxJhMD9dpSMJpYJCh1XKCfcsZhXJZtMzC++Goim6so/K1NXkFmUgHCJbr+TSnQBgqHZ1FpxLxx+AX6Boh1qX0AL8jTwf931qKNIJaGqHKA2Yu0WTCd2v/l2EKqS5RsOEwrZbNng6wO0Rk8/gesFcmZBaWinKh7ljyW9ZI2+t1vJDznja78ZgGYuJ+dZ3Il2XRLQ5dhdIyALvnQISlxJuEtlc0cT55JmKZSmJndV7txew7h8cbsK/mwELB7Cl7QFY+iFaC5WYlb34l840P359EE8MIIQzOu1jYtYrnQvujHj39Jyyj+PCXhFiaYt44XgroZBc7DuyUEOPLDyOY8lPuWntu+1fNdFQP4dAP6QwFtP7157PQNZoz1JelxBtiuOPb49v168b/Ney8XO7QUeRvWEcKIbI1C4yQD+GABp51P6/joZT6FgY9vrnJewTYOYFW3liI7btNQ+VvmGfu0D9vup/O0mHMk3IJP+bIp6Y5kPylggoCHp7GEsrFOUx31yNh21EFA+8byTVtVRJ14sBweasuEMgrP5b/k6X5wX0XJK3F3JdDL4xllmt6t4HMOLHRBgtaLp5hl6v6Uf5XPP4SxBe3qZTagyaj0jB3UwKamN7HVkeQdwImOU3TaW381jfrI+i3SlKRz5O22Nh09S5M0nv6F5t69j+xY4FM1ZpcjhPlSfgbEULeqIJ2WKqIzzEMJa7UY/yg1Y55BvsCASW/HaHtmL3A64hGCdWJNLlDu4egii1rMGeC6+eIi9trJqQX3oXVu1sFdkrd8GpSrhaNdSOlTEu8XWcCBB8Hy8c7gunUVqZwmHSAPvkK/+aU0PfBs2Epsq3ZhyJsMauEDYdixIZGO6hlsV2R/ZemXSQQAtn2ObMPLiQ8srSMBNBeXE1v+JyrqUa6i6oiNU4ve5likMXRKGKnwqPXHOdkWYPFsCcOgwopOIlBHSUoSss+NRHpyeYPFH6VC0dD9wM91xxV9G6/e9ehTA== X-Microsoft-Antispam-Message-Info: AL88OqUUKeAaYE4vLtdl7H2GBAxSY1OUB16nlPYeKIQmnUHbbmMB47r09i8TEp7jsOSP3ZQ0VoiBiEhwOi/cqn25tynW1gJfH1FXHK7Zpf1EzqD88HbGHj9Ij14re5miYAOv8A/xZ37QlQYAL5fvSBX8l/k0qT949eKqk3E/MCOFiUJs00AWeo9YquMne9PdaF/TVIJpgIaorPmWdDJID9NF/SlQCIniqzysTq9/yUzf0HLlXlLVqNLbOzGM2ZGqFtDMiZiYVhRGPg2p+K6RHTRP977uu954evb1zUJdTsG18ivDo+LyYRVy+mqZXRnYMAS6vyrFSfPgW8HNrSZ1EvKCswROBKuw/jwoxnNvY48= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:oC79nx0xNv9A3eLY17xvX3L0QW9QgxTudNQ0UtQgIZ5t3vYlUQtJeWIBF+lG89XJ/iKVRze72hXHH0UZAUgBTW3t0xKC6QNgCykAs9tnc+GsQK49s6yJHndwZetvf7Z+p/DxBQzeSZmUD4W34+3LzvKvNwUBdMEmAvu3//IKvNvg4bHkSPaDN+ybPasPdyeqgmH6iuINn50s24WFI0gl+Tx42W24tbbZinPn13WmSHPPcXoVsr2XpjDLBW7apcer3ODnBL4nH9NtckZU1f5ArsXmSLVHQyWcAzL3lgKZFpw9AQ6QQKyER3Ue7nYYOBEI7TbRqk0bnjJnhFuoi+5XJPqeVU9Xllfbzoq0qio9CVK9OPhgJ5Tr5xICV9AkI0+gzB0YWdlRsj2Cbcspc/mIgtEoR94M4ayBNlWy5vKKklKTlZNXVwL/O2B0b15GdkkVyqT2zBJxwDFCoD7hVDmWDQ==; 5:4z7nXrOn1A0IpdV2V6wnJzD5ZZ6K4ujjNU+ibChtX9FZG7nMAMFOQ2vGS82z8+BJeNMCzI8prjEnH2T4EXsZh68TAeIWqKXIq9KeWsoW55L9nftB9xlAMPaaXqHk1fGMPcq467KNBgMFnU317C5xaGAxhkXFi98JEeO+Zy9wnAM=; 7:g4D2P7MASDwly1UXXV428WpRcs+w4HABrj8S5d4I0VqVon1LyHP5dyE2QCPRZ0aLeZZzzI8ack0Hz1/fTbzn9BQ8dTZu70qAdY5DNU0dx35oFJXaprDkHLS5ictCNkcC6+/B8iMQptPLOy2EBPRn/N7nxPt5JxxTpbNnRm0KVy78lksgt+qoI/iUAZF1tHhGu2G1QYvmpQQdYlFfa6kZ55vhBV5qUkPdDi/sbRivMdzopjYoMwmbTfslKRNhZcJB SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:cOM9c66sDtQVbaGUjWvXHPZyHF6o+v14uNE8qExP4fugOEHUSoQ6CnzH2eNxTtj79QHLAlt87WFXwpvLao36QbG3GrR/f0YW6PG8MWOGHRXuXnBCVfoIwocG9JN09J9QS7qtJDt7pEgupsviACNltmNax1KPdalh6WYMwdocyuw= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:14.3036 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 31ab01c7-d082-4b7c-e697-08d5ee68b09f X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This commits extends existing bpf maps memory charging API to support dynamic charging/uncharging. This is required to account memory used by maps, if all entries are created dynamically after the map initialization. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf.h | 2 ++ kernel/bpf/syscall.c | 53 +++++++++++++++++++++++++++++++++++++--------------- 2 files changed, 40 insertions(+), 15 deletions(-) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 5b5ad95cf339..5a4a256473c3 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -435,6 +435,8 @@ struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref); void bpf_map_put_with_uref(struct bpf_map *map); void bpf_map_put(struct bpf_map *map); int bpf_map_precharge_memlock(u32 pages); +int bpf_map_charge_memlock(struct bpf_map *map, u32 pages); +void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages); void *bpf_map_area_alloc(size_t size, int numa_node); void bpf_map_area_free(void *base); void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr); diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c index d10ecd78105f..cee452a19538 100644 --- a/kernel/bpf/syscall.c +++ b/kernel/bpf/syscall.c @@ -181,32 +181,55 @@ int bpf_map_precharge_memlock(u32 pages) return 0; } -static int bpf_map_charge_memlock(struct bpf_map *map) +static int bpf_charge_memlock(struct user_struct *user, u32 pages) { - struct user_struct *user = get_current_user(); - unsigned long memlock_limit; + unsigned long memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT; - memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT; + if (atomic_long_add_return(pages, &user->locked_vm) > memlock_limit) { + atomic_long_sub(pages, &user->locked_vm); + return -EPERM; + } + return 0; +} - atomic_long_add(map->pages, &user->locked_vm); +static int bpf_map_init_memlock(struct bpf_map *map) +{ + struct user_struct *user = get_current_user(); + int ret; - if (atomic_long_read(&user->locked_vm) > memlock_limit) { - atomic_long_sub(map->pages, &user->locked_vm); + ret = bpf_charge_memlock(user, map->pages); + if (ret) { free_uid(user); - return -EPERM; + return ret; } map->user = user; - return 0; + return ret; } -static void bpf_map_uncharge_memlock(struct bpf_map *map) +static void bpf_map_release_memlock(struct bpf_map *map) { struct user_struct *user = map->user; - - atomic_long_sub(map->pages, &user->locked_vm); + atomic_long_sub(map->pages, &map->user->locked_vm); free_uid(user); } +int bpf_map_charge_memlock(struct bpf_map *map, u32 pages) +{ + int ret; + + ret = bpf_charge_memlock(map->user, pages); + if (ret) + return ret; + map->pages += pages; + return ret; +} + +void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages) +{ + atomic_long_sub(pages, &map->user->locked_vm); + map->pages -= pages; +} + static int bpf_map_alloc_id(struct bpf_map *map) { int id; @@ -256,7 +279,7 @@ static void bpf_map_free_deferred(struct work_struct *work) { struct bpf_map *map = container_of(work, struct bpf_map, work); - bpf_map_uncharge_memlock(map); + bpf_map_release_memlock(map); security_bpf_map_free(map); /* implementation dependent freeing */ map->ops->map_free(map); @@ -492,7 +515,7 @@ static int map_create(union bpf_attr *attr) if (err) goto free_map_nouncharge; - err = bpf_map_charge_memlock(map); + err = bpf_map_init_memlock(map); if (err) goto free_map_sec; @@ -515,7 +538,7 @@ static int map_create(union bpf_attr *attr) return err; free_map: - bpf_map_uncharge_memlock(map); + bpf_map_release_memlock(map); free_map_sec: security_bpf_map_free(map); free_map_nouncharge: From patchwork Fri Jul 20 17:45:46 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947138 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="SYsYSJbw"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="CQuARcHt"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJJ83NS0z9s9F for ; Sat, 21 Jul 2018 03:47:52 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388526AbeGTShF (ORCPT ); Fri, 20 Jul 2018 14:37:05 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38242 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388126AbeGTSgC (ORCPT ); Fri, 20 Jul 2018 14:36:02 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhGT025819; Fri, 20 Jul 2018 10:46: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=8NLCIWV9StwuXUEJ8T6cx3ZSKB/bXi1rvW79EoOIJK8=; b=SYsYSJbwR+YEJuUNuvsrI27aYMCBekG7foQFnSFQzBhkJl+7UXf6JnxMpvTqRfOva0bT MqHo8Hk+2Hx0t3U8LshJw2rvCrPFOJzXJiqbpoO3ARytW9KhAOMSboEYBR1bIfkglL+V PrlCckpicidfotl57GxUUBiXOo7FfggRUCM= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dh-3 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:20 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.27) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:18 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=8NLCIWV9StwuXUEJ8T6cx3ZSKB/bXi1rvW79EoOIJK8=; b=CQuARcHt/ITh5QSLnRGcCmOEUn8tBBA6siXfXrLvpXcfTyWysyDcc+Cv/n7Sl4mfvYZDWMG5nL+7jMH5WRbiEjEW6J5UB+VuXpB3vyhgy6zNVDwcwiNgOPuFhpeQNPyl3ErZM80ac/Ajoic7kFgwLzDrTAhpbYRGrlHg32/fsiY= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:15 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 02/14] bpf: introduce cgroup storage maps Date: Fri, 20 Jul 2018 10:45:46 -0700 Message-ID: <20180720174558.5829-3-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 9bc31e68-116c-4155-53bd-08d5ee68b14a X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:jpd8Pakc26AIvOaSfDI7bSeHIbCWuc4DoCcTYuN2TDXBusIqpVGQQSDmTNgYWVOL3ZUfuUbwJ9mqYQ+4iY+wYBGXSNGyhhZnLKYf1IOE6qkuLHLFj/sGjuW9fsQtjBryhxIEhMDuYB60qDs1pi2hPKJt3zcItXI0D/2zbqYvtYEc8msEHFKL55BYCPjMehpVt3/ICMvWVUh3uRKalRjOlH0P0BB0//yf350EkOizMcp6ajJe6SP3DWb6j+0ydJjB; 25:T29jSHt1NOo9NmM3N4ZsKZRn8jedJKDHbgP1NlhPNTERj2hn2UeEBaSK0Mh7CjfZcDwOBWc24/p1XcXyxfocmNKgVRAwApGEYK55/9lPzl4x43YwebCZGUqpWuRE3AFG7F1J945HGL/v8n2sVnVb+KuOSg30y65Z2sl01kf56Ba7M1QYUOoOXJm8idd87Kml4WkzzJk64mimIH7SPQLsI+OPgVMyy4MERsbN3084ECIq4RxZqJyuS1qv1GTxCyYW4CNf2jiNzJX97ZS2V2Nq+KFeOoNDaWenOeP/JiSPIYyB8bU9FMNLbiAvuDwbl8nSMTZ8bMQXJNaYitKv8K3g4w==; 31:22AC/i9m9OFndGmCz2aUA1tsGlSTQWKxdseI70ogT9zyt857LlUCcDSBTgAQACn3EsgZkPUea2LwsRqv4VM9OkPOQZkNBOwpRATlQ7/gpF5CGc66isbrImOXts00PcW2vwed/8tvSPmDF0kDpIDPf7iFFLjuzyT/OMOdzwX5GhLBVpJotP2oGNz/7D7rRfzhAUWPca2FQJHAR/tKXX1eBhuyS5rwLZpIwb5xeHL1iKU= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:mwtXGHIrOS/KI2n9GIPsFUTaXDGw5iNYcsnUlNHUAOcgLuR95VNswkj2spE1+9QuyfobS8pJUOTgEQj3tU5VSaTq2k48g12ynijVSLaaKuKgUZ0xxD7UrriQw9BB4vHAU6U7f1UxgPJn9Ws78pBJmwdO4cK20thCjnINuQkHitQepSl07/GoGlWx3iVcSbi96dknfpx2Qmz23L/G/Hbb3BOwiIjFk/HafTEO4A0bAd5k8SwV4GbiHdrgYgI/Mx9OyqXOiJkGHC0Ub4FbkGGaqMUKzd2p7KFPGx5hJMKmHScsYIGLjT9aWYPNEMuS3cQ/pQPJPPEPPR3PMPgnNCh8JXiRUB2Ya9V95RKDPJqCkrVrFsY1W4/vRNtkmpe0172nUExX7pcdkYo52dWG/ZIrhu4ASfqr9VRqzzh96NTknqO4Sqp4dtdo102GaqzZ9izdasjbcVU3Zc3GZ9AZeMauXQPSmedEstSLE023cYP433NbP9CyjQm9GE/rXP3C3vNe; 4:eGOvMOTjqBTzkoDE6ad1FQGqeTqBp/QPYy8biSxoNBiiiZtjUJEUlE41vxWGGVuRoGG5JuwY10gpjcC6DTVzbCV19uVzD7hUsZek9Bzz8tHZg4MnNxjltMOsL1wADWP5IsIDe2EobgAY0+BliZKKmseUPCVIJsJR2asjDSoY/MZPTLBX0HxMspuvqHsUdgqhY1AulyP02zQfBMed0dXfjyiTCrnEUoNMEdJjscqOm3+zejnhp3D3IGIviG58Ovg73UMJAu11HGT/a2nSH6C/KBzL/E3MJ4CEVOK4LnpUqXdkVTMLXNZNd5VbNj6+BTs+eSt5SeThuTFEWN481E6ZvdfOGXW+nds9j/bqF4o3ONg= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(788757137089)(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(575784001)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:diKC1VUCafO5q6PUtDWHqZilwxDAEiaaxnhHHO5EfFouXMWfJLCsFXTJUfRcUWYx8rBPtaws5SZJ2v3X2Be3ryqQNcPrSg9oZRCwvhGdNTTniv8Oh61LxmpzzUwNp8MBzvwJ50/h7/VbSULQv58qDHiGjWYXzGVoVsfBsoC6oiChrcQA58xh9kPztm+wLcqwnBCqQkABMaCU5/V9aFF5UsSz2/DjVisNZiDgNkgGUJLSnLF4ZX/xRfgXt+5CO2NAf/tvpl052Q3FuOJZZVrYlzcce0UtclIXP+ATj0Q7HJ+nh9Ck30OBEmSLvgwDFfMzvnpN2km69G9QZdnqzF86Zeah44ZR+AMdCLYN6xvPLQ/wzjfBAZEHW5j7CnYhjrN85/zrd/gkH+D++ocQMYwmL60WfkEkXP5vMxANJ/lk+UxDE4SGNoP2cmETkaCpvrD9+kltYOOPKyAPIYzAE6lMPnTbNkk7aU03RGg+SzY1QL1Igfi2d/617QWV9aPeAFykqm5dKEKIiRNZvW6jJ++OzbLsU8HDyGYV2oEgC4Yfssp3gUF3tXH4pWSlhkaumA6K4O34WXp7CsiaCCfZW8uXOcIcMysHrKTyiAhjFujxFIfRso9DNuPN+agyvMqR43O8d20CwJtaWqptOrDwruL9CTWUK1SK/QBsFl3jFFGOvwu6IdfQxavz/0tXorFDIUY7SLGIrlK5OeQ7yePxMFMqYmlQONaS4OEtfbhSnDh5/gzfEiMbitVxps1ae4vYK+SYJ3EwpxVVUeMmFzilJUQtrd2fB5GvdOJVB7buPWDYXiFzuhs7o1SmeEFAZzGYzXKbQg4ME79/h3wNN5RlU1o/hKNfM62hsAhezskXOu3XAM8vmim6XEl3Z3KbdwfbR8bTLrmjZilTAZVZe36GUMcInEKelHJAEAq40rqgUQ3yCGs8cykZGym1oA4weiwIL8hwvxeLxqrfFFR5rn7rfpNS2Y1C1Q0MkC8RL6NePGosJB8bKTaj7kEsjy8yftphkNucL5ls83fNK3p21KLlPz6JTp8Eq6Wq7qibLxUpAAgh3zVI2TBCNczT0yUgGo0xeMROPDuYR5rxdo6sxRRfCY6YIClR/9qR+z9BukNU2l3nerXNAlsEzyWD37/o6h9NJk57sIbp9u3OotYD3YdoERXz9KLizKor2jBDr3qqiccH9GRL3Agq/ux++K6dXw1LPDnPs0yKq9rVl3eoD2Oge5S7S49FRyAoQK7MXC0nGvMiBW11Bw5F1RRyaj0zYwSnjpN1nNwRl8+a3gPdy6iIXqUmOpNs0OAdSYHi7IP5OTk4PDOWIJQ/qaliJeEUacSPAR8o X-Microsoft-Antispam-Message-Info: 1PeRJqdWMbYts7v5KE/51xR5MyXnnjN/AhYPS8jRfmHbFjAs/11Sv6cF+OiNKM1fgYakeK6AxsVDn9DXZwr7JZfMUV7wlS3b2EdqqiNMQ+jr+Aq1uDuP/d6gveSdXwkws1t3S8wQte3gEuALdJpELp0X5bzfzZ2ZfWsLWz/DEdjgoFG4K31CPCzH83LkCuWcCt0zXiLWjSFr68BNa/qDDML1yRRMihLGvAkjUg4mNPwWw73hjOa095kN9sEotrP0qmwjv6SdlMbeH8O/zdR3mqAab9uh7p49IQe22JNHJo6KnGAcrRqAKvxsLqDOQJQco8dzBuv1sHz1PPK8hepsdxmZ3Tj8Knr6JWcY20Uk5e8= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:8J4u1L0FWWtBoO5YZKV8P1jhdS6Eun2wqyuP8aYi03yLABdz/6HwEMgMtyCF5aZnENdYwDDa5+MIRZ0Zr/gx1sbzJRI5jA3ETjaS/tRiXLNt9Asr3skq3/PHmEcO80EYGzUGYrAtK08SwPQzPjI1fHR8SFxMTSZFKXNrHjTApZQixawtrKTYEmucJiXP/KkWZV9m6f3LIpLcwxIstqpHtHenAs2MTYyWWqQrsNDXUWR7moKQuAsAJF7nSxJTGfXi8BetvSxXtarTGgvfH+XYGMOqnfNOPCLvgPr3kZq9KHE2MZvMC+EKGFfcWHsLJxuTd4ycVifmxkDzcxCtLL//WiQ83aC8TX6dqmROmkGcHkTWqL/QUmAj0WsS4/V/BIKJjxdiRRJDltIGu6r/TojVGfq5QLUX7tjOC/P2A/5PGqucq2iZR6O4Bsh4Az+PLc7CH+28/RJa11RQAqiYW/Nw1w==; 5:wdJpua/Ylcx1r/vTKd4Ra/Vf2nUs9mjKlrs+a107vN2G792Yu+roaeYlENaSQCrZLrd7NgdYbP96cSVIqoXOV14I3NVfXsfYfXWvR5t2lcX2EmLsXYM9UKeVlvy3FkY9ua+5gQaQo4TvhCCTz1MJzhPP8yGTwRuD9CTci8sARAQ=; 7:Q9p+DT6BVQu/57d6gWPsnxwexHdk+y13Y/53y0dgqBfNP3/k/qZ9drX0J+8zo9LJJKWf4Z8BEsfNCjjALNgBTjcHV1IboTAFKfcUuXSTXHNmIErIJoU7yVC3uPZSOeQSZ8x9RO8oh1nwqWUuiErqs5XK/TLQkomAKg6msPnqfIEBKl9HuVYq+A2EgkFMmklX8miIJj20t3vcj+Nxzqhw7MqGYeLRyrGIZnRP+ruxFBrQiHlDCs3YaKLR8o2UB6nL SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:StTqo0lhxZ8BQPpdGCAT7FiEH07lU4FQOhQdIEMumwXX9Y7erXS8eDOYFy7UTp+a3E1el3FbtWfMVsmzZtCVG5fVMDCA8/1hNxNC5VjFflNQmBs75MmkCJyprLeMr22vbnk/RJEM/G167VyDSIRRujYtc7zBv4MAxedu/OYQ/AI= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:15.4205 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 9bc31e68-116c-4155-53bd-08d5ee68b14a X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This commit introduces BPF_MAP_TYPE_CGROUP_STORAGE maps: a special type of maps which are implementing the cgroup storage. From the userspace point of view it's almost a generic hash map with the (cgroup inode id, attachment type) pair used as a key. The only difference is that some operations are restricted: 1) a user can't create new entries, 2) a user can't remove existing entries. The lookup from userspace is o(log(n)). Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf-cgroup.h | 38 +++++ include/linux/bpf.h | 1 + include/linux/bpf_types.h | 3 + include/uapi/linux/bpf.h | 6 + kernel/bpf/Makefile | 1 + kernel/bpf/local_storage.c | 367 +++++++++++++++++++++++++++++++++++++++++++++ kernel/bpf/verifier.c | 12 ++ 7 files changed, 428 insertions(+) create mode 100644 kernel/bpf/local_storage.c diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h index 79795c5fa7c3..6b0e7bd4b154 100644 --- a/include/linux/bpf-cgroup.h +++ b/include/linux/bpf-cgroup.h @@ -3,19 +3,39 @@ #define _BPF_CGROUP_H #include +#include #include struct sock; struct sockaddr; struct cgroup; struct sk_buff; +struct bpf_map; +struct bpf_prog; struct bpf_sock_ops_kern; +struct bpf_cgroup_storage; #ifdef CONFIG_CGROUP_BPF extern struct static_key_false cgroup_bpf_enabled_key; #define cgroup_bpf_enabled static_branch_unlikely(&cgroup_bpf_enabled_key) +struct bpf_cgroup_storage_map; + +struct bpf_storage_buffer { + struct rcu_head rcu; + char data[0]; +}; + +struct bpf_cgroup_storage { + struct bpf_storage_buffer *buf; + struct bpf_cgroup_storage_map *map; + struct bpf_cgroup_storage_key key; + struct list_head list; + struct rb_node node; + struct rcu_head rcu; +}; + struct bpf_prog_list { struct list_head node; struct bpf_prog *prog; @@ -76,6 +96,15 @@ int __cgroup_bpf_run_filter_sock_ops(struct sock *sk, int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor, short access, enum bpf_attach_type type); +struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog); +void bpf_cgroup_storage_free(struct bpf_cgroup_storage *storage); +void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage, + struct cgroup *cgroup, + enum bpf_attach_type type); +void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage); +int bpf_cgroup_storage_assign(struct bpf_prog *prog, struct bpf_map *map); +void bpf_cgroup_storage_release(struct bpf_prog *prog, struct bpf_map *map); + /* Wrappers for __cgroup_bpf_run_filter_skb() guarded by cgroup_bpf_enabled. */ #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb) \ ({ \ @@ -220,6 +249,15 @@ static inline int cgroup_bpf_prog_query(const union bpf_attr *attr, return -EINVAL; } +static inline int bpf_cgroup_storage_assign(struct bpf_prog *prog, + struct bpf_map *map) { return 0; } +static inline void bpf_cgroup_storage_release(struct bpf_prog *prog, + struct bpf_map *map) {} +static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc( + struct bpf_prog *prog) { return 0; } +static inline void bpf_cgroup_storage_free( + struct bpf_cgroup_storage *storage) {} + #define cgroup_bpf_enabled (0) #define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0) #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; }) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 5a4a256473c3..9d1e4727495e 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -282,6 +282,7 @@ struct bpf_prog_aux { struct bpf_prog *prog; struct user_struct *user; u64 load_time; /* ns since boottime */ + struct bpf_map *cgroup_storage; char name[BPF_OBJ_NAME_LEN]; #ifdef CONFIG_SECURITY void *security; diff --git a/include/linux/bpf_types.h b/include/linux/bpf_types.h index c5700c2d5549..add08be53b6f 100644 --- a/include/linux/bpf_types.h +++ b/include/linux/bpf_types.h @@ -37,6 +37,9 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_PERF_EVENT_ARRAY, perf_event_array_map_ops) #ifdef CONFIG_CGROUPS BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_ARRAY, cgroup_array_map_ops) #endif +#ifdef CONFIG_CGROUP_BPF +BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_STORAGE, cgroup_storage_map_ops) +#endif BPF_MAP_TYPE(BPF_MAP_TYPE_HASH, htab_map_ops) BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_HASH, htab_percpu_map_ops) BPF_MAP_TYPE(BPF_MAP_TYPE_LRU_HASH, htab_lru_map_ops) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 870113916cac..a0aa53148763 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -75,6 +75,11 @@ struct bpf_lpm_trie_key { __u8 data[0]; /* Arbitrary size */ }; +struct bpf_cgroup_storage_key { + __u64 cgroup_inode_id; /* cgroup inode id */ + __u32 attach_type; /* program attach type */ +}; + /* BPF syscall commands, see bpf(2) man-page for details. */ enum bpf_cmd { BPF_MAP_CREATE, @@ -120,6 +125,7 @@ enum bpf_map_type { BPF_MAP_TYPE_CPUMAP, BPF_MAP_TYPE_XSKMAP, BPF_MAP_TYPE_SOCKHASH, + BPF_MAP_TYPE_CGROUP_STORAGE, }; enum bpf_prog_type { diff --git a/kernel/bpf/Makefile b/kernel/bpf/Makefile index f27f5496d6fe..e8906cbad81f 100644 --- a/kernel/bpf/Makefile +++ b/kernel/bpf/Makefile @@ -3,6 +3,7 @@ obj-y := core.o obj-$(CONFIG_BPF_SYSCALL) += syscall.o verifier.o inode.o helpers.o tnum.o obj-$(CONFIG_BPF_SYSCALL) += hashtab.o arraymap.o percpu_freelist.o bpf_lru_list.o lpm_trie.o map_in_map.o +obj-$(CONFIG_BPF_SYSCALL) += local_storage.o obj-$(CONFIG_BPF_SYSCALL) += disasm.o obj-$(CONFIG_BPF_SYSCALL) += btf.o ifeq ($(CONFIG_NET),y) diff --git a/kernel/bpf/local_storage.c b/kernel/bpf/local_storage.c new file mode 100644 index 000000000000..940889eda2c7 --- /dev/null +++ b/kernel/bpf/local_storage.c @@ -0,0 +1,367 @@ +//SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include +#include + +#ifdef CONFIG_CGROUP_BPF + +struct bpf_cgroup_storage_map { + struct bpf_map map; + struct bpf_prog *prog; + + spinlock_t lock; + struct rb_root root; + struct list_head list; +}; + +static struct bpf_cgroup_storage_map *map_to_storage(struct bpf_map *map) +{ + return container_of(map, struct bpf_cgroup_storage_map, map); +} + +static int bpf_cgroup_storage_key_cmp( + const struct bpf_cgroup_storage_key *key1, + const struct bpf_cgroup_storage_key *key2) +{ + if (key1->cgroup_inode_id < key2->cgroup_inode_id) + return -1; + else if (key1->cgroup_inode_id > key2->cgroup_inode_id) + return 1; + else if (key1->attach_type < key2->attach_type) + return -1; + else if (key1->attach_type > key2->attach_type) + return 1; + return 0; +} + +static struct bpf_cgroup_storage *cgroup_storage_lookup( + struct bpf_cgroup_storage_map *map, struct bpf_cgroup_storage_key *key, + bool locked) +{ + struct rb_root *root = &map->root; + struct rb_node *node; + + /* + * This lock protects rbtree and list of storage entries, + * which are used from the syscall context only. + * So, simple spin_lock()/unlock() is fine here. + */ + if (!locked) + spin_lock(&map->lock); + + node = root->rb_node; + while (node) { + struct bpf_cgroup_storage *storage; + + storage = container_of(node, struct bpf_cgroup_storage, node); + + switch (bpf_cgroup_storage_key_cmp(key, &storage->key)) { + case -1: + node = node->rb_left; + break; + case 1: + node = node->rb_right; + break; + default: + if (!locked) + spin_unlock(&map->lock); + return storage; + } + } + + if (!locked) + spin_unlock(&map->lock); + + return NULL; +} + +static int cgroup_storage_insert(struct bpf_cgroup_storage_map *map, + struct bpf_cgroup_storage *storage) +{ + struct rb_root *root = &map->root; + struct rb_node **new = &(root->rb_node), *parent = NULL; + + while (*new) { + struct bpf_cgroup_storage *this; + + this = container_of(*new, struct bpf_cgroup_storage, node); + + parent = *new; + switch (bpf_cgroup_storage_key_cmp(&storage->key, &this->key)) { + case -1: + new = &((*new)->rb_left); + break; + case 1: + new = &((*new)->rb_right); + break; + default: + return -EEXIST; + } + } + + rb_link_node(&storage->node, parent, new); + rb_insert_color(&storage->node, root); + + return 0; +} + +static void *cgroup_storage_lookup_elem(struct bpf_map *_map, void *_key) +{ + struct bpf_cgroup_storage_map *map = map_to_storage(_map); + struct bpf_cgroup_storage_key *key = _key; + struct bpf_cgroup_storage *storage; + + storage = cgroup_storage_lookup(map, key, false); + if (!storage) + return NULL; + + return &READ_ONCE(storage->buf)->data[0]; +} + +static int cgroup_storage_update_elem(struct bpf_map *map, void *_key, + void *value, u64 flags) +{ + struct bpf_cgroup_storage_key *key = _key; + struct bpf_cgroup_storage *storage; + struct bpf_storage_buffer *new; + + if (flags & BPF_NOEXIST) + return -EINVAL; + + storage = cgroup_storage_lookup((struct bpf_cgroup_storage_map *)map, + key, false); + if (!storage) + return -ENOENT; + + new = kmalloc_node(sizeof(struct bpf_storage_buffer) + + map->value_size, __GFP_ZERO | GFP_USER, + map->numa_node); + if (!new) + return -ENOMEM; + + memcpy(&new->data[0], value, map->value_size); + + new = xchg(&storage->buf, new); + kfree_rcu(new, rcu); + + return 0; +} + +static int cgroup_storage_get_next_key(struct bpf_map *_map, void *_key, + void *_next_key) +{ + struct bpf_cgroup_storage_map *map = map_to_storage(_map); + struct bpf_cgroup_storage_key *key = _key; + struct bpf_cgroup_storage_key *next = _next_key; + struct bpf_cgroup_storage *storage; + + spin_lock(&map->lock); + + if (list_empty(&map->list)) + goto enoent; + + if (key) { + storage = cgroup_storage_lookup(map, key, true); + if (!storage) + goto enoent; + + storage = list_next_entry(storage, list); + if (!storage) + goto enoent; + } else { + storage = list_first_entry(&map->list, + struct bpf_cgroup_storage, list); + } + + spin_unlock(&map->lock); + next->attach_type = storage->key.attach_type; + next->cgroup_inode_id = storage->key.cgroup_inode_id; + return 0; + +enoent: + spin_unlock(&map->lock); + return -ENOENT; +} + +static struct bpf_map *cgroup_storage_map_alloc(union bpf_attr *attr) +{ + int numa_node = bpf_map_attr_numa_node(attr); + struct bpf_cgroup_storage_map *map; + + if (attr->key_size != sizeof(struct bpf_cgroup_storage_key)) + return ERR_PTR(-EINVAL); + + if (attr->value_size > PAGE_SIZE) + return ERR_PTR(-E2BIG); + + map = kmalloc_node(sizeof(struct bpf_cgroup_storage_map), + __GFP_ZERO | GFP_USER, numa_node); + if (!map) + return ERR_PTR(-ENOMEM); + + map->map.pages = round_up(sizeof(struct bpf_cgroup_storage_map), + PAGE_SIZE) >> PAGE_SHIFT; + + /* copy mandatory map attributes */ + bpf_map_init_from_attr(&map->map, attr); + + spin_lock_init(&map->lock); + map->root = RB_ROOT; + INIT_LIST_HEAD(&map->list); + + return &map->map; +} + +static void cgroup_storage_map_free(struct bpf_map *_map) +{ + struct bpf_cgroup_storage_map *map = map_to_storage(_map); + + WARN_ON(!RB_EMPTY_ROOT(&map->root)); + WARN_ON(!list_empty(&map->list)); + + kfree(map); +} + +static int cgroup_storage_delete_elem(struct bpf_map *map, void *key) +{ + return -EINVAL; +} + +const struct bpf_map_ops cgroup_storage_map_ops = { + .map_alloc = cgroup_storage_map_alloc, + .map_free = cgroup_storage_map_free, + .map_get_next_key = cgroup_storage_get_next_key, + .map_lookup_elem = cgroup_storage_lookup_elem, + .map_update_elem = cgroup_storage_update_elem, + .map_delete_elem = cgroup_storage_delete_elem, +}; + +/* + * Called by the verifier. bpf_verifier_lock must be locked. + */ +int bpf_cgroup_storage_assign(struct bpf_prog *prog, struct bpf_map *_map) +{ + struct bpf_cgroup_storage_map *map = map_to_storage(_map); + + if (map->prog && map->prog != prog) + return -EBUSY; + if (prog->aux->cgroup_storage && prog->aux->cgroup_storage != _map) + return -EBUSY; + + map->prog = prog; + prog->aux->cgroup_storage = _map; + + return 0; +} + +/* + * Called by the verifier. bpf_verifier_lock must be locked. + */ +void bpf_cgroup_storage_release(struct bpf_prog *prog, struct bpf_map *_map) +{ + struct bpf_cgroup_storage_map *map = map_to_storage(_map); + + if (map->prog == prog) { + WARN_ON(prog->aux->cgroup_storage != _map); + map->prog = NULL; + } +} + +struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog) +{ + struct bpf_cgroup_storage *storage; + struct bpf_map *map; + u32 pages; + + map = prog->aux->cgroup_storage; + if (!map) + return NULL; + + pages = round_up(sizeof(struct bpf_cgroup_storage) + + sizeof(struct bpf_storage_buffer) + + map->value_size, PAGE_SIZE) >> PAGE_SHIFT; + if (bpf_map_charge_memlock(map, pages)) + return ERR_PTR(-EPERM); + + storage = kmalloc_node(sizeof(struct bpf_cgroup_storage), + __GFP_ZERO | GFP_USER, map->numa_node); + if (!storage) { + bpf_map_uncharge_memlock(map, pages); + return ERR_PTR(-ENOMEM); + } + + storage->buf = kmalloc_node(sizeof(struct bpf_storage_buffer) + + map->value_size, __GFP_ZERO | GFP_USER, + map->numa_node); + if (!storage->buf) { + bpf_map_uncharge_memlock(map, pages); + kfree(storage); + return ERR_PTR(-ENOMEM); + } + + storage->map = (struct bpf_cgroup_storage_map *)map; + + return storage; +} + +void bpf_cgroup_storage_free(struct bpf_cgroup_storage *storage) +{ + u32 pages; + struct bpf_map *map; + + if (!storage) + return; + + map = &storage->map->map; + pages = round_up(sizeof(struct bpf_cgroup_storage) + + sizeof(struct bpf_storage_buffer) + + map->value_size, PAGE_SIZE) >> PAGE_SHIFT; + bpf_map_uncharge_memlock(map, pages); + + kfree_rcu(storage->buf, rcu); + kfree_rcu(storage, rcu); +} + +void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage, + struct cgroup *cgroup, + enum bpf_attach_type type) +{ + struct bpf_cgroup_storage_map *map; + + if (!storage) + return; + + storage->key.attach_type = type; + storage->key.cgroup_inode_id = cgroup->kn->id.id; + + map = storage->map; + + spin_lock(&map->lock); + WARN_ON(cgroup_storage_insert(map, storage)); + list_add(&storage->list, &map->list); + spin_unlock(&map->lock); +} + +void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage) +{ + struct bpf_cgroup_storage_map *map; + struct rb_root *root; + + if (!storage) + return; + + map = storage->map; + + spin_lock(&map->lock); + root = &map->root; + rb_erase(&storage->node, root); + + list_del(&storage->list); + spin_unlock(&map->lock); +} + +#endif diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 15d69b278277..0b089ba4595d 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -5140,6 +5140,14 @@ static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) return -E2BIG; } + if (map->map_type == BPF_MAP_TYPE_CGROUP_STORAGE && + bpf_cgroup_storage_assign(env->prog, map)) { + verbose(env, + "only one cgroup storage is allowed\n"); + fdput(f); + return -EBUSY; + } + /* hold the map. If the program is rejected by verifier, * the map will be released by release_maps() or it * will be used by the valid program until it's unloaded @@ -5148,6 +5156,10 @@ static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) map = bpf_map_inc(map, false); if (IS_ERR(map)) { fdput(f); + if (map->map_type == + BPF_MAP_TYPE_CGROUP_STORAGE) + bpf_cgroup_storage_release(env->prog, + map); return PTR_ERR(map); } env->used_maps[env->used_map_cnt++] = map; From patchwork Fri Jul 20 17:45:47 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947144 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="LAVNgOzJ"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="IwWt80Ns"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJKc47lhz9s9G for ; Sat, 21 Jul 2018 03:49:08 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388516AbeGTSiZ (ORCPT ); Fri, 20 Jul 2018 14:38:25 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:33110 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S2388126AbeGTSiZ (ORCPT ); Fri, 20 Jul 2018 14:38:25 -0400 Received: from pps.filterd (m0089730.ppops.net [127.0.0.1]) by m0089730.ppops.net (8.16.0.22/8.16.0.22) with SMTP id w6KHiNbI006915; Fri, 20 Jul 2018 10:48:43 -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=4Y2yU/4yD3i5oNYcl/ut9DlMjS9+srPiVmiDH/K7ZZk=; b=LAVNgOzJaTCxx0bbgVZ3n5zc1r/N+29mxcxQvCZ+Zjesu4UXAJ/jDIA8Jv/PFUTP9QcK MmGn2RlMolh16ShsjoObOnM5TD4ZuTWfbiA5An/I4OHCw02ECq0wevu9nVQHzvTXFiyd 54C7+Fm/Ybva2vTHLSBzP0UtrAlOF3RcXQc= Received: from mail.thefacebook.com ([199.201.64.23]) by m0089730.ppops.net with ESMTP id 2kbk20rbfb-4 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:48:43 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.54.28) by o365-in.thefacebook.com (192.168.16.11) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 10:46:37 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=4Y2yU/4yD3i5oNYcl/ut9DlMjS9+srPiVmiDH/K7ZZk=; b=IwWt80NszDTkPg0doGYm4NffRXFNnD67yoNesYbhTf2R66Grw7xlq8PoUF7udLON+jsYi8mtIATEXexs5QC4IfsWVuXuavKIwOHvBX+UNhc9aqLsITLsKxYlCTO1auxOVhHJNWZZsaW9QzI0ANhxaTwrILsdl+pgpBIUhDnV1xE= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:16 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 03/14] bpf: pass a pointer to a cgroup storage using pcpu variable Date: Fri, 20 Jul 2018 10:45:47 -0700 Message-ID: <20180720174558.5829-4-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 600f0b2c-af7c-4965-7905-08d5ee68b1fb X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:rfK5K2RHRZYqn0+CoUD2q0y3RZr5W0KY0E8MtvauI/6iUH4NOngTz37Ua2uXGLbER3k4pdTPhTJyuw+5sOaePRKEoj2X1sea7f+h6eEVSjBjd/HlzD++JFhoXnmVh4GaDeKYjANkAf9CXQXAAAVgafMIA4ss1U0/4EIW6tRf7zONflox6I+rArsd+G7JtMeVwwM/HjUWTb2TMm70BvN+dLhi27prcVhyoKqRQplF1wADBr9WARYIZWB0LiIxoeXr; 25:IVNjJTYlwlqDv1NadqFd7+pX4JXrocx2JLdK2MZhU+2LaI4uBzgJpeIzmCIEfXTeqzjLz3+eYkxPS8n9nONZXb/3fa0MKX8r1bbnqZ1Jt4Cf+U2k80c+lbCzykgGeFzRZByq11+Ey2sUWPYEUzEC8Soq/pyxgvgfv0iGJLALtWyI1TJu0odVwy+6fis/mDE71p0E+jPSAVl7iP0KN5k2NOV90vh6urDqQR54sWgBz8L5dOENIJ38bF9KQHP2Zwm5wIhFzhFrX05W6fKvGrdiwDV6HdfgPWNC/WZIJ1smHPZFIzVEjxnUlq6NeTr1HJjU+6XDG3n1CX+ob4jb7Jm15w==; 31:yFS9Ell4mgPdDJINpBc+nU+uoOR8PPswLJw+7hrNvf5GNdrKA2xklk72tOnTdBxe7DeEpQIwG+nxhsUNw0H2oKvFe7jgLzul+pNEF2gUAHGWAYfq2Qiupm4iEzNQVoFeemmfrulUuh7stky4TqtGJzF/0xunLMhYrw52+IGCHom0DlbWF+vuZG8zVA9DLtkCJ0nA2vjSl5oISMZz5HxVNtd7f/234BUNUV6Wnx5EjC0= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:xobZdQdZCpHcFdQhhLOAeVXVFtcZMRAMEjgsnvVofBQn1Lfjkir08C5rY3jg49Nqyngs9odvY0hxz3A0n7QOYzQrlel7dGr4P4SN5+knZouXN61XTN74Du6irpAuAwvs8KkLuqIfm6CzNh/KJxWkaRZ5uhh3xyNZ8gNGHucNmNPDAwFsIiatTTeAK1uAuj8nxxuFjBiZoHIqUk/9pguCu4G8vvoaDfUEf6AAACxw8hfjIRRqZyHurlGcK+IEuz42gAVnVko7KwIs842DW2n5cyrfRNXqiZ5dbJY93i4BSkuakyR5ZX0+ImnIivU2owVdLlAzR2sa+leigA0SB9dhsrpRIi4LY2LsBSyjw2gJGKFUW4bfNhEPjX68qA7p09Xa9MapkxyEg8HEc1tOX/gslgVx6qWoQNqBJeVWkF6gwA76LMoxn1dDd/6BWVU6wWwW0G7GmdCXwWcXKEduSH0yfrwslrULeAj0JxgMK5XCFMslxu23a5+2sIzACTKnj7+r; 4:4G1XCFlGT7e8HgHy2aDFUgl53LQx3yQayB90RbB0nonrqhxwwQ1Nwl3HnZwJlaHzHL+MsFjUQjMzWRPuof/pNq+cZbMIYKN0AM3N4JtzKcIAeDRbQ+cMf1NPaJUb4GPXWVK/kLhv+H7x/fkF1Q4vaKOw7zpxr90T4NpHTrmZFv5NvOgKDokzyk68WF8yYSDRCjimjT+zBmJn9l3H40AozQEtlejV9FrepESO8MU1Hb0oXck/Y1lCKw85iqnEPAYrdpbuHOxCLua4eB2nDI81xgsDl5X12Aar870qqgQEaW/mmcW9yf4g04hn5AXpNIJ+ X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(575784001)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:z4tvWUk0VRVlwTtMldXIo1jKWH1FKL5v4RsCkIY7B+VKhPZna2v+2ezVtOtpVjHCNDjsjnE1hRXRbzZ8f+bb1p/bppON20ZnNC9m6PLzLlN1D+NwKEN0DWsguwb0VcOFJkCCbiX+LmuBsT5ONNIaLUwXOvvQYyNUZby02PQGWAWqMnQXJcf+lkfrdjHMWVPe48It2AteG+nn6FPiAZDyutyti1B39kTChO8y4fFjV+4N86eCtVBrAWzsWnehbWVQCf20FlN/khhxXLaFvCIGX/FHPWLNj/XqKwG56FybAdcA4ZkMr0kxIndvu1c1YxRH7Pltm5tJQhBDm0fGYWPnL5/YiMTioJnGTV9k3UzrLCWeDzweY3azYcMRL8pR0SxtRhZUv6u4++eGLBTFyZCYRfLL7C5Sk4ug03ox1nJ5PlmkRvxRrKDj/mpMDV/Qr4YvMxmO6VVyhzFuwxLfeA7yhFGa38YUjtoVNuesB5XOwFtP+w7yZf5snS8YdsmoyoJtv8MSA83x29ZBe2Lia40al16XLd2O8XHDsiWKj5EbLuCUMeo9oybH4CkU5vsZ6SLx4ACoTRBR5/0Ss8Vlz5N5VtfF04xWYG9PDz4IdFXJ2yXNeBTSJ1KVqLsG044KCH41PS/HmcsBdmmoHwP6cADfsCS0W4behwl3YV2o54QGd0/EtAeMZ9Hz8XeCCOELj477csiK9Y/p9fa9LfDaKQtEctGZaethO52twWYnwzjuNqdu6slYPtVy25k5DqCEuTpSLWbi1Q1MNQGgJ/iIP5Pj5xBk5m61SGAD5OcUXQtgGuh9AJ6H0aYDfahMghSL1UM0CUyXnsKFk3dWagr3Fyws/CE0XMIVgt7B9NOkVUHySJxWqG+cIp1F40Uky3SvhGnGH1GmO533o6pgOC6pXhBlUftgzKqeLPfbJybO1YO3JlBsTOmOFgVlzX5ypes9+ZlqO/Mi9DQiogd3bIkaLeCvgChjaqcsMIxhJz9qMSduU7Al7BlGjSu7vPL7zYZmUStQ5EwxgLEFLKg9crRVgbedXG+V1go3oBI4eqlR4OuMmJDVUiWR1h5gJ9fZ/d4Mmepi9NnXMGjiVxaLGkDbVz5HZdiMSsTFPl3E3acapUzwqzIMa8WshJliTNpd8i/OXTlEuIeBFLh4uyJKdofYTy2YpoCsomCMgoHhrc/2HSWaZNNah63+K6NCz4YBJHuN0bP+mUnQb58OHTFLbYvwehdZoM1tFyC0rTOCXyiIKm9hSjC2RRyrbclJaENSbGaZ6ii8kBVCPWvPEYs22XbSRGhN5BLnyFfLtCfOz2j/Jh1Xfo1GUimQtuE4BAtxj6nQaZux X-Microsoft-Antispam-Message-Info: OgrmPL40jw7ZV5XBSXwC+fS6U8By0qtxyEb0mrMMG/pDDccKAIQKs3B+6fmvY4dUTTUEPnXYsyjL0Khorr1VZbPSL64JVqLrGiF5taS2BXNUktc+g10J9x7SsJOW6GFjlmkdm7iSS4zDwGAaweIhCAB4y4k8iyfjchobtXyZMPa/3MQP8l617oiYkvL12fAZe++Vs6XTVoQpVPLY4ZDRQ7qlj7tQ7CkX+BcXzwAKDG7z6pQo20aoJXRv5dFzX7OC8HOOWJ1hGc7TKp+RkssPcUIiF1VuMEh88+26FvX4DziRIrsRKHrgVi6hUfPsXidhSonqEHGLq0gsDGg5QcCVi5UrvZ8UhINAlobgt8qiJ34= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:JI6H1mJnN3/WvatVJVSOiv2Vsd3YlmUYxip278fB8whPJS/d/P8rkw+UMxG/LJSJCMp1porHM7Nrbaz28C4Rnzmgig7CEUdaLvcCIOdoIhPBy+oykaU/zp384yR0ltCM9lBFwGFBo1hRZbuIul4qJtHXphYmoxqZSX0PB4rwT5s5VmX0Oor8FpofQuIq1FUVS49ok/I9mLvOlcIGyDL+eFczj2z85JZQCYHZH3hWbNTmS74bRNxr+h0eIw+zfOruBJVB+wumwqPLPxlDZYV6uVoFRPqz175zrwDByTaxlARgTzI4p1x17sC9M3+1ZRGHhWVFXkQ0tiDoEgkc5mcHlgdcNbBuX61K8Tv+3XsT7s60hHIXdcxtPJdQnDoLnPA+hpNO/vdRpr3yec3DyFi1joNDM3DQiDgAW5m+oG9VE3JmAcVJb6S5eMsGHTMts2XdkWQzUJOeaX8bEz6h0eQUYg==; 5:1nGPIYOiFEycz6Q9v/oEpm8CXDXjqSk+f2BDf1cbYWfgPjUponDFAiwnrStdzqcjYzCjtaRUQKTmTOM0Gh6SMw9cRkie6EfQDD+1vsMQvpwWRreeN88VZbeBPO4ltOWP1toCCu3qkY+ls6p3cjpptnXagyRMCDL83LyyB1h74sA=; 7:wsPlLXUGtGcagPmQTD1W8oLfGBKiSr4/WyMgZQcdNbQjEKxGnQdFRZ7HbB5sktjuZn01yKJS3UOinjGdVMCfFFeX3XLbJBIoa8HgoOa7VHgcZMAMTxPjjE8WArrTF1orgBSOpbg8Ub1DDDGbpTMlNMurfbmhz1ehqk5vKT42CUF8HM9jdVIWe/3FP7XaD2byfy60FthUfi0eIAcA5F0YhOiTbeMK9UrG9CzTuNQX5BbUeD873Oy1MITkRyTI2g64 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:q78xS1xoLU9BC/f4zhL5OA2DrSkyhmr//4qkNRYXRTD3E+QlO6eRywItdMzDE9hHEl4MMVplCoH3HHN0oZnbaTVd3XYFgot65HJAd0OKQP8c4/nr8jyzg/H82JXX9gQz/y6ov5vlMyXMzeU1NPLgi+1K9oruTrGkK64+oDdXrBg= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:16.5824 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 600f0b2c-af7c-4965-7905-08d5ee68b1fb X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This commit introduces the bpf_cgroup_storage_set() helper, which will be used to pass a pointer to a cgroup storage to the bpf helper. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf-cgroup.h | 15 +++++++++++++++ kernel/bpf/local_storage.c | 2 ++ 2 files changed, 17 insertions(+) diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h index 6b0e7bd4b154..1b1b4e94d77d 100644 --- a/include/linux/bpf-cgroup.h +++ b/include/linux/bpf-cgroup.h @@ -3,6 +3,7 @@ #define _BPF_CGROUP_H #include +#include #include #include @@ -20,6 +21,8 @@ struct bpf_cgroup_storage; extern struct static_key_false cgroup_bpf_enabled_key; #define cgroup_bpf_enabled static_branch_unlikely(&cgroup_bpf_enabled_key) +DECLARE_PER_CPU(void*, bpf_cgroup_storage); + struct bpf_cgroup_storage_map; struct bpf_storage_buffer { @@ -96,6 +99,17 @@ int __cgroup_bpf_run_filter_sock_ops(struct sock *sk, int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor, short access, enum bpf_attach_type type); +static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage) +{ + struct bpf_storage_buffer *buf; + + if (!storage) + return; + + buf = READ_ONCE(storage->buf); + this_cpu_write(bpf_cgroup_storage, &buf->data[0]); +} + struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog); void bpf_cgroup_storage_free(struct bpf_cgroup_storage *storage); void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage, @@ -249,6 +263,7 @@ static inline int cgroup_bpf_prog_query(const union bpf_attr *attr, return -EINVAL; } +static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage) {} static inline int bpf_cgroup_storage_assign(struct bpf_prog *prog, struct bpf_map *map) { return 0; } static inline void bpf_cgroup_storage_release(struct bpf_prog *prog, diff --git a/kernel/bpf/local_storage.c b/kernel/bpf/local_storage.c index 940889eda2c7..38810a712971 100644 --- a/kernel/bpf/local_storage.c +++ b/kernel/bpf/local_storage.c @@ -7,6 +7,8 @@ #include #include +DEFINE_PER_CPU(void*, bpf_cgroup_storage); + #ifdef CONFIG_CGROUP_BPF struct bpf_cgroup_storage_map { From patchwork Fri Jul 20 17:45:48 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947136 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="EVNja8mn"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="N6ZMxb/z"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJHy2RHxz9s9F for ; Sat, 21 Jul 2018 03:47:42 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388378AbeGTSgE (ORCPT ); Fri, 20 Jul 2018 14:36:04 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38264 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387881AbeGTSgE (ORCPT ); Fri, 20 Jul 2018 14:36:04 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0p025812; Fri, 20 Jul 2018 10:46:25 -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=JLY4YhEmv2Q0OMvBg1KWpD1OGkIDUDn+eQMEK5i9oog=; b=EVNja8mnCTilNyerWL+fhIW8Z8dvTpGF2iECUoksu3jTFdQdiQJ5qiRmqdqcf/XKbtfr 5+TFgXNljT7w8Uoc12VQETf+MsRs6ImOr9A/6VyZIzVt7Q+J12scDro2WzptLY8CP5iq XCfdAZZ7VBa79z5UdU3h9P0mc3xGwgmfPU0= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-1 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:25 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=JLY4YhEmv2Q0OMvBg1KWpD1OGkIDUDn+eQMEK5i9oog=; b=N6ZMxb/zklntjPOQftXc7P7T3ykiF+/+4WiOmwSk00JSCeaH48iwtxn2L2Iign1WjzuaFM4PLRRfuMr+Kx8Z5043cEbO/vvmAqbt+uAc9XXr05/OI+L5YBQ4v5SLK96BQw6APgE8LxiJY8YMCVRA1lWlUq2vUTMeuBa4D8XfRtY= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:17 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 04/14] bpf: allocate cgroup storage entries on attaching bpf programs Date: Fri, 20 Jul 2018 10:45:48 -0700 Message-ID: <20180720174558.5829-5-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: d683ea4c-1203-452d-864e-08d5ee68b2a4 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:gbFhgdxoY53OcjU6q36QvMqubWaNNKVC66B+Vs/Ha+uOt7CkGJw7tRfL4hcfF3YPKTbuAfHNUTtNUU6CfVbFA3KGW/rwvDZm/ke8DrTNom121QCIhhlN895KvCeGSoAHF1enJ0B3+qUGT/HU3ok+TtxmQk1O7shJiCdWzoaKaClyCkWr6EZ7dVBp64K9Ja6mh+eJVN5sdTC0WlZskd0H/H/atJBFRhmMTX7OKDffLi0+vbhH28wLijtBC6Y5wATs; 25:EPg1wIKjT9uJGmgqAE3jXYtlMI6ZpAzLudNVUIRVTXqIYXTb8crBOUH0eg3XcDdPke95UPl8fuTBzpz8nnvmfzRyn+HO+lVZ49u2Enqeizxrbtd8/Qqf+h1o4h1d6ixhN2BOI6ytC3BiWTKskzPUrEUuFQXVXSLX7qXptWgqaIkpN+T0JbKvozRBSMB/aINu3ocg3MHLdoOM4sMTgTJIh6+hfl65XsbadlcKoFkw3Qcqm58EHA7LOyjGP5z7IiYB+GEnisTP6d2S6Zhf/OrPc1Qd17UrNIHnQqqCHzERfAUx9s52KGJuz0cImmZJSerac97rKRfyrk1aggRKT5Z8DA==; 31:yLnL3bohJL3gPFpHAokf5MDNWTxC3lSZyGqhdVGI1xpIYu8zwiGe8iKPx4QKbFSS484KDQ+JQ7v2Du4AmvO7gJrNupeIn3255GMjF7FlrvliHGdsnIM34R1tl5C2Z+QfwhK0Ljn3HbUmrJCxITaGLhF8ZxGQegV4/q9wK8JsZ8BIWE3RgLh8FtjOVfQ/zpgv9V/aKa0FofyhkeAOWvaywVdGhOQfkXvFZKwpR0UOir4= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:6JPICDUElr1glSEfgrDWDYI5gGTBnGA40GKxTrUtJGqs+8DfFzAn7I2R2pQoO2y3pJNoXWm/jwvGyZsSty6wApd1nTh8mlcK6KBvCr0Gio2TT/xmUAvHWrHhRnvezue9CRk5swpSOAGYnYg+Imv+StTC5GHb6iR+qTR4udkf/XdY/tWTGOffsaNKoiJ+32b+3mqCUjO8qFSp+KHr5naJGEjkAK68Y39d6OygNcSrqhUGogqEhu4VpulOsZN0N5TsAECdOfhs9jQYBAjg+bK9S8PEZvIVsA0+hnr4Vs+8Tc/7KE30QiLpFlnRQmZJrr0e0HoukBMqIm6FXw5aS3GKG+KR/5TDE5CvTLDqvrPyBtCLORHsMAIPkC9reIRn8bWamyUfIS2mLPfzvhzNzpAj/LKaiSXmaDk2FWDIohxWATXUy3XtKnJO2O9hxQ2iUh/0//bSkW5+FfXCMPORiB5xAEYKgw+CVJRCtajixxKI80NFPA1fJph+B8lQZhv2Kn4V; 4:/r0FBQo7ykVb46qhLnWqpCHCkvsrU2bGd4TOMgV4jTwwXVbCpYl+b6E7CxZYKqTRoJwdUZKm0Ko8cxhuVeYfn2qQMsG2T5SjCbGEyW8x+ogym2uRD3tZ/44fWl92Ct+/Db3VCFJAMAQgQq5FVURDdkX+4w3ZGYMLv2lApvSKgZpgvpYD9J0PBGzH7E62iMgYgHFIZ9lueI2fM724KR8qVc10PHaLdDuqyYtMZm+cjKgwt6akMIE5m3USF/s8Rpg36eNQc3rTxG+eQDXwtKAyraqWeLaEZk58yWwok5oKMIB0WTYNwn5eLme1sb9Wus2J X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(575784001)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:RVSPFlTSmgNDT/Zs7L/0AYV8CFpjsr2CGfZBTefXFcvgbodJmrOkl/QaTb2P6W3Q+ivT3tnvPLmosYo7u27Nx9OxOrmajPzaTzXXdgwnhr9G2pRnk0Wm3TerfDj1vCQCwL1v9lj4jemf8aW4DV4cIrTkYED92vF6+q4nbHL4yqOekA43Z10fiKDZnDm0xeG8OptWAnKFfWaFRYrdNXxYbFXMHNSK5VPVyfR4h/99hCtwUHEBj8s/sZhpzBDCubpnd6K7wf1gnvH6nEidFGhsi5jBTNY2OkZc9l5WzAp7wut1i7kJybQUu7tJs7Jyba4lKO70aD1gzIKqEOHpIoSb//cIm7yAV6nqLbb/WZzoiw4/GvSolOpWMkO/yKqp4o8zGg/yUUM7UGIX9fb6oWCLhO+TGeF23lHns4sHO01qvuQi5kCa+1KpkM92N7mFPl/Wf+NCNEVhMAjtuyWijfyUouT02DHnoaBhjAqKlqfhjAygTrVY/otIKN0xsk7A+AJlFsHWeBjxgwLR5DkWOyL2wioMOekFUQOsdTf00glUZyc512ccs5IpVKyxal4+e14eu0n32kgxYzjtfNFIfVb5pzsRqAMsUhGH7AxYE1oYTtv3s5QB3vrT0zuJJRmqMFqohieBcosHP5w/EaCVLdEOYhA1f7CxJZn92GtAoeE9YdyI/A3n1FNcD+X6JEyNqqiy0qc5wWtcO0DVeN5VY8jW7iIUSeKdcVgSY22rgVRTH8aPq452XPSc/zjWlb8tMikeRA3q0YuLrIvH3BxYR9aKYALqrtmWvSL/HeHE5CwTQ0UWL4pt/Lv5ixuAAVojeMWAUCJOcE36Or3f08GWWBCLjJZjNZri0yAYL95bldzYrVqd6OULhBRS6HiIv+BGdW+DT+UVacM5OtgzRG6S6hPw2yrgoeJeR9KMT317FfgYuCUGbrdvCWn2PbJ3FVZlQoqfauNpC/QKFr70ivry2vnesi26iN3u6WVgK0iLpiK2k1OTZIW7zcZUGeul4nsM8hJ0BmXHZ25v/jtOrO+77ybfXhZOXd4OT2wYSS37E3oJQ2EZcZo3xXWgD69Tz7CMIPFDLU9Z1azEYFrVmMmcFo4vxTqukShz/oAMa8WIQBfalwos/1qM36j1T+UsNq8cSjsCPSYCmh2Y/rZMvFalPdjbdB8AHa2yIE0Yc/GilfRKLR9WM1j6Guk7MeVrc3gwmShTe1j1gDMeUwIIZoa7niehEiAmDty//YRx3UcG+gU7jqbfettZ7Gcd6TRbg1OgWldACcxT3zM0hrIPbNvj6Fsv72YEh3/5W0h6mseEndaPReRtvK/GtYt3F9UeG4KxzjwK X-Microsoft-Antispam-Message-Info: PNOhc7bTLBUpWmKHRDGeO/UYg5drvh5TCtS3RSj7GZ4E1glhR+Tos5qpSgNNw9H6vyERghOWhe3pCgHDYaO8F+lwcLI13EqLVKo/ySvt9lPZXAq/UW011fW/rzUiMpXr5FjjybMtscRPmXrmdQQgCtd5/kb/1178KpQIZ57irKQomkijxeT26sTGeO9J+yn/2WL6a0BiM1YMmTVC4gS5EfyNZBkIxazqHcO37vNDMLVV1lbxP9CVDHZdzVsBXNtaHaLI/fCO5HdPzNhAGWvtVYTqPS0jdM3n5YRVWD0uFVgGpXx2t2MaapxLTANMfvl60zsxqEx01DLIKvjaJeVMqcbqRTCd8rob082XKq0SJ5s= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:bsdMSbx/CDtGtvfUu//C2XUDf139KcjIeslzDqJEYmEnEvERx+GGSKIl2Y0dExXo2ENcRgTCTi2gUYDzbP6IJIV7Vh8dt5AZZUxVBDS1hkYiXQtC0pssF9EWl73tsXjiIxdl1W4vtVOiGRAT+0GzmPgChdZsZaRB6UKuECnG2ph5E1wCE0yMsF/yfdAQezaQiWuPD4r43Evrfz5J1pG0Xv2KbS7WhXLnWP16A753vgoTldccSIbGmUPV1iteJfv1ELIdw9bHYSRhQBBjYJDw1Lf7TvGhhYomX53aVYVQz+biHx4RMeumo4YdLTFDyYVtVmrDupcqAye/0aaLLMiDLaKyWPTT06G/nbuJBvrhTfDmxMgyNHxjHkW58ym1o/oE5MsQu9xHYlxzn51tBeyWrhPGNE81ZRfFDO0bS20qXvPhEPcb89cgglSuotemQPt77KV2O5HEkOJq/pqs0S247w==; 5:WI4Jp8qUvAmyFWkBbhuvlecEDv6NkQ6hS8gVKRbjEk+E03/bFqjFF6+Nuei/1AROTHOsZurgpZgvipmcA/rtTGdbl0dST+SddNy82tHT4Q/E7RchcxRWJDeuxBWikdf91lkpp/bJ3fvsF2CPPGhsLdA/2ddSVlmr2UYWw3OupC0=; 7:LLooj4pfhu695UVXf1lZ5zTsXcM2drL9KufHjfIntKP41vjepTExfWX/SKLD31ugvr3OZ6xWAhHbgGgOIVa4i7vCVKPAoUpB1BxVosB/iGtdK+jidJhy3tIX67wDsPLfBSMjbTczKCC6+BARa4uMjzKk2hOEt/KH/cl7cc1YDO/paARu30EK6x2SiVmXiHugmYYK9K09CSjX8b5RZwcDTyaZDb0dvuKwXBDvwfbrxe8IpJyllXm1BYeb+rNPOt7W SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:DUTbDAcd+O5Qgxh76AoLANkHQIeKv4kuykf95l+BW/U6h73Jd0QrZkDyw3Cvo1u5bvExJlPmA7Cjc9MBkLED932nlIc4W79Ysp2oemO88+C1WpPqDS3d7RMsNOpgMpL9KuqkDlrR1AA7Wv5WbyXlleFtaETzFeA2rqCPTQV0BjQ= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:17.6893 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d683ea4c-1203-452d-864e-08d5ee68b2a4 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org If a bpf program is using cgroup local storage, allocate a bpf_cgroup_storage structure automatically on attaching the program to a cgroup and save the pointer into the corresponding bpf_prog_list entry. Analogically, release the cgroup local storage on detaching of the bpf program. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf-cgroup.h | 1 + kernel/bpf/cgroup.c | 28 ++++++++++++++++++++++++++-- 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h index 1b1b4e94d77d..f37347331fdb 100644 --- a/include/linux/bpf-cgroup.h +++ b/include/linux/bpf-cgroup.h @@ -42,6 +42,7 @@ struct bpf_cgroup_storage { struct bpf_prog_list { struct list_head node; struct bpf_prog *prog; + struct bpf_cgroup_storage *storage; }; struct bpf_prog_array; diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c index badabb0b435c..986ff18ef92e 100644 --- a/kernel/bpf/cgroup.c +++ b/kernel/bpf/cgroup.c @@ -34,6 +34,8 @@ void cgroup_bpf_put(struct cgroup *cgrp) list_for_each_entry_safe(pl, tmp, progs, node) { list_del(&pl->node); bpf_prog_put(pl->prog); + bpf_cgroup_storage_unlink(pl->storage); + bpf_cgroup_storage_free(pl->storage); kfree(pl); static_branch_dec(&cgroup_bpf_enabled_key); } @@ -188,6 +190,7 @@ int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog, { struct list_head *progs = &cgrp->bpf.progs[type]; struct bpf_prog *old_prog = NULL; + struct bpf_cgroup_storage *storage, *old_storage = NULL; struct cgroup_subsys_state *css; struct bpf_prog_list *pl; bool pl_was_allocated; @@ -210,6 +213,10 @@ int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog, if (prog_list_length(progs) >= BPF_CGROUP_MAX_PROGS) return -E2BIG; + storage = bpf_cgroup_storage_alloc(prog); + if (IS_ERR(storage)) + return -ENOMEM; + if (flags & BPF_F_ALLOW_MULTI) { list_for_each_entry(pl, progs, node) if (pl->prog == prog) @@ -217,24 +224,33 @@ int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog, return -EINVAL; pl = kmalloc(sizeof(*pl), GFP_KERNEL); - if (!pl) + if (!pl) { + bpf_cgroup_storage_free(storage); return -ENOMEM; + } + pl_was_allocated = true; pl->prog = prog; + pl->storage = storage; list_add_tail(&pl->node, progs); } else { if (list_empty(progs)) { pl = kmalloc(sizeof(*pl), GFP_KERNEL); - if (!pl) + if (!pl) { + bpf_cgroup_storage_free(storage); return -ENOMEM; + } pl_was_allocated = true; list_add_tail(&pl->node, progs); } else { pl = list_first_entry(progs, typeof(*pl), node); old_prog = pl->prog; + old_storage = pl->storage; + bpf_cgroup_storage_unlink(old_storage); pl_was_allocated = false; } pl->prog = prog; + pl->storage = storage; } cgrp->bpf.flags[type] = flags; @@ -257,10 +273,13 @@ int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog, } static_branch_inc(&cgroup_bpf_enabled_key); + if (old_storage) + bpf_cgroup_storage_free(old_storage); if (old_prog) { bpf_prog_put(old_prog); static_branch_dec(&cgroup_bpf_enabled_key); } + bpf_cgroup_storage_link(storage, cgrp, type); return 0; cleanup: @@ -276,6 +295,9 @@ int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog, /* and cleanup the prog list */ pl->prog = old_prog; + bpf_cgroup_storage_free(pl->storage); + pl->storage = old_storage; + bpf_cgroup_storage_link(old_storage, cgrp, type); if (pl_was_allocated) { list_del(&pl->node); kfree(pl); @@ -356,6 +378,8 @@ int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog, /* now can actually delete it from this cgroup list */ list_del(&pl->node); + bpf_cgroup_storage_unlink(pl->storage); + bpf_cgroup_storage_free(pl->storage); kfree(pl); if (list_empty(progs)) /* last program was detached, reset flags to zero */ From patchwork Fri Jul 20 17:45:49 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947135 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="mvczQkQo"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="CtP5vUDm"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJHl2p8Sz9s9F for ; Sat, 21 Jul 2018 03:47:31 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388410AbeGTSgH (ORCPT ); Fri, 20 Jul 2018 14:36:07 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38278 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388084AbeGTSgG (ORCPT ); Fri, 20 Jul 2018 14:36:06 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0q025812; Fri, 20 Jul 2018 10:46:26 -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=nhWywkFX6IxVsNEfqqLpZ74YgnutblIE82xvToSZxes=; b=mvczQkQoiI4c6svFr0SQNZ8TSG2AEpvrsDZtIeyNKbELQlMdezZ7uMM2CVNsheoKokk7 f2J1o7VdYuM/ESnwr7s8KecNI5XNnq0fOMOIzQUuhqHojr2UFfzMDzr3AHFitu4SXL1w dIJR0A928b8MmGOuBDi62flL9EkCHpU7pfI= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-2 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:25 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=nhWywkFX6IxVsNEfqqLpZ74YgnutblIE82xvToSZxes=; b=CtP5vUDm+LAgAMDbVoy1cseIckD/g9/S6IFcHix3D/Y/VYGAo3eUMMruBy+ARuk2r5wausSCM9LZjd1D563gp7e8lBFCP9YpKbdtgd6gMR3CRDbiHJY6XfENk2qAKC/SHbHP0Yp6lPZuKAxcZBDXaa7WP3nH+vWVNKR+zZ46FrE= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:18 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 05/14] bpf: extend bpf_prog_array to store pointers to the cgroup storage Date: Fri, 20 Jul 2018 10:45:49 -0700 Message-ID: <20180720174558.5829-6-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 913193fe-52db-4d6c-051a-08d5ee68b350 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:DqNhFULyznIoc7SxE0yCs1NPRlFt3aCrTBvFksKK3RhM7aGJ6PklLRkpMPBqIJqOUTsOOch4vOquGClYs7rLxu8GtRVZ7Cb3vDfTJ0vbBiT5xqyGmNItU4+/rifE9VwMC9Hu2TotmqVhLQ29EpTXmE1wqnbpgde++AMqAAPQI15OciR9924VfkO3u9ZNLI4tY4czpYiyknyzNQNy2nwWoXkW9c7gKPp14QnWXHj+U9MJmGOlJK682W33BKNCHxZq; 25:wWlFiyfOnSH5LtCj5rdiWkaMxGnLYwOXP6fAY5JeSu7qeMpCwOwhh8QBIM+P6GDu/cz5mJhMrKV+H9rnuwysQwyVM6OjdXaQgK1hdku+5aIJNtKMRc/X6gdOKbOKVMR6ud+1IPGi58B5U2erPPggbrdOFgXbv9SkwSOx6O1T3cQ3dITXnJF21AXlPDknk4zyt6krEbeYpI4vOIiDDr7rqgN4Sq1ztGsC7veWr/xynEfMUfzINxtpu7B1JK0kL7LnbT5UIEYhnqzWZ5IEUC1YB+jGbQxg7DQUDGxOzzrmG8kF21fhoX7rUnidgrw+CFNAiJ9fY783EX9zsd+hEQdxwg==; 31:jPopD0CHu7mqGij2fbL3ZUFNGjBO0g7h7XeeVGFdMbXDCOM3INja6Ks8Q/UlQLTwIswpXGQc/ayLZA8Bq8p9h+pid5HM9LytDeSDY54SVoHW6s1yJc7LNFn+FLbgcixwafHBJaM15LmmZHZ6SEbK7xJHCmjtGZGwsB7v84G+ES/eSjMZfgY0np1aHVmtohA1KmLem1QGxy3ZGoEAO5gWcTDaoerGckw+/Zi32uybCik= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:08VZwTn22IKF7jlLLzNF+ySSHo7fxt+p99w+suqpHrKl45sKm0jVyemLbHnNZrQUGYbJwkQDEqFPVPcAwqsrWe9pQ7MVDF0/GE49z5NRaAF6PfYEC5WGomyA4CioHzNdUSUZWUF1x5BTi9BljPgrgPF8w37rHXqElQ3zxTNYAGy5GYji7jrqj/s+56EY7iiJdNa12nwhfnHyxAxuq2CKUbWc/R2sKh0RJG7wLXp/Bo2WJM0V3yCN14TgGGHgKpxuUhEvTiqOFi5YzUAjEAX/f7EpJbyU5QTuZc9lKvdkInHZeA8AXtg8TiHCe1aEx/LxZcf9Y9egR3tcyR40G5W8wzetzHCXdVzxf929WR51ntlEYqB/ILk3Cx6I0pj5Y+Lcg55jHjwD007FZ/u2kOY/Ge9gHPihPFSNm9gZRPFljhcX9nFXgE+Ixrl2SZjxgZiU5Dngei9htRx+wbyete2q75sCdg7cjmICWTjmQqomfqhR7l/uiiYDIyHjRXVuX6KD; 4:smFdN89ZQIGoypxueg26meq/u4FR2OLRqBTb9VVM8eD67MWFo1gDAoWZmyf+YPa91dmUIw3FecRPcNE094s+ItyJp6HiFMXL36U7ZfKimj6kl19AIryeccUK5yDbn8Sh1N0Aj2JAynJq0epgcqwGHY67z8YjpErUoMeFolK/Se5PBYfkmtU7dmEzXumHz48a2Xs6tERdYKo1LgGJzexjVmZbVTQsrBUKK5KS3+nZ3VFiqCe3/L0QXtw58U0kj8aXcnuACnHnWVtIKM26JHf8L3zAHaTaHpWBqXPcy8NsAAWdNE//VIP/N5JeS8Pfg7tL X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:jN6kGdl8sHIKuvNhoZvvKjcPHLQMXHpU57IQLMIgzkB/ExaEdcfFBU76gxnIQFE3baWpPtuVARFFDUuSwYtBKNgtukTdFR3MUAYzqcB4xBRxcHudXj0THk47UpLKZWsOe/7Rspc56A/mD6cShZAK/SZzNVYwrIZB8BJj64tybW8O9x/xIRuDXNoR1B/c1ApNgEiKsPHO6lPLk6o3CpELaNXMsjVV3Wneg5Tyz2tHszwKjj8tZ1pyugGOcK6KdfqbZ6Zo31DIFtGiZ9dAmNpD5o0GKMzluZ3fgWJmRTFmDjX3yPZWOUEevK8SK6TTu58w2xRNgQN3jvOEOWU/ecm5x4PDxZiNMO3tNhlc8jz1xKEZvID6rt1G2ctPbYwZrndxCIVmz9IFgS2zpuy0jfPx1JToWWiouqYWjaamTbDuNqqoFLXTSoabrG66nOGJNHZopMkUhSd8Txr+2Jh+zlZTf8Xofk9H5c49SBkYS3Iw/FnNSo+n9shoQEi7+KM0qvEbg8+LRYq3QF1F5DY7CdOpqRK4gKeEOKT2htR9nYUQIG1CZ5mhOMHxsL9+T41jJu90ITSt4ULEtNvrsXuWqko1WPBRS3ZXo2FfiOH/mxrG05efEFeG1CBYIYf24lY3E1pHztnUKJjssD4Wa0II4pSkOlIER2O72SaphND8MGLUyKOPfFdJd3svlpfEPE8ut97Q5BHRBxlrwJ4B2SsnXbMTMjRbAYOdLzHlpHPNjcsaPZ7aTyq6iyzuZK+RFGcuDLsWC8WgYRHjARnbZ3fjbMk8SBOR9EZK+BLfIF2cOjxpwBu9t9zh8ZjrquT1q0BkacI7nPTj+7No8tVdV7jENx8cXYV2H3TBHbFkPRNDGOrCL9kQlg433BhhAYRBn/wrLTaDf8FvvWVEsn52SmXUXQ0scCmzxKDRSnpfNHrXPCHnXr1p774cNV/58pugmz7RFb0DzTOY7AHqzP6N8EdIhQEay7O0aBK3D5YXgbHRP47p9HxOTfjrbjOOayTgS8fpkBp926oOyyQsaelrt08FjmzNddo90LGUfVpnd3P2s4mZ3NE/xG+LotuZL4zmc9TRuIKFcVMeQAV9IHL/erHm9NTUBXmPxOGyUouRxawXYW/qbA+UNkXxPKy9gp/HyZjpm76av34MjeaEGwa16hTwcsh6Jc3NbsLMYzN355aTnDIOZSEynjX9MIfVpMQJkUwVJZT6gLuzY3s4ze8eQSpf5rsAW3/Lr+u9Ag51xE95sx21F4Z1AV3e2dj5Qb2gTRZ8L9fW+XX6luGz9+A9EzWuuegnGtxLEpnjGJBFB/VsK7Re+eI= X-Microsoft-Antispam-Message-Info: DrtsES7tDLlNWlVGyw5lvNX9cftdpaMd3aBxsRaU1s88U9uLr4Tj1bjCBKcTwuPjI7Mbs1tB4joFUmFqOG4w4ig2b5Br3CmqXnzXtsW7dBZTDV6RFdTTVoEH2A40IDJSDb5Fi9HE+dNR4saZK8JPrHdatWmmRVNxzu4yr1gueE+c2bPdmTzUTHRy0GtMn6gXrraPVGil5eVuCGRhp0JPFx06N3Oi4CDX1Oq/Nf1OOp7khWmuBL50u+dBQFQaA8828G+7L+445f3ayBQ4r/CtSsgZJcdY9JVGsf70o8kiq0N8g7e/R+FqxGCa2ENqfIffN7Lwamfuz0lafbfmz2kY/UMgtxCB7PcMDJaRpX2UgzY= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:RZXHQ/W4abeJk/xaiBxN4OpYmjyX07lvm7+TtYl8eXJEIp/mUyq4gEjrQOc1DujSZXCfPb1x0oPuZz+vGFhHXuAsqaahsrNG2LJsLyl0NnGu1uIt+JgS/fW1H87nMCkTrBpCsX0OY89FiarZ3xnYbOgIEFG43WCM5fBay4C/G/8gJtcyKCLVrV0hwbf2czoWRAsuESAK+zt4Ip+j3gyN7QLTfI8mSLZv3YF90cxHcMeUUzQNVAgIzHVsVmD3ipz22erwMp+hlR9qe+/hpzVsPqHBsedatWFeKNsqfj4g5lgvQAeGq03NFbXOc4jTJv8UTV9nyi/vxxYiOxuR6ZBfhqaxSciQ9Gvxh9a/ycS1Dtrl9HrTRcJ/vecYLsarfZjpJKhUI2JuqZ+/YoxQGLx9d5y5qq9rehyKHY7BCsqqqc7EH+O8jsBxdEdOrOBiVliy+wXEWOkVnY0/Q/R7hQMDEw==; 5:kYYhtbbZCeO+bHumeVm1theYvtyX8DnMU0HVzj1NnUlhBrfA1lX1QocjPiY3yqzAnyzZgFZqdKpCz6fMMfV0frK6C9jJbvEeKH+T2uUM8UhqarchXa0fhm0UM991yIqDRnrbLc/Lh4EoJ9z7N4caCskerNtkvq5YgCPLNk0UBWk=; 7:IOi537nAgozJlGWuHlxyGP9/MkMuYRAc+pTpssyTacrObKSeSgQNVbZUyYjjQiSCO/cTy7iENeUDCOQ8OVulZRBr1CjHo6dKrRxDdQzmup7Wf+hng4bNESi/lkhHZ2IBc9ASR+12Naz2hUNMdTpjsHO6TSeHu0KehD3RtOGcFGFVLfUFNZzHFFxgrdCLlIrGd5fNbEdwGRsunc8PI2OqRGsTdgK9QmeY8oIDPO2XbXMPaw4jc+Ms6uEf6a8jN7L5 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:z8A/bR5Nhn80MlxpoqsMnN6R6dg2xzM8T146ERx5/8SxZ0w0+JIjJB8YX/r2gXL/ntxTMZDDCytWadrzfrdOZ7MZgSDyjMS+mgN34Cluv3yA766C6LsUH4gZ+2YHcTxpKI2TgLAv2g5JHlwYymfXnVd537FXnsDg1uNuQ3q+UdQ= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:18.8142 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 913193fe-52db-4d6c-051a-08d5ee68b350 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This patch converts bpf_prog_array from an array of prog pointers to the array of struct bpf_prog_array_item elements. This allows to save a cgroup storage pointer for each bpf program efficiently attached to a cgroup. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- drivers/media/rc/bpf-lirc.c | 10 +++--- include/linux/bpf.h | 19 ++++++++---- kernel/bpf/cgroup.c | 21 +++++++------ kernel/bpf/core.c | 76 +++++++++++++++++++++++---------------------- 4 files changed, 70 insertions(+), 56 deletions(-) diff --git a/drivers/media/rc/bpf-lirc.c b/drivers/media/rc/bpf-lirc.c index fcfab6635f9c..8c26df9b96c1 100644 --- a/drivers/media/rc/bpf-lirc.c +++ b/drivers/media/rc/bpf-lirc.c @@ -195,14 +195,16 @@ void lirc_bpf_run(struct rc_dev *rcdev, u32 sample) */ void lirc_bpf_free(struct rc_dev *rcdev) { - struct bpf_prog **progs; + struct bpf_prog_array_item *item; if (!rcdev->raw->progs) return; - progs = rcu_dereference(rcdev->raw->progs)->progs; - while (*progs) - bpf_prog_put(*progs++); + item = rcu_dereference(rcdev->raw->progs)->items; + while (item->prog) { + bpf_prog_put(item->prog); + item++; + } bpf_prog_array_free(rcdev->raw->progs); } diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 9d1e4727495e..16be67888c30 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -349,9 +349,14 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, * The 'struct bpf_prog_array *' should only be replaced with xchg() * since other cpus are walking the array of pointers in parallel. */ +struct bpf_prog_array_item { + struct bpf_prog *prog; + struct bpf_cgroup_storage *cgroup_storage; +}; + struct bpf_prog_array { struct rcu_head rcu; - struct bpf_prog *progs[0]; + struct bpf_prog_array_item items[0]; }; struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags); @@ -372,7 +377,8 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, #define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null) \ ({ \ - struct bpf_prog **_prog, *__prog; \ + struct bpf_prog_array_item *_item; \ + struct bpf_prog *_prog; \ struct bpf_prog_array *_array; \ u32 _ret = 1; \ preempt_disable(); \ @@ -380,10 +386,11 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, _array = rcu_dereference(array); \ if (unlikely(check_non_null && !_array))\ goto _out; \ - _prog = _array->progs; \ - while ((__prog = READ_ONCE(*_prog))) { \ - _ret &= func(__prog, ctx); \ - _prog++; \ + _item = &_array->items[0]; \ + while ((_prog = READ_ONCE(_item->prog))) { \ + bpf_cgroup_storage_set(_item->cgroup_storage); \ + _ret &= func(_prog, ctx); \ + _item++; \ } \ _out: \ rcu_read_unlock(); \ diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c index 986ff18ef92e..ac480086effd 100644 --- a/kernel/bpf/cgroup.c +++ b/kernel/bpf/cgroup.c @@ -117,15 +117,18 @@ static int compute_effective_progs(struct cgroup *cgrp, cnt = 0; p = cgrp; do { - if (cnt == 0 || (p->bpf.flags[type] & BPF_F_ALLOW_MULTI)) - list_for_each_entry(pl, - &p->bpf.progs[type], node) { - if (!pl->prog) - continue; - progs->progs[cnt++] = pl->prog; - } - p = cgroup_parent(p); - } while (p); + if (cnt > 0 && !(p->bpf.flags[type] & BPF_F_ALLOW_MULTI)) + continue; + + list_for_each_entry(pl, &p->bpf.progs[type], node) { + if (!pl->prog) + continue; + + progs->items[cnt].prog = pl->prog; + progs->items[cnt].cgroup_storage = pl->storage; + cnt++; + } + } while ((p = cgroup_parent(p))); rcu_assign_pointer(*array, progs); return 0; diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c index 253aa8e79c7b..9abcf25ebf9f 100644 --- a/kernel/bpf/core.c +++ b/kernel/bpf/core.c @@ -1542,7 +1542,8 @@ struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags) { if (prog_cnt) return kzalloc(sizeof(struct bpf_prog_array) + - sizeof(struct bpf_prog *) * (prog_cnt + 1), + sizeof(struct bpf_prog_array_item) * + (prog_cnt + 1), flags); return &empty_prog_array.hdr; @@ -1556,43 +1557,45 @@ void bpf_prog_array_free(struct bpf_prog_array __rcu *progs) kfree_rcu(progs, rcu); } -int bpf_prog_array_length(struct bpf_prog_array __rcu *progs) +int bpf_prog_array_length(struct bpf_prog_array __rcu *array) { - struct bpf_prog **prog; + struct bpf_prog_array_item *item; u32 cnt = 0; rcu_read_lock(); - prog = rcu_dereference(progs)->progs; - for (; *prog; prog++) - if (*prog != &dummy_bpf_prog.prog) + item = rcu_dereference(array)->items; + for (; item->prog; item++) + if (item->prog != &dummy_bpf_prog.prog) cnt++; rcu_read_unlock(); return cnt; } -static bool bpf_prog_array_copy_core(struct bpf_prog **prog, + +static bool bpf_prog_array_copy_core(struct bpf_prog_array __rcu *array, u32 *prog_ids, u32 request_cnt) { + struct bpf_prog_array_item *item; int i = 0; - for (; *prog; prog++) { - if (*prog == &dummy_bpf_prog.prog) + item = rcu_dereference(array)->items; + for (; item->prog; item++) { + if (item->prog == &dummy_bpf_prog.prog) continue; - prog_ids[i] = (*prog)->aux->id; + prog_ids[i] = item->prog->aux->id; if (++i == request_cnt) { - prog++; + item++; break; } } - return !!(*prog); + return !!(item->prog); } -int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs, +int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *array, __u32 __user *prog_ids, u32 cnt) { - struct bpf_prog **prog; unsigned long err = 0; bool nospc; u32 *ids; @@ -1611,8 +1614,7 @@ int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs, if (!ids) return -ENOMEM; rcu_read_lock(); - prog = rcu_dereference(progs)->progs; - nospc = bpf_prog_array_copy_core(prog, ids, cnt); + nospc = bpf_prog_array_copy_core(array, ids, cnt); rcu_read_unlock(); err = copy_to_user(prog_ids, ids, cnt * sizeof(u32)); kfree(ids); @@ -1623,14 +1625,14 @@ int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs, return 0; } -void bpf_prog_array_delete_safe(struct bpf_prog_array __rcu *progs, +void bpf_prog_array_delete_safe(struct bpf_prog_array __rcu *array, struct bpf_prog *old_prog) { - struct bpf_prog **prog = progs->progs; + struct bpf_prog_array_item *item = array->items; - for (; *prog; prog++) - if (*prog == old_prog) { - WRITE_ONCE(*prog, &dummy_bpf_prog.prog); + for (; item->prog; item++) + if (item->prog == old_prog) { + WRITE_ONCE(item->prog, &dummy_bpf_prog.prog); break; } } @@ -1641,7 +1643,7 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, struct bpf_prog_array **new_array) { int new_prog_cnt, carry_prog_cnt = 0; - struct bpf_prog **existing_prog; + struct bpf_prog_array_item *existing; struct bpf_prog_array *array; bool found_exclude = false; int new_prog_idx = 0; @@ -1650,15 +1652,15 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, * the new array. */ if (old_array) { - existing_prog = old_array->progs; - for (; *existing_prog; existing_prog++) { - if (*existing_prog == exclude_prog) { + existing = old_array->items; + for (; existing->prog; existing++) { + if (existing->prog == exclude_prog) { found_exclude = true; continue; } - if (*existing_prog != &dummy_bpf_prog.prog) + if (existing->prog != &dummy_bpf_prog.prog) carry_prog_cnt++; - if (*existing_prog == include_prog) + if (existing->prog == include_prog) return -EEXIST; } } @@ -1684,15 +1686,17 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, /* Fill in the new prog array */ if (carry_prog_cnt) { - existing_prog = old_array->progs; - for (; *existing_prog; existing_prog++) - if (*existing_prog != exclude_prog && - *existing_prog != &dummy_bpf_prog.prog) - array->progs[new_prog_idx++] = *existing_prog; + existing = old_array->items; + for (; existing->prog; existing++) + if (existing->prog != exclude_prog && + existing->prog != &dummy_bpf_prog.prog) { + array->items[new_prog_idx++].prog = + existing->prog; + } } if (include_prog) - array->progs[new_prog_idx++] = include_prog; - array->progs[new_prog_idx] = NULL; + array->items[new_prog_idx++].prog = include_prog; + array->items[new_prog_idx].prog = NULL; *new_array = array; return 0; } @@ -1701,7 +1705,6 @@ int bpf_prog_array_copy_info(struct bpf_prog_array __rcu *array, u32 *prog_ids, u32 request_cnt, u32 *prog_cnt) { - struct bpf_prog **prog; u32 cnt = 0; if (array) @@ -1714,8 +1717,7 @@ int bpf_prog_array_copy_info(struct bpf_prog_array __rcu *array, return 0; /* this function is called under trace/bpf_trace.c: bpf_event_mutex */ - prog = rcu_dereference_check(array, 1)->progs; - return bpf_prog_array_copy_core(prog, prog_ids, request_cnt) ? -ENOSPC + return bpf_prog_array_copy_core(array, prog_ids, request_cnt) ? -ENOSPC : 0; } From patchwork Fri Jul 20 17:45:50 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947130 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="O70eYm7W"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="aKl00G2a"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJH02v7Cz9s9F for ; Sat, 21 Jul 2018 03:46:52 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388436AbeGTSgH (ORCPT ); Fri, 20 Jul 2018 14:36:07 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38276 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387881AbeGTSgF (ORCPT ); Fri, 20 Jul 2018 14:36:05 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0r025812; Fri, 20 Jul 2018 10:46:26 -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=DX7rdIOZ5zSldQg76TLlywvYRw69nJiAZA6/AZroUuQ=; b=O70eYm7Wje/CJWtlMdAYw+QzeCzIzJTymwlop3xzEn1AnCbdBIeKfwpH2zc0sC4Xt1ZN rPOFVui1Yo2K09SUPhPuilQ2G6NR07eaxGLn5LyxsoYEUV0GaMcoRAj33HtkUf2uKH8B A0Nb75ZN8umBQ8Ik2unuRPdXkGiY9tc4Kag= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-3 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:26 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:24 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=DX7rdIOZ5zSldQg76TLlywvYRw69nJiAZA6/AZroUuQ=; b=aKl00G2ayHxzcC6FemNlJ8Kt3KJJgepPZDkGT4viQlPXI25XdTPRmRBfjlvispkO4qCttwxUVQ867GsYpakuZFePJ/9ADvEDZsLRXpuGDXK7mblsjqqLJ0ztIuNa5KGfWz+6H8OmsYX4GeVZ+LcqryANw0ESKCp58AUG8H2hNE4= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:19 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 06/14] bpf/verifier: introduce BPF_PTR_TO_MAP_VALUE Date: Fri, 20 Jul 2018 10:45:50 -0700 Message-ID: <20180720174558.5829-7-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: d7970b75-d6e4-48cc-6090-08d5ee68b3f9 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:NXhEo+V3zlodAfD3flS5jhfWh5zKmU+WwcxHAK/HaBRL4eOsm3+eS5GEiR35+jhcwWtJ4roKkwicnduQ9nFeq//hcnpr/2nZPx0ZuhSya70Bu7qAVMUIyClBG4zmN6f9PpLsYttUrnE1VG3Vp3R017o45Sx+bz5CZtgZ5cvoLpa3B4gdqA71HhuENoyXAFYuV46HtIa4naCUe8XWMMZffAI2H+P8tnq3fhiUuEmwCe1hFFKJ0bY/gTRsiUqRO6Hp; 25:qZh9ftg1dDatF+Ght2ebrPncxpNwC7qJPsvqyIXqS5ZHO5b2RzLUr4lLP/2wH7Q78cBVarkkHkl41FNbc2bLxA0jcp2C4za1q/aRwRDiskYOFvYr4QeSqT2Lo5lZQWJpBZs2X6+7IZIj4bLPjVNwGa9opKr8Vkf3+cHqf58HM1YKOYhWvq3h4u2LHNATXIB/EfOAZlSuZVhddaDXaPLmsaZ1aX0mG79OxfChfhzwpyBGyQAlC/H+R+zKVnhpiRKp3e3oVHp3f7SCJQ9frj179sok+CNcBOIZ+moH4C6wWB+pYdsLjsco3+/ihukYhj1valMI9cZEOSgTM0IXdvRcrQ==; 31:zwrLuMMXQFGqI0JlKUw5Mx0S0DOCtAUkPxMhjN1ibN5shXvMgIZXbHfb8o64SGqy9gySRy6k7L33wdMi08mLRz+41ZTqcgf9hm1HXvEP5VWDGZqgcS1wg0u0kvk5Qpiz4tMdg1t73JF17g+mKQwRtNwPI8ggltxmPYhGSTiV9TuPpczLfv//dUnM7ymww9T/aIjrpJ7LxnC64NEX7691OujzYTg9ZAWuSOYqX77uEBU= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:uABCKQHT7Js0zoZm0roj8QhBPKH/Lv9DeWIUchS8uYK3Z93seSBPXH/pUBACYQ7RQ/B93G3mp2Hui6UoDCnMYWzd8t8vVBBwfl4wAy/UErYOaO/VSfZz+7QCI2HECTCdrJ0kSed41E1LF+ZLgW4Rzvwo54dbR/7JDm+3W/pXXB6KY7qtQJgIell/OhfB0Fdst4eV0dLZIQZKtEMHu8lsNfJBXNt4LJxGZey0RIEcdLV+j6JrlC4xJAOB+BNIGgllxj/UM9x854IG1fi5rzplF5UDWUS0VGOkJXdrcsZaN1j2elwAfr3TfAV/8bo5nERY1C9dc616VyvzMQE124hY0J+JAwoGmJP4SNfPaJBPWhV0amg1N7ZqrAYLH+stMyT2MQA/RYTipDPBisDu9bg363kcC3hj1XiZKH8cCjf5iUbZMr9oYqY78MlvaBCSpE8XhrOzKVsnn+97zyPLZSLv+4JXTjjs76qQ5AXPaFzMFGp1OtCmIZUIbH67V9KdFDOe; 4:EEu37NMuptqt4TznZjBS1IPiJLLV+2GQrJwFkUPR8YIvgwW9jJiiMSrCP4L9CYQjUUa02wmtXrABQqiPaYuXdxlO6KH54ChM6Jf/wEg5eOmX6H85IX+iyRCcUUsPuDlAUT+fZAZuA0yn9pI8nHkWtdkrZAavcaxR6oXIrr1xXL7gdyrJ3Lx8I8Y4owUSalkp8fXw57aDRs1ckWd6+W4ZQ9S6kVaL0b3W3dUmmxGu0a374JmvbugU9fDRUYwJsNLGwNygffcpmHPQqSkp8iklWEFU8QNh3D4Dlt+WSHKBKfV+8QYn3sLYtNArgL38TQ3/ X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:+cJFglssASWnT9M3DMLcQ52MtUneFztlFYQKpjZbaBOZkj/8e0r1dprFqgsmyEYy5CG6SLF7Ay2LROcwzL+FeqbipMXFFOzc+fBSCz6mzxck0W8loTPv1dW/76PyQamctNjfDqyg9NaeEFNa8BlapDjtA1fa6oZFDhTNBoSunUSnvGy8Ys4eK7hnlq84O7BwodnW25OM0HfZNtZ9ohUqqJYEvJVWa4RVhD/Ea2/q69Ye6DARdb8jr6LNsQp6PKitQhrWdy64dSdN4kmUiyV1xxW9gl+yNm2AdJzl55ZKQ/QXerR74m4E25WApWQ/7xxeT3q4ZIgK+bJW0wfIF36PdIPq6QYpFg6DRu06WTR0BplMBGztETGAbzxCgqbTVrqYgTait7+uifctOmIaMwpV5CtoPcc4Ei13bDuBa3f5rF5egxmKbG/JP7PyDK0CZG4Axmq1QRjVFTujag9y8bfC8KcPZCSX5uwj56b0PnqlRqBSTsZTy9Xuv3w2LkfsKjPRvBngw387BNms4UxrdMvz+QHvbbEA3I2A3KHHOq+2x8MhknLhICGWMEe8cO16hBgYMwFlvKU8ZJu/vy4YTr2Z913B3yL1cdGNwW5OrqOeoTFPG84JS5sYw7pJBMQ3kQv5n/N5pompI+ASZZrD8zibVOVIlunTbtabjCMCjTdpuRrlwKl2WGgvCueRmDDueagTbgGtpgK2G2vOmK752lzRNSTAy0R6MrWqmC8xygYeEA6jonZKpRUJUnwbSqqiJjMjj7ClKkuPiNL49lHB8tWhaHIka+yymyi0PiAZ4du9Ncy7rj3yVSatpP22Fs3y5azpciII9mFISB7ND6Pr6y0mexBLZcORhkJaWpnsYBL+dNuWLfItBb65laAPvh8rVZWCqyHFl3DDk8H4c6RTTsC+7I3Zs44VL4Uwfu4c23Z4e0SgBk3DJVjtqKqK80h/8HBd6cede+pVDJMpLS/KJEmKvnNakXG/aGx6GrBSDLZ4qdPv7gSIE1j2dwvNFYTgRZQ/X5RCBtPlvzDIrNQ24X1I+NAkbqzCyDBWh5u80LWVjW+rW5fjKGHwDoPPGBEj31nx6mbK5I0w2yKjAzh4V1ByhpLXPh+kwFwpKCb6FF/eL8gCkR+2Wprz9E6A5knkXKlCFOcmLFwwNyfaRjGTmV49sBstaL/w8nFhLKzYvmRdF9DmpbcD0YrjtJL8OsyeqU3t2fCN5uXRTnAA6dJmkcYemMutJtAKVWNBJdGPRI5u1yAvu0ILuLpb1g8S6zn/jVSCV1PlKbL06ABNB2Z5vam5vA== X-Microsoft-Antispam-Message-Info: mwYp2E+5WA2Pwfjc+nC4/nmx9WAuinDKjmveZTCug/Wq7EQFaqUulpCKfZ+izqPzkf2lTmr6zcCtNzczs1SKaEt84BbtmTR9RG5iWpTVihvNKpuN/LVTVgdValv6VC1tVR+fSZppC2PMXY8nfT2qli7ERzWk4cejt4/8EvtDM6xV4lNsaKw8Gro//DmjNBoeZMJIUFFD1/R2uiNXWs/I6+Z/LZu3uDGhHXSsC91gOOhQBdeee9513aWI0Z21YmkuLXG2UTLG9S4um7g9tf5nfpTA/NGT4FOP0ePGhhKathkope16xzzuQpDC6T0SNGA8Pk1MonNejFe9lqa2Opkci59DuGnx5pL2P/XVYvrtPGg= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:KsYhnSN5lx2JGdVK4HjqPQ4gUA0uQ0Kvv7PghqDjKQlHQCBUBBxxMz1qu6hXDeVLD9BKTT7Zaa7knsyEZ1XofTjHl8oXsRH1ofKQkdkWVVGSjAWvIwnwD/TBTpRAMFQ8Mzowx4rxAtk1iWsmkstME5g4hUt9BQDY+0rLyLERNG9NT+qpJAvSzfVCfYM9x/P9/RXiccepM4eB9eGWPkEOoqDwpocoLI2Ss6rNtRMz8su+vGBHT8cBwhMACPE0nq4ijkRj74VaNpIJ4PESyzg8/11nXHdIu3PWZ70NL7lHTapaEciRqVw7S0ZNtjmye772ifuvVzEORgqKQHvM9rzfxEEMtYOps0McyrA5OzM+Mqv0taULtmBvoNalO+04OlAI26R6ZD9tAEZkwbrEIlnWtAITKLLQcQSFq7HW1rgGi3+PvLyy6QAJksRqvPPTz/l0rHpmIoXx8Z2VEHKXZ3eicA==; 5:GCoPr0S8uQD99Ye4Rqnmynqrss9neyUHZCr5rWmOdNv7bGC5CI5f+GURW6uTDQAaSGaITca+7/WxIv+osSEghqaLIftVDMfepS3r377j4xFwwtHPKB2rK7fjQmZiqLTYnAHvOEfcJwMkiWsKMSIyBltg/jb5Jd7cUFTOakfaxGY=; 7:AlIg5JTWM+5wN8Z40ZRZPTOV4A1sP5Bqg0xDewcwDot+QQEgUOECBOukXvfiw046ptd7CBM7rytqyoFMiymF+nAEwFkDVyg6ILV1fJFIXBF8MOITrXbvdL37Z09+OBtSNu01cGVyytCbVxYZ74nPc17BUm8MHkfYzhoCEOzI4WQUYReHsdG/N1KV6BhjeUXGE5RU6KEOjLQkURhjzAyQX6Bw3dDoVxqjeJY8qO9TTLQuoiGtt3Dryeo+0j++9LxN SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:cF3hnpyvk0C+dAS3tG87CQ58mqUOeRRLHOUX2UpNQ2DvkJZyar0r5gVqJZqiXn7jHeZ0yWENYP5OvylGqzeXuAt1rwR/NgXRvF0Fe91KPJYbeluDLs/8JV0iLLe1VzpjBsy6Xog2v3AdeBDQnnUql4ixeESGR3quA9sYTsWOMFg= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:19.9221 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d7970b75-d6e4-48cc-6090-08d5ee68b3f9 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org BPF_MAP_TYPE_CGROUP_STORAGE maps are special in a way that the access from the bpf program side is lookup-free. That means the result is guaranteed to be a valid pointer to the cgroup storage; no NULL-check is required. This patch introduces BPF_PTR_TO_MAP_VALUE return type, which is required to cause the verifier accept programs, which are not checking the map value pointer for being NULL. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf.h | 1 + kernel/bpf/verifier.c | 8 ++++++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 16be67888c30..ca4ac2a39def 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -155,6 +155,7 @@ enum bpf_arg_type { enum bpf_return_type { RET_INTEGER, /* function returns integer */ RET_VOID, /* function doesn't return anything */ + RET_PTR_TO_MAP_VALUE, /* returns a pointer to map elem value */ RET_PTR_TO_MAP_VALUE_OR_NULL, /* returns a pointer to map elem value or NULL */ }; diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 0b089ba4595d..8098e39f825e 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -2545,8 +2545,12 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn mark_reg_unknown(env, regs, BPF_REG_0); } else if (fn->ret_type == RET_VOID) { regs[BPF_REG_0].type = NOT_INIT; - } else if (fn->ret_type == RET_PTR_TO_MAP_VALUE_OR_NULL) { - regs[BPF_REG_0].type = PTR_TO_MAP_VALUE_OR_NULL; + } else if (fn->ret_type == RET_PTR_TO_MAP_VALUE_OR_NULL || + fn->ret_type == RET_PTR_TO_MAP_VALUE) { + if (fn->ret_type == RET_PTR_TO_MAP_VALUE) + regs[BPF_REG_0].type = PTR_TO_MAP_VALUE; + else + regs[BPF_REG_0].type = PTR_TO_MAP_VALUE_OR_NULL; /* There is no offset yet applied, variable or fixed */ mark_reg_known_zero(env, regs, BPF_REG_0); regs[BPF_REG_0].off = 0; From patchwork Fri Jul 20 17:45:51 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947137 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="I8dqMZf8"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="IXGoUi8f"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJJ25PN5z9s9F for ; Sat, 21 Jul 2018 03:47:46 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388356AbeGTSgC (ORCPT ); Fri, 20 Jul 2018 14:36:02 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38250 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387881AbeGTSgB (ORCPT ); Fri, 20 Jul 2018 14:36:01 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0s025812; Fri, 20 Jul 2018 10:46:26 -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=qGtDowD9XKbzM8Jae4SYFfVcCSuFG5sG+sEXv0fEVv0=; b=I8dqMZf8HD8fNM4Q26ekiMt6CAnqKAM3wkJK3NNTtacKzomBdz66E2L+xYwGO8BlSPFj UZK7+OI8R5N56VP7IqpKOAaWexc/18TxFaOEqCy/omYDEehh0voCp+cbY7zECwPNxI0A xXjuaeSkm0rAvGbRp6sCaSzBIC3oPiIFJ5g= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-4 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:26 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:24 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=qGtDowD9XKbzM8Jae4SYFfVcCSuFG5sG+sEXv0fEVv0=; b=IXGoUi8fjPm6xr3qZQUPo2s34vhkNQ7KURKuPYmI8UabUVPkxcTqCaXAy8ACLyinigSJgv+a7pWpKmPzctEY9NwT84NiU0hn1TcKgyyMFVbAbCaHD5+aLxoe3SofLrSz0qskra73vlm9zRwSkSq68DkMv+1mgMDMaxMlk9ANiqQ= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:21 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 07/14] bpf: don't allow create maps of cgroup local storages Date: Fri, 20 Jul 2018 10:45:51 -0700 Message-ID: <20180720174558.5829-8-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3c8d2bc7-b913-4239-586e-08d5ee68b4a3 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:VjL2fahZfqsPVBz5581ZfaTrGhlH3mGT/isSz8JQEz2DwlH4Szs0dSSDrZmZd1sqXmqCK9hnrIst8HaJ6IABDp74whTDgQ0Jm+w0KIQHPPHo0pVsrXk18LxLyFIGiDPNR5Vedoex3/J4HbGN2FvQrSWHD6QQ9yWmIKt5JABkdz3OijmfmA4tTRIkcEkAl//GQVVCRuujaizgj8w1UloTcw6xznD4/dfoxvEJlzuAfoWL8rHbi2xUFKr0Koc6oWeh; 25:89mM1L9sV4s2jI4s85pmGMA9DUykKvaA1qV+bcPi2e97sn+Nhj4YPF7/2eRv3KVKckdupmHZnTk84pePp89gaFVcckFuFNvYGM/0e9YPQNm3+ASo9wbL2iq4P42Nm6wU6+dfV2o0ul0ia+QwADV1cyhfwCWca+UyYrSeX5fYXcZceCgFR6YZbnKAvJ8BIrVbfY9IaIJXFwYGSB/EXXp6Z1pzD3fbMuADtDWKPewQVOz4auGwpvrTrnqU16YWKbejKdNIAz1sMzi1zQihse6R7oM6mIGNBhUdbAsfhp1b5gCKJbhDij205sn+emLrQTAjKGrhHOld/e7aG7MDtxb/fA==; 31:RjI/hyQb9JBBnDDwIaGIQwZMCqnkenc/gGrrTCAV0ZmpzHxKzgL6G2JZNJIVVDBv1dF+852PR4IeFNLPMrP83UiDOidlN7lMP6mwx6a3ICPWR4aYcBiMuoVp/97p1NSLqWBySVUJ9+inZYy0FcDFFL2ROSeD5VuEqG+mIp6p0aclpGpei3m+2apCVBCPyfQBRrRcNyBGOhT4iV2yRptK1b59wnYPV5rEfUpiayuw2vg= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:zgjqDJuh3Ty2iOSOnpW99BH1QHlin1Wi4FFp7bXmKFL0XHcV6GafkGwECfka8uHsWJ1AYGwKt321B7Ptqal131vwkAahIJdWUMDmfpYTI2IuTZyill9fbZJhxg07PNZ4stC5XSN60NQDsCdcKgx7XtcwfVCetBdkKWbD2g57151M+lQlqYTgosSDO4BbYKHgovhuXFSSprNCzj145O2TjFEOPkfuoprW1qnM/KSai6ACCD31XNbT+GZjGLa/hLeRksh0NZEhtAZ7jp+tbEbpGM/yr20UuXydolBRbCfIs73XPJTYNUTr/uhCTh31h2y8WvTGYoRZyCvWgRbJ8ASr00xE6pJRagpVyuYRZ4ctdfKvhBMGPbbaRHYVKWTjrZ8Dvq192i0ycLybWzLqvnnlc+3hYEZqk59ZYibiG15raV55a0ASEFKVa0wca1vYTJX/jZ2mjRKhpf7kQOWkxKjOldJ4azh35uFZfDngjXeHYTuos0UDbx+XuOlIAXv+v9ra; 4:qY+S9EH4JSH5kQKpqXIkk0Kn63Pq7FQpHglovodD68JTmd48GbamExN1HlERcY8Q9xQ3oQCQAHVIgbkUvg6XyernvutfGIQADlihDr+TCnt93R0chK736XQTngLeImymTORrH/X+dVWnAxhQmmJwXY0M1826mOQvCQmL70O64tIRvEQ0Zp2HWJ9wWmRYptpKELAVfxv5wzFZwy0dBCgb12dUkosxDlz5wJxHaJdL4B9/VURNcKJdyAPk7GRqb7NSQCwMR357u9JXTlEqLLej9ZVQUXcj8WT+JE7Nji4ExTSZR8hBjSOejiSePQInHJAe X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:pAhKgDpBpDOMZt8M28M76uYnl6txA4p611BUPIdI4Q5aNkyjqmNWH3jc/LIvnXDNAlGQQ0V4nihG7M+9ZL6FKidiasU5OVUpiblb/sCHC3VZBZKMeMtggawvB5CnuaVknviCV51CPYWdBdX6qIH95AC8niwpUuS7M4taWYzud4Rp4mSnzQIoY5ZCL/XTgtaJOUx56KBC9HvKqygiRNipXFG7bXf8U6X+lttW9dOAXj/uDHpqHwnbo8xOMYaxgKA7GCoHjmBd8FBSG5GC9QxkeauBu9pFP4aX8pCZX3TkODYw/X/Vyd1vjFKwHYAlnumam3i2ZnJKElh9kDtrpWCnAB0+yn9eEDrXAF7okNg7XkYUKbWx+6IF+ASmNnoSiB8iEkR6R8KZk98gZvvmktZHcHJgVr0DVoEJrJ4iP1CY1l8Uagd2nnNarj/7WW0G9m7QEqAXboeJ88lYVgc2ZK5cDm4jxoZ1Axe1GQy+jdMG9qdF3KEtwjk7tNslFY4opUkxNJpeacXzuG/GZTdfcW9i9udR2IOOkZD6wMXmgYlH2a8hY+NZKa0nC6kdd7H6EBcE9fw7qqA/ZaTNx3JmhDxKLDvXKDrRiWsJuEhLF7g/w2HY4CLl9s25WeeMEvr7dshwGkM66WlO+7AJdOEYlTWkOzaeBq++QQd+V2itRpylfch1PctnFuDYDKcrdw//6xcbUub/wfIr8rqf1cBR4uHY0iGClCajgNwQtR0AdRSAXSMVdQNXBsg2cBCeecC8soahlnS7KqkfokYSfsm7mUOiC9ggEXpaqvlwQHl47o8cTfCJ943eBqjqWgvpcGI8USqYRwh9wjHagSEeiKz5nbDS0Ae0i4XmoqWqvOYNrvi41w52QETEDhMAzYaEe+ItCLNgyH+iB+eyfYdzjzS8yvuVpHpy/f3Tu4X2wKYbLGyI472hqqUYVXoMbnDjv+yDCZk3x9RYUpf7lVrj5bpIEtjdTMsCSUmRqKZHahXmAGUjXKJHKS+JGvlSf4TF+uKuQlSmpInJjxsWLKkvuHCbQx4navnx2PqJacL7/QY5aLgnNO/bvJamHb36U32/fRa5Tv6N5uMUp0G5jYd6hmGmaNdwBTQmwIf8q/rrcNmKVgkCicrB9eVNiCyMUKetMik2H31jnoAjWfBkS32qIqOInI5KCgMAQ7Sgucvt8A8XVHvPfylkPjgkFJ/eZ72mR8Uvk9ta6IgRCaxxqE9OX4bMNYkex3fkSv4sXKMZ9EuHO3YW0b4uWwlzrkuFWEPULJOq5J9bR1vPec2sDzk0D8pwC9UJKw== X-Microsoft-Antispam-Message-Info: VtV0b9O77PXhWbd+w+vnlb9hpTvHdOCh69hLgYmnzPZxSUZJpzUa+ZMOvjTl0L74zwJEJOFoKhYy1Du6Y2DNRKnimDhue7n2dAsbb8arAZ56txN6j1GW5dKL/DR9Rmh3KARJZwlqu6MvDFrTUx8iK5me+VS42D8RzS2bhOulsupcrnAo8bJqnwMCnhIJ40v7nACZ2UPKpQmKVJ1NZZumEaV/cfUhmNmdRPeJbq2tpNpN+OJvJ9/QFzdh+0T4jbK9VeS+HO46M65Xs8pV+ywngAHS57mv3VNVpKa/QYQovpKFiwwxlpDgTKchRwsjNrvifBsdC4wqDL9dkfgmsXbV4/hLQG+N2UCWIfd8eMrlZok= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:czdx1KtarLi+/pNgWOyCy/SSZ0VRkTLREmz7wnviXfMbwxpwv2sycuJChEq90/ystqSWcBmLIi2yQx20zvUMDpQ8fXaPoP6lkhDBnBrxGndvIvK/pDb1/uR0zXuLlH4qgbVI4371O/GVKdwfCRh0ELFVdkYhwZEIRY88BurpExPtofGYGQUP78V5dVOAqtEfagvyZGRjipQsZwea/42XuyjjS/AsmUHgdRcw7CkaTQmNSl5w/E8C8MFaxU/uXdycvdSxZv+a3fD7cD5jp3f1TjxOQ/eXUCZtILzvi70LN0heFdO6zWigzYszdP2WdJzxG3pZh8XEzTwWNIT8TxeTeQJE3Y/RIz2FvPah98utFrIEqEn/ia8TyCizWt3kCSfcTGrDrCQahzNt/dFhvGMDYk0DyVu9ej6TpIsDUlzgxPzSfxegAHJjxlqtIjOOOXE0JCH0a3xA5ADXmWIQs3uHqA==; 5:wQk8NtTas/qT2bhTyPSe0CafOR7ki6KxU+B6nU/6/I+MiGh9JGiRnnJPgIu5kZy1MVm8GqVyeiHbfaYL4t4f4CJBzsW6BzG5WUA3TV4YMQVVWkoqjYQlv7dSfSm3aQllIKP+Fm7ohtow44Oqd8T9+5+edZ2frHrvStNBZga5C0U=; 7:+B9CLWTr1HZonaLsRaXcUw/dx0Oui9F8IlDT4m2wrpR+sw3mdYBgHQ2d2NyniG5Ljt3/CBqYVWRB2R7FfJyj1ZxEzFEujICOUOKJ9TAWAVm9wfBV2cj9iPcvHSXzdd8Z/KI38bE+ykJgBTEYCca9fz77twhbrxi0c/q4WpwrphhIvhFbaQog+IjvHzg2oWZqEIA1Zys5mCFohNaPdKFqPR3u63r/bFmq90wsYnFsrMeSjPuJQhMYLB7vQX77Pbby SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:/CLhRWDqowtDePz5RbdbnryPJSXOLK5fl68Le7jHNTxv1B8wTbxeZC+maYWWeId15xhGGhjoVJSqcetXEBZEGNtg4YSBS4+pkERabyz1KMDJXEL7804KdjRwvbDHjN4AZjAlDmA25pBSdz9qV4mRJDUucrTxst14PSnhjbwj/FI= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:21.0360 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 3c8d2bc7-b913-4239-586e-08d5ee68b4a3 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org As there is one-to-one relation between a bpf program and cgroup local storage map, there is no sense in creating a map of cgroup local storage maps. Forbid it explicitly to avoid possible side effects. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- kernel/bpf/map_in_map.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/kernel/bpf/map_in_map.c b/kernel/bpf/map_in_map.c index 1da574612bea..3bfbf4464416 100644 --- a/kernel/bpf/map_in_map.c +++ b/kernel/bpf/map_in_map.c @@ -23,7 +23,8 @@ struct bpf_map *bpf_map_meta_alloc(int inner_map_ufd) * is a runtime binding. Doing static check alone * in the verifier is not enough. */ - if (inner_map->map_type == BPF_MAP_TYPE_PROG_ARRAY) { + if (inner_map->map_type == BPF_MAP_TYPE_PROG_ARRAY || + inner_map->map_type == BPF_MAP_TYPE_CGROUP_STORAGE) { fdput(f); return ERR_PTR(-ENOTSUPP); } From patchwork Fri Jul 20 17:45:52 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947132 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="GLnwhvUg"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="Xe7Ms9yW"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJHG2np5z9s9F for ; Sat, 21 Jul 2018 03:47:06 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388466AbeGTSgJ (ORCPT ); Fri, 20 Jul 2018 14:36:09 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38286 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388414AbeGTSgI (ORCPT ); Fri, 20 Jul 2018 14:36:08 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0t025812; Fri, 20 Jul 2018 10:46:27 -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=79UrqdJRtJvsS0blTmNOmoVoTagaWl+Y6xDaozbmzrY=; b=GLnwhvUgFDexw83BclT46AtItn8VF5AB4SnLsNbprFIbGOLQdDC+bqIlSFyD6CuB0qf0 LQJJ+regwppdQ3tMiNwA3AYdcScUWryI4dTq2US02hRB/qvC4nOXcPBOc4AKlvfRp+QJ TIu9OIwR1cJzP0gjjddNOdgX/ssspgM1Zps= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-5 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:27 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:25 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=79UrqdJRtJvsS0blTmNOmoVoTagaWl+Y6xDaozbmzrY=; b=Xe7Ms9yWxRglddw88bVnsnNVrEQ5MXnIfNyoEr3uf+jpFiVbyfpYQkabp3sjzh0m9rxVaQhAZfmAHp5EEFP0fkAZb93bz5xyoCI2i1A3rvq1jdH7HAmfcM/fS7c8a26pLSpHfua5uacxKyLERyAGAJn+lbxAoqvG/0aziBiTEKE= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:22 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 08/14] bpf: introduce the bpf_get_local_storage() helper function Date: Fri, 20 Jul 2018 10:45:52 -0700 Message-ID: <20180720174558.5829-9-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: f1c80783-2fbe-4273-30bd-08d5ee68b549 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:yCvYKBh1XDnqMtCi4sSkg2IkO0JRl/YXBhiRPuiXCgBAkaFqIM1feOlybKnzXd4jbyyZa4yWahsfUZWCowfIg6H4enpFUlDDzc4bKGXPddqvRDv+zZVPkqUAboAdkREdP4VQDBdc/bjSblCIrZLeq4KIINcG++BHjHcSAuG8PeiwRokx3oV8WbTUUHk0AIExLGTcATHRfvnps3uMJM5stkPRM9e0KIoaK17LYbVpmSPoPGD+lHrufTUYduz/K1Zw; 25:xsYlGnpYzqH4W6kKb9c9U8NIVzqzcFyPXGX/i9LO7kT9/bbaaYq9UPOIpQAtjCTUKVzVmpg9VaXL91HveqXHddV4u3YpkUVqgEJoXvzpBB22lVgnAsk+0kDCfmvZlJDsqY/5pcDlwicNERq7TfsIGon0NdIneuIjhUlEtCyvDMNEGpNv84JRtvbpFTKTkuu2mbij/qnDZ6WqDDMx7atkjmeUT54l62pGdb/iUrKVtJecemPQ9ar0SnCis0KZHeLBMEHYvLyhRmv8vqDhQjRF3AL7Wa7s1o1dVbQWxvZwuPF4dK59GT1oOgJZ5rvbEpwt48/Kc7VvlcaLcfM+cqeccA==; 31:hY+qm+JY8IjUUSKCBPArrsMbDKlyoJHknhcAMT4r6mTCjHxKHffdZ6a+KoMXaHnOVm/Z46F5HusRtEG5G2ySPsAs9WhVOyWxK/dFnbHEbNrOD8Kdi9A4de5jXxi4RyubKZk3GRvQKDARmcgFSbcmT3tJ9Hi5io8b1gsE22SJLznuPwWhgccnUjHCBj0CZCFXy1+BtacV88UDwcWWXrlf/IYeUVDPjo7cXzsAsz+UCS8= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:P+O6N4ni+Hpo8gFwjN/RagY+BoPTTSi8QVAtU+RAFAy3YC3ys2PyePzca/JSLXLjO0pqsMf6FfNkL5p4JRSIE7RsG/cJHtgufQJs2+jln+hdBvZ++9SqgJ0j8AI/WUa5maMyn/GMZKFoa9G5JSA7VrEbyBf0BpCGHd1FRcvtYJiQicjc1J0aa26XAv6YA2J/h6AfD9CvzMTmkLod9FfBG3sy8Ozy83s2Kspn8KDnzatBI3TAA3eKj9nh+y1hYxZ2cfHtuOd65nXyk8eQ9OYPE8MVs8hTxscov5YNs/Sytm3alhbGaBF9A4uWSlHBl905U5/qEDyXRaI5XuBY/jkExz0FvEO3mJjVT8rhUBtpJNz9yiHgcPVXaj0heFyBBGXDWSC3JnYRjeJGiyNj0j2uK7C51ERw4mY4+ky0bAY9bz+rZKMjjn8uih47kSu1MLJRhfXzK/701/hYjA5Ad71r4lgI07JHrX31f1uxwCrC6ME7waV0apc0T9yMo84AQkmc; 4:M2Deof5UXLi5WUQGV5A5jkJl9COW91xxx/CLlFeUHKs4O7yJIM28E70QHtppguSoYgfPd2F+TdrxJB4D0wlufu8e4RagrvfaYoniSK8FvrzNLWDZmQFJiDSCd+oPog/o1GcmBYSVAgjMVuVKzwjhMjQyKpnZJUfbRfGuMBnc6mJzu44V81xZl212S2wPuoX9Lxpp2BAZX1+XEGf5JYHdVtLg9dazqFJIl7kcMvZUZlPhT92nFW2cgWn6xfxJBMBX/R7VLfy0Rs2ONtYoiXXp0kJYsKS2YUPIrbD5QbDAgxt2Oj5KprftZX0/mE5y1kITppcgnDoBEK69v/kpBxJ7Kb5uXKywIDpJyI3m9/ZzA98= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(131327999870524)(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(575784001)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:4M9VT6chl0VDEsT80X4TzwJov5t49Q5qDJmnWq+LNHsybXaP3W1UZQR3k52BErXQh3vUyliHE5jGH8iqPRwgtCc7SStJ2plxK5iQV7s/5SJV5IeWsOZCCBHImfsXqyo0W8yT5kvXFVx10xg6Eewm37MnA/NkwplKHqAjtrb3HiwgBopbWir1zY6c6vHbJEBKfa/NhD3NMfmKpcdRdVD+CyYZWgj2ttR2hWLkSmySrATocs6pJfu0D1rc0BiNyVAw28Zbwzc81CKw3F4LFbVQfxaFCZqI7n34aWXdnpuq8/OXIuKiM7p0zghmyYIc2wxXB21e/m04pn6IxotGfBSlk3e1KTYflV21PUT83H6kt/p6D6ajhK2ImDH9h3YLNPULfrOxMXm5K/3BT9nBk7b3mJk5NrAfB2D+GxV/7xJBrwmOaMk4XAQ1VqMVbhsVQe5DtYTIK36kwkMrzG11SEeIYbsEqpbI+JxpjkZe3B5D9oK7HvuXIPADsU2KN4chLbjjrLdaQtp2IkddKbOiBJfcHq7BL8cPducy3eZo6IrlN6CMT9CIN+0tzTR+wiPw40aozIKIAljVo8njFWjWJggVEKOP2wdRm9HTyQghw7w2QJFVpcVusx4AavasZDjNoHWkxMj8GnCVUqfvSipkBJB7BOxlINHbbMAaDE5Pd2yqzH8Po95LzXcqGEA8Ocm14APsJfzupEyNLC7L9ots8GxxJD4wbXD3P4cO6K3eH+z4not+66Ve8JGrLQz8lAR6hM/UM4kNsCVXKsp2TcWDNf8Sb7MAd1a97gqOSw/I/0zTl7aZuv5IVvzEA4/eRUhJsaO4YhkUCkvxjWZR7JcQif5Hp8KqM5hvZ1FnJiI8iHnltyCLtjFqzZasrxbHMj8Hcplvsin1y7esHbcMCnxfJ/ioackUnpqy0rcfDyCP1OldEwaltMQCzwt5YK6tRXSzw7/+59cb6sSkvnigK2CMoxX2wklAv/sgAA+QTVNp0GJeh8DXelzsgsFO1swh7NGHa8KjdV5d/BNlOv9OsUyuznDYngOKPPmryDE5XWFWillY32NtO7aXfc2qi+zEyIqWffx/5v+MXL30q+WMADbUhIHDyB7AjomnU1MIc/U9YKab0FtwtUl7KvzeHBmZyAdii8HwAmLUaFLl7+XNCSjv4suvvsH//IXX6yk6UPYHzxL4Yh2AZoHjuoyzz49NToMpgQRug9EN1u2pZsbpGOmjibqwzCRxP8Ce+kZ0OLmSqyO1+gZiPJWMphYpKK71+pFz4XUJZHCAW1/c/mlgBEXIoWtblH+PSNO8uOSDRYJM2RctepI= X-Microsoft-Antispam-Message-Info: cXauGSuGG3idvq8wPfqie1j72SXhjC1031A9Gg1FjVHFDFZwzG+AZTHbNQd+aSP3nUWPTa4H98WobcW61SOiL9POSIEVrDd+GMH6J44XQa7xnPRDnx4XRC6ylUplhmCEcL9FkFjU21lXWPE1kMHgKdgQLmJV8gcgbjhBbu+BkOm/XT+TZmWdeqKOHEJSkHWLh6xO6dyRVN45GD8Xt6ocvnidlMeAgBwwGRPKAWNZ+W88YNXP4++v1g/pTx4f4RtzQ9IPvjHUoVD784qVesehup/FhYsJHgyysv4MT/8wbRZs03vpQZHF04chW5dHGVd4sqKEvQ/iP3LxVJ3szoMisVsDAPSifHl35gRpcYi3jNQ= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:5tbU7RqMYXZ0eqhjT2BdrmyZ5JTrhl3Zyih79G2PUAdQIliHs5e3ZR3VBz8o1KtJykx9JTSAEwba8HQXfzXpXm6+YUUuKZfiV4rPkJDmOFdyiNvqbZZ5YTu5HqvjY1Rjq/OEcfOKqm1TL21o+F6mURM1VqpfNw6t1UeR1mpZnuKGLPyOk2d+1xqJ0GBiGLThK7oHwiYbqIV+HbHYH3m/Y4ZMFF/C/MhWHs/eIRYf60Qu/GNEyLItF2mR275imK+g9wuGa4XEHy8pN8pSjmG3SygILfHKrc+YrcD7fVqicnhK6nbeHAiFd7lRl6t3Xb4oZt5g5RRUglg/xfLV+uwOoMhfatp5BmtZ0dWrFnD50Qeh3e5kgLn0uGH2MwTdg6QrN6s7JzXXGEhUT+I2eNzAXXIV/IgYTIn5dvpGCIKi49fsGKUw90Xk4+ShS0zaVzX11iw5BPXGEBVXFLijMKDgUQ==; 5:ESVJh4beYVs7VxgicFf5ft1AHi1EB4yExxeTBu+O85A/KxjgcEH2Gf/nxzHzSB23LWtGbf28BTpEj8qMHx4qxwW6VxCn63ITZUHyw0NHvNjaqLmiTaDfy8zc1cAfefG+Jf3wtLw9hSy7MLU2Qx37d3RVgOldZ4ZByAbNDz1hh6Y=; 7:j1rSbB72P9AjaGHBIVt3YSrADLa1p90aYozVmw+cSJKKeuw4yMoCpBGL2pbfx9YxBZVXQ18MpEdLbKyPY4gSJFna2LjqLFEi7naFLHanLL11pvZG7qq2WgmWW4kzrOYYCMHxM0UqZEV5DHpqjYfwC8RGozfMuGDpQ7CUQk3fduFEhCOaQzR6W9ex51vLGyYMBPA/Ny1l0+uAkPS/8Li/In0w1sThrvtpmYyD/Gu97Ujsf0+W13BycJbsno10RB2Y SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:9bSfy9j50KjUjsp6qyDC7dyvBiHxbcrPJYLC5n8636Cc0JMbgHYHbMxD+kgEOuX7KmLWb4WblXsfWrn2urhd9kI67h3OlUVPn0MAXzR+qY8Tfrf+PTtKoHA9QP0Euae330CvhdWEOOvtw9s530aNSbF7sOoIw3V9v1O3kF2QDc8= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:22.1179 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: f1c80783-2fbe-4273-30bd-08d5ee68b549 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The bpf_get_local_storage() helper function is used to get a pointer to the bpf local storage from a bpf program. It takes a pointer to a storage map and flags as arguments. Right now it accepts only cgroup storage maps, and flags argument has to be 0. Further it can be extended to support other types of local storage: e.g. thread local storage etc. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- include/linux/bpf.h | 2 ++ include/uapi/linux/bpf.h | 13 ++++++++++++- kernel/bpf/cgroup.c | 2 ++ kernel/bpf/core.c | 1 + kernel/bpf/helpers.c | 20 ++++++++++++++++++++ kernel/bpf/verifier.c | 18 ++++++++++++++++++ net/core/filter.c | 23 ++++++++++++++++++++++- 7 files changed, 77 insertions(+), 2 deletions(-) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index ca4ac2a39def..cd8790d2c6ed 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -788,6 +788,8 @@ extern const struct bpf_func_proto bpf_sock_map_update_proto; extern const struct bpf_func_proto bpf_sock_hash_update_proto; extern const struct bpf_func_proto bpf_get_current_cgroup_id_proto; +extern const struct bpf_func_proto bpf_get_local_storage_proto; + /* Shared helpers among cBPF and eBPF. */ void bpf_user_rnd_init_once(void); u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5); diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index a0aa53148763..495180f229ee 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -2081,6 +2081,16 @@ union bpf_attr { * Return * A 64-bit integer containing the current cgroup id based * on the cgroup within which the current task is running. + * + * void* get_local_storage(void *map, u64 flags) + * Description + * Get the pointer to the local storage area. + * The type and the size of the local storage is defined + * by the *map* argument. + * The *flags* meaning is specific for each map type, + * and has to be 0 for cgroup local storage. + * Return + * Pointer to the local storage area. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -2163,7 +2173,8 @@ union bpf_attr { FN(rc_repeat), \ FN(rc_keydown), \ FN(skb_cgroup_id), \ - FN(get_current_cgroup_id), + FN(get_current_cgroup_id), \ + FN(get_local_storage), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c index ac480086effd..27236346900a 100644 --- a/kernel/bpf/cgroup.c +++ b/kernel/bpf/cgroup.c @@ -681,6 +681,8 @@ cgroup_dev_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_map_delete_elem_proto; case BPF_FUNC_get_current_uid_gid: return &bpf_get_current_uid_gid_proto; + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; case BPF_FUNC_trace_printk: if (capable(CAP_SYS_ADMIN)) return bpf_get_trace_printk_proto(); diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c index 9abcf25ebf9f..4d09e610777f 100644 --- a/kernel/bpf/core.c +++ b/kernel/bpf/core.c @@ -1795,6 +1795,7 @@ const struct bpf_func_proto bpf_get_current_comm_proto __weak; const struct bpf_func_proto bpf_sock_map_update_proto __weak; const struct bpf_func_proto bpf_sock_hash_update_proto __weak; const struct bpf_func_proto bpf_get_current_cgroup_id_proto __weak; +const struct bpf_func_proto bpf_get_local_storage_proto __weak; const struct bpf_func_proto * __weak bpf_get_trace_printk_proto(void) { diff --git a/kernel/bpf/helpers.c b/kernel/bpf/helpers.c index 73065e2d23c2..1991466b8327 100644 --- a/kernel/bpf/helpers.c +++ b/kernel/bpf/helpers.c @@ -193,4 +193,24 @@ const struct bpf_func_proto bpf_get_current_cgroup_id_proto = { .gpl_only = false, .ret_type = RET_INTEGER, }; + +DECLARE_PER_CPU(void*, bpf_cgroup_storage); + +BPF_CALL_2(bpf_get_local_storage, struct bpf_map *, map, u64, flags) +{ + /* map and flags arguments are not used now, + * but provide an ability to extend the API + * for other types of local storages. + * verifier checks that their values are correct. + */ + return (unsigned long) this_cpu_read(bpf_cgroup_storage); +} + +const struct bpf_func_proto bpf_get_local_storage_proto = { + .func = bpf_get_local_storage, + .gpl_only = false, + .ret_type = RET_PTR_TO_MAP_VALUE, + .arg1_type = ARG_CONST_MAP_PTR, + .arg2_type = ARG_ANYTHING, +}; #endif diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 8098e39f825e..609ca398d7f1 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -2127,6 +2127,10 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env, func_id != BPF_FUNC_current_task_under_cgroup) goto error; break; + case BPF_MAP_TYPE_CGROUP_STORAGE: + if (func_id != BPF_FUNC_get_local_storage) + goto error; + break; /* devmap returns a pointer to a live net_device ifindex that we cannot * allow to be modified from bpf side. So do not allow lookup elements * for now. @@ -2209,6 +2213,10 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env, if (map->map_type != BPF_MAP_TYPE_SOCKHASH) goto error; break; + case BPF_FUNC_get_local_storage: + if (map->map_type != BPF_MAP_TYPE_CGROUP_STORAGE) + goto error; + break; default: break; } @@ -2533,6 +2541,16 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn } regs = cur_regs(env); + + /* check that flags argument in get_local_storage(map, flags) is 0, + * this is required because get_local_storage() can't return an error. + */ + if (func_id == BPF_FUNC_get_local_storage && + !tnum_equals_const(regs[BPF_REG_2].var_off, 0)) { + verbose(env, "get_local_storage() doesn't support non-zero flags\n"); + return -EINVAL; + } + /* reset caller saved regs */ for (i = 0; i < CALLER_SAVED_REGS; i++) { mark_reg_not_init(env, regs, caller_saved[i]); diff --git a/net/core/filter.c b/net/core/filter.c index b9ec916f4e3a..269e5bba119a 100644 --- a/net/core/filter.c +++ b/net/core/filter.c @@ -4675,6 +4675,8 @@ sock_filter_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) */ case BPF_FUNC_get_current_uid_gid: return &bpf_get_current_uid_gid_proto; + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; default: return bpf_base_func_proto(func_id); } @@ -4697,6 +4699,8 @@ sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) default: return NULL; } + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; default: return bpf_base_func_proto(func_id); } @@ -4719,6 +4723,17 @@ sk_filter_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) } } +static const struct bpf_func_proto * +cg_skb_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) +{ + switch (func_id) { + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; + default: + return sk_filter_func_proto(func_id, prog); + } +} + static const struct bpf_func_proto * tc_cls_act_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) { @@ -4839,6 +4854,8 @@ sock_ops_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_sock_map_update_proto; case BPF_FUNC_sock_hash_update: return &bpf_sock_hash_update_proto; + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; default: return bpf_base_func_proto(func_id); } @@ -4858,6 +4875,8 @@ sk_msg_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_msg_cork_bytes_proto; case BPF_FUNC_msg_pull_data: return &bpf_msg_pull_data_proto; + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; default: return bpf_base_func_proto(func_id); } @@ -4885,6 +4904,8 @@ sk_skb_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_sk_redirect_map_proto; case BPF_FUNC_sk_redirect_hash: return &bpf_sk_redirect_hash_proto; + case BPF_FUNC_get_local_storage: + return &bpf_get_local_storage_proto; default: return bpf_base_func_proto(func_id); } @@ -6687,7 +6708,7 @@ const struct bpf_prog_ops xdp_prog_ops = { }; const struct bpf_verifier_ops cg_skb_verifier_ops = { - .get_func_proto = sk_filter_func_proto, + .get_func_proto = cg_skb_func_proto, .is_valid_access = sk_filter_is_valid_access, .convert_ctx_access = bpf_convert_ctx_access, }; From patchwork Fri Jul 20 17:45:53 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947133 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="p9PK5PpI"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="RyFz+upl"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJHP671mz9sBJ for ; Sat, 21 Jul 2018 03:47:13 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388446AbeGTSgI (ORCPT ); Fri, 20 Jul 2018 14:36:08 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38288 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388412AbeGTSgI (ORCPT ); Fri, 20 Jul 2018 14:36:08 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhh0u025812; Fri, 20 Jul 2018 10:46:27 -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=yfQNPwrixdaFLklu1XukLvaBulPKXRb5WdJIli+pp/s=; b=p9PK5PpIqCaM4eprIx+ujEDiiQIGDrjcCZnB3P6LoO0cWDQLnKSR36//pMTLV+Pa84RR uYlHUQaz8v6sM6q48AYgKihlnRQvwSTPI2SOOvvy4fsiIL2zUm/vVeJFEM1JiCBeZFwX 46GKhSQNtszXIaXF2qJB972KPQHK7kTDaNc= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80dv-6 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:27 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:26 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=yfQNPwrixdaFLklu1XukLvaBulPKXRb5WdJIli+pp/s=; b=RyFz+uplWOKY4wAtK6lDKGRgl9QRNGUx77Roueldl/ODdsMZ8idjg/iEQxMCZMNqT7GBC1lN8yy+CFn/Ka1YRV8LfAF7v02N4imi3NC0rMyu1UHslf2t6nxfH3btWcMZB/842PwckJp5eNUBkD0lBsNkdtHN1XI3CX1seTDCTOw= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:23 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 09/14] bpf: sync bpf.h to tools/ Date: Fri, 20 Jul 2018 10:45:53 -0700 Message-ID: <20180720174558.5829-10-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 4a17a84b-bfae-4a9f-3924-08d5ee68b61e X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:9EHpSsqM1QkcDFd62ntqxepIP+Sff7UJWVk8ndnjT5IkVbx5Gb4gu8ZPxJOH/pkcZcEMau754Ze5j0gS3avHYenVX06ZzTkrKuQK4dPLQh1wmjcvMMCHUoaTTDziC5HiBgn7UtV5HPvIXTC3V/9fcyfw7dONeh0IqWRdv7ns4YGi7SR9qfKNG2GQGv2B8PrScFZgei404dwrITvg58SWELJZcdqYrRzcaXkQe4RFM2XYN/J3s1Ac7/R5rdbzis8H; 25:fwO4838E1PnnQu6CyKDAZz3v5XfS7Y4VFdxQVIFpCNzjrGEd37HFKgAdmTxq1S2JHje/kSvFG/RY4E5/ziIBlJQPKyPoTh8WS0Kpq0Ey7WiKfTSw1AReCEZag40lFyI/Y+acCnQhW8dRy9i2or7AAGCEKC2V6GS8wWWbHuUHlQNbWmtQC12vNth/TB7kBadg+efBATdaGzy4Y4ifTmvUZM7QftqPnpITdXLDVSUmo7eTwuCJlXQljRve4gviLz2jbGEHMY8OC7tz//hFlMhrEej7wvHRNp6hO3dLwsqiN0UPBpu3c7lDNp1cOkJQ7hTdGFZi4oAIe2fO0aiwl1bg+g==; 31:mKOfgljmOrog3sIKWqx380A1vUYcZddQjBXD5IWOx5BX21kV38c6HYY6VP1FLQ9YO0a/XnyXSLCtvqpRzg2/RVFSlYTbcJasJdoA7y9lKooT93NXeCaxm05/FRSWWkZ60ruq79FpPZ0IfFQ60qN3nX8HECFXMws4kcIz6Hx4iupjpIpxf3AkRlFfT0viPPo6ZG5DxqdCs1UkIr7IUSoRlaBc/PdqYts0148SLfC9UQM= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:zWpHv5Y1yFalWjAlLozyII8jafe4OhgaFfe467uosh8azfKU3figCepwpkVWrX+NVFII7+Q+stc0A/sEy2N6A461CRLWiancUreY4htj3yaqyl1vLdagiYy/96JNujUYtUVNIiJnNo6l/AuaB5y419hC0bkaPMVI6etbrgOqJtijpHoq2Ud7Ts64SiTRCna2WHFeUWiBsG3W0AxUpCR+B69YS05K+CEbRvcAZ8D5VcH4gOU5Js1RWHd0i1wPAJp4BlcPv1zsUdrF5nMsl4MdOG48x0n3RW48Dx+qUW7xmy+In/1GP6PhYm6ENIL2D5xjNkBXB1Im49kIwesoPoYSz+uHhhuwLHMy9g4GUcpD7HkdlIPf6IfD2fhOYRg/ygk0qqszVV88dL92nKPFPycD+HrwZWkU4i/DXLGFq+ub4ei8hPcl8WkemxA+fgFUhQPWqiPyywBKpNV9u8hSSyKcRfj+hmA6PZ0zZ0TicKwzeCQ9Bxga28nkd0Oq7bUiCbo/; 4:EWRDJ0OugtJfuggvuhcoLMfksSRoDV02csVKgjONUGawO1E/xVkOC9DzCbNxD+jJy9aV9kj840m/EmgoBSNjX6pTf4fWYYIymQWMqkZ/fNqgzXjuYXPcKpwYCz67F0M7oDiiW90WcOGq+A8LlSgL8vibFWs4UkBpRNHHzUDiXKprizXLyypvWqRWeBarRBwuEghZaKBJEoAvJyzf/iaSHJivdRz/dDow6xNoIh+Fd+5bbhyJWVyRQStOJTP2/Bf1DZe8cTmVInSyoTH5Ln2pBdBME0a8+xUCBPLQR/ZLKhseAOrBiCnDEd7yv/clU/kn X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:2ayUlEk0yNCBxSXkr8VzG86957Wt5q3W0PRqWpyIO5nNVOO97ejBum+Kn73ssW7QVFn3uEkqHE5ws71WS2gKO9W2BcgFuGiJo9lGUpVY8kojhwC520VuvdEm6noKWGAmFTLa5KloOxEmbHo7zVi7qPjvaoI5ObcT8jttFYaimpZH4iZ4wH+MKcwo22g71XK6TH2ai3uW2sfKovNOSU9rbMtPYmujoCB+rKdiT32OhYZ5sbef1wM5r7eLngjCiwwb8fj7q52dhiBk9oIb+O8HVyK6Qc1O+3vazmg89qLEI/L5YxGtgHVZOzCFQ8mjwWY+UEHGKDlbN5bU5i52ikf72sLS/tPrgqjxUO+/sDiDCgJ8FYhGR9lzqjNAp46van6r+EPmBEH+zVtUOraa+LH4XYVKnjOKik7wdljKQunS+AXkK8EoCK//tVodXZXAhoB+041r5BNF2cQ3zXLEkEj+afXbdSC7vbwLFQB9pDuGzit+MYeAe07m0mbzoezvLxq+e6AxT4imRXnCx3a/qjGqhxm1aUhMKBv3Kt+AAsU3PHwW22CCfPat0Cqv//nP/Dwg86dTYnrDqRDlmtM9cEpTMq7EikagiRRFkUiWFludMoCtABULcvetGHnF0+G+fU5vkFzg5YHt7OUDoDBeFwUGdqmkKjhM321dr7WQh2H2hHooqmfVYuS5ZFaqR5vuG/tvMaLeZxeDlT6F7T3umUbiBk+cUzvueHekHxrAB/GYvmir+FOTgMK//gbt4Sk2LRSCLpFD3QCGYwBYafTc+klA6DytwQQEMa6cH8vP8qrLSSv9FzvB2y50w5kqLeOrazjJm7hgINYIWnFT5PYOOzWcQbMI5MSoFYhW5d/BGDn5I6XixFtJ1VLM3WkoOzMknc/Nuy+nTkwcCrcEzcZ5DaDNO8LrWlKbWcj5hi0Jon3X8Ix5bqnYn6+jDGIB4d4RC1Lv/cAwOjCUYS53/ra+voYC2gs5CiZcDyxAfSxm58YGa4mFJpMdz149fBgIy5E1GrliEuDMbFjLqL7cKVNg4cKAub4kZDNTM/yns/M/iMjh+JALDUYXOCaHC03dCMiTZhoavAnk7WxmI7/43xTsC5xTGUsAJcFeMGJHTLc5qh+OxJOhfLCv+4v1AA7j0mwH74SiSrnx25aWkHiV2WKdKi1esdkZfGkWGNGnu4sCg1IkR1ep2pdFjd7YBhT311WbBUUKuej94fAGSJnfMFDIvrZ8v8WjFCGEM2w1u+YaFUu12JAS/5MESVj1km/n4kdYwdxXMUcDWP5bw5FzMQpV2+/NW6B8wvHXDdirFf6I2jCy3zw= X-Microsoft-Antispam-Message-Info: j+yttIzQFSJ7sTAkEDcnwllbqXaZX2vxiqqvV0TLLAGpPmZUEhRs+/KQjn4Zj+UD1dPzJ3x5Yagh+eUxRkcajp1sf2S1dOc5HNbLX6g7VVwKqItNlj3UvMfWlx/jdpVkTfcNbF6Hz3FwKjH5nKtKq43gp7tFX8HXzNMv/YOk6R8cNVE+q9ecsniqDofVNZVt+i31f48iNSceeRbYIbEARswlRZhanFDN4X6AnrGFWENlx9fYGGtnS5OGCFSPm9HRwvk4rcTjBXRo9F/3FvjhY/r7SWBzHSmBLCsALf4BGAYG5TWzDksHzygrG5Cl/dh6BOfRhNX0oP0ELb1sE3iXRDk2c8qBWBYoWLexXmnc0iA= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:jWneY5jdaA0gkOMm0sfxBtOatGd/WcdIusZC6v7FcRNk8ZYlXBnFsGU9aCMUol0Xx60sXPqJeKmuOThVGwSAPBX6CfeQ2ETQdv5/8apMWjqUD+ltZvqPHNKv0sGa8lAyB7qYdOK0/jhlySeP/Mwqzsl/XR7hOEBG8z8J/UrhWj+E13idZAny0hX33vBT2hNOdN6DepZwZmToEQG87761gfSpb/EQdbeiO8xCZPIuLznkXIwNQaZMhODP3FyBlSYYLl/ZKULUcFMJXX5MZ1D6Z3vM+bNpJogoP+wSn+I8hKTG5IyG7fJ2reUIdkVjMMm9pg7qIIv0kE4Dw8ZVyWZTOj2WF0jo3pnYXZfYBDFNa89fV0RhrfPfnf9ee8hiyVl0pdGbmtsHhp6ZYZumMGV0KXd3OixHwj2BVNMlpje8OQ05PeY0NKUMzZcsdNkDH263msBOBZWtTdEq9JOUkRyM5A==; 5:cpA17oG4qYBD49ToQFln8N/GQKgL3Ix2NbD3vEGYP7xCrnHM4QyPuwwxjcrpcizCII9yD7gNzg9tuZCk7vpMSHUN43th3VLSriKUkp4f6qVKxW9F02eLyfd0XMKZ94wLA49gJXCxhl9X6tl+QUXr9Ko5SGOyB4yB022zAEiwU2o=; 7:aldfsbDYAm7LrQpL4mpicT6d6moyNMCWZlCEY+18OfT/9ca++HQLo2MP1JnVGuAy+PJe5eY0qLARiuTI55JsNZhndWeYTUvA79Zx17jPVu3J/I2PEGWDV774wmKpkfb4RtnFWlZnIT0mpE5Y4bFCCFNpFpVT3QhvP/+MqC6K+rjInUfMWYMdMs2j/714d8uySB8+9fHN1X3+8VVgL2z/wOhYw5iBuGteTwHCShOrsbDeu8588lNjrc1OkoMY7Rpe SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:o+cGurbdFPcx/NSyHCSe73AxdqdIA4u/nnRQcFjtX2LOzOZVwczAd+LXguWFk2MHh3wm6tUDLUz4XeDJa8HFLgpQIwQqeYIsK7Ilx2UuZjfvwnjSQVRxyWIvf7JSj1bhPkYVQglb5HtFn1Od2iA9/oLIja/9rOzNJNNIE1YGr10= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:23.2408 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 4a17a84b-bfae-4a9f-3924-08d5ee68b61e X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Sync cgroup storage related changes: 1) new BPF_MAP_TYPE_CGROUP_STORAGE map type 2) struct bpf_cgroup_sotrage_key definition 3) get_local_storage() helper Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- tools/include/uapi/linux/bpf.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 870113916cac..05583cec3a16 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -75,6 +75,11 @@ struct bpf_lpm_trie_key { __u8 data[0]; /* Arbitrary size */ }; +struct bpf_cgroup_storage_key { + __u64 cgroup_inode_id; /* cgroup inode id */ + __u32 attach_type; /* program attach type */ +}; + /* BPF syscall commands, see bpf(2) man-page for details. */ enum bpf_cmd { BPF_MAP_CREATE, @@ -120,6 +125,7 @@ enum bpf_map_type { BPF_MAP_TYPE_CPUMAP, BPF_MAP_TYPE_XSKMAP, BPF_MAP_TYPE_SOCKHASH, + BPF_MAP_TYPE_CGROUP_STORAGE, }; enum bpf_prog_type { @@ -2157,7 +2163,8 @@ union bpf_attr { FN(rc_repeat), \ FN(rc_keydown), \ FN(skb_cgroup_id), \ - FN(get_current_cgroup_id), + FN(get_current_cgroup_id), \ + FN(get_local_storage), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call From patchwork Fri Jul 20 17:45:54 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947134 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="NwA+CrzI"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="SMf9X2TQ"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJHX0BSRz9s9l for ; Sat, 21 Jul 2018 03:47:20 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388249AbeGTSgf (ORCPT ); Fri, 20 Jul 2018 14:36:35 -0400 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:48076 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388248AbeGTSgH (ORCPT ); Fri, 20 Jul 2018 14:36:07 -0400 Received: from pps.filterd (m0109332.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhnse025347; Fri, 20 Jul 2018 10:46:29 -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=PhR/xlbeiqF/vPQucmBmPxNrNch58rDdW7OXsqEZZVU=; b=NwA+CrzIhYxgnlKZNm1wp8RaPZbnww2cguEdm8EcsiPiZsm+j2ZOCcSnHXsvghi7LTis wwxlQhimOPFz9oiCigWzU91FFO9BeumgOqK5lbRvEMIA8uezrCnM73Tc0ei1VOEVzGvW sx+7G3yeNh2vcIBPjWDVogLnEKEN/YEvFfk= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbjxmrbv6-1 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:28 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:27 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=PhR/xlbeiqF/vPQucmBmPxNrNch58rDdW7OXsqEZZVU=; b=SMf9X2TQfjebi9Z+gyuQJIFg3quzfevhoR85XU8MFdprVi1yApp3kbYzWSmrDKvYBILAA7w0GW4k84DPukbtIRbAgRHYlRM03tSTmhdHlesp/iWK0Rt9osc9ss9MTPTTWJtC6xannAd8Z+Flz6n2FSo8r1q9xzmOrCFPLfcjo8o= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:24 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 10/14] bpftool: add support for CGROUP_STORAGE maps Date: Fri, 20 Jul 2018 10:45:54 -0700 Message-ID: <20180720174558.5829-11-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 7f012e30-86f1-4f86-581f-08d5ee68b6c8 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:gAeBPivIQurXQan2kTG4/KD3KKTkZDVRmB5xC3jNUU7ankr9pOwyOLZSUGH7VU9WVXksLqKQDoez4OsxSiUiTiv180i6lrdn3boneoUXljtjAD7xfFVhC9Cr0qHVcaky702avxj9GLKF74J7vqzSXvafPVnO7/IM1Y/n+OUUg46Ura8UkgXNnb+cYRwVFunWiHhcWJfkS/cb9QeKXtUykvijQRTziX7gPxHM51jf9CHgY+SiI/zgzjGW4YU44UMY; 25:UHOb137Pzp7UiHndRaIwsv9APCmG8Zz6WR9m/6gSJWlBiTWP50T/kuZ5voFIa68jKuSw71Ta0Q0QLrjfXCt3+K8izdJ3Ir657rsX2dXap2KLCPxt8XAA8CHWX8v+JzbWBTJ1UQztEHRp1Z12PaPyjLbaElA7EL6wRMFqwRHUD8vO1+heg61lmjRysrEdHB7z3nB4vtGK1si6l70tiRYUxl6sM44oSQwnJP+TCC4B9VyUhZXg76nuJb6MgqEX9mu9AFNAQ1bd7vKqKPX4FSbio8d61iz473HIDDSfjcESe1DKyWITok92q+/ixHQXHarHWqv4d1wjOG2op5WvbisFjA==; 31:JH640/2WcNiM2CWhdBz9bOb5C6tIJe7ZJzQhVNHcS7o1bQjOOdEutbAUJSZoybCt0tDWGZRxx1mxgO+uErs7f95vG2vPn8Q8+vsFsL6yOZKod8KWxhc6l5Vr6a8KA0QpoBMKOaWi19c6uguZGWrjXN1rbFqIk9jq/mLUzkPfYskkOxPa/BzidKcStQXlGSca/D+qKFy/t5s+5pL+ujqrOsbLnYopaJNzMz1kMwJxHww= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:ZoLaYR/u6SptuDihvQ90rHylQYErdxWUFk17GLSX37806HsSwlftDxjqIiosXDlS91TvR2Ab0PUFtTLNQ/Dn1C95o2spDPf4+T8lZvXdbZ0YWPONgIP/t/BMnTPyLmszDe/5HsQWkQAVGIshlkHDHShakWYOStt6vlXyyytxfQIjLLdNXA0rMw28dbZtzz/YH655WaSh3LxvptUQ5co7cFRFAfO0RDKWmq2qC/3oJbvgOO1xZpi8Z3dHxi8eU5+UWNOyVHoczm8Q8jCmoBr+EaBLra1TySsSKGNX+VL3x+fT6qRQyVOcOtylJ/rGbDfYfQn84myg3YuXx4gwIk7UOLIPUUPD2gdXY3x8T7Isnhh21QLXS8rbMj97dUeVq54X/YcEcB7NFG3vJrfCsAsllQVed42cNQzbz2YFHy2DMJE/NEpgM8ldUCcPk6x0P7cnvPRggf+IOi8bnDvvxUReF6vxS4IfqieOZx38uRJMqm9zMJuH90MCLqksfi/vx5p0; 4:LV670nOHDsFozo5n6O0mprQeyNr68vEJSxXEWiKfKbJMHOQ3X3RuPGODheMEzZwqI4Qh5uIqWlgH6DbxTTVQEfG9RgW1iwxwkBfeljutJT7rMdLpB5m75s7J+D7oOa0Y3+agWAoqfnEbjNGEY7NekgEpSCIbOLjS+XytebR53R/noLbbTJizIAFkRFQ21ao0d8hgdScZxfzOsmWuC/5GeOwaqa3VKl8pRzt+paaRsLEylXLvjYlun8Xuyuq8e0tMdRhCM8rWeglYBqDSbE1H7kpFBXkBcAl6D4CM5CYdMxSoVOlZrUB2MeAkhniXSNTa X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:sSGEmCVjtmqtD4OjjeObQHdGjHe5pD1EYsXplQlHEAoHsaNnDpn99FIkW2YsqFEGPzluo5pwIYX0x/C87SS9fIzi28ajhKsdiscnzIFIRSyv7QNLQbunYB5BoTfz/i7u46CfBWC9XUWYfGYt5BmDI+ps9jcKXbkzA4+bsXJ2+8or3RZzdTVGDDTBckGK7Dp8s2EIVGSxZzGBTq0F/OnM/6bZcN8uNsuiDzbsTiduE9a0cR7bsLIaODyU8nKt/cXkEtOUsXHr2OoPsrVwaUkTKMyTsG2tqJbLL5cNSiQnIqmbKWYDXAL0AgcVg8/DXpaZA5ccSd3WaCZwHcYmnM1db5kG3gCx83oCap6wGtQJ08QKyc3Yab/jQkTiR5nmqcmw+RnZcw/nVaAEXVfRF5nWlfNEjctduhBHVNx8p2WBr/eG+BK0olIdJNjkNektLYWzFHQkOevKVn0OFelteQ83fGzRwI6B1eMoIU/4p+1AN7UMei4WnpDPKBXXgM36Me0LePKhxzexhB6WR0Py0yTBHeobAB2lcD6ltgoptt1/T9XeFbAKDqHePploXJ11WXXiMh29SxmAuwBT120/PnjT69VW5855t1ErylSsOR1F/aFezctabK+8MbsejT9cI2lin2WRGcx1CK+8R+QJe4UnSlesOX5C1C5JOd/R6f4Xrd8ME1g4fs5Akx4dv/i3zuH4FIYsfiuaKd7VHP7RSjPFU6HWbjYn/2lvPbSmoGMYDIguUz/EdVVh9WZt/HmwaWHXjoTNsOBZMnwA2iQUP4wQjUC3+zVs+k/Bo5t4RpJ0EGvLSM5SOn+sE+W4GWAx86S+OE2hCPwEd62ocr+sZTBR9fnCZpPFRy2v1H98BPLK68HySgM+fc4VGxxzNG0uYz2jQrti/8QJ5GNgfCxs9PqhM8jWM7n9+liHO0Zv6c0UA8rH09wQ1s9U1gY9UqYxO0tBCRLKXzlHOdatPRO5myy/C1YsptzicbyXFGBlgvOol4PZh1+9wWz6X8U+1DWhbG0Mxn2vNMmW6LBLUy+JKK3AODCSDPndaEvNqoIgZOGhJ0XSergOvmb/m0DqssASDg1O3vPLzk5vME1ZFamRRgs0SscH4aiezAsAKd6ZNvruHrXmo20yVfpx88IMFEr2G/syUaURUw8EbYhqIv8fkcxXnfliqpxzA17FmcRfl7KtZpv2rI59HjP5/9GXue+dyww4QBdUfPum0bzhhflCEC9dANBNKgRYPc9pht5mBA8nxwHgw8wW4MxT9bNenV/4KdAg/9worTk7cPZNBiGUII+XBw== X-Microsoft-Antispam-Message-Info: nlbB5cJA0F5RxcD1mtjeWuTFOaYDFdQJ7cDwD48XSmoQZwlPUdcY2dYrqIM7kyqUk1MpTgC2nsxVUa+z80jIQTumwQqcOfVyA2I8m/GbNb6igB6S7WE/les3mR/NdXiijXT035qKoCwD2Tv/qZDL2eF8hQLmBWvWa5o6V+at6VKob5ybl9yr7BHkA/KR0v4V0yau2vb3ULf0g0eiqOFOQ5uegML1ULmMhc+2sobu/ETaxlLRhHXQT9bWdoPTPc5mpCzsLhIXHdhyvcy37UOJ2eLoCvs1P/eC+YzdACQfi58nAVocQsv4uX7HkKlHSe3fNAjEkJN1Q2HubjWr1rIy1vUVrOvPiu/G5KpzXziWbDQ= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:txz2H8LtEUdX+nYQOebQNYeWK7TWUaYz8Y3VXgEEey6G6y3Sw8znEc2vnuRoAkIFno8pTGz+fj+0ajGv4hqF1cDJgzTWbisJgWDoree0o0cnLGhURuOzZm8uGpRucuqJ8+tbIArfaG3lDLGjmV8TFwaITP770Xuk7Cz4uOAd3hh/IQIh05uq7JkwDSYA+lwOdAby4CeXD5KMo+Bf1FDv6dBZN/bDsfULZMJSRAJLhqJXFwOSlUe0xN0+jirXgn5xjm1P+2JeLTXl/p6qzLilE9SRhmeMFtLgsadr0PqZdaLPiupy4O2Wx71dmcZZDb6H3avL89dj4OAmwkUuCzDWgL94M34CZqshTuqKEUas/ehFYOVqSM+/47j959FMgT44wbzsBJg4xeAKKDSluDsq5aCu7JidB3rPxNwVXz5cbYlWULCjqmdwzR2th3UQ3aF3Cf4vxNPGNJ/Yd2w1EptpiQ==; 5:778r8BxZ1ShkUBQApG4Yc1m++SzTz5tTgB+hkV5yyxxgwkqQTmJzCxd+65PDDU8yYcQanyR+unenx+S1XDAXquw3pf1Wr8QwVyu5FtzmSyNuz/hEWy6OAxqyauBhT29GZfT27suQjZzP5AmJ/Xw7dksfSEaeZCBYTm9S37ZBD1w=; 7:ncKPDcE4YSpO83zWuAvQv710/6tlCsjSnC3kShoelbgATUcUgd8mfwHLM90Y7ARBZ9G8I67QgiUPU9sOR/7VELuDF/VCWRpbHAt8+ImcEfZm5WSo1WxUDrlxFZajV9EU9ov81TPLTW5mNAquS/MXCcKqaouYHlHNuAfmW8pK9md5jpWWOw4sG7AQHpl0noFdTgeuaXstSsODL3kaqzQTcY7V4T+2YfHtQ0/lQ6cqQAoO4CbUFvUxRRMLp8a38Vq1 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:ebRBxLk3nw+XzcEyPFnce9BABR3pwSWCuxwtnw235rq1E2JeCCjIZaERQhb+Tfqh/uT7K+I288G/0D5ytDOnDJ766wVpb4To4/cVNNuHZfJGbPb6Yeh/J9JDj7Ul5HuHIBe/F824JVGI0m8gnV7ofsYCMfK4likfAmHZkYbseqw= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:24.6350 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 7f012e30-86f1-4f86-581f-08d5ee68b6c8 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add BPF_MAP_TYPE_CGROUP_STORAGE maps to the list of maps types which bpftool recognizes. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Jakub Kicinski Acked-by: Martin KaFai Lau --- tools/bpf/bpftool/map.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c index 9c8191845585..2ff02d319c02 100644 --- a/tools/bpf/bpftool/map.c +++ b/tools/bpf/bpftool/map.c @@ -68,6 +68,7 @@ static const char * const map_type_name[] = { [BPF_MAP_TYPE_SOCKMAP] = "sockmap", [BPF_MAP_TYPE_CPUMAP] = "cpumap", [BPF_MAP_TYPE_SOCKHASH] = "sockhash", + [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage", }; static bool map_is_per_cpu(__u32 type) From patchwork Fri Jul 20 17:45:55 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947131 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="l8AHkW2T"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="LIFBCPFG"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJH955pLz9s9F for ; Sat, 21 Jul 2018 03:47:01 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388494AbeGTSgN (ORCPT ); Fri, 20 Jul 2018 14:36:13 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:51870 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388414AbeGTSgM (ORCPT ); Fri, 20 Jul 2018 14:36:12 -0400 Received: from pps.filterd (m0109334.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhnX031415; Fri, 20 Jul 2018 10:46:31 -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=bORC1JD0YP835z1QFQWDyQXRjeP3qHZESb5m6qq3qEU=; b=l8AHkW2Te7HvJ4rJTDGgD7Llo0Unl+5e6gG05xSBTK/fKWOPkJP3bYo1T0fOBJa4Oxgj D/ktY2NwYg6RLvu4GH/nHOvqvZgQZW//lImLFaMKRd4lJw7VBr5zKRHD21no9TPX3tRH ljWzQZ0QmO6XfvXx+I33OAEwMwPp3AkQ3hQ= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbj23rknq-1 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:46:30 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.183.28) by o365-in.thefacebook.com (192.168.177.31) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 13:46:29 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=bORC1JD0YP835z1QFQWDyQXRjeP3qHZESb5m6qq3qEU=; b=LIFBCPFGGFOZrZpBBWX8381wzfz5VgDUQs3soPY0DHse3CNKkFzU4oQ/T2jE7cs+GJNea2cOlZWXZ4qPaZ+0gVQlQ6Zcc8EqBUY+M0Ab37/+POZZyWqSMzsiFo8OXACjfkX2QoTEEk70n/FoIfEJ+srDsMOD17c6UJoWpbGXJng= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:25 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 11/14] bpf/test_run: support cgroup local storage Date: Fri, 20 Jul 2018 10:45:55 -0700 Message-ID: <20180720174558.5829-12-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: bfda2d98-db7f-4f4a-9a5b-08d5ee68b774 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:Fs5YN1wFPDakYRL9sWgqnoyyfBGFeSLJ3I5kCGi2IcWjfBtu3Vt8KKcl6ngOajn5IriUkm7F3ZHLwOyVevl4mD1a1lOjUmFXOrnu8xUt/licNISb9Ko9N70bsDrJyWRKD3jlKAabvlbobVuQ5QOTi2I8oLSp9STsJNRWXvSoBpJ0MhkRUlfciU1kSl22YAX/m1o7kZjalR+cVWtiGzKG4IZZTNxQk/6bRXL6OgvPLDWZaWBLClVMTsOjbpJJK2V4; 25:Ci9eQtcgLCv224FTkXNEkVMMFH3idMij7m/lOYgHd2fgm8B3maHhl2yNah70bWGWPrIg4WScfxvAwCWgfA4n79HKUtrHkhrytHok9Q3lMNa0IQqSfKdtJft2c12AkAJlmt3vpxPECn0hGqbi8ZUcRlLpzrLdKjiy3YpwwnuGKUOK0B06P+10ZLV74vVyd2extrw0H1+5Ja7MaHgXlYf6K8WhGShktFTUIRJtDwStqn+cdwxb+IcUQyMZnJPpAM0QA9TY4GpZuEguKtuPhYzUf3cQyrIPvHFefGR1Du19i7kqfWTd+pLBD25ZXVEswVA0VU/AGoMiOB7G0/8cvTWrOA==; 31:armCNfe/OXOX1ZnQh9KGgQRrFWNpEJmgKTNACyhd1S0MCyJe+XMPNxoH4iarFsHYtbMoK4eo/+31GSxYxA/DaNPa09LcO2D9SEJA8JJlT9QsU28KJ6wnooLJq4y8s0WeKkEBbVEBHZPQQmP0Wm8I2m8hrlGqB9+fTYWqwNMKd2q2AIhBsjuZiEuEvvVSYx6eFJBjLfQ4RJ5d/G33XIeugDwPwfuDeQYhXiDlNFaGlPE= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:eXdwVqvrKFRSpytsjjkqlzgYT1lnPIA25C1DhnFgge7b5AGyGdCoh/Nsiyd4v/eKdyIhTrE1oxBJ9/9ZB7IktEcfo1ZeEUGZzSN2u+8dWoLB7zbpSjPMd4VsVPq+z+WnPBm7E6xQvO5899ib+pjwJXVPuCzI/OMq93NkN7SNDL5EHSAHHwoOTVyz4oCi6RFujVpUV38VXdan4CGnWIfqU07YjmrFjbNTcwm2DYoRThqxSGi8+N5gWS92/aLDYU+DLhYVWp6yfndDjowdCIKO8PGovvdqexgDSh/Gf6cINNDPrZodcgfa7xlKWhHXlzTBFGTKjirkUaLwphghppu7anHqWDBfQB4ioaMGV9FkwqYuQNg5bq9lTntBG/n6+nkPn6g0fzgURX1ELAsg6VlKbL4RHL4N54TbL4e2yQ8dWoNAkD67dgjDq7bwZVSinlAVw1Uqh21tI/pXnivl4nXCFjzivtUFAySVHZ4tAIJCjJyWZNbA1BfRMDF5ZhQaN9U2; 4:gZa76OO+GzCKsz9RpDwSDd1G1rcL/nooUJHdcnH0RIoNLTZb4f2DWRMScFMAGJ5djUYqOVXV1othzGmrem2O5FHPK1jUZTxE7oFpc1112NT6A4V4z0FgNgEDVbI0/b6hUs38GvfRlZUdVVAjDM4XacPmvlErLNGJqzYCd5DmWR+x9dQOxibhTsNoep8DTmWYkqUQENgvq/HmN9GiyPFUAoGPQ9IRqp5mQPWRRtJoixvVGSd7P+cjLLm2Dg2tSUgb0DpSxsxpNVgYu3KyONmZkkDY9qoDvYzjEoyIFy8Oqom7thaaWrwXQ4FDTS2CLKni X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:rloC8xsKTq1oPS74huYlVlE8UaJzuAYnaEIlcujlfL8uLdPj0HDeRQUa6iq2E0cEONLxb6YLSjlHQdppI5c5pToorIs/fvs/nBrDXfuXCXNI42aBXr5zqn9T3WN2I8dg9VUkiSDKlqx/HG7uF9N5unkUlw46OHG58UYvp5ePRCwN/l342Sm1Y8Q5hJMxrbhsFry2RWNqUfNjJbCMvK+A7Qbk0OQKmvasf2hf+vkkBPk4FWMuwRRwXTe+ZBCm6NhPpzkguLQWW3bcrZeCUiio63LKJuRDE28RO/uMPqfMcUcA1sxzqYWd9I7+EY+OF9vqQnA/3yHI8RqV6gDZn+ygOQ9T41PZEiSnfSS9Brp6rJKp9uj8PRHLF2p8oTGqveoS5xqZ8q2vIbBFO11ohpdgg6H0TnWhNUbr5b9aY1sB0tvEdEMcx3V8CHeu+R4wj3Kbw5aN6URKIxrSV/bjrp7duYmTMpiR7JRA2izjrHLATF1uoqHDCJytn8PJJk1Oq2T7XhiaUJeispaJUYkJdu0hTTtM4GKwOhNjnl7b3NVNvDaAv7r+VVZlSOlR88PdYqrGK6R/BT5eIEeLzOzCcFMSK2eybzX8TefEBTvOetJPvAR9i7OcAohlTRYTjieFpJ0Jk+CAFs06z0ieVNwDIxuK8KoFpAi02HcWtEZALaWs/mkVM/U+XJ4obmVv4/699T9+CTbUImE3YmBI0UPBeK1ZfsFY/UYZD6NIl65zddWGmI7H8cjGvCy9tDTQPXBzY/dZCD2bMz9v7SNFMKfQg/FrhEFhaaIYgDLuoLC9wN/eMzu6nM/9LCtUCi4/4vUB1JHkIXqXabmjXlmEZU3hDGMxc5xoyCVO+zocwdXll3RRgThlaum4UfoNyzO5CLUokbsXFd0QG2C9s7ACRqb6u1b0t6UGbgklDKaf3dptob+EG+xxvVXOvmoMPRBztuYGpdxlsjxD7QiljFcgm//xu6eh6JPsfw2iMiLaxCdsGbXt2nvo74oBhACRhjLsV1ED+4pmjHxhz41JLQkoTz+LBK2S0+4jPLWzHMwLATtNjnluCmjmYYEhZTxBPFwmr9HOZ9w7n0E62dcN9SfUCAxy3mUUKby5xLzSdmfq7nQGCSjGA/2YAeKoJneZFmFgKT5KMnApPOjvRwTKCmDIWlNs7vjNmKtCkdPUcq78ha6DeuVVrwIskSlmFOj9rILU71IK9jAvBiFmHI6sdUKAk+ifbbg9D91W21YywsvbYNuSO7yJ9sH3iEgTy3sufxu/Kfsj6PAv+yLicG+qjYkG0w04REGBQMckjDsbvgN/r1Zv/TbHJKU= X-Microsoft-Antispam-Message-Info: gOguBOZP1MNDDHPmJTfphZPpj1NjfxAWcCA7hRtOD7Fe8FKNebpFxJFPj2O5SownhcS4zSF7j/TtUMOFkK28ChIfv9m6QP4g9nlZ+mol2Nho51riO8qKw+zvSwyppBxCwLjOYfXfOXUyZaniw2rU3yRSW33llGqW6gBy/LYdC3FIIimBCGzhGQBuKrn7JrhhVH1/Ox6VZ+ZLJ42/h55Ystz3K+wtvLmcW+/20n0Cvefowi0+OuhZcdctMO9ZRwsEkIMzx5JV+ZsMnZX+C8IDRnMv8qVanMz6kbTiTvre41pMqNDDl5Hz0DvwaCeIg9QdUlyaT94dzX02GTcYSf2vWFAseAMr4ReLahb8OaeNwPk= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:uUtt3WTRfKVhrka36kxeeKIxafj2IrHZKZg0PoVOHk2hhv8V+yf38GT+tujzhXEouFlfzxV/CNSrPuARCeUxsfrHT4zPKLisu3HfCQpfyXLRfJtoLJzignH7sT2yQs5hHIEpSiQw55ehkyYRuVpHyAh2bU2Oo9b9eFpm6wIlspMW1FCYTvef07R06xHuXzFEweNGMH32UETHkHeeB1pgbdoQLkxzMuTD1hYTUU/dRzlCJjKTRXo9Xyak8scndmhRdi6++WM4fqlbHxbGUTV9goTu0X99jhbdMmedMns5MROYeoDMjoHAfct7kUaD/VXSVVOLZhbZds/wAuFibrecWgycDCE0F4Dtjt1Bdp8pQ1hxrb0oGKsxrLwnyIihIHVPjoS7DFYa6ZLxoQcOkMCZwSUMTJMwpNhyShr/sFqXdMKhY5/u6CTZ843frQwO8GsApuoTkrV4dSTwf9YTIMcHeA==; 5:zfHAy8kkeqiPLo69dc2qOFjxqn+x3kJsoZOSA31XyBwDr6fykbwhune9fHYvYmSiXljW5tvZMz0tuJN3fD/Wcq75Ch6ap4RqwWXfHx77rKCQQcczwFH36Hf80QhPUEr6/+ZU8WyOuQwCdBLBfHaBgjym61Aa36rMijUrSxkZeYc=; 7:xYKpPUO1PTNoBqQatDMeMPJg7rYc4n8t4v74UuoR2ATWy7rf/Bx/NCg4uvuu+Pe1enA4MkhNaEU+x6EIJxUpFfFr329cjIqu5JZiLQ+nK5IYyXS6rbeLRVBvGJxjVn0wkIsY2gX6w7lKi0CPZ1ZSfrkPiM6+hNO8TCD8PxryTKD8WjSnjABGChgBNkapRYUtGA5dI4w8AY4vZgrzJenshMJaWECjSSs94AmIAUNu2Qb26IRgnWLEkUXX0BDoHz7o SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:f0BgpfOmupFDzoB72X1SFuKKhNzg1ZgG/HMMufIfxHH3hDG0wpkZ96pS5ap87pytWVMn0BWemook6KB43LvQtdcm3Y9NxgluNPVIupt6CurjReWe17o4Pp0AFgwSCJB9SJBP2MvSpWM0HytnpPM/QACxkk/oTkCHYGEzQxilaaY= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:25.7639 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: bfda2d98-db7f-4f4a-9a5b-08d5ee68b774 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Allocate a temporary cgroup storage to use for bpf program test runs. Because the test program is not actually attached to a cgroup, the storage is allocated manually just for the execution of the bpf program. If the program is executed multiple times, the storage is not zeroed on each run, emulating multiple runs of the program, attached to a real cgroup. Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- net/bpf/test_run.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 68c3578343b4..74971a9b7cfb 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -11,12 +11,14 @@ #include #include -static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx) +static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx, + struct bpf_cgroup_storage *storage) { u32 ret; preempt_disable(); rcu_read_lock(); + bpf_cgroup_storage_set(storage); ret = BPF_PROG_RUN(prog, ctx); rcu_read_unlock(); preempt_enable(); @@ -26,14 +28,19 @@ static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx) static u32 bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *time) { + struct bpf_cgroup_storage *storage = NULL; u64 time_start, time_spent = 0; u32 ret = 0, i; + storage = bpf_cgroup_storage_alloc(prog); + if (IS_ERR(storage)) + return PTR_ERR(storage); + if (!repeat) repeat = 1; time_start = ktime_get_ns(); for (i = 0; i < repeat; i++) { - ret = bpf_test_run_one(prog, ctx); + ret = bpf_test_run_one(prog, ctx, storage); if (need_resched()) { if (signal_pending(current)) break; @@ -46,6 +53,8 @@ static u32 bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *time) do_div(time_spent, repeat); *time = time_spent > U32_MAX ? U32_MAX : (u32)time_spent; + bpf_cgroup_storage_free(storage); + return ret; } From patchwork Fri Jul 20 17:45:56 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947142 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="NFeDpfZU"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="E2Zpa+2v"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJK04YwVz9s9l for ; Sat, 21 Jul 2018 03:48:36 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388444AbeGTShr (ORCPT ); Fri, 20 Jul 2018 14:37:47 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38682 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388126AbeGTSh0 (ORCPT ); Fri, 20 Jul 2018 14:37:26 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhGn025819; Fri, 20 Jul 2018 10:47:45 -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=cKQG0CMEAsoJMedIhmEy7BnXo0h0UXd6qsQx+9xY5W0=; b=NFeDpfZUElGW1CjKw5DBaSipLM2Y7tYKq0BywPGam585zIWNxGdCwMgXOgmTUU8vLlJf KdQmGNyyIJA5K31dwW/hgyCwk9MQ/ASsdaMU0n6+6XFj+1zWNrYYTiQtaOkIeePGUlwD Fx3icHE+S0zxNhrcP3+JPkyikYUUNymIYlM= Received: from mail.thefacebook.com ([199.201.64.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80h7-11 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:47:45 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.54.28) by o365-in.thefacebook.com (192.168.16.24) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 10:46:33 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=cKQG0CMEAsoJMedIhmEy7BnXo0h0UXd6qsQx+9xY5W0=; b=E2Zpa+2vl6cCTRmzjeFsbbt6tMzorVnTLIUTfuf1o49BhnN6d1sPSkXMt4eRArTdES06dxP9KHP2m484EJML9oJrmGGO5/YpQhxPUFL10MWj+HbIJ+ts/2rK6hvIB56cDxJP1m16VkpgZTuoPkUllLWSaOPBw/1klybZmw/tIUM= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:26 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 12/14] selftests/bpf: add verifier cgroup storage tests Date: Fri, 20 Jul 2018 10:45:56 -0700 Message-ID: <20180720174558.5829-13-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: ae0c07ff-fd13-412d-1062-08d5ee68b82f X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:K04kxTqZtleuX5Mpv88qS09ZkiKySgCCDASQovaQJaw7H5nUmjeSagPISskyxgArGcYaywqR+4hyba+/lN6SsR5iHDMaADVUI+HSMrHYmMp4Q+u4sfhUe9/1TofmaTMQSmr8PVNN10d3NDLN/8rjq6pSFhfVhL60LzqMxfFs3xwMAAKoj6kGj4b8iEjau/tJCulN1G5VluXqdhjTFMFMpLJgBI0VKd8fRjzetUlHDzsHfOujTNyDUdMEcXqiXoTP; 25:YZBJsApgGvJSicxtH/rkLAWOVjBam8mhPJ+Gwoez8y6zoayquLYRfN5t7mfjTflglY5l4zo6oKzB8aNNpKwRFEJSmLAoLBsaCq6Rvb6Ja7ENT6+2lJNhbaQBNtVUc/f5MjQTrj25gvs6sT4blGyuZRp6UVfsT8sTrgcgZJ0eEBTOxLsnxzFbj2q35eJSsxkbzv/DDI53nCnIB5RGdr/zbBgUsQRs8IweaB1HQ14QhEq7yaZSK1llbzJItUF/WU/nZNHLv3Msoc7oNPXnbh6PxlJ2DWN5k608PQvmIx1IyZC6+jTfRnu5gQReY44yWGuc4ZiT7yUHDRPOxLubYa+NjA==; 31:ys+Z1LFpAaczzXISpru8QexKcI6eZzkQJ0JGVhrp1wXB8WXVOjxRktdPwygZuFxpxCQ/L3W7KJW5cH+4g8/p5WImEF530sh641eBwNkkjrJAg/QF4B4+1tcMZvZg1btecH64o5hyHi9e52FbNHx4UimxTbsekDAXLfnHIFCupFILtbWrOinOyNMrszyCWz/egOQNn9PbkiZ7ID/OEcKbPMDxXElGrm9HX7iJBCC4+VY= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:Z0qsDTNhlQfztMeDUQV7A2EdpflBQskqRbnVpBoHndgiksodHdeX9ge9HY6utV6NCrRW/VEWWOvGrkJH2V6tipwNnvB2n078PPUCdjJKmPUNnzOt7a9FSEl66ZJSRLc0guHVe3QQmYR7g79uahWzQuDYm+3HYVqa4s0yzVKj8uvzjNUD86BhYyZb5eng1Noua/LMzZj2Hh+UxriamWiny633IRC3PcUbSwTcHw3kLjNLUAKm6X7DkviB8tTOV5342X3CoLY3IMDkoL0GpiT/GkrJN4IRnX6KZUUfROh94qr16ACNGpvQnVvh8EpOZRzhXxXC3/6aLjxBnz/BvOvlnyOupHATIpLO7gFAZ+7rdClNgeIf3NQ7UEM1v7SLHkDswe3XKktDWN0UX5repFjVBqO1cZlAs7eK18U0SwYz6EmBxeuhEIPHEF3wPnQbuQE7xoiue4ag8l16UFP/6RY4YxORQ8sgeKJIavNcBGpPbUPCpe494XgBmX4zEo9Y1UiN; 4:fyD/OKSg81Ybo1KCOG3SPDDroQkLX/A49Si9zSWjw6ZHzXcJYVExQHhhNwMyc5luPnRk6WKo0POnxSBnAXm0Gy5jiP0N8hMpIDvUn1VxysDlNeR9LftuW4KyKahDmvtNzKh78NphcSs3nmkAsUzkLHb2hCfWsBTWdPbfu7y2n5xV3Qpn4vGScNyw2yJkZc+6dI6Z6OZ91iRnsgVNr3lOKVHrNUfMhNH0ydkCH2UMyAQysiDEY0gO5pSM3PaoCQfs8FZXD/8gLH8T2W74C3h5CK61KMTccqWQyANa3pJWG0V9u/2CQdXA8JsHipkGhNIo X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:hBEYYu9bsWg/fMltg/Wzgk/hqpiJI74qF0saq7oI9vlJHQYwDy58AWIUilNS90ao6gGF7XhoKc0gVcJYNmkusciya+Ldh2MbAXa0uRKoqaBLDHpEcJe5Y2IuoJYb1uwT80+IhtwIUBMwS+LIPNCK9Tn9//zxeD26D3gk4Okz9Uq0mvtfST27xO1QneEbPclqogK2TplZVl9jIwvHtlgitqGMvLlLZPzFrH5zrtOki8vUpBLHu6fIVMTooUdlAsOqFEZGdq5ZEIo1/apburDOxrygUgY3usGWn2sF5S0M/PwYG1KCo12MSm7WXAjiqybw8PV+SEe43ArReHkfgwyvstTrLzz9kxqqUZnfBYt+f4VndXklXxDHP01eAnTb96WySPjQMFzcvgXf9sWSf8ay+EaHkljUpWYdUYoXC25tJHujA54HvwfP/kRcUJW3BRLay30lZfZyYM5RQ+cttVo2ddo9+BfVOTRtz7wCTRSHIeP/DCxv+POQ9p0GKdL9CE7Ni/OY0Sp1Tl/1ZFLv6LOafOkvEab7kN5TerMA7lhNO09GDgSlzS7trCCpIkn3ERSUJrgvo7T0Vv4jOCDU8XsC7R0D8qVKzrJZyQE66DX31UcG8tWWzw1uTRdObhy0JiSf4w3IPMDI3XtIOJR3iDw/ruVt3viz/DDEcgYLzB5TA97OotwIwobcemPFULoek0L2ZarDb/uzlCnxpzdpS5cwz8de0fzK6AU+0oErdgl09JD5gbsXMl3rJrbCfERdBURKFPiESAFpgDFf3PNBAcVjVPz/P0x86RHbyboNzOSt2cWBI0j6W2TOuXwVOEdjh3G4BorTd+tTA83qAeEdP7QIsq018rqiYr4uWWJaw4QF1yA99tw7YHwKFmYQ+GpmNzSwySG2+EO5LIlfo63qjV5PJVtOQUfCFikks2wlbIGmflTgAMAcVwjMimnWYlcHd2I5K5fEMMgHiHzqrjEcBU2OYxqGfW43383qtPqZFb7rqvqCpPzWOs4uwZu0kOuUXezNI1LCUXzkj8oZwRtpoF0AYBkYTngi56o71kw96VaTZUACRDEnoQ7XaeHP8A52/w43sYzgBbicSX+YITSuwgbw0tiq3T0CcIycDKE4fDnMxXsrZueKK0sBUDsk2i8563FO7yFqLFwu67fg3osJWnhnJaGLPXYB8wisbcKXm2ocXx2Iqy6eHkv4NVOrgu9Nh8gKVA1VIUzYBPoJ56EIffDyiSWth3M0cEx7y2hrvKoEPNZAta22jv9qBordlb63krKDE/w/eS8I4kjYmCpLziKvyQ== X-Microsoft-Antispam-Message-Info: XzAPPc6mcivdyZZxdKaMw/dr/7ey4f69dt9XVD/H5nmXR+mM5bHJNNfgw/oWXIzpLaJJe7bkoymoTAkBUTZnlcBfFUfrSba1jm7MhrUpS3Z0RTzJl5UlfW066mW7PyWnt7mpvl+UcmmZ2TvxjbYi8ob7t65Ahlv8oLLQP54hEgpeaWidIaYEXecG3m3RFE97WEwdFDCKwDetQgaCOlyed6T46waWwq0tFSXWR7LXF/2GAByOKWAC+RpMSTL9/+wCw3tdDslAs3KjfbVHax8ZssX9WdJeVnf8TAQ8rUFfCy5GXWc1Qdy5Xf5zty0pelvWrBklBzjrI65fiie1tFp7gWcFoN8QIdLoeNfRgwkCg84= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:PUVrN1YCef830nUu8YrzYxZteoalioDbk50kRWQ44S5CGt5D+1E7SQe/C3AqBcyUtY0HVZPsWI1qoVQoXQ5d+kmRuyZHLLZX//nTqxbj3TXGQWb4hAgFNlrpCpkE5V/pr2kszMh0tdi3uxSJc2hmRqbC9pCUm37lmVNQwV3xgux/KwEUTXyyZBEboB82f+txLc/X4qrFARsayDqZMxPy6IuJGC5f9W8v40KZR6l4OSpbGQwBf7GVR2bnpUytnbE/VLSKHwGht+b6DOkOIBUJ9BtStyqPkU7paFd4WmyirGs+JmfdX79ve+r4b+zsReIkUni4TU0RF1kKu2XpPOl3+qxOqS82OVHu8UZkl0QkuVwf5hUQ1N+fOTT2S7uF+FM94cz4vPEJx0UgUGiz9iTuQ8pZxzdl1XJ2KvxQtQ3tc3dcGBJURnQDTpn9QRsUTwUu5GKCHBfFJDDvlt5l3y15fQ==; 5:A1I4VKX6tUKXXpeaeZM30nPbpvMwOlcYVAeqRGZIfdyBtv2te6W1wnFeF/55Twv0arQPEU+elR64Gt+oP6CTpHOPZhFGONa/9oCwRqKKxSLA0JZ1TkkOdvNvvxb0Fa89XgZLPDA8T0+L5CABKkuqIesrWU2bBkYP3HkVwTBVwB8=; 7:RszeeBKp/8mQ3HekrPCR/2Nede/+xtbNxJG1ytbKfSUfF7aoA/FVPpPLt24L9bG81oxzvqF8Rd9gDnqomxpdlAMnq8MQRZfvfYcJuL9AEthdTE3XWMzGP68olsdC3cofwWosmEuQtTVXXwcpRfwhpuOpR1aAkOgYU+eav6FPPqz9r5rUthbpWWv3OzNbok7JSKFT2cF2xDB9Pw8pFNMqLpRxaMejNbVYPl7KX+aE1N+5IX+WhtQmOrK3nN+g9DMJ SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:qpxAf0GPBKpCL0e2cfpMmwTdZO04kna01w6GPrDFyZa5b5alp1jfXh2UJtGS6cBDjuEsRNbCkng/e7ObWPnQuDzTudD9Zp6E5G2zXBJEO9nsOhIFJ6m8tGn+WnVSPbcX3ddgVbSk3DRSs6zTWqrF8OKWv+2jQPcUHmkY2CRCPvk= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:26.9008 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: ae0c07ff-fd13-412d-1062-08d5ee68b82f X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add the following verifier tests to cover the cgroup storage functionality: 1) valid access to the cgroup storage 2) invalid access: use regular hashmap instead of cgroup storage map 3) invalid access: use invalid map fd 4) invalid access: try access memory after the cgroup storage 5) invalid access: try access memory before the cgroup storage 6) invalid access: call get_local_storage() with non-zero flags For tests 2)-6) check returned error strings. Expected output: $ ./test_verifier #0/u add+sub+mul OK #0/p add+sub+mul OK #1/u DIV32 by 0, zero check 1 OK ... #280/p valid cgroup storage access OK #281/p invalid cgroup storage access 1 OK #282/p invalid cgroup storage access 2 OK #283/p invalid per-cgroup storage access 3 OK #284/p invalid cgroup storage access 4 OK #285/p invalid cgroup storage access 5 OK ... #649/p pass modified ctx pointer to helper, 2 OK #650/p pass modified ctx pointer to helper, 3 OK Summary: 901 PASSED, 0 SKIPPED, 0 FAILED Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- tools/testing/selftests/bpf/bpf_helpers.h | 2 + tools/testing/selftests/bpf/test_verifier.c | 123 +++++++++++++++++++++++++++- 2 files changed, 124 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/bpf_helpers.h b/tools/testing/selftests/bpf/bpf_helpers.h index f2f28b6c8915..ccd959fd940e 100644 --- a/tools/testing/selftests/bpf/bpf_helpers.h +++ b/tools/testing/selftests/bpf/bpf_helpers.h @@ -133,6 +133,8 @@ static int (*bpf_rc_keydown)(void *ctx, unsigned int protocol, (void *) BPF_FUNC_rc_keydown; static unsigned long long (*bpf_get_current_cgroup_id)(void) = (void *) BPF_FUNC_get_current_cgroup_id; +static void *(*bpf_get_local_storage)(void *map, unsigned long long flags) = + (void *) BPF_FUNC_get_local_storage; /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c index 2ecd27b670d7..7016fb2964a1 100644 --- a/tools/testing/selftests/bpf/test_verifier.c +++ b/tools/testing/selftests/bpf/test_verifier.c @@ -50,7 +50,7 @@ #define MAX_INSNS BPF_MAXINSNS #define MAX_FIXUPS 8 -#define MAX_NR_MAPS 7 +#define MAX_NR_MAPS 8 #define POINTER_VALUE 0xcafe4all #define TEST_DATA_LEN 64 @@ -70,6 +70,7 @@ struct bpf_test { int fixup_prog1[MAX_FIXUPS]; int fixup_prog2[MAX_FIXUPS]; int fixup_map_in_map[MAX_FIXUPS]; + int fixup_cgroup_storage[MAX_FIXUPS]; const char *errstr; const char *errstr_unpriv; uint32_t retval; @@ -4630,6 +4631,104 @@ static struct bpf_test tests[] = { .result = REJECT, .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, }, + { + "valid cgroup storage access", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_LD_MAP_FD(BPF_REG_1, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1), + BPF_EXIT_INSN(), + }, + .fixup_cgroup_storage = { 1 }, + .result = ACCEPT, + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { + "invalid cgroup storage access 1", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_LD_MAP_FD(BPF_REG_1, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1), + BPF_EXIT_INSN(), + }, + .fixup_map1 = { 1 }, + .result = REJECT, + .errstr = "cannot pass map_type 1 into func bpf_get_local_storage", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { + "invalid cgroup storage access 2", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_LD_MAP_FD(BPF_REG_1, 1), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1), + BPF_EXIT_INSN(), + }, + .result = REJECT, + .errstr = "fd 1 is not pointing to valid bpf_map", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { + "invalid per-cgroup storage access 3", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_LD_MAP_FD(BPF_REG_1, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 256), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1), + BPF_MOV64_IMM(BPF_REG_0, 0), + BPF_EXIT_INSN(), + }, + .fixup_cgroup_storage = { 1 }, + .result = REJECT, + .errstr = "invalid access to map value, value_size=64 off=256 size=4", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { + "invalid cgroup storage access 4", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_LD_MAP_FD(BPF_REG_1, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, -2), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1), + BPF_EXIT_INSN(), + }, + .fixup_cgroup_storage = { 1 }, + .result = REJECT, + .errstr = "invalid access to map value, value_size=64 off=-2 size=4", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { + "invalid cgroup storage access 5", + .insns = { + BPF_MOV64_IMM(BPF_REG_2, 7), + BPF_LD_MAP_FD(BPF_REG_1, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1), + BPF_EXIT_INSN(), + }, + .fixup_cgroup_storage = { 1 }, + .result = REJECT, + .errstr = "get_local_storage() doesn't support non-zero flags", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, { "multiple registers share map_lookup_elem result", .insns = { @@ -12418,6 +12517,19 @@ static int create_map_in_map(void) return outer_map_fd; } +static int create_cgroup_storage(void) +{ + int fd; + + fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE, + sizeof(struct bpf_cgroup_storage_key), + TEST_DATA_LEN, 0, 0); + if (fd < 0) + printf("Failed to create array '%s'!\n", strerror(errno)); + + return fd; +} + static char bpf_vlog[UINT_MAX >> 8]; static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog, @@ -12430,6 +12542,7 @@ static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog, int *fixup_prog1 = test->fixup_prog1; int *fixup_prog2 = test->fixup_prog2; int *fixup_map_in_map = test->fixup_map_in_map; + int *fixup_cgroup_storage = test->fixup_cgroup_storage; if (test->fill_helper) test->fill_helper(test); @@ -12497,6 +12610,14 @@ static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog, fixup_map_in_map++; } while (*fixup_map_in_map); } + + if (*fixup_cgroup_storage) { + map_fds[7] = create_cgroup_storage(); + do { + prog[*fixup_cgroup_storage].imm = map_fds[7]; + fixup_cgroup_storage++; + } while (*fixup_cgroup_storage); + } } static void do_test_single(struct bpf_test *test, bool unpriv, From patchwork Fri Jul 20 17:45:57 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947140 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="BSSI5aYw"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="WIf1HRVq"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJJY1BS7z9s9F for ; Sat, 21 Jul 2018 03:48:13 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388567AbeGTSh1 (ORCPT ); Fri, 20 Jul 2018 14:37:27 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38674 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731305AbeGTShZ (ORCPT ); Fri, 20 Jul 2018 14:37:25 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhGo025819; Fri, 20 Jul 2018 10:47:45 -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=29NOACPFayXMg25FAWiA0pHV/s5tN/evpNO4eWkigbU=; b=BSSI5aYwPx3ZNBSYuf9WPaQi1HEELJCegzKcZw0qfj9i7nP2zrpzgmm5pq/qFHXRxIOg 6ZWvjc/wo+9VmbJbMgHqqp7AemV/VQhXAL4+c5ZtSPuE0EqxmlA/wa8kv4njTSDDeASp HGvcY6hUkXAAXNX1J1VzPZqCQfFtszSfdMA= Received: from mail.thefacebook.com ([199.201.64.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80h7-12 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:47:45 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.54.28) by o365-in.thefacebook.com (192.168.16.24) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 10:46:33 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=29NOACPFayXMg25FAWiA0pHV/s5tN/evpNO4eWkigbU=; b=WIf1HRVqFL+p+9U2zrkQcRMUmqdQr4wApO6lrYFRgCSEDBbQ758GRCgBFoPBZzVoPewdLM7VFnAznPRMLWd/A/Vy0OnXoUwZdvZa/YO8ltEbExlu5DzTliDfVf3xBEYOgR/u+sA/VmMOm4o2BNZ+lGhuhw0hNvb7JXvUZzEwv4s= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:28 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 13/14] selftests/bpf: add a cgroup storage test Date: Fri, 20 Jul 2018 10:45:57 -0700 Message-ID: <20180720174558.5829-14-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: c7f794d1-e054-4b17-175a-08d5ee68b8d1 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:HsA2Dec7oC06zmJ8DwxjwTPIQ9dOJZseRI3mShhtjY5CEzOhQ07Cs8DGivn2T/ibgCOZimqG3P+f4ejMS0/UbHJAIDzuNK3KcDBcwgHLHPxBPfsVgE4LOEvWqW/S1XS6VFcbgJW+WtEYqcPfj92o9F5FeLw/nJymcI2+XxVO8Lnunx0s/zssJFOT4XNo5bJqXk2PlEXAwY7I3NYoNqwST3Oi87vc9w2XIb7AbGd5O/fcJSFWN8NE3BENL4oJcRjp; 25:hvmEFpIzcULWP1mCYSnrAtx9VMBc/cH5FU6LbCvDsiLhcr+mY1bhlPNEJDE+pk5nrmOySKwx9EK+t28BPnGlqxyH8zGzBTAbSxNqOaEzjJdu2sX1rcVOG3+AcYMQs4ScDRGUfUqo1/Fg92C4EoIBAv0eQK+H04iA4RAhQDQru4ylclxt/+bltgRCSROFA6CMiW1NkqGhCu0pKGbrGl57PnZoUMEVFKQvuK9v+MT4y9OO1HoAmBafzNHs8xSOFd9/5ZjXUa/uowIQqHu2pygj/vdc8s2bsp0pRkSwggP4MqwfjWxmQOVIbBwA1yn6ByUZ74hU1LglOSyC0IntJvqxPQ==; 31:8LdNFVnx0V3Mh7R0CeUFjAK1kFDvpUY3CZAkJVNWrqQgOnn2yoG2M0boiCEpS84Cdbud3Er2XwqtZaYhwArUZzS1aAUUtv8zazJD65O6/n2h/jSjQuPvrjCQNlV9w9B7MUrZtbl4qOKTUr8ctxpS245FyWRq1GOA4nOqMJB/3e//VQ1bEdcYJuf5aa1NDDMDf5sPIeZLgqsDUZFC6FQk/pHANNW7prc+G7GrkRciNik= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:inoL+lOOjmz7MoHCnrlFv4hxu2ZYUiMhnXSQvh+r0hpTmasiej77NvaV+48Sye1KqmWRqCaQUfMdbj/b8IWkN7ncmepy6Zx/o+wumlYjQW5+cVV+SR6tgzbZlPOXWN0MvqtxNq/jMSx8xdBvbt+DXVs6+iwnSgXzwu2rKtjslfSv/XSl2vmW5bHmRpByH6GE4FZc4bD+b+Qudd9sb7RhwgmlRvzMDPKszZotp6m9wNlS9v3LTFWKf7EPN/zcCWMHXfI4cXHpLBQfoqzDUlJyP/EDwNAoYAUJ0EfvgvzA6nabcS/2VYfGoMrH5ahhEsCbAcU27XGIhJwtPFRC8Lhr/TImvPNkQhyPApImdDTdeXUAhFgFLsnGTbmcqcF0+ogWWEqjWM4uuPVrCCY3vV6cMVNgGn0jGfhuiVyKnwiYq545W2b4hurLsE+r7wrT5qboJ8QYQcrvv5KDczaVG7nmAdt5UAungdLceuQGo0XQaprVFpaVH1LHiGM102UqXr+X; 4:GZueefIhFOIXrX/nc+Y/ZtnTkkAeSheAPIH8rUIpxG+jwIFZlPpBQBb27bQrQO+ExjrVLuKLlUlvCRSE461l2bAmU3owQveLG2q45Felcfz6BDhNyoL/E3a7Tz9gnN8t6mcJMQM/UzU8PXXP7bKwkeLf0PLYt14Zo1qLIcP+09ekqjjL6TSfg+9MUHzuP/AmHcAr6bnbB1EfvPOLxBhgsjlRsiutawY9uhraGLnL/J5/WCGKdKcBm7pFJ4Q3LenwvrmsUUQVoJiJyf4hHw/zZrh61lztsuWcxPXZP4vW0qtSuWU3XvbW5NUVAwtKaYN6nAFdcADAo59ymN2IvHgWgqLX5kkfZXEt/aFOhZkFJYw= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(265634631926514)(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(1496009)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:hZItyrgJbKAFeQRtAYWAaoXVWn+AwNTOXb07HRC5hoawJKuhwhEEXsLIwVP/M0fl73klsjg7p9yn8zTXEAK9rnK9FRN4cKAIhJMkVt1ys9p/0YvPCd7gZ1Fcpxs/SetGg/Tqc00mHA4qDD+VeKi2uBvTq1nOvv03ZA90qZCohz+WTGrVPFQWrmI6IG4iTZKoWVzRrqf0IY31kIUMSwA5yuvwgl66kJAXnUjpQZ7MRE9SWlHcRjZuLtBhGAzjK6PuwZMhaPttZ/13Jxj7Cow0xN5G0yXgChLWRisTdNbpoVI8wwrrRULNd0vrZv6W0Dc7A75uQuGt7TmOfMBoEzYY48wcn707tP/GNRnovHcbQhK0wspEaSdanr4YG4AYkN2YLaMCCKTUeMD4gSjprGj5dEldvyWDcFuWdcUCrb6p0eQTRwtkAx8qsG3RHhQFm3aKnunEqHfEigu5ECQqDuUVCs2A6ux1SU08aF13m630SX4sEWhZ2VNBavSgy7ktLH8g9PAYeSbWem9uytDGFcOwTW369a8jvZt8bxBlsxIrh2WkJwDmgFKrYrybrWg8LxYnDv5biq5srlT1ZWhhFHM7TT3pNowX45aVaIN3rNIFcZ0ypSEr8f5ebKPKvjLWiUtYNlAYggoNSpN+5dFlrJGDIORW0Yo566y143dex+ZZaFiXwimtBwOcE2CGVlWmpdofK+Ee7SK+wV5ISGMhaSxz7Z6d/2K3fANln7MmH81jDZ1ZICGQOd49j651fKxS9xWWcDlCVqGYBqPGZLAFA+1QcnBP8F/xVGttZSAnLaaOlFwTTKI68/YRlbQvFk0zxAOlQvkk93swU1jkUPZS3NQhw/S8ReclA65WQoRyEe7avZNJlSRyvd5n90Jhe2sns+A9mcS2qZDEzyBAERUTCZWZNdScdqprFlvlhoP9pv8zaUYgFjWOCmz54vqve26U+0/Xa+AwMWjwQhfteWowXUQubgyEQuPM9o6sbZRivaosJFayvjIiwvzc5qKIhSAeFOC2wChiHyENBsR2tNy/Onx14txDoEnNmXYmiCF5b9s5FFgj5RTmbKuQxjc5bMfLwqg/YcnyPm1kCdFDcsLeA2x56qZD7Y9BUzj+nlXmGCGrcrjnjsUQp1sAPXJ1CR9AqjowtljpkItzUvvybOCQWTxnJia1BWtXmbMzGUjXmQqsw1mLEkvIWu0SuSPhqHbOzmJBdgqdIC7JEDHXdu3ybt2l40ITzz5Ua/BQiH76KzWJsVrfFAWZ/r75NRsc3N8WOdnOu3QzDB57PAw19NGvION4Jg0o6ynK1x2C7S74COHqhzPDkOLJ7g/t/lPIqmu2Gq39 X-Microsoft-Antispam-Message-Info: GzftWolC43t8j2WrSuv64DQC/FfMKQxFLIUfdtGNDJ9ZkNWy88pgZ/cbYJmVuComanCmd56H1opQD99S86Mqky2EMU7QqSgALJElmP5PGxLPMJ9nkanbZN7+kV9tkIKJFk9SpB6bM96kxmF5OwdbmRw0vHiPlxheQrjer8DHT7CiNkQ8rYs4Q9ED/JtuGhSBOXcB0brWNvB2qYUDH+QvJ91dO5ERR/kSXYXfckCav/nNJR7DEZOqnTMvg8jE9y+7FbU2g8k5fIk3IjkdtvpgvzvY8RndzKgnkm1D7OjYElR7sX8ZfbaiRtKSYSC5EUWQQhp+iN2v7I78tP4hbjSNJ5Zqx0UEW3NN7Zv/8br9M8o= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:T+OUkRchLiapUUrTPBc4eHKs5rmpl2lf4CcLpTTsajIf9SHVZgl98sq0EGj9SLHItiDClybx2eu3pKtg8AnJzdARjsEBkSTznCLz03yiQ9wbSUXL46i8oa+CkoagX828y+VNqq8vnF9fYmdCg+Qy3uInb4tKK/QrWm5dV4bB2PtXPklTdpPbVBF2Wy5TIaDFArKCrgBNcLbzE1a0SN0V/bRl1IjXOx3pMrDwwdDS2ez4RGkrRaPYeEpSMXuW8DJynbKb8M8wvfZp5Elsz+Z2Y8eJZyPE09CbSIS/QK02tW8imBfHb2InHP+k51EqCnS8PYuxfU2nAekEHTblrJbE9GergiVjJbrwMcoBE7WQSP0TitLdP5XWhDfQKRB2eSFIbp5589lo2WeUwxRX1vZLBaxYCNcxIqPQuIgq8GThEt9RYkiCcNmbiATHYFM/cp78ZZ15HDprmhr62UVeOnaEAQ==; 5:5tOWxsZQb5dXhh3l/WWIXC4Mbz56GpvmQDxvyJ4RFwMsKpvQycQ28sApd1pqdUufX4rsii4q+9RxoxJxEnW4Ni/45pkhsjHYWkyS4+9u1tHqYy/agyM6lUVb1lTBfosFIAgOkbg+/RHmKCmCGSdW9nfZeyeDz3KZQK/tPsruflU=; 7:i2RV/IDCIvQ2Zd2tsJrGtUdmy6rC4IDnsvzfi1N667CKBV1f0cgo5MptnL4hG+0Z97SfHd7We2S/m527QPQSPzRu2ACJaRjsnj8AoezqEflDsyAhTGqcvC2cywa60LppmD5INdhmVFUyujeMiWzs/BHDx5H9znHT1gOpD4kmN0MOn95hfAY52YPOB2x0iZKLrWLvJ8unAk1H8DLiblk8zW+7s07HJhLOoJ3JCMm9umu+xQKKVVflQUF1CPL2Evxf SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:/Fhd/tqG6PvHhYRCJsjiPy/PRpHZ39rrnzSToWg9CX4ayLLkBkfBvt4LRn8j8AjkSdXHlcyUGolnNlzSL+W+HhIMd3v2jspAMFqiY/DgT5EM2p3RAfmlhvOuGhoFwRFRzADdAL8lmJSAO8IBog1D57kZf1rlpAH5O6Htr2H9weI= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:28.0487 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: c7f794d1-e054-4b17-175a-08d5ee68b8d1 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Implement a test to cover the cgroup storage functionality. The test implements a bpf program which drops every second packet by using the cgroup storage as a persistent storage. The test also use the userspace API to check the data in the cgroup storage, alter it, and check that the loaded and attached bpf program sees the update. Expected output: $ ./test_cgroup_storage test_cgroup_storage:PASS Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- tools/testing/selftests/bpf/Makefile | 4 +- tools/testing/selftests/bpf/test_cgroup_storage.c | 130 ++++++++++++++++++++++ 2 files changed, 133 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/test_cgroup_storage.c diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile index 478bf1bcbbf5..8f466af33e09 100644 --- a/tools/testing/selftests/bpf/Makefile +++ b/tools/testing/selftests/bpf/Makefile @@ -22,7 +22,8 @@ $(TEST_CUSTOM_PROGS): $(OUTPUT)/%: %.c # Order correspond to 'make run_tests' order 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 test_lirc_mode2_user get_cgroup_id_user + test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \ + test_cgroup_storage TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o \ test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o \ @@ -64,6 +65,7 @@ $(OUTPUT)/test_sockmap: cgroup_helpers.c $(OUTPUT)/test_tcpbpf_user: cgroup_helpers.c $(OUTPUT)/test_progs: trace_helpers.c $(OUTPUT)/get_cgroup_id_user: cgroup_helpers.c +$(OUTPUT)/test_cgroup_storage: cgroup_helpers.c .PHONY: force diff --git a/tools/testing/selftests/bpf/test_cgroup_storage.c b/tools/testing/selftests/bpf/test_cgroup_storage.c new file mode 100644 index 000000000000..0597943ce34b --- /dev/null +++ b/tools/testing/selftests/bpf/test_cgroup_storage.c @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include + +#include "cgroup_helpers.h" + +char bpf_log_buf[BPF_LOG_BUF_SIZE]; + +#define TEST_CGROUP "/test-bpf-cgroup-storage-buf/" + +int main(int argc, char **argv) +{ + struct bpf_insn prog[] = { + BPF_LD_MAP_FD(BPF_REG_1, 0), /* map fd */ + BPF_MOV64_IMM(BPF_REG_2, 0), /* flags, not used */ + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, + BPF_FUNC_get_local_storage), + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1), + BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), + BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0x1), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_EXIT_INSN(), + }; + size_t insns_cnt = sizeof(prog) / sizeof(struct bpf_insn); + int error = EXIT_FAILURE; + int map_fd, prog_fd, cgroup_fd; + struct bpf_cgroup_storage_key key; + unsigned long long value; + + map_fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE, sizeof(key), + sizeof(value), 0, 0); + if (map_fd < 0) { + printf("Failed to create map: %s\n", strerror(errno)); + goto out; + } + + prog[0].imm = map_fd; + prog_fd = bpf_load_program(BPF_PROG_TYPE_CGROUP_SKB, + prog, insns_cnt, "GPL", 0, + bpf_log_buf, BPF_LOG_BUF_SIZE); + if (prog_fd < 0) { + printf("Failed to load bpf program: %s\n", bpf_log_buf); + goto out; + } + + if (setup_cgroup_environment()) { + printf("Failed to setup cgroup environment\n"); + goto err; + } + + /* Create a cgroup, get fd, and join it */ + cgroup_fd = create_and_get_cgroup(TEST_CGROUP); + if (!cgroup_fd) { + printf("Failed to create test cgroup\n"); + goto err; + } + + if (join_cgroup(TEST_CGROUP)) { + printf("Failed to join cgroup\n"); + goto err; + } + + /* Attach the bpf program */ + if (bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0)) { + printf("Failed to attach bpf program\n"); + goto err; + } + + if (bpf_map_get_next_key(map_fd, NULL, &key)) { + printf("Failed to get the first key in cgroup storage\n"); + goto err; + } + + if (bpf_map_lookup_elem(map_fd, &key, &value)) { + printf("Failed to lookup cgroup storage\n"); + goto err; + } + + /* Every second packet should be dropped */ + assert(system("ping localhost -c 1 -W 1 -q > /dev/null") == 0); + assert(system("ping localhost -c 1 -W 1 -q > /dev/null")); + assert(system("ping localhost -c 1 -W 1 -q > /dev/null") == 0); + + /* Check the counter in the cgroup local storage */ + if (bpf_map_lookup_elem(map_fd, &key, &value)) { + printf("Failed to lookup cgroup storage\n"); + goto err; + } + + if (value != 3) { + printf("Unexpected data in the cgroup storage: %llu\n", value); + goto err; + } + + /* Bump the counter in the cgroup local storage */ + value++; + if (bpf_map_update_elem(map_fd, &key, &value, 0)) { + printf("Failed to update the data in the cgroup storage\n"); + goto err; + } + + /* Every second packet should be dropped */ + assert(system("ping localhost -c 1 -W 1 -q > /dev/null") == 0); + assert(system("ping localhost -c 1 -W 1 -q > /dev/null")); + assert(system("ping localhost -c 1 -W 1 -q > /dev/null") == 0); + + /* Check the final value of the counter in the cgroup local storage */ + if (bpf_map_lookup_elem(map_fd, &key, &value)) { + printf("Failed to lookup the cgroup storage\n"); + goto err; + } + + if (value != 7) { + printf("Unexpected data in the cgroup storage: %llu\n", value); + goto err; + } + + error = 0; + printf("test_cgroup_storage:PASS\n"); + +err: + cleanup_cgroup_environment(); + +out: + return error; +} From patchwork Fri Jul 20 17:45:58 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 947141 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="hld2X+/l"; dkim=pass (1024-bit key; unprotected) header.d=fb.onmicrosoft.com header.i=@fb.onmicrosoft.com header.b="Fl2jgM1f"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41XJJk43yNz9s9G for ; Sat, 21 Jul 2018 03:48:22 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388546AbeGTSh1 (ORCPT ); Fri, 20 Jul 2018 14:37:27 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:38678 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387909AbeGTShZ (ORCPT ); Fri, 20 Jul 2018 14:37:25 -0400 Received: from pps.filterd (m0044008.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.22/8.16.0.22) with SMTP id w6KHhhGp025819; Fri, 20 Jul 2018 10:47:45 -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=ccUkIiuy+r9fHc6FqtW+NV/batrBqZJEIjW+tLZ/ydU=; b=hld2X+/lZhcaEY0eziXFNdkbYgy8J8sQbaKFiUFQSJAG3zTHNFTkCDdM/kE6ZebOe/cK 3pdCcHOElMHWZA0yG87i8FUiWq72bWoacc9sT8Cz9rGOEGnsSliep1QRHy/rn3Mpsfp3 sKu9LUZ4BlXKwHGLn4pocOBQS0lxGQYzFOY= Received: from mail.thefacebook.com ([199.201.64.23]) by mx0a-00082601.pphosted.com with ESMTP id 2kbmbv80h7-13 (version=TLSv1 cipher=ECDHE-RSA-AES256-SHA bits=256 verify=NOT); Fri, 20 Jul 2018 10:47:45 -0700 Received: from NAM03-BY2-obe.outbound.protection.outlook.com (192.168.54.28) by o365-in.thefacebook.com (192.168.16.24) with Microsoft SMTP Server (TLS) id 14.3.361.1; Fri, 20 Jul 2018 10:46:34 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.onmicrosoft.com; s=selector1-fb-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=ccUkIiuy+r9fHc6FqtW+NV/batrBqZJEIjW+tLZ/ydU=; b=Fl2jgM1fOo1n4o+mAVuAVL0hXUjiq2PBGweVzYZPDfAPoPHdduPxzKkVO9e8V1dT4n0okY+W7tasQ9mUw4m5Po3pO8z11QIKzpocQhtIGjBEPlIcqQ5gs+zhybFdNbcgCwQ1X2WolNB0Y+Yh7vAGKyZjwc2gKA9Wf7oCh9Zgl+Y= Received: from castle.thefacebook.com (2620:10d:c090:200::6:ca05) by SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Fri, 20 Jul 2018 17:46:29 +0000 From: Roman Gushchin To: CC: , , Roman Gushchin , Alexei Starovoitov , Daniel Borkmann Subject: [PATCH v3 bpf-next 14/14] samples/bpf: extend test_cgrp2_attach2 test to use cgroup storage Date: Fri, 20 Jul 2018 10:45:58 -0700 Message-ID: <20180720174558.5829-15-guro@fb.com> X-Mailer: git-send-email 2.14.4 In-Reply-To: <20180720174558.5829-1-guro@fb.com> References: <20180720174558.5829-1-guro@fb.com> MIME-Version: 1.0 X-Originating-IP: [2620:10d:c090:200::6:ca05] X-ClientProxiedBy: MWHPR17CA0096.namprd17.prod.outlook.com (2603:10b6:300:c2::34) To SN1PR15MB0175.namprd15.prod.outlook.com (2a01:111:e400:58cf::14) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 70bdb759-4661-441f-6127-08d5ee68b979 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(5600067)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060)(7193020); SRVR:SN1PR15MB0175; X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 3:xNinmYrK2y7ykH4Q2fnVdltJHABSVMDCj6+O7ot1SXmxqOu9C7AcYwH3GqcuilXO2IZRLhWuZffRTTknC0gJq0n6IB/oKOYzwqelV/nhSsU4IQBfZuU7flhVCOguxWsbwxysV2DCMfgM6p96w3yw4dLzfo/1cnW14Dxa6ys22HtqjX/x66zZhFI1Kf5KwwrJRziS3SaSrM5VJG8N+sTcNb3/+w5yTvaViWGmuIPll7r0ah4fvdkAVC9jTTTlLjYH; 25:D2B26821b1RTXXNoUynNRG1sSvp28l7mNlZI7p/IYvYJN9tf66cRm7AAi5vWW1ewd9fZ4wHvQS1pDfUwLVzWK3g/+cGcuLK2hVvnJoOQiDkt4vLN3oy0o8W+s6nfgRAvps/pDEuJ5l2CY/2d2RFq+vRz8LpmX1QYUVZN4cBhiLNST2fhMmTDl/9VGys9SujUpUw9kx4j5w3GfdHEd38lw2gBp/K9On3xcoeqyIbtO9DZEQjSsElHcixtmIWYkDmgZHcP2NdYOvH6zhkr7cBYLkvKnBcp33/TwrHqU/s3B114y+HKvbz6kh1hBltoOPFojsHJZ9zbDx5TGSZOgcbu8A==; 31:aoRY396QrTd35c6uqkteDjMW024yeAq08NzUs6afrGnF7yxgI1XCv7O7lvJ9hQHfLBTUarHpQnnSrLNSOJH8uzY7fyqY5RKOGdlFmGKk1HY5oKEjwv0Cf1jBufFq+vY6ODGqk7A330Nr0p7S3S19E4vji6lLCx9R2FMoggafwybTouV8zDs00sWNdnxRkHWwXAFwWSbxNsy7ErpWmTQHf8yyE1XNi8D0fTxHWBQtw/E= X-MS-TrafficTypeDiagnostic: SN1PR15MB0175: X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:HvUXws7dCx8iTzPw7Hd6AwtBS8yM++ALIv2Cc4jabCzrBJcQXWp0wxGZB6x1hyj/gD2jOIsBgQ5weN70CKMaYxcuRVYqcGeGzYFM/JT+eg6mYQUUiJDi8yQmDynMllCFwLFqyaSnhTr0ORvQwcYsECvJQeFDZK1BZ86yd10W0JUbOiolGyFhO9+o/9UPu1GTog7GM+kif1rYanKTu54oa6XM5NQBfET/mqEenwQ0hIEUbFW347lQtoj7qNuN/Uv+vBa9e0JGem5etaq6hvD8AujFtbNCwHmPhCUn/y3p0o18r+hxoVNc5r1hllgQDjKy9qYyWFQGwDhKjosEsgtSFDIOw0R+dPDIqd45W4sBKcarJSox15iMiFSZQnJFBh2v2QeQ6Sge79NGGaicqX1la5HsPZolGIRD5UQ9VbeddlGmXByS8xWIJnn5piHtskfyKUCp5mr5k51mzg41sHJq+nvVTtGKhR6LWfoNyKEqfDjTB+rJujzXBDYs/8BCefA0; 4:Njp2q6BJI56fy9HvysowwB1UTJYRpNaeqyN7bZpWboAlGFBShW3CsS28nQ62tEmJfBGwAaNOXWbbbpqZIk+I2OFiMuH5QnMywWyQwc1tofFBF1n9LR7QwCU4NbcRTw7vqe5WBH2LJYB8hIRYheliDyaxnoPKrUsx3DaF2Q9wLT3Lkp5Ydt1coFsK50QMiUQLkCQqeAFxSVGX335EFHH9kLUB61jUp6419dmQJX8i1kZRQ5AAfMrRNcGd/CED7IevugpJzKSVqmdr/uZIk+GlX9psyCoQMHWnoLA9T8G0RrmgHw9akRsiZyGk69mhr9DH X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(67672495146484); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(93006095)(93001095)(3231311)(11241501184)(944501410)(52105095)(10201501046)(3002001)(149027)(150027)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(20161123558120)(20161123560045)(20161123564045)(6072148)(201708071742011)(7699016); SRVR:SN1PR15MB0175; BCL:0; PCL:0; RULEID:; SRVR:SN1PR15MB0175; X-Forefront-PRVS: 073966E86B X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10019020)(1496009)(346002)(39860400002)(366004)(136003)(376002)(396003)(189003)(199004)(2906002)(6666003)(50466002)(81166006)(53416004)(8676002)(48376002)(2351001)(68736007)(81156014)(106356001)(8936002)(25786009)(105586002)(1076002)(5660300001)(6512007)(6486002)(36756003)(478600001)(86362001)(69596002)(7736002)(6116002)(305945005)(97736004)(2361001)(16586007)(316002)(52116002)(51416003)(52396003)(446003)(50226002)(46003)(54906003)(14444005)(47776003)(2616005)(5024004)(476003)(486006)(15760500003)(6916009)(11346002)(386003)(76176011)(16526019)(53936002)(6506007)(186003)(4326008)(42262002); DIR:OUT; SFP:1102; SCL:1; SRVR:SN1PR15MB0175; H:castle.thefacebook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: fb.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 23:bSaCToy3SPw1R5FALm/BFzU+JMkK03rjkn+iHXaVBQYafoPdbghGerVS3l3eNhU7vgubC9vcQ/2Lm1M+YoJNM4eSHfy4/fgoYYqztPrcHzjAQv/I5pz2ltjOBumFwDco6E8fZL8AMHBcGvQqSbIZm9nQ1Ih/2dcSPrrSUS8duLlWdzEDpE/VygItv2CTJoRiJ+R+BMHpK+RsWdEEcq0E1N4uqCX39yT/1+XOdTsWdhpVqbAnGSeCXnKp94DA9Ngb6lsThr799ng0ufa1BQb6y/FyDairJQAKYw/1moOiO3KumIvnSKxKN2em2shx5jmjfwAHj0xzlhEzgip78auMGOed0ZuS8D5ee4RjZKZmjbhbtMlArqlB8BHOp/iWfn7fRKeGwQgqa46tTdC4cCisWBmsJ1uO93lYSV5Gj1MreO3Avpj379dKbHDXrcKSwLhp+fGDj1BWAgOYtKdnZ3sjNiQMe+f/YOWl/WR7h2bqMBdlpl8tUngBVCQmTL1lhVHWkmyz/ZfoxlJCW5tlJv+TsdQIPoRHDeISbXZTwrAlncTcyH2Q2TSUxexR49bMO66lQkPIfQ4HIexWtkzGfiAHbTKB4JYc+YmYm+T2Z4NeHz0P8ES4v385z3ngXnN4QQQJnyRtvFXN6lQMJ5y7b4BzzQRky3dvvAEIgZfitgLDDBWg0yFY/OjOBo07QLF64pVvUoTwDpt7TJVVWWqpFsHJ/sNGPTScv4iGeA0QSRT2MAhXwpS7OjGG9Rv6HRVHrWXEjJxEdk3AtC27ZOkwPp7H2KSvKPnJXzH/Y0ozU7YxRmQ239BCPhslNGJ2qgq08MUPnAB+6/er/SeKb6sRv8KcI3oNLaKZYBs7T5ZSyhs6cX/iPleT6/kM9qte3ebeUCYT87AjbdEt/YYxy+YqAn0mmWHiMQuP42FEjndR/H9woFVjaa0IbuRQofwRfENvDfVzdF5HA/sakUvzdV4yDbvxjSqB3/9mLd6muxCnjtP+Xox/TG+TTLLkvlUmxKjGtN5pt+kwQtWytkE8da9/lipyEQsnZ9YQJYE/wGLF9ItbkkrQMio0DGdkcBJjEQqoBx8uLr2qZry+FcgcTTouM/znXHJQUd7tYr/5FEmnpGi3tf14KJjnmdpgBvH4Ob6uWrX3PgvquqvqKvosl+ffBhnfrO5Os1KwG+YPwXkrZnhQ2e5TeiNk2dOoZ7OivEB/pR+G/FNyItsiuUhVcWEIIeMN4cWWDWBAKy+Eehb8ns5OLLA8DLS3CkPTmdZ+P9qAnqZpszLWx1FYnAzxPIrecjcKXpnOyNEIEguDBc88dCcUGkmh4dGlbr5WQDZSYbgDrS4MBnnUp/KCfqspYXKa5ppdTw== X-Microsoft-Antispam-Message-Info: eovqUWbsw0bXH2D3erasXH6fLELiCXfX60nG3F1jobTe9MQ2j2O2nOF7DYLkyRr+2f8xKoBh+UbszY09OUzkIV0DHJUCRGqJwq/MTPNauXeUN00vd2Dr1ZsDQqiI8KJ6sdiJ+6wbe1hYY+hh/xQMu/Ytfrxf7HsdVc7Jwrp2oNVAmbPnQPxmiQS45QG6Z7uTk5Q91uDvFEeOQUyLg442t0o6ukpnlM37LhFQAxRjnPZaj6nD/Ioge1aBmw9z50acrQ00vpUpQwYK9Eu2BT1rPIzNX/Zin3kh3RkO5ZD8VLvAlm5XRLAjr6XBkwMlfte/khk/0h2oVq/BQNi2tRikZITz5KVXeMf+ymZe37FXqn8= X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 6:7Bl+66DSARY4FbJgb41Otbiw0Fzs5GP3sFWcj5bhSuNYNZmifCZEFQQChvw8vZbwSqV5awWEYXq2wnL/9Ui+ZaNGr67F84qBTwuouc3miSPFKCSyoRxUw0oqJH9Jhasz31eJmdt2btw6fpF4Y5DPFPkbMmdWatZ75PnsQm4zSXhiVEPr6SAyJ3B/5oamYUsq/OjHXNekOn+TXmYJp7x2vHD6bi2J5r8ETShBmgbt5rCq9jbzyY+x1jovAlzJfpiMC7a2wu5gGHFo9JiB42UHIsYTdyQd9723NCTzMsBOYT3ne+CRCeyUE9ckgIF3C8EaLI0NiIENuBO6ZAx/42MnwD+TeXXgxrA1FnfKOVZsSAMghtwpZpP23yhWoLLW3OfuJ7yUdhrWCHBQz8s2FajRs1e9KIRp03OFxQROk1yNz/gT7W3wfTVd0kUCNn6Akx+vbjVVTqchjHxU9bNPn0l8MA==; 5:LBPVENViqSRZmjRHdRlnPB9X/wezIge+dkDjEflsRVgc9jiOD/QwpDxFx0VUPDjV5Yq3BdvA0hNeu+VljKtwWY+EDkgyC1Lb9ivy8+WeCUjzwVGvzVocPiWyuYdy9gYuyXbsgmWwK7PU/jVtGnbE0nsnx3CBTVcd/zFWlvnjp44=; 7:3wl16ttWH7Vsjq6OuQP8erFYAZ12Qnd4ji73GzrkLBN/gQrXqHk3rg+xYHS6cyH84RlsB2Vm3IiId+eexxp05f8nRZVaNBSwvV7J3UGzr35DkDPCP8S9dK7F9tBNETJICHecxSZgZguyRQW7KamE084swcz0D3kJg0R+4P7VyQUHpOwY6CusAb7ysTmWBOoCwWebKyif4ai1eG455QxavG2wLDbvPhgWMCzLxhoL7WIM9aIaplUzqutEtPaWMgee SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; SN1PR15MB0175; 20:7DT45pDZSepf4NZVxhvzYuJf+hz7ppb06rEUFL2hp78d/lhO2JPC4WSu294UUY9+fGPPRh7xuY/r64vZj+TiQUP1/NSEEa1WdogmSAlPBQQwLhSp+JFyyMMuH2crr8DUHpZK14sCVPaOja2DQ6cImvcfHayrupr33gtTurw56+o= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jul 2018 17:46:29.1506 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 70bdb759-4661-441f-6127-08d5ee68b979 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ae927fe-1255-47a7-a2af-5f3a069daaa2 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN1PR15MB0175 X-OriginatorOrg: fb.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:, , definitions=2018-07-20_05:, , signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The test_cgrp2_attach test covers bpf cgroup attachment code well, so let's re-use it for testing allocation/releasing of cgroup storage. The extension is pretty straightforward: the bpf program will use the cgroup storage to save the number of transmitted bytes. Expected output: $ ./test_cgrp2_attach2 Attached DROP prog. This ping in cgroup /foo should fail... ping: sendmsg: Operation not permitted Attached DROP prog. This ping in cgroup /foo/bar should fail... ping: sendmsg: Operation not permitted Attached PASS prog. This ping in cgroup /foo/bar should pass... Detached PASS from /foo/bar while DROP is attached to /foo. This ping in cgroup /foo/bar should fail... ping: sendmsg: Operation not permitted Attached PASS from /foo/bar and detached DROP from /foo. This ping in cgroup /foo/bar should pass... ### override:PASS ### multi:PASS Signed-off-by: Roman Gushchin Cc: Alexei Starovoitov Cc: Daniel Borkmann Acked-by: Martin KaFai Lau --- samples/bpf/test_cgrp2_attach2.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/samples/bpf/test_cgrp2_attach2.c b/samples/bpf/test_cgrp2_attach2.c index b453e6a161be..180f9d813bca 100644 --- a/samples/bpf/test_cgrp2_attach2.c +++ b/samples/bpf/test_cgrp2_attach2.c @@ -8,7 +8,8 @@ * information. The number of invocations of the program, which maps * to the number of packets received, is stored to key 0. Key 1 is * incremented on each iteration by the number of bytes stored in - * the skb. + * the skb. The program also stores the number of received bytes + * in the cgroup storage. * * - Attaches the new program to a cgroup using BPF_PROG_ATTACH * @@ -21,12 +22,15 @@ #include #include #include +#include +#include #include #include #include #include "bpf_insn.h" +#include "bpf_rlimit.h" #include "cgroup_helpers.h" #define FOO "/foo" @@ -205,6 +209,8 @@ static int map_fd = -1; static int prog_load_cnt(int verdict, int val) { + int cgroup_storage_fd; + if (map_fd < 0) map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, 4, 8, 1, 0); if (map_fd < 0) { @@ -212,6 +218,13 @@ static int prog_load_cnt(int verdict, int val) return -1; } + cgroup_storage_fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE, + sizeof(struct bpf_cgroup_storage_key), 8, 0, 0); + if (cgroup_storage_fd < 0) { + printf("failed to create map '%s'\n", strerror(errno)); + return -1; + } + struct bpf_insn prog[] = { BPF_MOV32_IMM(BPF_REG_0, 0), BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* *(u32 *)(fp - 4) = r0 */ @@ -222,6 +235,11 @@ static int prog_load_cnt(int verdict, int val) BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2), BPF_MOV64_IMM(BPF_REG_1, val), /* r1 = 1 */ BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0), /* xadd r0 += r1 */ + BPF_LD_MAP_FD(BPF_REG_1, cgroup_storage_fd), + BPF_MOV64_IMM(BPF_REG_2, 0), + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_local_storage), + BPF_MOV64_IMM(BPF_REG_1, val), + BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_W, BPF_REG_0, BPF_REG_1, 0, 0), BPF_MOV64_IMM(BPF_REG_0, verdict), /* r0 = verdict */ BPF_EXIT_INSN(), }; @@ -237,6 +255,7 @@ static int prog_load_cnt(int verdict, int val) printf("Output from verifier:\n%s\n-------\n", bpf_log_buf); return 0; } + close(cgroup_storage_fd); return ret; }