Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2003-2005 Devicescape Software, Inc. |
| 3 | * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> |
| 4 | * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License version 2 as |
| 8 | * published by the Free Software Foundation. |
| 9 | */ |
| 10 | |
| 11 | #include <linux/kobject.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 12 | #include <linux/slab.h> |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 13 | #include "ieee80211_i.h" |
Johannes Berg | 2c8dccc | 2008-04-08 15:14:40 -0400 | [diff] [blame] | 14 | #include "key.h" |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 15 | #include "debugfs.h" |
| 16 | #include "debugfs_key.h" |
| 17 | |
Eliad Peller | 07caf9d | 2010-10-27 14:58:29 +0200 | [diff] [blame] | 18 | #define KEY_READ(name, prop, format_string) \ |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 19 | static ssize_t key_##name##_read(struct file *file, \ |
| 20 | char __user *userbuf, \ |
| 21 | size_t count, loff_t *ppos) \ |
| 22 | { \ |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 23 | struct ieee80211_key *key = file->private_data; \ |
Eliad Peller | 07caf9d | 2010-10-27 14:58:29 +0200 | [diff] [blame] | 24 | return mac80211_format_buffer(userbuf, count, ppos, \ |
| 25 | format_string, key->prop); \ |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 26 | } |
Eliad Peller | 07caf9d | 2010-10-27 14:58:29 +0200 | [diff] [blame] | 27 | #define KEY_READ_D(name) KEY_READ(name, name, "%d\n") |
| 28 | #define KEY_READ_X(name) KEY_READ(name, name, "0x%x\n") |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 29 | |
| 30 | #define KEY_OPS(name) \ |
| 31 | static const struct file_operations key_ ##name## _ops = { \ |
| 32 | .read = key_##name##_read, \ |
| 33 | .open = mac80211_open_file_generic, \ |
Arnd Bergmann | 2b18ab3 | 2010-07-06 19:05:31 +0200 | [diff] [blame] | 34 | .llseek = generic_file_llseek, \ |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | #define KEY_FILE(name, format) \ |
| 38 | KEY_READ_##format(name) \ |
| 39 | KEY_OPS(name) |
| 40 | |
Eliad Peller | 07caf9d | 2010-10-27 14:58:29 +0200 | [diff] [blame] | 41 | #define KEY_CONF_READ(name, format_string) \ |
| 42 | KEY_READ(conf_##name, conf.name, format_string) |
| 43 | #define KEY_CONF_READ_D(name) KEY_CONF_READ(name, "%d\n") |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 44 | |
| 45 | #define KEY_CONF_OPS(name) \ |
| 46 | static const struct file_operations key_ ##name## _ops = { \ |
| 47 | .read = key_conf_##name##_read, \ |
| 48 | .open = mac80211_open_file_generic, \ |
Arnd Bergmann | 2b18ab3 | 2010-07-06 19:05:31 +0200 | [diff] [blame] | 49 | .llseek = generic_file_llseek, \ |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | #define KEY_CONF_FILE(name, format) \ |
| 53 | KEY_CONF_READ_##format(name) \ |
| 54 | KEY_CONF_OPS(name) |
| 55 | |
| 56 | KEY_CONF_FILE(keylen, D); |
| 57 | KEY_CONF_FILE(keyidx, D); |
| 58 | KEY_CONF_FILE(hw_key_idx, D); |
Johannes Berg | 11a843b | 2007-08-28 17:01:55 -0400 | [diff] [blame] | 59 | KEY_FILE(flags, X); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 60 | KEY_FILE(tx_rx_count, D); |
Eliad Peller | 07caf9d | 2010-10-27 14:58:29 +0200 | [diff] [blame] | 61 | KEY_READ(ifindex, sdata->name, "%s\n"); |
Johannes Berg | e7a64f1 | 2007-08-28 17:01:55 -0400 | [diff] [blame] | 62 | KEY_OPS(ifindex); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 63 | |
| 64 | static ssize_t key_algorithm_read(struct file *file, |
| 65 | char __user *userbuf, |
| 66 | size_t count, loff_t *ppos) |
| 67 | { |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 68 | char buf[15]; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 69 | struct ieee80211_key *key = file->private_data; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 70 | u32 c = key->conf.cipher; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 71 | |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 72 | sprintf(buf, "%.2x-%.2x-%.2x:%d\n", |
| 73 | c >> 24, (c >> 16) & 0xff, (c >> 8) & 0xff, c & 0xff); |
| 74 | return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf)); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 75 | } |
| 76 | KEY_OPS(algorithm); |
| 77 | |
| 78 | static ssize_t key_tx_spec_read(struct file *file, char __user *userbuf, |
| 79 | size_t count, loff_t *ppos) |
| 80 | { |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 81 | u64 pn; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 82 | char buf[20]; |
| 83 | int len; |
| 84 | struct ieee80211_key *key = file->private_data; |
| 85 | |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 86 | switch (key->conf.cipher) { |
| 87 | case WLAN_CIPHER_SUITE_WEP40: |
| 88 | case WLAN_CIPHER_SUITE_WEP104: |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 89 | len = scnprintf(buf, sizeof(buf), "\n"); |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 90 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 91 | case WLAN_CIPHER_SUITE_TKIP: |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 92 | len = scnprintf(buf, sizeof(buf), "%08x %04x\n", |
Harvey Harrison | b0f76b3 | 2008-05-14 16:26:19 -0700 | [diff] [blame] | 93 | key->u.tkip.tx.iv32, |
| 94 | key->u.tkip.tx.iv16); |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 95 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 96 | case WLAN_CIPHER_SUITE_CCMP: |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 97 | pn = atomic64_read(&key->u.ccmp.tx_pn); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 98 | len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n", |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 99 | (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24), |
| 100 | (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn); |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 101 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 102 | case WLAN_CIPHER_SUITE_AES_CMAC: |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 103 | pn = atomic64_read(&key->u.aes_cmac.tx_pn); |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 104 | len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n", |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 105 | (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24), |
| 106 | (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn); |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 107 | break; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 108 | default: |
| 109 | return 0; |
| 110 | } |
| 111 | return simple_read_from_buffer(userbuf, count, ppos, buf, len); |
| 112 | } |
| 113 | KEY_OPS(tx_spec); |
| 114 | |
| 115 | static ssize_t key_rx_spec_read(struct file *file, char __user *userbuf, |
| 116 | size_t count, loff_t *ppos) |
| 117 | { |
| 118 | struct ieee80211_key *key = file->private_data; |
| 119 | char buf[14*NUM_RX_DATA_QUEUES+1], *p = buf; |
| 120 | int i, len; |
| 121 | const u8 *rpn; |
| 122 | |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 123 | switch (key->conf.cipher) { |
| 124 | case WLAN_CIPHER_SUITE_WEP40: |
| 125 | case WLAN_CIPHER_SUITE_WEP104: |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 126 | len = scnprintf(buf, sizeof(buf), "\n"); |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 127 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 128 | case WLAN_CIPHER_SUITE_TKIP: |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 129 | for (i = 0; i < NUM_RX_DATA_QUEUES; i++) |
| 130 | p += scnprintf(p, sizeof(buf)+buf-p, |
| 131 | "%08x %04x\n", |
Harvey Harrison | b0f76b3 | 2008-05-14 16:26:19 -0700 | [diff] [blame] | 132 | key->u.tkip.rx[i].iv32, |
| 133 | key->u.tkip.rx[i].iv16); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 134 | len = p - buf; |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 135 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 136 | case WLAN_CIPHER_SUITE_CCMP: |
Jouni Malinen | 9190252 | 2010-06-11 10:27:33 -0700 | [diff] [blame] | 137 | for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++) { |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 138 | rpn = key->u.ccmp.rx_pn[i]; |
| 139 | p += scnprintf(p, sizeof(buf)+buf-p, |
| 140 | "%02x%02x%02x%02x%02x%02x\n", |
| 141 | rpn[0], rpn[1], rpn[2], |
| 142 | rpn[3], rpn[4], rpn[5]); |
| 143 | } |
| 144 | len = p - buf; |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 145 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 146 | case WLAN_CIPHER_SUITE_AES_CMAC: |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 147 | rpn = key->u.aes_cmac.rx_pn; |
| 148 | p += scnprintf(p, sizeof(buf)+buf-p, |
| 149 | "%02x%02x%02x%02x%02x%02x\n", |
| 150 | rpn[0], rpn[1], rpn[2], |
| 151 | rpn[3], rpn[4], rpn[5]); |
| 152 | len = p - buf; |
| 153 | break; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 154 | default: |
| 155 | return 0; |
| 156 | } |
| 157 | return simple_read_from_buffer(userbuf, count, ppos, buf, len); |
| 158 | } |
| 159 | KEY_OPS(rx_spec); |
| 160 | |
| 161 | static ssize_t key_replays_read(struct file *file, char __user *userbuf, |
| 162 | size_t count, loff_t *ppos) |
| 163 | { |
| 164 | struct ieee80211_key *key = file->private_data; |
| 165 | char buf[20]; |
| 166 | int len; |
| 167 | |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 168 | switch (key->conf.cipher) { |
| 169 | case WLAN_CIPHER_SUITE_CCMP: |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 170 | len = scnprintf(buf, sizeof(buf), "%u\n", key->u.ccmp.replays); |
| 171 | break; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 172 | case WLAN_CIPHER_SUITE_AES_CMAC: |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 173 | len = scnprintf(buf, sizeof(buf), "%u\n", |
| 174 | key->u.aes_cmac.replays); |
| 175 | break; |
| 176 | default: |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 177 | return 0; |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 178 | } |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 179 | return simple_read_from_buffer(userbuf, count, ppos, buf, len); |
| 180 | } |
| 181 | KEY_OPS(replays); |
| 182 | |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 183 | static ssize_t key_icverrors_read(struct file *file, char __user *userbuf, |
| 184 | size_t count, loff_t *ppos) |
| 185 | { |
| 186 | struct ieee80211_key *key = file->private_data; |
| 187 | char buf[20]; |
| 188 | int len; |
| 189 | |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 190 | switch (key->conf.cipher) { |
| 191 | case WLAN_CIPHER_SUITE_AES_CMAC: |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 192 | len = scnprintf(buf, sizeof(buf), "%u\n", |
| 193 | key->u.aes_cmac.icverrors); |
| 194 | break; |
| 195 | default: |
| 196 | return 0; |
| 197 | } |
| 198 | return simple_read_from_buffer(userbuf, count, ppos, buf, len); |
| 199 | } |
| 200 | KEY_OPS(icverrors); |
| 201 | |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 202 | static ssize_t key_key_read(struct file *file, char __user *userbuf, |
| 203 | size_t count, loff_t *ppos) |
| 204 | { |
| 205 | struct ieee80211_key *key = file->private_data; |
Jesper Juhl | 520efd1 | 2010-10-29 16:10:26 +0200 | [diff] [blame] | 206 | int i, bufsize = 2 * key->conf.keylen + 2; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 207 | char *buf = kmalloc(bufsize, GFP_KERNEL); |
| 208 | char *p = buf; |
Jesper Juhl | 520efd1 | 2010-10-29 16:10:26 +0200 | [diff] [blame] | 209 | ssize_t res; |
| 210 | |
| 211 | if (!buf) |
| 212 | return -ENOMEM; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 213 | |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 214 | for (i = 0; i < key->conf.keylen; i++) |
| 215 | p += scnprintf(p, bufsize + buf - p, "%02x", key->conf.key[i]); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 216 | p += scnprintf(p, bufsize+buf-p, "\n"); |
| 217 | res = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf); |
| 218 | kfree(buf); |
| 219 | return res; |
| 220 | } |
| 221 | KEY_OPS(key); |
| 222 | |
| 223 | #define DEBUGFS_ADD(name) \ |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 224 | debugfs_create_file(#name, 0400, key->debugfs.dir, \ |
| 225 | key, &key_##name##_ops); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 226 | |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 227 | void ieee80211_debugfs_key_add(struct ieee80211_key *key) |
| 228 | { |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 229 | static int keycount; |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 230 | char buf[50]; |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 231 | struct sta_info *sta; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 232 | |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 233 | if (!key->local->debugfs.keys) |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 234 | return; |
| 235 | |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 236 | sprintf(buf, "%d", keycount); |
Johannes Berg | d9c58f3 | 2008-04-08 16:46:36 -0400 | [diff] [blame] | 237 | key->debugfs.cnt = keycount; |
Johannes Berg | 50339a6 | 2007-08-28 17:01:52 -0400 | [diff] [blame] | 238 | keycount++; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 239 | key->debugfs.dir = debugfs_create_dir(buf, |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 240 | key->local->debugfs.keys); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 241 | |
| 242 | if (!key->debugfs.dir) |
| 243 | return; |
| 244 | |
Johannes Berg | 40b275b | 2011-05-13 14:15:49 +0200 | [diff] [blame] | 245 | sta = key->sta; |
| 246 | if (sta) { |
Johannes Berg | 0c68ae26 | 2008-10-27 15:56:10 -0700 | [diff] [blame] | 247 | sprintf(buf, "../../stations/%pM", sta->sta.addr); |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 248 | key->debugfs.stalink = |
| 249 | debugfs_create_symlink("station", key->debugfs.dir, buf); |
Johannes Berg | 40b275b | 2011-05-13 14:15:49 +0200 | [diff] [blame] | 250 | } |
Johannes Berg | 3b96766 | 2008-04-08 17:56:52 +0200 | [diff] [blame] | 251 | |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 252 | DEBUGFS_ADD(keylen); |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 253 | DEBUGFS_ADD(flags); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 254 | DEBUGFS_ADD(keyidx); |
| 255 | DEBUGFS_ADD(hw_key_idx); |
| 256 | DEBUGFS_ADD(tx_rx_count); |
| 257 | DEBUGFS_ADD(algorithm); |
| 258 | DEBUGFS_ADD(tx_spec); |
| 259 | DEBUGFS_ADD(rx_spec); |
| 260 | DEBUGFS_ADD(replays); |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 261 | DEBUGFS_ADD(icverrors); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 262 | DEBUGFS_ADD(key); |
Johannes Berg | e7a64f1 | 2007-08-28 17:01:55 -0400 | [diff] [blame] | 263 | DEBUGFS_ADD(ifindex); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 264 | }; |
| 265 | |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 266 | void ieee80211_debugfs_key_remove(struct ieee80211_key *key) |
| 267 | { |
| 268 | if (!key) |
| 269 | return; |
| 270 | |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 271 | debugfs_remove_recursive(key->debugfs.dir); |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 272 | key->debugfs.dir = NULL; |
| 273 | } |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 274 | |
| 275 | void ieee80211_debugfs_key_update_default(struct ieee80211_sub_if_data *sdata) |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 276 | { |
| 277 | char buf[50]; |
Johannes Berg | 78520ca | 2008-05-03 01:04:47 +0200 | [diff] [blame] | 278 | struct ieee80211_key *key; |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 279 | |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 280 | if (!sdata->debugfs.dir) |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 281 | return; |
| 282 | |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 283 | lockdep_assert_held(&sdata->local->key_mtx); |
Johannes Berg | 78520ca | 2008-05-03 01:04:47 +0200 | [diff] [blame] | 284 | |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 285 | if (sdata->default_unicast_key) { |
Johannes Berg | 40b275b | 2011-05-13 14:15:49 +0200 | [diff] [blame] | 286 | key = key_mtx_dereference(sdata->local, |
| 287 | sdata->default_unicast_key); |
Johannes Berg | 78520ca | 2008-05-03 01:04:47 +0200 | [diff] [blame] | 288 | sprintf(buf, "../keys/%d", key->debugfs.cnt); |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 289 | sdata->debugfs.default_unicast_key = |
| 290 | debugfs_create_symlink("default_unicast_key", |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 291 | sdata->debugfs.dir, buf); |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 292 | } else { |
| 293 | debugfs_remove(sdata->debugfs.default_unicast_key); |
| 294 | sdata->debugfs.default_unicast_key = NULL; |
| 295 | } |
Johannes Berg | 78520ca | 2008-05-03 01:04:47 +0200 | [diff] [blame] | 296 | |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 297 | if (sdata->default_multicast_key) { |
Johannes Berg | 40b275b | 2011-05-13 14:15:49 +0200 | [diff] [blame] | 298 | key = key_mtx_dereference(sdata->local, |
| 299 | sdata->default_multicast_key); |
Johannes Berg | f7e0104 | 2010-12-09 19:49:02 +0100 | [diff] [blame] | 300 | sprintf(buf, "../keys/%d", key->debugfs.cnt); |
| 301 | sdata->debugfs.default_multicast_key = |
| 302 | debugfs_create_symlink("default_multicast_key", |
| 303 | sdata->debugfs.dir, buf); |
| 304 | } else { |
| 305 | debugfs_remove(sdata->debugfs.default_multicast_key); |
| 306 | sdata->debugfs.default_multicast_key = NULL; |
| 307 | } |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 308 | } |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 309 | |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 310 | void ieee80211_debugfs_key_add_mgmt_default(struct ieee80211_sub_if_data *sdata) |
| 311 | { |
| 312 | char buf[50]; |
| 313 | struct ieee80211_key *key; |
| 314 | |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 315 | if (!sdata->debugfs.dir) |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 316 | return; |
| 317 | |
Johannes Berg | 40b275b | 2011-05-13 14:15:49 +0200 | [diff] [blame] | 318 | key = key_mtx_dereference(sdata->local, |
| 319 | sdata->default_mgmt_key); |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 320 | if (key) { |
| 321 | sprintf(buf, "../keys/%d", key->debugfs.cnt); |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 322 | sdata->debugfs.default_mgmt_key = |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 323 | debugfs_create_symlink("default_mgmt_key", |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 324 | sdata->debugfs.dir, buf); |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 325 | } else |
| 326 | ieee80211_debugfs_key_remove_mgmt_default(sdata); |
| 327 | } |
| 328 | |
| 329 | void ieee80211_debugfs_key_remove_mgmt_default(struct ieee80211_sub_if_data *sdata) |
| 330 | { |
| 331 | if (!sdata) |
| 332 | return; |
| 333 | |
Johannes Berg | 7bcfaf2 | 2009-10-27 12:59:03 +0100 | [diff] [blame] | 334 | debugfs_remove(sdata->debugfs.default_mgmt_key); |
| 335 | sdata->debugfs.default_mgmt_key = NULL; |
Jouni Malinen | 3cfcf6a | 2009-01-08 13:32:02 +0200 | [diff] [blame] | 336 | } |
| 337 | |
Jiri Benc | e9f207f | 2007-05-05 11:46:38 -0700 | [diff] [blame] | 338 | void ieee80211_debugfs_key_sta_del(struct ieee80211_key *key, |
| 339 | struct sta_info *sta) |
| 340 | { |
| 341 | debugfs_remove(key->debugfs.stalink); |
| 342 | key->debugfs.stalink = NULL; |
| 343 | } |