1 files changed, 85 insertions, 141 deletions

diff --git a/kernel/relay.c b/kernel/relay.c
index d797502140b9..da79a109dbeb 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -214,7 +214,7 @@ static void relay_destroy_buf(struct rchan_buf *buf)
                         __free_page(buf->page_array[i]);
                 relay_free_page_array(buf->page_array);
         }
-        chan->buf[buf->cpu] = NULL;
+        *per_cpu_ptr(chan->buf, buf->cpu) = NULL;
         kfree(buf->padding);
         kfree(buf);
         kref_put(&chan->kref, relay_destroy_channel);
@@ -328,13 +328,15 @@ static struct rchan_callbacks default_channel_callbacks = {
 
 /**
  *      wakeup_readers - wake up readers waiting on a channel
- *      @data: contains the channel buffer
+ *      @work: contains the channel buffer
  *
- *      This is the timer function used to defer reader waking.
+ *      This is the function used to defer reader waking
  */
-static void wakeup_readers(unsigned long data)
+static void wakeup_readers(struct irq_work *work)
 {
-        struct rchan_buf *buf = (struct rchan_buf *)data;
+        struct rchan_buf *buf;
+
+        buf = container_of(work, struct rchan_buf, wakeup_work);
         wake_up_interruptible(&buf->read_wait);
 }
 
@@ -352,9 +354,10 @@ static void __relay_reset(struct rchan_buf *buf, unsigned int init)
         if (init) {
                 init_waitqueue_head(&buf->read_wait);
                 kref_init(&buf->kref);
-                setup_timer(&buf->timer, wakeup_readers, (unsigned long)buf);
-        } else
-                del_timer_sync(&buf->timer);
+                init_irq_work(&buf->wakeup_work, wakeup_readers);
+        } else {
+                irq_work_sync(&buf->wakeup_work);
+        }
 
         buf->subbufs_produced = 0;
         buf->subbufs_consumed = 0;
@@ -382,20 +385,21 @@ static void __relay_reset(struct rchan_buf *buf, unsigned int init)
  */
 void relay_reset(struct rchan *chan)
 {
+        struct rchan_buf *buf;
         unsigned int i;
 
         if (!chan)
                 return;
 
-        if (chan->is_global && chan->buf[0]) {
-                __relay_reset(chan->buf[0], 0);
+        if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0))) {
+                __relay_reset(buf, 0);
                 return;
         }
 
         mutex_lock(&relay_channels_mutex);
         for_each_possible_cpu(i)
-                if (chan->buf[i])
-                        __relay_reset(chan->buf[i], 0);
+                if ((buf = *per_cpu_ptr(chan->buf, i)))
+                        __relay_reset(buf, 0);
         mutex_unlock(&relay_channels_mutex);
 }
 EXPORT_SYMBOL_GPL(relay_reset);
@@ -440,7 +444,7 @@ static struct rchan_buf *relay_open_buf(struct rchan *chan, unsigned int cpu)
         struct dentry *dentry;
 
         if (chan->is_global)
-                return chan->buf[0];
+                return *per_cpu_ptr(chan->buf, 0);
 
         buf = relay_create_buf(chan);
         if (!buf)
@@ -464,7 +468,7 @@ static struct rchan_buf *relay_open_buf(struct rchan *chan, unsigned int cpu)
         __relay_reset(buf, 1);
 
         if(chan->is_global) {
-                chan->buf[0] = buf;
+                *per_cpu_ptr(chan->buf, 0) = buf;
                 buf->cpu = 0;
         }
 
@@ -486,7 +490,7 @@ free_buf:
 static void relay_close_buf(struct rchan_buf *buf)
 {
         buf->finalized = 1;
-        del_timer_sync(&buf->timer);
+        irq_work_sync(&buf->wakeup_work);
         buf->chan->cb->remove_buf_file(buf->dentry);
         kref_put(&buf->kref, relay_remove_buf);
 }
@@ -512,46 +516,25 @@ static void setup_callbacks(struct rchan *chan,
         chan->cb = cb;
 }
 
