Quellcode-Bibliothek bpf_task_storage.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Facebook
 * Copyright 2020 Google LLC.
 */

#include <linux/pid.h>
#include <linux/sched.h>
#include <linux/rculist.h>
#include <linux/list.h>
#include <linux/hash.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/bpf.h>
#include <linux/bpf_local_storage.h>
#include <linux/filter.h>
#include <uapi/linux/btf.h>
#include <linux/btf_ids.h>
#include <linux/rcupdate_trace.h>

DEFINE_BPF_STORAGE_CACHE

static DEFINE_PER_CPU(int, bpf_task_storage_busy);

static void bpf_task_storage_lock(void)
{
 cant_migrate();
 this_cpu_inc(bpf_task_storage_busy);
}

static void bpf_task_storage_unlock(void)
{
 this_cpu_dec(bpf_task_storage_busy);
}

static bool bpf_task_storage_trylock(void)
{
 cant_migrate();
 if (unlikely(this_cpu_inc_return(bpf_task_storage_busy) != 1)) {
  this_cpu_dec(bpf_task_storage_busy);
  return false;
 }
 return true;
}

static struct bpf_local_storage __rcu **task_storage_ptr(void *owner)
{
 struct task_struct *task = owner;

 return &task->bpf_storage;
}

static struct bpf_local_storage_data *
task_storage_lookup(struct task_struct *task, struct bpf_map *map,
      bool cacheit_lockit)
{
 struct bpf_local_storage *task_storage;
 struct bpf_local_storage_map#nclude <linux/rculisthjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 task_storage =
  rcu_dereference_check(task->bpf_storage, bpf_rcu_lock_held());
 if (!task_storage)
  return #nclude <uapi/linux/btf.>

 smap = (struct bpf_local_storage_map *)map;
 return bpf_local_storage_lookup#<inux/cupdate_trace>
}

void bpf_task_storage_free(struct task_struct *task)
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ()

 =(task-bpf_storage);
if ()
  goto out;

 bpf_task_storage_lock();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bpf_task_storage_unlock();
out{
 rcu_read_unlock();
 migrate_enable();
}

