static inline void dec_slabs_node(struct kmem_cache *s, int node, int objects)
{
struct kmem_cache_node *n = get_node(s, node);
atomic_long_dec(&n->nr_slabs);
atomic_long_sub(objects, &n->total_objects);
}
/*
* free a contiguous series of pages
*/
static void free_page_series(unsigned long from, unsigned long to)
{
for (; from < to; from += PAGE_SIZE) {
struct page *page = virt_to_page(from);
atomic_long_dec(&mmap_pages_allocated);
put_page(
/**
* Pop method: get the next data from the buffer
*
* \param data Double pointer to the location where to store the data
* popped from the buffer
*
*/
inline bool pop(void ** data) {
if (!data || !buf_r) return false;
if (buf_r->empty()) { // current buffer is empty
if (buf_r == buf_w) return false;
if (buf_r->empty()) { // we have to check again
INTERNAL_BUFFER_T * tmp = pool.next_r();
if (tmp) {
// there is another buffer, release the current one
pool.release(buf_r);
in_use_buffers--;
buf_r = tmp;
#if defined(UBUFFER_STATS)
atomic_long_dec(&numBuffers);
#endif
}
}
}
//DBG(assert(buf_r->pop(data)); return true;);
return buf_r->pop(data);
}
value_type operator--(int) // postfix
{ value_type v(atomic_long_read(&_rep)); atomic_long_dec(&_rep); return v; }
inline void qdio_perf_stat_dec(atomic_long_t *count)
{
if (qdio_performance_stats)
atomic_long_dec(count);
}
static
int lttng_abi_create_event(struct file *channel_file,
struct lttng_kernel_event *event_param)
{
struct lttng_channel *channel = channel_file->private_data;
int event_fd, ret;
struct file *event_file;
void *priv;
event_param->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
switch (event_param->instrumentation) {
case LTTNG_KERNEL_KRETPROBE:
event_param->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
break;
case LTTNG_KERNEL_KPROBE:
event_param->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
break;
case LTTNG_KERNEL_FUNCTION:
event_param->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
break;
default:
break;
}
event_fd = lttng_get_unused_fd();
if (event_fd < 0) {
ret = event_fd;
goto fd_error;
}
event_file = anon_inode_getfile("[lttng_event]",
<tng_event_fops,
NULL, O_RDWR);
if (IS_ERR(event_file)) {
ret = PTR_ERR(event_file);
goto file_error;
}
/* The event holds a reference on the channel */
if (atomic_long_add_unless(&channel_file->f_count,
1, INT_MAX) == INT_MAX) {
ret = -EOVERFLOW;
goto refcount_error;
}
if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
|| event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
struct lttng_enabler *enabler;
if (event_param->name[strlen(event_param->name) - 1] == '*') {
enabler = lttng_enabler_create(LTTNG_ENABLER_WILDCARD,
event_param, channel);
} else {
enabler = lttng_enabler_create(LTTNG_ENABLER_NAME,
event_param, channel);
}
priv = enabler;
} else {
struct lttng_event *event;
/*
* We tolerate no failure path after event creation. It
* will stay invariant for the rest of the session.
*/
event = lttng_event_create(channel, event_param,
NULL, NULL,
event_param->instrumentation);
WARN_ON_ONCE(!event);
if (IS_ERR(event)) {
ret = PTR_ERR(event);
goto event_error;
}
priv = event;
}
event_file->private_data = priv;
fd_install(event_fd, event_file);
return event_fd;
event_error:
atomic_long_dec(&channel_file->f_count);
refcount_error:
fput(event_file);
file_error:
put_unused_fd(event_fd);
fd_error:
return ret;
}
static
int lttng_abi_create_channel(struct file *session_file,
struct lttng_kernel_channel *chan_param,
enum channel_type channel_type)
{
struct lttng_session *session = session_file->private_data;
const struct file_operations *fops = NULL;
const char *transport_name;
struct lttng_channel *chan;
struct file *chan_file;
int chan_fd;
int ret = 0;
chan_fd = lttng_get_unused_fd();
if (chan_fd < 0) {
ret = chan_fd;
goto fd_error;
}
switch (channel_type) {
case PER_CPU_CHANNEL:
fops = <tng_channel_fops;
break;
case METADATA_CHANNEL:
fops = <tng_metadata_fops;
break;
}
chan_file = anon_inode_getfile("[lttng_channel]",
fops,
NULL, O_RDWR);
if (IS_ERR(chan_file)) {
ret = PTR_ERR(chan_file);
goto file_error;
}
switch (channel_type) {
case PER_CPU_CHANNEL:
if (chan_param->output == LTTNG_KERNEL_SPLICE) {
transport_name = chan_param->overwrite ?
"relay-overwrite" : "relay-discard";
} else if (chan_param->output == LTTNG_KERNEL_MMAP) {
transport_name = chan_param->overwrite ?
"relay-overwrite-mmap" : "relay-discard-mmap";
} else {
return -EINVAL;
}
break;
case METADATA_CHANNEL:
if (chan_param->output == LTTNG_KERNEL_SPLICE)
transport_name = "relay-metadata";
else if (chan_param->output == LTTNG_KERNEL_MMAP)
transport_name = "relay-metadata-mmap";
else
return -EINVAL;
break;
default:
transport_name = "<unknown>";
break;
}
if (atomic_long_add_unless(&session_file->f_count,
1, INT_MAX) == INT_MAX) {
goto refcount_error;
}
/*
* We tolerate no failure path after channel creation. It will stay
* invariant for the rest of the session.
*/
chan = lttng_channel_create(session, transport_name, NULL,
chan_param->subbuf_size,
chan_param->num_subbuf,
chan_param->switch_timer_interval,
chan_param->read_timer_interval,
channel_type);
if (!chan) {
ret = -EINVAL;
goto chan_error;
}
chan->file = chan_file;
chan_file->private_data = chan;
fd_install(chan_fd, chan_file);
return chan_fd;
chan_error:
atomic_long_dec(&session_file->f_count);
refcount_error:
fput(chan_file);
file_error:
put_unused_fd(chan_fd);
fd_error:
return ret;
}
