1 /* 2 * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 */ 8 #include <linux/netdevice.h> 9 #include <linux/types.h> 10 #include <linux/skbuff.h> 11 #include <linux/debugfs.h> 12 #include <linux/ieee80211.h> 13 #include <linux/export.h> 14 #include <net/mac80211.h> 15 #include "rc80211_minstrel.h" 16 #include "rc80211_minstrel_ht.h" 17 18 static ssize_t 19 minstrel_stats_read(struct file *file, char __user *buf, size_t len, loff_t *ppos) 20 { 21 struct minstrel_debugfs_info *ms; 22 23 ms = file->private_data; 24 return simple_read_from_buffer(buf, len, ppos, ms->buf, ms->len); 25 } 26 27 static int 28 minstrel_stats_release(struct inode *inode, struct file *file) 29 { 30 kfree(file->private_data); 31 return 0; 32 } 33 34 static char * 35 minstrel_ht_stats_dump(struct minstrel_ht_sta *mi, int i, char *p) 36 { 37 const struct mcs_group *mg; 38 unsigned int j, tp_max, tp_avg, eprob, tx_time; 39 char htmode = '2'; 40 char gimode = 'L'; 41 u32 gflags; 42 43 if (!mi->supported[i]) 44 return p; 45 46 mg = &minstrel_mcs_groups[i]; 47 gflags = mg->flags; 48 49 if (gflags & IEEE80211_TX_RC_40_MHZ_WIDTH) 50 htmode = '4'; 51 else if (gflags & IEEE80211_TX_RC_80_MHZ_WIDTH) 52 htmode = '8'; 53 if (gflags & IEEE80211_TX_RC_SHORT_GI) 54 gimode = 'S'; 55 56 for (j = 0; j < MCS_GROUP_RATES; j++) { 57 struct minstrel_rate_stats *mrs = &mi->groups[i].rates[j]; 58 static const int bitrates[4] = { 10, 20, 55, 110 }; 59 int idx = i * MCS_GROUP_RATES + j; 60 unsigned int duration; 61 62 if (!(mi->supported[i] & BIT(j))) 63 continue; 64 65 if (gflags & IEEE80211_TX_RC_MCS) { 66 p += sprintf(p, "HT%c0 ", htmode); 67 p += sprintf(p, "%cGI ", gimode); 68 p += sprintf(p, "%d ", mg->streams); 69 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 70 p += sprintf(p, "VHT%c0 ", htmode); 71 p += sprintf(p, "%cGI ", gimode); 72 p += sprintf(p, "%d ", mg->streams); 73 } else { 74 p += sprintf(p, "CCK "); 75 p += sprintf(p, "%cP ", j < 4 ? 'L' : 'S'); 76 p += sprintf(p, "1 "); 77 } 78 79 *(p++) = (idx == mi->max_tp_rate[0]) ? 'A' : ' '; 80 *(p++) = (idx == mi->max_tp_rate[1]) ? 'B' : ' '; 81 *(p++) = (idx == mi->max_tp_rate[2]) ? 'C' : ' '; 82 *(p++) = (idx == mi->max_tp_rate[3]) ? 'D' : ' '; 83 *(p++) = (idx == mi->max_prob_rate) ? 'P' : ' '; 84 85 if (gflags & IEEE80211_TX_RC_MCS) { 86 p += sprintf(p, " MCS%-2u", (mg->streams - 1) * 8 + j); 87 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 88 p += sprintf(p, " MCS%-1u/%1u", j, mg->streams); 89 } else { 90 int r = bitrates[j % 4]; 91 92 p += sprintf(p, " %2u.%1uM", r / 10, r % 10); 93 } 94 95 p += sprintf(p, " %3u ", idx); 96 97 /* tx_time[rate(i)] in usec */ 98 duration = mg->duration[j]; 99 duration <<= mg->shift; 100 tx_time = DIV_ROUND_CLOSEST(duration, 1000); 101 p += sprintf(p, "%6u ", tx_time); 102 103 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100)); 104 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_ewma); 105 eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000); 106 107 p += sprintf(p, "%4u.%1u %4u.%1u %3u.%1u" 108 " %3u %3u %-3u " 109 "%9llu %-9llu\n", 110 tp_max / 10, tp_max % 10, 111 tp_avg / 10, tp_avg % 10, 112 eprob / 10, eprob % 10, 113 mrs->retry_count, 114 mrs->last_success, 115 mrs->last_attempts, 116 (unsigned long long)mrs->succ_hist, 117 (unsigned long long)mrs->att_hist); 118 } 119 120 return p; 121 } 122 123 static int 124 minstrel_ht_stats_open(struct inode *inode, struct file *file) 125 { 126 struct minstrel_ht_sta_priv *msp = inode->i_private; 127 struct minstrel_ht_sta *mi = &msp->ht; 128 struct minstrel_debugfs_info *ms; 129 unsigned int i; 130 int ret; 131 char *p; 132 133 if (!msp->is_ht) { 134 inode->i_private = &msp->legacy; 135 ret = minstrel_stats_open(inode, file); 136 inode->i_private = msp; 137 return ret; 138 } 139 140 ms = kmalloc(32768, GFP_KERNEL); 141 if (!ms) 142 return -ENOMEM; 143 144 file->private_data = ms; 145 p = ms->buf; 146 147 p += sprintf(p, "\n"); 148 p += sprintf(p, 149 " best ____________rate__________ ____statistics___ _____last____ ______sum-of________\n"); 150 p += sprintf(p, 151 "mode guard # rate [name idx airtime max_tp] [avg(tp) avg(prob)] [retry|suc|att] [#success | #attempts]\n"); 152 153 p = minstrel_ht_stats_dump(mi, MINSTREL_CCK_GROUP, p); 154 for (i = 0; i < MINSTREL_CCK_GROUP; i++) 155 p = minstrel_ht_stats_dump(mi, i, p); 156 for (i++; i < ARRAY_SIZE(mi->groups); i++) 157 p = minstrel_ht_stats_dump(mi, i, p); 158 159 p += sprintf(p, "\nTotal packet count:: ideal %d " 160 "lookaround %d\n", 161 max(0, (int) mi->total_packets - (int) mi->sample_packets), 162 mi->sample_packets); 163 if (mi->avg_ampdu_len) 164 p += sprintf(p, "Average # of aggregated frames per A-MPDU: %d.%d\n", 165 MINSTREL_TRUNC(mi->avg_ampdu_len), 166 MINSTREL_TRUNC(mi->avg_ampdu_len * 10) % 10); 167 ms->len = p - ms->buf; 168 WARN_ON(ms->len + sizeof(*ms) > 32768); 169 170 return nonseekable_open(inode, file); 171 } 172 173 static const struct file_operations minstrel_ht_stat_fops = { 174 .owner = THIS_MODULE, 175 .open = minstrel_ht_stats_open, 176 .read = minstrel_stats_read, 177 .release = minstrel_stats_release, 178 .llseek = no_llseek, 179 }; 180 181 static char * 182 minstrel_ht_stats_csv_dump(struct minstrel_ht_sta *mi, int i, char *p) 183 { 184 const struct mcs_group *mg; 185 unsigned int j, tp_max, tp_avg, eprob, tx_time; 186 char htmode = '2'; 187 char gimode = 'L'; 188 u32 gflags; 189 190 if (!mi->supported[i]) 191 return p; 192 193 mg = &minstrel_mcs_groups[i]; 194 gflags = mg->flags; 195 196 if (gflags & IEEE80211_TX_RC_40_MHZ_WIDTH) 197 htmode = '4'; 198 else if (gflags & IEEE80211_TX_RC_80_MHZ_WIDTH) 199 htmode = '8'; 200 if (gflags & IEEE80211_TX_RC_SHORT_GI) 201 gimode = 'S'; 202 203 for (j = 0; j < MCS_GROUP_RATES; j++) { 204 struct minstrel_rate_stats *mrs = &mi->groups[i].rates[j]; 205 static const int bitrates[4] = { 10, 20, 55, 110 }; 206 int idx = i * MCS_GROUP_RATES + j; 207 unsigned int duration; 208 209 if (!(mi->supported[i] & BIT(j))) 210 continue; 211 212 if (gflags & IEEE80211_TX_RC_MCS) { 213 p += sprintf(p, "HT%c0,", htmode); 214 p += sprintf(p, "%cGI,", gimode); 215 p += sprintf(p, "%d,", mg->streams); 216 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 217 p += sprintf(p, "VHT%c0,", htmode); 218 p += sprintf(p, "%cGI,", gimode); 219 p += sprintf(p, "%d,", mg->streams); 220 } else { 221 p += sprintf(p, "CCK,"); 222 p += sprintf(p, "%cP,", j < 4 ? 'L' : 'S'); 223 p += sprintf(p, "1,"); 224 } 225 226 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[0]) ? "A" : "")); 227 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[1]) ? "B" : "")); 228 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[2]) ? "C" : "")); 229 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[3]) ? "D" : "")); 230 p += sprintf(p, "%s" ,((idx == mi->max_prob_rate) ? "P" : "")); 231 232 if (gflags & IEEE80211_TX_RC_MCS) { 233 p += sprintf(p, ",MCS%-2u,", (mg->streams - 1) * 8 + j); 234 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 235 p += sprintf(p, ",MCS%-1u/%1u,", j, mg->streams); 236 } else { 237 int r = bitrates[j % 4]; 238 p += sprintf(p, ",%2u.%1uM,", r / 10, r % 10); 239 } 240 241 p += sprintf(p, "%u,", idx); 242 243 duration = mg->duration[j]; 244 duration <<= mg->shift; 245 tx_time = DIV_ROUND_CLOSEST(duration, 1000); 246 p += sprintf(p, "%u,", tx_time); 247 248 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100)); 249 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_ewma); 250 eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000); 251 252 p += sprintf(p, "%u.%u,%u.%u,%u.%u,%u,%u," 253 "%u,%llu,%llu,", 254 tp_max / 10, tp_max % 10, 255 tp_avg / 10, tp_avg % 10, 256 eprob / 10, eprob % 10, 257 mrs->retry_count, 258 mrs->last_success, 259 mrs->last_attempts, 260 (unsigned long long)mrs->succ_hist, 261 (unsigned long long)mrs->att_hist); 262 p += sprintf(p, "%d,%d,%d.%d\n", 263 max(0, (int) mi->total_packets - 264 (int) mi->sample_packets), 265 mi->sample_packets, 266 MINSTREL_TRUNC(mi->avg_ampdu_len), 267 MINSTREL_TRUNC(mi->avg_ampdu_len * 10) % 10); 268 } 269 270 return p; 271 } 272 273 static int 274 minstrel_ht_stats_csv_open(struct inode *inode, struct file *file) 275 { 276 struct minstrel_ht_sta_priv *msp = inode->i_private; 277 struct minstrel_ht_sta *mi = &msp->ht; 278 struct minstrel_debugfs_info *ms; 279 unsigned int i; 280 int ret; 281 char *p; 282 283 if (!msp->is_ht) { 284 inode->i_private = &msp->legacy; 285 ret = minstrel_stats_csv_open(inode, file); 286 inode->i_private = msp; 287 return ret; 288 } 289 290 ms = kmalloc(32768, GFP_KERNEL); 291 292 if (!ms) 293 return -ENOMEM; 294 295 file->private_data = ms; 296 297 p = ms->buf; 298 299 p = minstrel_ht_stats_csv_dump(mi, MINSTREL_CCK_GROUP, p); 300 for (i = 0; i < MINSTREL_CCK_GROUP; i++) 301 p = minstrel_ht_stats_csv_dump(mi, i, p); 302 for (i++; i < ARRAY_SIZE(mi->groups); i++) 303 p = minstrel_ht_stats_csv_dump(mi, i, p); 304 305 ms->len = p - ms->buf; 306 WARN_ON(ms->len + sizeof(*ms) > 32768); 307 308 return nonseekable_open(inode, file); 309 } 310 311 static const struct file_operations minstrel_ht_stat_csv_fops = { 312 .owner = THIS_MODULE, 313 .open = minstrel_ht_stats_csv_open, 314 .read = minstrel_stats_read, 315 .release = minstrel_stats_release, 316 .llseek = no_llseek, 317 }; 318 319 void 320 minstrel_ht_add_sta_debugfs(void *priv, void *priv_sta, struct dentry *dir) 321 { 322 struct minstrel_ht_sta_priv *msp = priv_sta; 323 324 debugfs_create_file("rc_stats", 0444, dir, msp, 325 &minstrel_ht_stat_fops); 326 debugfs_create_file("rc_stats_csv", 0444, dir, msp, 327 &minstrel_ht_stat_csv_fops); 328 } 329