linux/kernel/rcupreempt_trace.c
<<
>>
Prefs
   1/*
   2 * Read-Copy Update tracing for realtime implementation
   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 as published by
   6 * the Free Software Foundation; either version 2 of the License, or
   7 * (at your option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write to the Free Software
  16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 *
  18 * Copyright IBM Corporation, 2006
  19 *
  20 * Papers:  http://www.rdrop.com/users/paulmck/RCU
  21 *
  22 * For detailed explanation of Read-Copy Update mechanism see -
  23 *              Documentation/RCU/ *.txt
  24 *
  25 */
  26#include <linux/types.h>
  27#include <linux/kernel.h>
  28#include <linux/init.h>
  29#include <linux/spinlock.h>
  30#include <linux/smp.h>
  31#include <linux/rcupdate.h>
  32#include <linux/interrupt.h>
  33#include <linux/sched.h>
  34#include <asm/atomic.h>
  35#include <linux/bitops.h>
  36#include <linux/module.h>
  37#include <linux/completion.h>
  38#include <linux/moduleparam.h>
  39#include <linux/percpu.h>
  40#include <linux/notifier.h>
  41#include <linux/rcupdate.h>
  42#include <linux/cpu.h>
  43#include <linux/mutex.h>
  44#include <linux/rcupreempt_trace.h>
  45#include <linux/debugfs.h>
  46
  47static struct mutex rcupreempt_trace_mutex;
  48static char *rcupreempt_trace_buf;
  49#define RCUPREEMPT_TRACE_BUF_SIZE 4096
  50
  51void rcupreempt_trace_move2done(struct rcupreempt_trace *trace)
  52{
  53        trace->done_length += trace->wait_length;
  54        trace->done_add += trace->wait_length;
  55        trace->wait_length = 0;
  56}
  57void rcupreempt_trace_move2wait(struct rcupreempt_trace *trace)
  58{
  59        trace->wait_length += trace->next_length;
  60        trace->wait_add += trace->next_length;
  61        trace->next_length = 0;
  62}
  63void rcupreempt_trace_try_flip_1(struct rcupreempt_trace *trace)
  64{
  65        atomic_inc(&trace->rcu_try_flip_1);
  66}
  67void rcupreempt_trace_try_flip_e1(struct rcupreempt_trace *trace)
  68{
  69        atomic_inc(&trace->rcu_try_flip_e1);
  70}
  71void rcupreempt_trace_try_flip_i1(struct rcupreempt_trace *trace)
  72{
  73        trace->rcu_try_flip_i1++;
  74}
  75void rcupreempt_trace_try_flip_ie1(struct rcupreempt_trace *trace)
  76{
  77        trace->rcu_try_flip_ie1++;
  78}
  79void rcupreempt_trace_try_flip_g1(struct rcupreempt_trace *trace)
  80{
  81        trace->rcu_try_flip_g1++;
  82}
  83void rcupreempt_trace_try_flip_a1(struct rcupreempt_trace *trace)
  84{
  85        trace->rcu_try_flip_a1++;
  86}
  87void rcupreempt_trace_try_flip_ae1(struct rcupreempt_trace *trace)
  88{
  89        trace->rcu_try_flip_ae1++;
  90}
  91void rcupreempt_trace_try_flip_a2(struct rcupreempt_trace *trace)
  92{
  93        trace->rcu_try_flip_a2++;
  94}
  95void rcupreempt_trace_try_flip_z1(struct rcupreempt_trace *trace)
  96{
  97        trace->rcu_try_flip_z1++;
  98}
  99void rcupreempt_trace_try_flip_ze1(struct rcupreempt_trace *trace)
 100{
 101        trace->rcu_try_flip_ze1++;
 102}
 103void rcupreempt_trace_try_flip_z2(struct rcupreempt_trace *trace)
 104{
 105        trace->rcu_try_flip_z2++;
 106}
 107void rcupreempt_trace_try_flip_m1(struct rcupreempt_trace *trace)
 108{
 109        trace->rcu_try_flip_m1++;
 110}
 111void rcupreempt_trace_try_flip_me1(struct rcupreempt_trace *trace)
 112{
 113        trace->rcu_try_flip_me1++;
 114}
 115void rcupreempt_trace_try_flip_m2(struct rcupreempt_trace *trace)
 116{
 117        trace->rcu_try_flip_m2++;
 118}
 119void rcupreempt_trace_check_callbacks(struct rcupreempt_trace *trace)
 120{
 121        trace->rcu_check_callbacks++;
 122}
 123void rcupreempt_trace_done_remove(struct rcupreempt_trace *trace)
 124{
 125        trace->done_remove += trace->done_length;
 126        trace->done_length = 0;
 127}
 128void rcupreempt_trace_invoke(struct rcupreempt_trace *trace)
 129{
 130        atomic_inc(&trace->done_invoked);
 131}
 132void rcupreempt_trace_next_add(struct rcupreempt_trace *trace)
 133{
 134        trace->next_add++;
 135        trace->next_length++;
 136}
 137
 138static void rcupreempt_trace_sum(struct rcupreempt_trace *sp)
 139{
 140        struct rcupreempt_trace *cp;
 141        int cpu;
 142
 143        memset(sp, 0, sizeof(*sp));
 144        for_each_possible_cpu(cpu) {
 145                cp = rcupreempt_trace_cpu(cpu);
 146                sp->next_length += cp->next_length;
 147                sp->next_add += cp->next_add;
 148                sp->wait_length += cp->wait_length;
 149                sp->wait_add += cp->wait_add;
 150                sp->done_length += cp->done_length;
 151                sp->done_add += cp->done_add;
 152                sp->done_remove += cp->done_remove;
 153                atomic_set(&sp->done_invoked, atomic_read(&cp->done_invoked));
 154                sp->rcu_check_callbacks += cp->rcu_check_callbacks;
 155                atomic_set(&sp->rcu_try_flip_1,
 156                           atomic_read(&cp->rcu_try_flip_1));
 157                atomic_set(&sp->rcu_try_flip_e1,
 158                           atomic_read(&cp->rcu_try_flip_e1));
 159                sp->rcu_try_flip_i1 += cp->rcu_try_flip_i1;
 160                sp->rcu_try_flip_ie1 += cp->rcu_try_flip_ie1;
 161                sp->rcu_try_flip_g1 += cp->rcu_try_flip_g1;
 162                sp->rcu_try_flip_a1 += cp->rcu_try_flip_a1;
 163                sp->rcu_try_flip_ae1 += cp->rcu_try_flip_ae1;
 164                sp->rcu_try_flip_a2 += cp->rcu_try_flip_a2;
 165                sp->rcu_try_flip_z1 += cp->rcu_try_flip_z1;
 166                sp->rcu_try_flip_ze1 += cp->rcu_try_flip_ze1;
 167                sp->rcu_try_flip_z2 += cp->rcu_try_flip_z2;
 168                sp->rcu_try_flip_m1 += cp->rcu_try_flip_m1;
 169                sp->rcu_try_flip_me1 += cp->rcu_try_flip_me1;
 170                sp->rcu_try_flip_m2 += cp->rcu_try_flip_m2;
 171        }
 172}
 173
 174static ssize_t rcustats_read(struct file *filp, char __user *buffer,
 175                                size_t count, loff_t *ppos)
 176{
 177        struct rcupreempt_trace trace;
 178        ssize_t bcount;
 179        int cnt = 0;
 180
 181        rcupreempt_trace_sum(&trace);
 182        mutex_lock(&rcupreempt_trace_mutex);
 183        snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE - cnt,
 184                 "ggp=%ld rcc=%ld\n",
 185                 rcu_batches_completed(),
 186                 trace.rcu_check_callbacks);
 187        snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE - cnt,
 188                 "na=%ld nl=%ld wa=%ld wl=%ld da=%ld dl=%ld dr=%ld di=%d\n"
 189                 "1=%d e1=%d i1=%ld ie1=%ld g1=%ld a1=%ld ae1=%ld a2=%ld\n"
 190                 "z1=%ld ze1=%ld z2=%ld m1=%ld me1=%ld m2=%ld\n",
 191
 192                 trace.next_add, trace.next_length,
 193                 trace.wait_add, trace.wait_length,
 194                 trace.done_add, trace.done_length,
 195                 trace.done_remove, atomic_read(&trace.done_invoked),
 196                 atomic_read(&trace.rcu_try_flip_1),
 197                 atomic_read(&trace.rcu_try_flip_e1),
 198                 trace.rcu_try_flip_i1, trace.rcu_try_flip_ie1,
 199                 trace.rcu_try_flip_g1,
 200                 trace.rcu_try_flip_a1, trace.rcu_try_flip_ae1,
 201                         trace.rcu_try_flip_a2,
 202                 trace.rcu_try_flip_z1, trace.rcu_try_flip_ze1,
 203                         trace.rcu_try_flip_z2,
 204                 trace.rcu_try_flip_m1, trace.rcu_try_flip_me1,
 205                        trace.rcu_try_flip_m2);
 206        bcount = simple_read_from_buffer(buffer, count, ppos,
 207                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
 208        mutex_unlock(&rcupreempt_trace_mutex);
 209        return bcount;
 210}
 211
 212static ssize_t rcugp_read(struct file *filp, char __user *buffer,
 213                                size_t count, loff_t *ppos)
 214{
 215        long oldgp = rcu_batches_completed();
 216        ssize_t bcount;
 217
 218        mutex_lock(&rcupreempt_trace_mutex);
 219        synchronize_rcu();
 220        snprintf(rcupreempt_trace_buf, RCUPREEMPT_TRACE_BUF_SIZE,
 221                "oldggp=%ld  newggp=%ld\n", oldgp, rcu_batches_completed());
 222        bcount = simple_read_from_buffer(buffer, count, ppos,
 223                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
 224        mutex_unlock(&rcupreempt_trace_mutex);
 225        return bcount;
 226}
 227
 228static ssize_t rcuctrs_read(struct file *filp, char __user *buffer,
 229                                size_t count, loff_t *ppos)
 230{
 231        int cnt = 0;
 232        int cpu;
 233        int f = rcu_batches_completed() & 0x1;
 234        ssize_t bcount;
 235
 236        mutex_lock(&rcupreempt_trace_mutex);
 237
 238        cnt += snprintf(&rcupreempt_trace_buf[cnt], RCUPREEMPT_TRACE_BUF_SIZE,
 239                                "CPU last cur F M\n");
 240        for_each_online_cpu(cpu) {
 241                long *flipctr = rcupreempt_flipctr(cpu);
 242                cnt += snprintf(&rcupreempt_trace_buf[cnt],
 243                                RCUPREEMPT_TRACE_BUF_SIZE - cnt,
 244                                        "%3d %4ld %3ld %d %d\n",
 245                               cpu,
 246                               flipctr[!f],
 247                               flipctr[f],
 248                               rcupreempt_flip_flag(cpu),
 249                               rcupreempt_mb_flag(cpu));
 250        }
 251        cnt += snprintf(&rcupreempt_trace_buf[cnt],
 252                        RCUPREEMPT_TRACE_BUF_SIZE - cnt,
 253                        "ggp = %ld, state = %s\n",
 254                        rcu_batches_completed(),
 255                        rcupreempt_try_flip_state_name());
 256        cnt += snprintf(&rcupreempt_trace_buf[cnt],
 257                        RCUPREEMPT_TRACE_BUF_SIZE - cnt,
 258                        "\n");
 259        bcount = simple_read_from_buffer(buffer, count, ppos,
 260                        rcupreempt_trace_buf, strlen(rcupreempt_trace_buf));
 261        mutex_unlock(&rcupreempt_trace_mutex);
 262        return bcount;
 263}
 264
 265static struct file_operations rcustats_fops = {
 266        .owner = THIS_MODULE,
 267        .read = rcustats_read,
 268};
 269
 270static struct file_operations rcugp_fops = {
 271        .owner = THIS_MODULE,
 272        .read = rcugp_read,
 273};
 274
 275static struct file_operations rcuctrs_fops = {
 276        .owner = THIS_MODULE,
 277        .read = rcuctrs_read,
 278};
 279
 280static struct dentry *rcudir, *statdir, *ctrsdir, *gpdir;
 281static int rcupreempt_debugfs_init(void)
 282{
 283        rcudir = debugfs_create_dir("rcu", NULL);
 284        if (!rcudir)
 285                goto out;
 286        statdir = debugfs_create_file("rcustats", 0444, rcudir,
 287                                                NULL, &rcustats_fops);
 288        if (!statdir)
 289                goto free_out;
 290
 291        gpdir = debugfs_create_file("rcugp", 0444, rcudir, NULL, &rcugp_fops);
 292        if (!gpdir)
 293                goto free_out;
 294
 295        ctrsdir = debugfs_create_file("rcuctrs", 0444, rcudir,
 296                                                NULL, &rcuctrs_fops);
 297        if (!ctrsdir)
 298                goto free_out;
 299        return 0;
 300free_out:
 301        if (statdir)
 302                debugfs_remove(statdir);
 303        if (gpdir)
 304                debugfs_remove(gpdir);
 305        debugfs_remove(rcudir);
 306out:
 307        return 1;
 308}
 309
 310static int __init rcupreempt_trace_init(void)
 311{
 312        mutex_init(&rcupreempt_trace_mutex);
 313        rcupreempt_trace_buf = kmalloc(RCUPREEMPT_TRACE_BUF_SIZE, GFP_KERNEL);
 314        if (!rcupreempt_trace_buf)
 315                return 1;
 316        return rcupreempt_debugfs_init();
 317}
 318
 319static void __exit rcupreempt_trace_cleanup(void)
 320{
 321        debugfs_remove(statdir);
 322        debugfs_remove(gpdir);
 323        debugfs_remove(ctrsdir);
 324        debugfs_remove(rcudir);
 325        kfree(rcupreempt_trace_buf);
 326}
 327
 328
 329module_init(rcupreempt_trace_init);
 330module_exit(rcupreempt_trace_cleanup);
 331
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.