diff options
Diffstat (limited to 'runtime')
| -rw-r--r-- | runtime/ChangeLog | 6 | ||||
| -rw-r--r-- | runtime/print_new.c | 6 | ||||
| -rw-r--r-- | runtime/transport/ChangeLog | 6 | ||||
| -rw-r--r-- | runtime/transport/utt.c | 94 | ||||
| -rw-r--r-- | runtime/transport/utt.h | 36 |
5 files changed, 145 insertions, 3 deletions
diff --git a/runtime/ChangeLog b/runtime/ChangeLog index 6ad7e51f..e5594783 100644 --- a/runtime/ChangeLog +++ b/runtime/ChangeLog @@ -1,3 +1,9 @@ +2008-09-17 Frank Ch. Eigler <fche@elastic.org> + + PR 6487, 6504. + From Masami Hiramatsu <mhiramat@redhat.com> + * print_new.c (stp_print_flush): Use new utt_reserve(). + 2008-09-12 Masami Hiramatsu <mhiramat@redhat.com> BZ 6028 diff --git a/runtime/print_new.c b/runtime/print_new.c index 07af2e33..4136ecbe 100644 --- a/runtime/print_new.c +++ b/runtime/print_new.c @@ -34,13 +34,13 @@ void EXPORT_FN(stp_print_flush) (_stp_pbuf *pb) #ifdef STP_BULKMODE { #ifdef NO_PERCPU_HEADERS - void *buf = relay_reserve(_stp_utt->rchan, len); + void *buf = utt_reserve(_stp_utt, len); if (likely(buf)) memcpy(buf, pb->buf, len); else atomic_inc (&_stp_transport_failures); #else - void *buf = relay_reserve(_stp_utt->rchan, + void *buf = utt_reserve(_stp_utt, sizeof(struct _stp_trace) + len); if (likely(buf)) { struct _stp_trace t = { .sequence = _stp_seq_inc(), @@ -56,7 +56,7 @@ void EXPORT_FN(stp_print_flush) (_stp_pbuf *pb) void *buf; unsigned long flags; spin_lock_irqsave(&_stp_print_lock, flags); - buf = relay_reserve(_stp_utt->rchan, len); + buf = utt_reserve(_stp_utt, len); if (likely(buf)) memcpy(buf, pb->buf, len); else diff --git a/runtime/transport/ChangeLog b/runtime/transport/ChangeLog index 693f06d1..42c6fc2a 100644 --- a/runtime/transport/ChangeLog +++ b/runtime/transport/ChangeLog @@ -1,3 +1,9 @@ +2008-09-17 Frank Ch. Eigler <fche@elastic.org> + + PR 6487, 6504. + From Masami Hiramatsu <mhiramat@redhat.com> + * utt.c (utt_switch_subbof, _utt_wakeup*, utt_reserve): New. + 2008-07-17 Frank Ch. Eigler <fche@elastic.org> * symbols.c (_stp_do_relocation): Adapt to stp_module decl changes. diff --git a/runtime/transport/utt.c b/runtime/transport/utt.c index 182c1178..b8281bb4 100644 --- a/runtime/transport/utt.c +++ b/runtime/transport/utt.c @@ -31,6 +31,96 @@ static int utt_overwrite_flag = 0; +/* + * utt_switch_subbuf - switch to a new sub-buffer + * + * Most of this function is deadcopy of relay_switch_subbuf. + */ +size_t utt_switch_subbuf(struct utt_trace *utt, struct rchan_buf *buf, + size_t length) +{ + void *old, *new; + size_t old_subbuf, new_subbuf; + + if (unlikely(buf == NULL)) + return 0; + + if (unlikely(length > buf->chan->subbuf_size)) + goto toobig; + + if (buf->offset != buf->chan->subbuf_size + 1) { + buf->prev_padding = buf->chan->subbuf_size - buf->offset; + old_subbuf = buf->subbufs_produced % buf->chan->n_subbufs; + buf->padding[old_subbuf] = buf->prev_padding; + buf->subbufs_produced++; + buf->dentry->d_inode->i_size += buf->chan->subbuf_size - + buf->padding[old_subbuf]; + smp_mb(); + if (waitqueue_active(&buf->read_wait)) + /* + * Calling wake_up_interruptible() and __mod_timer() + * from here will deadlock if we happen to be logging + * from the scheduler and timer (trying to re-grab + * rq->lock/timer->base->lock), so just set a flag. + */ + atomic_set(&utt->wakeup, 1); + } + + old = buf->data; + new_subbuf = buf->subbufs_produced % buf->chan->n_subbufs; + new = buf->start + new_subbuf * buf->chan->subbuf_size; + buf->offset = 0; + if (!buf->chan->cb->subbuf_start(buf, new, old, buf->prev_padding)) { + buf->offset = buf->chan->subbuf_size + 1; + return 0; + } + buf->data = new; + buf->padding[new_subbuf] = 0; + + if (unlikely(length + buf->offset > buf->chan->subbuf_size)) + goto toobig; + + return length; + +toobig: + buf->chan->last_toobig = length; + return 0; +} + +static void __utt_wakeup_readers(struct rchan_buf *buf) +{ + if (buf && waitqueue_active(&buf->read_wait) && + buf->subbufs_produced != buf->subbufs_consumed) + wake_up_interruptible(&buf->read_wait); +} + +static void __utt_wakeup_timer(unsigned long val) +{ + struct utt_trace *utt = (struct utt_trace *)val; + int i; + + if (atomic_read(&utt->wakeup)) { + atomic_set(&utt->wakeup, 0); + if (utt->is_global) + __utt_wakeup_readers(utt->rchan->buf[0]); + else + for_each_possible_cpu(i) + __utt_wakeup_readers(utt->rchan->buf[i]); + } + + mod_timer(&utt->timer, jiffies + UTT_TIMER_INTERVAL); +} + +static void __utt_timer_init(struct utt_trace * utt) +{ + atomic_set(&utt->wakeup, 0); + init_timer(&utt->timer); + utt->timer.expires = jiffies + UTT_TIMER_INTERVAL; + utt->timer.function = __utt_wakeup_timer; + utt->timer.data = (unsigned long)utt; + add_timer(&utt->timer); +} + void utt_set_overwrite(int overwrite) { utt_overwrite_flag = overwrite; @@ -241,6 +331,8 @@ struct utt_trace *utt_trace_setup(struct utt_trace_setup *utts) goto err; utt->rchan->private_data = utt; + utt->is_global = utts->is_global; + utt->trace_state = Utt_trace_setup; utts->err = 0; @@ -274,6 +366,7 @@ int utt_trace_startstop(struct utt_trace *utt, int start, utt->trace_state == Utt_trace_stopped) { if (trace_seq) (*trace_seq)++; + __utt_timer_init(utt); smp_mb(); utt->trace_state = Utt_trace_running; ret = 0; @@ -281,6 +374,7 @@ int utt_trace_startstop(struct utt_trace *utt, int start, } else { if (utt->trace_state == Utt_trace_running) { utt->trace_state = Utt_trace_stopped; + del_timer_sync(&utt->timer); relay_flush(utt->rchan); ret = 0; } diff --git a/runtime/transport/utt.h b/runtime/transport/utt.h index b2c9fa9f..fd704009 100644 --- a/runtime/transport/utt.h +++ b/runtime/transport/utt.h @@ -15,11 +15,18 @@ struct utt_trace { atomic_t dropped; struct dentry *utt_tree_root; /* systemtap */ void *private_data; + atomic_t wakeup; + struct timer_list timer; + int is_global; }; #define UTT_TRACE_ROOT_NAME_SIZE 64 /* Largest string for a root dir identifier */ #define UTT_TRACE_NAME_SIZE 64 /* Largest string for a trace identifier */ +#ifndef UTT_TIMER_INTERVAL +#define UTT_TIMER_INTERVAL ((HZ + 99) / 100) /* Wakeup timer interval in jiffies (default 10 ms)*/ +#endif + /* * User setup structure */ @@ -39,4 +46,33 @@ extern int utt_trace_startstop(struct utt_trace *utt, int start, extern void utt_trace_cleanup(struct utt_trace *utt); extern int utt_trace_remove(struct utt_trace *utt); +#ifndef STP_OLD_TRANSPORT +extern size_t utt_switch_subbuf(struct utt_trace *utt, struct rchan_buf *buf, + size_t length); +/** + * utt_reserve - reserve slot in channel buffer + * @utt: utt channel + * @length: number of bytes to reserve + * + * Returns pointer to reserved slot, NULL if full. + * + * This function is utt_switch_subbuf version of relay_reserve. + */ +static inline void *utt_reserve(struct utt_trace *utt, size_t length) +{ + void *reserved; + struct rchan_buf *buf = utt->rchan->buf[smp_processor_id()]; + + if (unlikely(buf->offset + length > buf->chan->subbuf_size)) { + length = utt_switch_subbuf(utt, buf, length); + if (!length) + return NULL; + } + reserved = buf->data + buf->offset; + buf->offset += length; + + return reserved; +} +#endif + #endif |