int alloc_cpu_buffers(void) { int i; unsigned long buffer_size = oprofile_cpu_buffer_size; op_ring_buffer_read = ring_buffer_alloc(buffer_size, OP_BUFFER_FLAGS); if (!op_ring_buffer_read) goto fail; op_ring_buffer_write = ring_buffer_alloc(buffer_size, OP_BUFFER_FLAGS); if (!op_ring_buffer_write) goto fail; for_each_possible_cpu(i) { struct oprofile_cpu_buffer *b = &per_cpu(cpu_buffer, i); b->last_task = NULL; b->last_is_kernel = -1; b->tracing = 0; b->buffer_size = buffer_size; b->sample_received = 0; b->sample_lost_overflow = 0; b->backtrace_aborted = 0; b->sample_invalid_eip = 0; b->cpu = i; INIT_DELAYED_WORK(&b->work, wq_sync_buffer); } return 0; fail: free_cpu_buffers(); return -ENOMEM; }
/** * init_stats - Setup global state statistics for the hardware latency detector * * We use data to store various statistics and global state. We also use * a global ring buffer (ring_buffer) to keep raw samples of detected hardware * induced system latencies. This function initializes these structures and * allocates the global ring buffer also. */ static int init_stats(void) { int ret = -ENOMEM; mutex_init(&data.lock); init_waitqueue_head(&data.wq); atomic_set(&data.sample_open, 0); ring_buffer = ring_buffer_alloc(buf_size, BUF_FLAGS); if (WARN(!ring_buffer, KERN_ERR BANNER "failed to allocate ring buffer!\n")) goto out; __reset_stats(); data.threshold = DEFAULT_LAT_THRESHOLD; /* threshold us */ data.sample_window = DEFAULT_SAMPLE_WINDOW; /* window us */ data.sample_width = DEFAULT_SAMPLE_WIDTH; /* width us */ ret = 0; out: return ret; }
static void late_ack_tracker_init_instance(LateAckTracker *self, LogSource *source) { self->super.source = source; source->ack_tracker = (AckTracker *)self; ring_buffer_alloc(&self->ack_record_storage, sizeof(LateAckRecord), log_source_get_init_window_size(source)); g_static_mutex_init(&self->storage_mutex); _setup_callbacks(self); }
static void late_ack_tracker_init_instance(LateAckTracker *self, LogSource *source) { self->super.late = TRUE; self->super.source = source; source->ack_tracker = (AckTracker *)self; self->super.request_bookmark = late_ack_tracker_request_bookmark; self->super.track_msg = late_ack_tracker_track_msg; self->super.manage_msg_ack = late_ack_tracker_manage_msg_ack; ring_buffer_alloc(&self->ack_record_storage, sizeof(LateAckRecord), log_source_get_init_window_size(source)); g_static_mutex_init(&self->storage_mutex); }
int alloc_cpu_buffers(void) { int i; unsigned long buffer_size = oprofile_cpu_buffer_size; unsigned long byte_size = buffer_size * (sizeof(struct op_sample) + RB_EVENT_HDR_SIZE); op_ring_buffer_read = ring_buffer_alloc(byte_size, OP_BUFFER_FLAGS); if (!op_ring_buffer_read) goto fail; op_ring_buffer_write = ring_buffer_alloc(byte_size, OP_BUFFER_FLAGS); if (!op_ring_buffer_write) goto fail; for_each_possible_cpu(i) { struct oprofile_cpu_buffer *b = &per_cpu(cpu_buffer, i); b->last_task = NULL; b->last_is_kernel = -1; b->tracing = 0; b->buffer_size = buffer_size; b->sample_received = 0; b->sample_lost_overflow = 0; b->backtrace_aborted = 0; b->sample_invalid_eip = 0; b->cpu = i; #ifdef CONFIG_CA_CSS b->ca_css_interval = 0; #endif INIT_DELAYED_WORK(&b->work, wq_sync_buffer); } return 0; fail: free_cpu_buffers(); return -ENOMEM; }
static void test_drop_elements() { RingBuffer rb; const int rb_capacity = 103; const int drop = 31; ring_buffer_alloc(&rb, sizeof(TestData), rb_capacity); _ringbuffer_fill(&rb, rb_capacity, 1, TRUE); ring_buffer_drop(&rb, drop); assert_true(ring_buffer_count(&rb) == (rb_capacity - drop), "drop failed"); ring_buffer_free(&rb); }
static int __stp_alloc_ring_buffer(void) { int i; unsigned long buffer_size = _stp_bufsize * 1024 * 1024; if (!alloc_cpumask_var(&_stp_relay_data.trace_reader_cpumask, (GFP_KERNEL & ~__GFP_WAIT))) goto fail; cpumask_clear(_stp_relay_data.trace_reader_cpumask); if (buffer_size == 0) { dbug_trans(1, "using default buffer size...\n"); buffer_size = _stp_nsubbufs * _stp_subbuf_size; } dbug_trans(1, "using buffer size %lu...\n", buffer_size); /* The number passed to ring_buffer_alloc() is per cpu. Our * 'buffer_size' is a total number of bytes to allocate. So, * we need to divide buffer_size by the number of cpus. */ buffer_size /= num_online_cpus(); dbug_trans(1, "%lu\n", buffer_size); _stp_relay_data.rb = ring_buffer_alloc(buffer_size, 0); if (!_stp_relay_data.rb) goto fail; /* Increment _stp_allocated_memory and _stp_allocated_net_memory to approximately account for buffers allocated by ring_buffer_alloc. */ { #ifndef DIV_ROUND_UP #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) #endif u64 relay_pages; relay_pages = DIV_ROUND_UP (buffer_size, PAGE_SIZE); if (relay_pages < 2) relay_pages = 2; relay_pages *= num_online_cpus(); _stp_allocated_net_memory += relay_pages * PAGE_SIZE; _stp_allocated_memory += relay_pages * PAGE_SIZE; } dbug_trans(0, "size = %lu\n", ring_buffer_size(_stp_relay_data.rb)); return 0; fail: __stp_free_ring_buffer(); return -ENOMEM; }
static void test_tail() { RingBuffer rb; TestData *td_tail; ring_buffer_alloc(&rb, sizeof(TestData), 103); _ringbuffer_fill2(&rb, 103, 0, TRUE); ring_buffer_pop(&rb); td_tail = ring_buffer_tail(&rb); td_tail->idx = 103; assert_true(ring_buffer_push(&rb) == td_tail, "Push should return last tail."); assert_test_data_idx_range_in(&rb, 1, 103); ring_buffer_free(&rb); }
static void _ringbuffer_init(RingBuffer *self) { ring_buffer_alloc(self, sizeof(TestData), capacity); }