int lib_ring_buffer_release(struct inode *inode, struct file *file,
struct lib_ring_buffer *buf)
{
lib_ring_buffer_release_read(buf);
return 0;
}
void ustctl_destroy_stream(struct ustctl_consumer_stream *stream)
{
struct lttng_ust_lib_ring_buffer *buf;
struct ustctl_consumer_channel *consumer_chan;
assert(stream);
buf = stream->buf;
consumer_chan = stream->chan;
(void) ustctl_stream_close_wait_fd(stream);
(void) ustctl_stream_close_wakeup_fd(stream);
lib_ring_buffer_release_read(buf, consumer_chan->chan->handle);
free(stream);
}
/*
* This is not used by anonymous file descriptors. This code is left
* there if we ever want to implement an inode with open() operation.
*/
int lib_ring_buffer_open(struct inode *inode, struct file *file,
struct lib_ring_buffer *buf)
{
int ret;
if (!buf)
return -EINVAL;
ret = lib_ring_buffer_open_read(buf);
if (ret)
return ret;
ret = nonseekable_open(inode, file);
if (ret)
goto release_read;
return 0;
release_read:
lib_ring_buffer_release_read(buf);
return ret;
}
static
int consume_stream(struct lttng_ust_shm_handle *handle, int cpu, char *outfile)
{
struct channel *chan;
struct lttng_ust_lib_ring_buffer *buf;
int outfd, ret;
int *shm_fd, *wait_fd;
uint64_t *memory_map_size;
chan = shmp(handle, handle->chan);
/* open stream */
buf = channel_get_ring_buffer(&chan->backend.config,
chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size);
if (!buf)
return -ENOENT;
ret = lib_ring_buffer_open_read(buf, handle, 1);
if (ret) {
return -1;
}
/* copy */
outfd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if (outfd < 0) {
perror("open output");
return -1;
}
printf("Waiting for buffer data for %s\n", outfile);
for (;;) {
unsigned long read_size;
unsigned long copy_size;
char *ptr;
ret = lib_ring_buffer_get_next_subbuf(buf, handle);
printf("get next ret %d\n", ret);
if (ret == -ENODATA)
break;
if (ret == -EAGAIN) {
sleep(1);
continue;
}
if (ret) {
printf("Error %d in lib_ring_buffer_get_next_subbuf\n", ret);
return -1;
}
read_size = lib_ring_buffer_get_read_data_size(
&chan->backend.config, buf, handle);
read_size = PAGE_ALIGN(read_size);
ptr = lib_ring_buffer_read_offset_address(
&buf->backend, 0, handle);
printf("WRITE: copy %lu bytes\n", read_size);
copy_size = write(outfd, ptr, read_size);
if (copy_size < read_size) {
printf("write issue: copied %lu, expected %lu\n", copy_size, read_size);
}
lib_ring_buffer_put_next_subbuf(buf, handle);
}
ret = close(outfd);
if (ret) {
perror("close");
return -1;
}
/* close stream */
lib_ring_buffer_release_read(buf, handle, 1);
return 0;
}
void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle,
struct lttng_ust_lib_ring_buffer *buf)
{
assert(handle && buf);
lib_ring_buffer_release_read(buf, handle, 1);
}
