Merge commit 'v2.6.31-rc8' into core/locking
Ingo Molnar [Mon, 31 Aug 2009 15:54:18 +0000 (17:54 +0200)]
Merge reason: we were on -rc4, move to -rc8 before applying
              a new batch of locking infrastructure changes.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

1  2 
kernel/lockdep_proc.c

diff --combined kernel/lockdep_proc.c
  
  static void *l_next(struct seq_file *m, void *v, loff_t *pos)
  {
 -      struct lock_class *class;
 -
 -      (*pos)++;
 -
 -      if (v == SEQ_START_TOKEN)
 -              class = m->private;
 -      else {
 -              class = v;
 -
 -              if (class->lock_entry.next != &all_lock_classes)
 -                      class = list_entry(class->lock_entry.next,
 -                                         struct lock_class, lock_entry);
 -              else
 -                      class = NULL;
 -      }
 -
 -      return class;
 +      return seq_list_next(v, &all_lock_classes, pos);
  }
  
  static void *l_start(struct seq_file *m, loff_t *pos)
  {
 -      struct lock_class *class;
 -      loff_t i = 0;
 -
 -      if (*pos == 0)
 -              return SEQ_START_TOKEN;
 -
 -      list_for_each_entry(class, &all_lock_classes, lock_entry) {
 -              if (++i == *pos)
 -              return class;
 -      }
 -      return NULL;
 +      return seq_list_start_head(&all_lock_classes, *pos);
  }
  
  static void l_stop(struct seq_file *m, void *v)