-/**
- *      relay_hotcpu_callback - CPU hotplug callback
- *      @nb: notifier block
- *      @action: hotplug action to take
- *      @hcpu: CPU number
- *
- *      Returns the success/failure of the operation. (%NOTIFY_OK, %NOTIFY_BAD)
- */
-static int relay_hotcpu_callback(struct notifier_block *nb,
-                                unsigned long action,
-                                void *hcpu)
+int relay_prepare_cpu(unsigned int cpu)
 {
-        unsigned int hotcpu = (unsigned long)hcpu;
         struct rchan *chan;
+        struct rchan_buf *buf;
 
-        switch(action) {
-        case CPU_UP_PREPARE:
-        case CPU_UP_PREPARE_FROZEN:
-                mutex_lock(&relay_channels_mutex);
-                list_for_each_entry(chan, &relay_channels, list) {
-                        if (chan->buf[hotcpu])
-                                continue;
-                        chan->buf[hotcpu] = relay_open_buf(chan, hotcpu);
-                        if(!chan->buf[hotcpu]) {
-                                printk(KERN_ERR
-                                        "relay_hotcpu_callback: cpu %d buffer "
-                                        "creation failed\n", hotcpu);
-                                mutex_unlock(&relay_channels_mutex);
-                                return notifier_from_errno(-ENOMEM);
-                        }
+        mutex_lock(&relay_channels_mutex);
+        list_for_each_entry(chan, &relay_channels, list) {
+                if ((buf = *per_cpu_ptr(chan->buf, cpu)))
+                        continue;
+                buf = relay_open_buf(chan, cpu);
+                if (!buf) {
+                        pr_err("relay: cpu %d buffer creation failed\n", cpu);
+                        mutex_unlock(&relay_channels_mutex);
+                        return -ENOMEM;
                 }
-                mutex_unlock(&relay_channels_mutex);
-                break;
-        case CPU_DEAD:
-        case CPU_DEAD_FROZEN:
-                /* No need to flush the cpu : will be flushed upon
-                 * final relay_flush() call. */
-                break;
+                *per_cpu_ptr(chan->buf, cpu) = buf;
         }
-        return NOTIFY_OK;
+        mutex_unlock(&relay_channels_mutex);
+        return 0;
 }
 
 /**
@@ -583,6 +566,7 @@ struct rchan *relay_open(const char *base_filename,
 {
         unsigned int i;
         struct rchan *chan;
+        struct rchan_buf *buf;
 
         if (!(subbuf_size && n_subbufs))
                 return NULL;
@@ -593,6 +577,7 @@ struct rchan *relay_open(const char *base_filename,
         if (!chan)
                 return NULL;
 
+        chan->buf = alloc_percpu(struct rchan_buf *);
         chan->version = RELAYFS_CHANNEL_VERSION;
         chan->n_subbufs = n_subbufs;
         chan->subbuf_size = subbuf_size;
@@ -608,9 +593,10 @@ struct rchan *relay_open(const char *base_filename,
 
         mutex_lock(&relay_channels_mutex);
         for_each_online_cpu(i) {
-                chan->buf[i] = relay_open_buf(chan, i);
-                if (!chan->buf[i])
+                buf = relay_open_buf(chan, i);
+                if (!buf)
                         goto free_bufs;
+                *per_cpu_ptr(chan->buf, i) = buf;
         }
         list_add(&chan->list, &relay_channels);
         mutex_unlock(&relay_channels_mutex);
@@ -619,8 +605,8 @@ struct rchan *relay_open(const char *base_filename,
 
 free_bufs:
         for_each_possible_cpu(i) {
-                if (chan->buf[i])
-                        relay_close_buf(chan->buf[i]);
+                if ((buf = *per_cpu_ptr(chan->buf, i)))
+                        relay_close_buf(buf);
         }
 
         kref_put(&chan->kref, relay_destroy_channel);
@@ -666,6 +652,7 @@ int relay_late_setup_files(struct rchan *chan,
         unsigned int i, curr_cpu;
         unsigned long flags;
         struct dentry *dentry;
+        struct rchan_buf *buf;
         struct rchan_percpu_buf_dispatcher disp;
 
         if (!chan || !base_filename)
@@ -684,10 +671,11 @@ int relay_late_setup_files(struct rchan *chan,
 
         if (chan->is_global) {
                 err = -EINVAL;
-                if (!WARN_ON_ONCE(!chan->buf[0])) {
-                        dentry = relay_create_buf_file(chan, chan->buf[0], 0);
+                buf = *per_cpu_ptr(chan->buf, 0);
+                if (!WARN_ON_ONCE(!buf)) {
+                        dentry = relay_create_buf_file(chan, buf, 0);
                         if (dentry && !WARN_ON_ONCE(!chan->is_global)) {
-                                relay_set_buf_dentry(chan->buf[0], dentry);
+                                relay_set_buf_dentry(buf, dentry);
                                 err = 0;
                         }
                 }
@@ -702,13 +690,14 @@ int relay_late_setup_files(struct rchan *chan,
          * on all currently online CPUs.
          */
         for_each_online_cpu(i) {
-                if (unlikely(!chan->buf[i])) {
+                buf = *per_cpu_ptr(chan->buf, i);
+                if (unlikely(!buf)) {
                         WARN_ONCE(1, KERN_ERR "CPU has no buffer!\n");
                         err = -EINVAL;
                         break;
                 }
 
-                dentry = relay_create_buf_file(chan, chan->buf[i], i);
+                dentry = relay_create_buf_file(chan, buf, i);
                 if (unlikely(!dentry)) {
                         err = -EINVAL;
                         break;
@@ -716,10 +705,10 @@ int relay_late_setup_files(struct rchan *chan,
 
                 if (curr_cpu == i) {
                         local_irq_save(flags);
-                        relay_set_buf_dentry(chan->buf[i], dentry);
+                        relay_set_buf_dentry(buf, dentry);
                         local_irq_restore(flags);
                 } else {
-                        disp.buf = chan->buf[i];
+                        disp.buf = buf;
                         disp.dentry = dentry;
                         smp_mb();
                         /* relay_channels_mutex must be held, so wait. */
@@ -768,14 +757,15 @@ size_t relay_switch_subbuf(struct rchan_buf *buf, size_t length)
                         buf->early_bytes += buf->chan->subbuf_size -
                                             buf->padding[old_subbuf];
                 smp_mb();
-                if (waitqueue_active(&buf->read_wait))
+                if (waitqueue_active(&buf->read_wait)) {
                         /*
                          * Calling wake_up_interruptible() from here
                          * will deadlock if we happen to be logging
                          * from the scheduler (trying to re-grab
                          * rq->lock), so defer it.
                          */
-                        mod_timer(&buf->timer, jiffies + 1);
+                        irq_work_queue(&buf->wakeup_work);
+                }
         }
 
         old = buf->data;
@@ -822,11 +812,10 @@ void relay_subbufs_consumed(struct rchan *chan,
         if (!chan)
                 return;
 
-        if (cpu >= NR_CPUS || !chan->buf[cpu] ||
-                                        subbufs_consumed > chan->n_subbufs)
+        buf = *per_cpu_ptr(chan->buf, cpu);
+        if (cpu >= NR_CPUS || !buf || subbufs_consumed > chan->n_subbufs)
                 return;
 
-        buf = chan->buf[cpu];
         if (subbufs_consumed > buf->subbufs_produced - buf->subbufs_consumed)
                 buf->subbufs_consumed = buf->subbufs_produced;
         else
@@ -842,18 +831,19 @@ EXPORT_SYMBOL_GPL(relay_subbufs_consumed);
  */
 void relay_close(struct rchan *chan)
 {
+        struct rchan_buf *buf;
         unsigned int i;
 
         if (!chan)
                 return;
 
         mutex_lock(&relay_channels_mutex);
-        if (chan->is_global && chan->buf[0])
-                relay_close_buf(chan->buf[0]);
+        if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0)))
+                relay_close_buf(buf);
         else
                 for_each_possible_cpu(i)
-                        if (chan->buf[i])
-                                relay_close_buf(chan->buf[i]);
+                        if ((buf = *per_cpu_ptr(chan->buf, i)))
+                                relay_close_buf(buf);
 
         if (chan->last_toobig)
                 printk(KERN_WARNING "relay: one or more items not logged "
@@ -874,20 +864,21 @@ EXPORT_SYMBOL_GPL(relay_close);
  */
 void relay_flush(struct rchan *chan)
 {
+        struct rchan_buf *buf;
         unsigned int i;
 
         if (!chan)
                 return;
 
-        if (chan->is_global && chan->buf[0]) {
-                relay_switch_subbuf(chan->buf[0], 0);
+        if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0))) {
+                relay_switch_subbuf(buf, 0);
                 return;
         }
 
         mutex_lock(&relay_channels_mutex);
         for_each_possible_cpu(i)
-                if (chan->buf[i])
-                        relay_switch_subbuf(chan->buf[i], 0);
+                if ((buf = *per_cpu_ptr(chan->buf, i)))
+                        relay_switch_subbuf(buf, 0);
         mutex_unlock(&relay_channels_mutex);
 }
 EXPORT_SYMBOL_GPL(relay_flush);
@@ -1121,51 +1112,23 @@ static size_t relay_file_read_end_pos(struct rchan_buf *buf,
         return end_pos;
 }
 
-/*
- *      subbuf_read_actor - read up to one subbuf's worth of data
- */
-static int subbuf_read_actor(size_t read_start,
-                             struct rchan_buf *buf,
-                             size_t avail,
-                             read_descriptor_t *desc)
-{
-        void *from;
-        int ret = 0;
-
-        from = buf->start + read_start;
-        ret = avail;
-        if (copy_to_user(desc->arg.buf, from, avail)) {
-                desc->error = -EFAULT;
-                ret = 0;
-        }
-        desc->arg.data += ret;
-        desc->written += ret;
-        desc->count -= ret;
-
-        return ret;
-}
-
-typedef int (*subbuf_actor_t) (size_t read_start,
-                               struct rchan_buf *buf,
-                               size_t avail,
-                               read_descriptor_t *desc);
-
-/*
- *      relay_file_read_subbufs - read count bytes, bridging subbuf boundaries
- */
-static ssize_t relay_file_read_subbufs(struct file *filp, loff_t *ppos,
-                                        subbuf_actor_t subbuf_actor,
-                                        read_descriptor_t *desc)
+static ssize_t relay_file_read(struct file *filp,
+                               char __user *buffer,
+                               size_t count,
+                               loff_t *ppos)
 {
         struct rchan_buf *buf = filp->private_data;
         size_t read_start, avail;
+        size_t written = 0;
         int ret;
 
-        if (!desc->count)
+        if (!count)
                 return 0;
 
         inode_lock(file_inode(filp));
         do {
+                void *from;
+
                 if (!relay_file_read_avail(buf, *ppos))
                         break;
 
@@ -1174,32 +1137,22 @@ static ssize_t relay_file_read_subbufs(struct file *filp, loff_t *ppos,
                 if (!avail)
                         break;
 
-                avail = min(desc->count, avail);
-                ret = subbuf_actor(read_start, buf, avail, desc);
-                if (desc->error < 0)
+                avail = min(count, avail);
+                from = buf->start + read_start;
+                ret = avail;
+                if (copy_to_user(buffer, from, avail))
                         break;
 
-                if (ret) {
-                        relay_file_read_consume(buf, read_start, ret);
-                        *ppos = relay_file_read_end_pos(buf, read_start, ret);
-                }
-        } while (desc->count && ret);
-        inode_unlock(file_inode(filp));
+                buffer += ret;
+                written += ret;
+                count -= ret;
 
-        return desc->written;
-}
+                relay_file_read_consume(buf, read_start, ret);
+                *ppos = relay_file_read_end_pos(buf, read_start, ret);
+        } while (count);
+        inode_unlock(file_inode(filp));
 
-static ssize_t relay_file_read(struct file *filp,
-                               char __user *buffer,
-                               size_t count,
-                               loff_t *ppos)
-{
-        read_descriptor_t desc;
-        desc.written = 0;
-        desc.count = count;
-        desc.arg.buf = buffer;
-        desc.error = 0;
-        return relay_file_read_subbufs(filp, ppos, subbuf_read_actor, &desc);
+        return written;
 }
 
 static void relay_consume_bytes(struct rchan_buf *rbuf, int bytes_consumed)
@@ -1377,12 +1330,3 @@ const struct file_operations relay_file_operations = {
         .splice_read    = relay_file_splice_read,
 };
 EXPORT_SYMBOL_GPL(relay_file_operations);
-
-static __init int relay_init(void)
-{
-
-        hotcpu_notifier(relay_hotcpu_callback, 0);
-        return 0;
-}
-
-early_initcall(relay_init);