/linux-master/lib/ |
H A D | hashtable_test.c | 13 int key; member in struct:hashtable_test_entry 41 a.key = 1; 43 hash_add(hash, &a.node, a.key); 54 a.key = 1; 56 hash_add(hash, &a.node, a.key); 57 b.key = 1; 59 hash_add(hash, &b.node, b.key); 71 a.key = 1; 74 hash_add(hash, &a.node, a.key); 75 b.key [all...] |
H A D | bsearch.c | 15 * @key: pointer to item being searched for 25 * Note that the key need not have the same type as the elements in 26 * the array, e.g. key could be a string and the comparison function 28 * the key and elements in the array are of the same type, you can use 31 void *bsearch(const void *key, const void *base, size_t num, size_t size, cmp_func_t cmp) argument 33 return __inline_bsearch(key, base, num, size, cmp);
|
/linux-master/tools/testing/selftests/bpf/progs/ |
H A D | test_map_ops.c | 12 __type(key, int); 25 __type(key, int); 32 static u64 callback(u64 map, u64 key, u64 val, u64 ctx, u64 flags) argument 40 const int key = 0; local 46 err = bpf_map_update_elem(&hash_map, &key, &val, BPF_NOEXIST); 54 const int key = 0; local 59 err = bpf_map_delete_elem(&hash_map, &key); 106 const int key = 0; local 114 bpf_map_update_elem(&array_map, &key, &val, flags); 124 const int key local [all...] |
H A D | stacktrace_map_skip.c | 13 __type(key, __u32); 20 __type(key, __u32); 27 __type(key, __u32); 39 __u32 key = 0, val = 0; local 49 key = bpf_get_stackid(ctx, &stackmap, TEST_STACK_DEPTH); 50 if ((int)key >= 0) { 52 bpf_map_update_elem(&stackid_hmap, &key, &val, 0); 53 stack_p = bpf_map_lookup_elem(&stack_amap, &key);
|
H A D | access_map_in_map.c | 18 __type(key, int); 30 __type(key, int); 46 int i, key, value = 0xdeadbeef; local 53 key = 1; 54 inner_map = bpf_map_lookup_elem(outer_map, &key); 59 key = 0; 60 inner_map = bpf_map_lookup_elem(outer_map, &key); 66 bpf_map_update_elem(inner_map, &key, &value, 0);
|
H A D | bpf_iter_bpf_percpu_array_map.c | 18 __type(key, __u32); 30 __u32 *key = ctx->key; local 35 if (key == (void *)0 || pptr == (void *)0) 38 key_sum += *key;
|
H A D | twfw.c | 24 __type(key, __u32); 31 __type(key, __u32); 42 const uint32_t key = 0; local 43 const struct twfw_tier_value* tier = bpf_map_lookup_elem(&tiers, &key); 47 struct rule* rule = bpf_map_lookup_elem(&rules, &key);
|
H A D | get_cgroup_id_kern.c | 10 __type(key, __u32); 17 __type(key, __u32); 25 __u32 key = 0, *expected_pid; local 28 expected_pid = bpf_map_lookup_elem(&pidmap, &key); 32 val = bpf_map_lookup_elem(&cg_ids, &key);
|
H A D | bpf_hashmap_full_update_bench.c | 14 __type(key, u32); 22 static int loop_update_callback(__u32 index, u32 *key) argument 26 bpf_map_update_elem(&hash_map_bench, key, &init_val, BPF_ANY); 34 u32 key = cpu + MAX_ENTRIES; local 37 bpf_loop(nr_loops, loop_update_callback, &key, 0);
|
/linux-master/crypto/asymmetric_keys/ |
H A D | pkcs7_trust.c | 14 #include <linux/key.h> 24 struct key *trust_keyring) 28 struct key *key; local 50 key = find_asymmetric_key(trust_keyring, 52 if (!IS_ERR(key)) { 58 pr_devel("sinfo %u: Cert %u as key %x\n", 59 sinfo->index, x509->index, key_serial(key)); 62 if (key == ERR_PTR(-ENOMEM)) 82 key [all...] |
H A D | asymmetric_type.c | 2 /* Asymmetric public-key cryptography key type 25 [VERIFYING_KEY_SIGNATURE] = "key sig", 26 [VERIFYING_KEY_SELF_SIGNATURE] = "key self sig", 35 * find_asymmetric_key - Find a key by ID. 44 * Find a key in the given keyring by identifier. The preferred identifier is 46 * former is matched (exactly or partially) against either of the sought key's 47 * identifiers and the latter must match the found key's second identifier 48 * exactly. If both are missing, id_2 must match the sought key's third 51 struct key *find_asymmetric_ke 57 struct key *key; local 261 asymmetric_key_cmp(const struct key *key, const struct key_match_data *match_data) argument 274 asymmetric_key_cmp_partial(const struct key *key, const struct key_match_data *match_data) argument 287 asymmetric_key_cmp_name(const struct key *key, const struct key_match_data *match_data) argument 362 asymmetric_key_describe(const struct key *key, struct seq_file *m) argument 466 asymmetric_key_destroy(struct key *key) argument 486 asymmetric_restriction_alloc( key_restrict_link_func_t check, struct key *key) argument 532 struct key *key; local 574 struct key *key = params->key; local [all...] |
/linux-master/net/rxrpc/ |
H A D | server_key.c | 2 /* RxRPC key management 17 #include <linux/key-type.h> 29 static void rxrpc_destroy_s(struct key *); 30 static void rxrpc_describe_s(const struct key *, struct seq_file *); 34 * description and the key material as the payload. 48 * Vet the description for an RxRPC server key. 65 * Preparse a server secret key. 101 static void rxrpc_destroy_s(struct key *key) argument 103 const struct rxrpc_security *sec = key 109 rxrpc_describe_s(const struct key *key, struct seq_file *m) argument 123 struct key *key; local [all...] |
H A D | security.c | 72 struct key *key = call->key; local 75 if (!key) 78 ret = key_validate(key); 82 for (token = key->payload.data[0]; token; token = token->next) { 101 struct key *key = conn->key; local 104 _enter("{%d},{%x}", conn->debug_id, key_serial(key)); 164 struct key *key = ERR_PTR(-EKEYREJECTED); local [all...] |
/linux-master/tools/lib/bpf/ |
H A D | hashmap.h | 43 typedef size_t (*hashmap_hash_fn)(long key, void *ctx); 51 * - these auxiliary macros cast the key and value parameters as 56 * hasmap_entry->key should be used for integer keys and 62 long key; member in union:hashmap_entry::__anon4479 96 * - HASHMAP_ADD - only add key/value if key doesn't exist yet; 97 * - HASHMAP_SET - add key/value pair if key doesn't exist yet; otherwise, 99 * - HASHMAP_UPDATE - update value, if key already exists; otherwise, do 101 * - HASHMAP_APPEND - always add key/valu [all...] |
/linux-master/tools/perf/util/ |
H A D | hashmap.h | 43 typedef size_t (*hashmap_hash_fn)(long key, void *ctx); 51 * - these auxiliary macros cast the key and value parameters as 56 * hasmap_entry->key should be used for integer keys and 62 long key; member in union:hashmap_entry::__anon27 96 * - HASHMAP_ADD - only add key/value if key doesn't exist yet; 97 * - HASHMAP_SET - add key/value pair if key doesn't exist yet; otherwise, 99 * - HASHMAP_UPDATE - update value, if key already exists; otherwise, do 101 * - HASHMAP_APPEND - always add key/valu [all...] |
H A D | pstack.h | 11 void pstack__remove(struct pstack *pstack, void *key); 12 void pstack__push(struct pstack *pstack, void *key);
|
H A D | bpf_map.c | 31 void *prev_key = NULL, *key, *value; local 42 key = malloc(bpf_map__key_size(map)); 43 if (key == NULL) 50 while ((err = bpf_map_get_next_key(fd, prev_key, key) == 0)) { 51 int intkey = *(int *)key; 53 if (!bpf_map_lookup_elem(fd, key, value)) { 61 prev_key = key; 69 free(key);
|
/linux-master/security/keys/ |
H A D | keyring.c | 25 * When plumbing the depths of the key tree, this sets a hard limit 40 static inline struct key *keyring_ptr_to_key(const struct assoc_array_ptr *x) 43 return (struct key *)((unsigned long)object & ~KEYRING_PTR_SUBTYPE); 45 static inline void *keyring_key_to_ptr(struct key *key) argument 47 if (key->type == &key_type_keyring) 48 return (void *)((unsigned long)key | KEYRING_PTR_SUBTYPE); 49 return key; 70 * The keyring key type definition. Keyrings are simply keys of this type and 76 static int keyring_instantiate(struct key *keyrin 305 const struct key *key = keyring_ptr_to_key(object); local 312 const struct key *key = keyring_ptr_to_key(object); local 461 const struct key *key = keyring_ptr_to_key(object); local 565 key_default_cmp(const struct key *key, const struct key_match_data *match_data) argument 577 const struct key *key = keyring_ptr_to_key(object); local 675 struct key *key; local 952 key_ref_t key; local 1101 struct key *keyring, *key; local 1193 const struct key *key = keyring_ptr_to_key(object); local 1350 __key_link_check_live_key(struct key *keyring, struct key *key) argument 1367 __key_link(struct key *keyring, struct key *key, struct assoc_array_edit **_edit) argument 1407 __key_link_check_restriction(struct key *keyring, struct key *key) argument 1435 key_link(struct key *keyring, struct key *key) argument 1484 __key_unlink_begin(struct key *keyring, struct key *key, struct assoc_array_edit **_edit) argument 1506 __key_unlink(struct key *keyring, struct key *key, struct assoc_array_edit **_edit) argument 1545 key_unlink(struct key *keyring, struct key *key) argument 1590 key_move(struct key *key, struct key *from_keyring, struct key *to_keyring, unsigned int flags) argument 1692 struct key *key = keyring_ptr_to_key(object); local 1703 const struct key *key = keyring_ptr_to_key(object); local [all...] |
H A D | request_key_auth.c | 2 /* Request key authorisation token key definition. 7 * See Documentation/security/keys/request-key.rst 20 static int request_key_auth_instantiate(struct key *, 22 static void request_key_auth_describe(const struct key *, struct seq_file *); 23 static void request_key_auth_revoke(struct key *); 24 static void request_key_auth_destroy(struct key *); 25 static long request_key_auth_read(const struct key *, char *, size_t); 28 * The request-key authorisation key typ 54 request_key_auth_instantiate(struct key *key, struct key_preparsed_payload *prep) argument 64 request_key_auth_describe(const struct key *key, struct seq_file *m) argument 82 request_key_auth_read(const struct key *key, char *buffer, size_t buflen) argument 134 request_key_auth_revoke(struct key *key) argument 146 request_key_auth_destroy(struct key *key) argument [all...] |
/linux-master/include/crypto/ |
H A D | twofish.h | 13 /* Structure for an expanded Twofish key. s contains the key-dependent 21 int __twofish_setkey(struct twofish_ctx *ctx, const u8 *key, 23 int twofish_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int key_len);
|
/linux-master/samples/bpf/ |
H A D | offwaketime_user.c | 47 static void print_stack(struct key_t *key, __u64 count) argument 53 printf("%s;", key->target); 54 if (bpf_map_lookup_elem(map_fd[1], &key->tret, ip) != 0) { 61 if (bpf_map_lookup_elem(map_fd[1], &key->wret, ip) != 0) { 67 printf(";%s %lld\n", key->waker, count); 69 if ((key->tret == -EEXIST || key->wret == -EEXIST) && !warned) { 72 } else if (((int)(key->tret) < 0 || (int)(key->wret) < 0)) { 73 printf("err stackid %d %d\n", key 79 struct key_t key = {}, next_key; local [all...] |
H A D | trace_event_kern.c | 22 __type(key, struct key_t); 46 struct key_t key; local 53 bpf_get_current_comm(&key.comm, sizeof(key.comm)); 54 key.kernstack = bpf_get_stackid(ctx, &stackmap, KERN_STACKID_FLAGS); 55 key.userstack = bpf_get_stackid(ctx, &stackmap, USER_STACKID_FLAGS); 56 if ((int)key.kernstack < 0 && (int)key.userstack < 0) { 71 val = bpf_map_lookup_elem(&counts, &key); 75 bpf_map_update_elem(&counts, &key, [all...] |
/linux-master/arch/mips/include/asm/ |
H A D | jump_label.h | 40 static __always_inline bool arch_static_branch(struct static_key *key, bool branch) argument 47 : : "i" (&((char *)key)[branch]) : : l_yes); 54 static __always_inline bool arch_static_branch_jump(struct static_key *key, bool branch) argument 60 : : "i" (&((char *)key)[branch]) : : l_yes); 76 jump_label_t key; member in struct:jump_entry
|
/linux-master/tools/perf/util/bpf_skel/ |
H A D | func_latency.bpf.c | 47 __u64 key, now; local 52 key = bpf_get_current_pid_tgid(); 64 __u32 pid = key & 0xffffffff; 75 bpf_map_update_elem(&functime, &key, &now, BPF_ANY); 94 __u32 key; local 103 for (key = 0; key < (NUM_BUCKET - 1); key++) { 104 if (delta < (cmp_base << key)) 108 hist = bpf_map_lookup_elem(&latency, &key); [all...] |
/linux-master/include/net/ |
H A D | arp.h | 15 u32 key = *(const u32 *)pkey; local 16 u32 val = key ^ hash32_ptr(dev); 22 static inline struct neighbour *__ipv4_neigh_lookup_noref(struct net_device *dev, u32 key) argument 25 key = INADDR_ANY; 27 return ___neigh_lookup_noref(&arp_tbl, neigh_key_eq32, arp_hashfn, &key, dev); 31 struct neighbour *__ipv4_neigh_lookup_noref(struct net_device *dev, u32 key) argument 37 static inline struct neighbour *__ipv4_neigh_lookup(struct net_device *dev, u32 key) argument 42 n = __ipv4_neigh_lookup_noref(dev, key); 50 static inline void __ipv4_confirm_neigh(struct net_device *dev, u32 key) argument 55 n = __ipv4_neigh_lookup_noref(dev, key); [all...] |