@@@ -56,11 -82,11 +56,11 @@@ static void print_name(struct seq_file 
  
  static int l_show(struct seq_file *m, void *v)
  {
 -      struct lock_class *class = v;
 +      struct lock_class *class = list_entry(v, struct lock_class, lock_entry);
        struct lock_list *entry;
        char usage[LOCK_USAGE_CHARS];
  
 -      if (v == SEQ_START_TOKEN) {
 +      if (v == &all_lock_classes) {
                seq_printf(m, "all lock classes:\n");
                return 0;
        }
@@@ -102,7 -128,17 +102,7 @@@ static const struct seq_operations lock
  
  static int lockdep_open(struct inode *inode, struct file *file)
  {
 -      int res = seq_open(file, &lockdep_ops);
 -      if (!res) {
 -              struct seq_file *m = file->private_data;
 -
 -              if (!list_empty(&all_lock_classes))
 -                      m->private = list_entry(all_lock_classes.next,
 -                                      struct lock_class, lock_entry);
 -              else
 -                      m->private = NULL;
 -      }
 -      return res;
 +      return seq_open(file, &lockdep_ops);
  }
  
  static const struct file_operations proc_lockdep_operations = {
  };
  
  #ifdef CONFIG_PROVE_LOCKING
 -static void *lc_next(struct seq_file *m, void *v, loff_t *pos)
 -{
 -      struct lock_chain *chain;
 -
 -      (*pos)++;
 -
 -      if (v == SEQ_START_TOKEN)
 -              chain = m->private;
 -      else {
 -              chain = v;
 -
 -              if (*pos < nr_lock_chains)
 -                      chain = lock_chains + *pos;
 -              else
 -                      chain = NULL;
 -      }
 -
 -      return chain;
 -}
 -
  static void *lc_start(struct seq_file *m, loff_t *pos)
  {
        if (*pos == 0)
                return SEQ_START_TOKEN;
  
 -      if (*pos < nr_lock_chains)
 -              return lock_chains + *pos;
 +      if (*pos - 1 < nr_lock_chains)
 +              return lock_chains + (*pos - 1);
  
        return NULL;
  }
  
 +static void *lc_next(struct seq_file *m, void *v, loff_t *pos)
 +{
 +      (*pos)++;
 +      return lc_start(m, pos);
 +}
 +
  static void lc_stop(struct seq_file *m, void *v)
  {
  }
@@@ -170,7 -220,16 +170,7 @@@ static const struct seq_operations lock
  
  static int lockdep_chains_open(struct inode *inode, struct file *file)
  {
 -      int res = seq_open(file, &lockdep_chains_ops);
 -      if (!res) {
 -              struct seq_file *m = file->private_data;
 -
 -              if (nr_lock_chains)
 -                      m->private = lock_chains;
 -              else
 -                      m->private = NULL;
 -      }
 -      return res;
 +      return seq_open(file, &lockdep_chains_ops);
  }
  
  static const struct file_operations proc_lockdep_chains_operations = {
@@@ -199,10 -258,16 +199,10 @@@ static void lockdep_stats_debug_show(st
                debug_atomic_read(&chain_lookup_hits));
        seq_printf(m, " cyclic checks:                 %11u\n",
                debug_atomic_read(&nr_cyclic_checks));
 -      seq_printf(m, " cyclic-check recursions:       %11u\n",
 -              debug_atomic_read(&nr_cyclic_check_recursions));
        seq_printf(m, " find-mask forwards checks:     %11u\n",
                debug_atomic_read(&nr_find_usage_forwards_checks));
 -      seq_printf(m, " find-mask forwards recursions: %11u\n",
 -              debug_atomic_read(&nr_find_usage_forwards_recursions));
        seq_printf(m, " find-mask backwards checks:    %11u\n",
                debug_atomic_read(&nr_find_usage_backwards_checks));
 -      seq_printf(m, " find-mask backwards recursions:%11u\n",
 -              debug_atomic_read(&nr_find_usage_backwards_recursions));
  
        seq_printf(m, " hardirq on events:             %11u\n", hi1);
        seq_printf(m, " hardirq off events:            %11u\n", hi2);
@@@ -344,10 -409,8 +344,10 @@@ static int lockdep_stats_show(struct se
                        nr_unused);
        seq_printf(m, " max locking depth:             %11u\n",
                        max_lockdep_depth);
 -      seq_printf(m, " max recursion depth:           %11u\n",
 -                      max_recursion_depth);
 +#ifdef CONFIG_PROVE_LOCKING
 +      seq_printf(m, " max bfs queue depth:           %11u\n",
 +                      max_bfs_queue_depth);
 +#endif
        lockdep_stats_debug_show(m);
        seq_printf(m, " debug_locks:                   %11u\n",
                        debug_locks);
@@@ -375,6 -438,7 +375,6 @@@ struct lock_stat_data 
  };
  
  struct lock_stat_seq {
 -      struct lock_stat_data *iter;
        struct lock_stat_data *iter_end;
        struct lock_stat_data stats[MAX_LOCKDEP_KEYS];
  };
@@@ -562,22 -626,34 +562,22 @@@ static void seq_header(struct seq_file 
  static void *ls_start(struct seq_file *m, loff_t *pos)
  {
        struct lock_stat_seq *data = m->private;
 +      struct lock_stat_data *iter;
  
        if (*pos == 0)
                return SEQ_START_TOKEN;
  
 -      data->iter = data->stats + *pos;
 -      if (data->iter >= data->iter_end)
 -              data->iter = NULL;
 +      iter = data->stats + (*pos - 1);
 +      if (iter >= data->iter_end)
 +              iter = NULL;
  
 -      return data->iter;
 +      return iter;
  }
  
  static void *ls_next(struct seq_file *m, void *v, loff_t *pos)
  {
 -      struct lock_stat_seq *data = m->private;
 -
        (*pos)++;
 -
 -      if (v == SEQ_START_TOKEN)
 -              data->iter = data->stats;
 -      else {
 -              data->iter = v;
 -              data->iter++;
 -      }
 -
 -      if (data->iter == data->iter_end)
 -              data->iter = NULL;
 -
 -      return data->iter;
 +      return ls_start(m, pos);
  }
  
  static void ls_stop(struct seq_file *m, void *v)
@@@ -615,6 -691,7 +615,6 @@@ static int lock_stat_open(struct inode 
                struct lock_stat_data *iter = data->stats;
                struct seq_file *m = file->private_data;
  
 -              data->iter = iter;
                list_for_each_entry(class, &all_lock_classes, lock_entry) {
                        iter->class = class;
                        iter->stats = lock_stats(class);
                }
                data->iter_end = iter;
  
 -              sort(data->stats, data->iter_end - data->iter,
 +              sort(data->stats, data->iter_end - data->stats,
                                sizeof(struct lock_stat_data),
                                lock_stat_cmp, NULL);
  
@@@ -657,6 -734,7 +657,6 @@@ static int lock_stat_release(struct ino
        struct seq_file *seq = file->private_data;
  
        vfree(seq->private);
 -      seq->private = NULL;
        return seq_release(inode, file);
  }
  
@@@ -680,7 -758,8 +680,8 @@@ static int __init lockdep_proc_init(voi
                    &proc_lockdep_stats_operations);
  
  #ifdef CONFIG_LOCK_STAT
-       proc_create("lock_stat", S_IRUSR, NULL, &proc_lock_stat_operations);
+       proc_create("lock_stat", S_IRUSR | S_IWUSR, NULL,
+                   &proc_lock_stat_operations);
  #endif
  
        return 0;