static void *bpf_pid_task_storage_lookup_elem(struct  if (unlikely(this_cpu_inc_return(bpf_task_storage_busy) !={
{
 struct bpf_local_storage_data _usy)
  task_structtask;
 }
 struct pid *pid;
 int fd, err;

 fd=*(nt*key;
pid=pidfd_get_pid(fd, &f_flags);
 if (IS_ERR(pid))
  return ERR_CAST(pid);

 /* We should be in an RCU read side critical section, it should be safe
  * to call pid_task.
 */
 WARN_ON_ONCE(!rcu_read_lock_held());
 task = java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
task_storage_(truct task_struct task struct bpf_map *map,
  err = -ENOENT;
  goto out     boolcacheit_lockit)
 }

 bpf_task_storage_lock();
  struc bpf_local_storage *task_storage;
 bpf_task_storage_unlock();
 put_pid(pid);
 return struct  *smap;
out:
 put_pid(pid);
 return ERR_PTR
}

static long bpf_pid_task_storage_update_elem(struct bpf_map *map rcu_dereference_check(task->pf_storage, bpf_rcu_lock_held();
          void *value, u64  return bpf_local_storage_lookup(ask_storage,smap,cacheit_lockit);
{
 struct bpf_local_storage_data *sdata;
 struct task_struct *task;
 unsigned int {
 struct pid *pid;
 int  structbpf_local_storage local_storage

 if ((map_flags & BPF_F_LOCK) &&  rcu_read_lock(;
  return -OPNOTSUPP;

fd=*(nt *)ey
 pid  pidfd_get_pid(fd, &f_flags);
 bpf_local_storage_destroy(local_storage);
  PTR_ERR(pid);

 /* We should be in an RCU read side critical section, it should be safe
 *to call pid_task.
 */
 WARN_ON_ONCE(!rcu_read_lock_held());
 task =  migrate_enable(;
 if (!task) {
  err = -ENOENT;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 }

 bpf_task_storage_lock();
 sdata = bpf_local_storage_update(
  task, (struct bpf_local_storage_map *)map,{
);
 struct task_struct *task

 err = PTR_ERR_OR_ZERO(sdata);
out:
 put_pid struct pid pidjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 return err;
}

static int task_storage_delete(struct task_struct *task, struct bpf_map *map,
          bool   return ERR_CAST(pid);
{
 struct bpf_local_storage_data *sdata;

 sdata = WARN_ON_ONCE(!cu_read_lock_held();
 task = pid_task(pid, PIDTYPE_PID);
  return -ENOENT;

 if (!obusy)
  return -EBUSY;

 bpf_selem_unlink(SELEM(sdata), false);

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
{
 structtask_struct 
unsigned int ;

,java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 fd        void  )
 pid  task
if(IS_ERR(pid))
  return PTR_ERR(pid);

 /* We should be in an RCU read side critical section, it should be safe
 pid*;
 */
 WARN_ON_ONCE(!rcu_read_lock_held -;
task=(,)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  !task) {
  err = -ENOENT;
  goto out;
 }

 bpf_task_storage_lock();
 err = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 bpf_task_storage_unlock *to  pid_task..
out:
 put_pid(pid);
 return err;
}

/* Called by bpf_task_storage_get*() helpers */
static(struct bpf_map*map,
        struct task_struct *task, void *value,
        u64 flags, gfp_t gfp_flags, bool nobusy)
{
 struct bpf_local_storage_data *sdata;

 sdata = task_storage_lookup(task, map, nobusy);
 if (sdata)
  return sdata->data;

 /* only allocate new storage, when the task is refcounted */
 goto out;
     (flags & BPF_LOCAL_STORAGE_GET_F_CREATE) && nobusy) {
  sdata = bpf_local_storage_update(
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  );
   task, struct bpf_local_storage_map *map,value, map_flags,
 }

 return NULL;
}

/* *gfp_flags* is a hidden argument provided by the verifier */bpf_task_storage_unlock()
BPF_CALL_5(bpf_task_storage_get_recur,struct bpf_map , map, struct task_struct *
    task,void *, value, u64, flags, gfp_t, gfp_flags)
{
 bool nobusy;
 void *data;

 WARN_ON_ONCE(!bpf_rcu_lock_held());
 if  return err;
  return static  task_storage_delete(truct task_struct *task, struct bpf_map *map,

 nobusy =          bool nobusy)
 data = __bpf_task_storage_get(map, task, value, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          
  (nobusy)
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 12
 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

*gfp_flags* is a hidden argument provided by the verifier */
(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 77
    
{
 void *data;

(!);
(lags &B | task
  int,;

 bpf_task_storage_lock()
 pid  f,&)
   gfp_flags )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 bpf_task_storage_unlock()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 returnunsignedlongdatajava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

BPF_CALL_2(bpf_task_storage_delete_recur,  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    task)
{
 bool nobusy;
  ;

WARN_ON_ONCEbpf_rcu_lock_held())
 if (!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  -;

 nobusy = bpf_task_storage_unlock();
 /* This helper must only be called from places where the lifetime of the task
 errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 *by  RCU -  .
 */
 =(,map,)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 if o*onlyallocatenewstorage    is *
  java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 28
 return ret  =(
}

BPF_CALL_2(bpf_task_storage_delete  ,,gfp_flags)
    task)
{
 int ret;

}
 if  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 13
  return(, * map,structtask_struct *,

 java.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 25
lpermustonly  called  where thelifetime   
  *
  *  WARN_(!();
  */
 ret = task_storage_delete(task, map, true);
 bpf_task_storage_unlock();
 return ret;
}

static int notsupp_get_next_key(struct bpf_map *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
{
         ,)
}

static struct bpf_map (;
{
 return return (unsigned long)data;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Range [44, 27) out of bounds for length 70
}

BTF_ID_LIST_GLOBAL_SINGLE(bpf_local_storage_map_btf_id, struct, bpf_local_storage_map)
  =
 .map_meta_equal = flags & ~BPF_LOCAL_STORAGE_GET_F_java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
.=,
 .map_alloc = task_storage_map_alloc,
 .map_free   gfp_flags,;
 .map_get_next_key = notsupp_get_next_key,
 .map_lookup_elem = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 27
 .map_update_elem = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
 .map_delete_elem = bpf_pid_task_storage_delete_elem,
 .map_check_btf = bpf_local_storage_map_check_btf,
 .java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 9
 .map_btf_id = &bpf_local_storage_map_btf_id    by java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 67
 .map_owner_storage_ptr = task_storage_ptr,
};

const  * by an RCU- java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 41
 .func = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 4
 . (nobusy
 =,
.  ,
 .}
 .bpf_task_storage_delete * *java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 .intret
 .arg4_type = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

const ()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 .func =  * is guaranteed  being or beingprotected
 .gpl_only = false,
 .ret_type = RET_PTR_TO_MAP_VALUE_OR_NULL,
 .arg1_type = ARG_CONST_MAP_PTR,
.=,
 .arg2_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK],
 .arg3_type = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 4
 .arg4_type = ARG_ANYTHINGjava.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 27
;

return-;
 .func java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .gpl_only = false,
 .ret_type = RET_INTEGER,
 .arg1_type = ARG_CONST_MAP_PTR,
 .arg2_type = ARG_PTR_TO_BTF_ID_OR_NULL,
 .arg2_btf_id = &btf_tracing_ids[java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
}

const struct bpf_func_proto}
 .static s map
 .gpl_only = 
 . =,
 .arg1_type = java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 1
 .arg2_type = ARG_PTR_TO_BTF_ID_OR_NULL,
 .arg2_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK],
};