<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/share/systemtap/runtime/transport/relay_v2.c</h2><form method='post'><textarea name='content' class='file-edit'>/* -*- linux-c -*- 
 *
 * This transport version uses relayfs on top of a debugfs or procfs
 * file.  This code started as a proposed relayfs interface called
 * 'utt'.  It has been modified and simplified for systemtap.
 *
 * Changes Copyright (C) 2009-2020 Red Hat Inc.
 *
 * Original utt code by:
 *   Copyright (C) 2006 Jens Axboe &lt;axboe@suse.de&gt;
 *   Moved to utt.c by Tom Zanussi, 2006
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see &lt;http://www.gnu.org/licenses/&gt;.
 *
 */
#include &lt;linux/kernel.h&gt;
#include &lt;linux/module.h&gt;
#include &lt;linux/percpu.h&gt;
#include &lt;linux/init.h&gt;
#include &lt;linux/debugfs.h&gt;
#include &lt;linux/mm.h&gt;
#include &quot;../linux/timer_compatibility.h&quot;
#include &quot;../uidgid_compatibility.h&quot;
#include &quot;relay_compat.h&quot;

#ifndef STP_RELAY_TIMER_INTERVAL
/* Wakeup timer interval in jiffies (default 10 ms) */
#define STP_RELAY_TIMER_INTERVAL		((HZ + 99) / 100)
#endif

/* Note: if struct _stp_relay_data_type changes, staplog.c might need
 * to be changed. */
struct _stp_relay_data_type {
	struct rchan *rchan;
	atomic_t /* enum _stp_transport_state */ transport_state;
	atomic_t wakeup;
	struct timer_list timer;
	int overwrite_flag;
};
struct _stp_relay_data_type _stp_relay_data;

/* relay_file_operations is const, so .owner is obviously not set there.
 * Below struct, filled in _stp_transport_data_fs_init(), fixes it. */
static struct file_operations relay_file_operations_w_owner;

/*
 *	__stp_relay_switch_subbuf - switch to a new sub-buffer
 *
 *	Most of this function is deadcopy of relay_switch_subbuf.
 */
static size_t __stp_relay_switch_subbuf(struct rchan_buf *buf, size_t length)
{
	char *old, *new;
	size_t old_subbuf, new_subbuf;

	if (unlikely(buf == NULL))
		return 0;

	if (unlikely(length &gt; buf-&gt;chan-&gt;subbuf_size))
		length = buf-&gt;chan-&gt;subbuf_size;

	if (buf-&gt;offset != buf-&gt;chan-&gt;subbuf_size + 1) {
		buf-&gt;prev_padding = buf-&gt;chan-&gt;subbuf_size - buf-&gt;offset;
		old_subbuf = buf-&gt;subbufs_produced % buf-&gt;chan-&gt;n_subbufs;
		buf-&gt;padding[old_subbuf] = buf-&gt;prev_padding;
		buf-&gt;subbufs_produced++;
		buf-&gt;dentry-&gt;d_inode-&gt;i_size += buf-&gt;chan-&gt;subbuf_size -
			buf-&gt;padding[old_subbuf];
		smp_mb();
	}

	old = buf-&gt;data;
	new_subbuf = buf-&gt;subbufs_produced % buf-&gt;chan-&gt;n_subbufs;
	new = (char*)buf-&gt;start + new_subbuf * buf-&gt;chan-&gt;subbuf_size;
	buf-&gt;offset = 0;
	if (!buf-&gt;chan-&gt;cb-&gt;subbuf_start(buf, new, old, buf-&gt;prev_padding)) {
		buf-&gt;offset = buf-&gt;chan-&gt;subbuf_size + 1;
		return 0;
	}
	buf-&gt;data = new;
	buf-&gt;padding[new_subbuf] = 0;

	return length;
}

static bool __stp_relay_buf_empty(struct rchan_buf *buf)
{
	return !buf-&gt;offset &amp;&amp; buf-&gt;subbufs_produced == buf-&gt;subbufs_consumed;
}

static unsigned int __stp_relay_file_poll(struct file *filp, poll_table *wait)
{
	struct rchan_buf *buf = filp-&gt;private_data;

	if (buf-&gt;finalized)
		return POLLERR;

	if (filp-&gt;f_mode &amp; FMODE_READ) {
		poll_wait(filp, &amp;buf-&gt;read_wait, wait);
		if (!__stp_relay_buf_empty(buf))
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

static ssize_t __stp_relay_file_read(struct file *filp, char __user *buffer,
				     size_t count, loff_t *ppos)
{
	struct rchan_buf *buf = filp-&gt;private_data;
	unsigned long flags;

	/* This trylock will only fail after the print driver is destroyed */
	if (_stp_print_trylock_irqsave(&amp;flags)) {
		/* Switch out the current buffer if it has any data */
		if (buf-&gt;offset)
			__stp_relay_switch_subbuf(buf, 0);
		_stp_print_unlock_irqrestore(&amp;flags);
	}

	/*
	 * Optimization: bail out early if there's nothing to read. This is
	 * faster than going into relay's read() function without having any
	 * data, as it will acquire a mutex lock for the inode before bailing.
	 */
	if (buf-&gt;subbufs_produced == buf-&gt;subbufs_consumed)
		return -ENODATA;

	return relay_file_operations.read(filp, buffer, count, ppos);
}

static void __stp_relay_wakeup_readers(struct rchan_buf *buf)
{
	if (buf &amp;&amp; waitqueue_active(&amp;buf-&gt;read_wait) &amp;&amp;
	    !__stp_relay_buf_empty(buf))
		wake_up_interruptible(&amp;buf-&gt;read_wait);
}

static void __stp_relay_wakeup_timer(stp_timer_callback_parameter_t unused)
{
	int i;

	if (atomic_cmpxchg(&amp;_stp_relay_data.wakeup, 1, 0)) {
		struct rchan_buf *buf;
		
		for_each_possible_cpu(i) {
			buf = _stp_get_rchan_subbuf(_stp_relay_data.rchan-&gt;buf,
						    i);
			__stp_relay_wakeup_readers(buf);
		}
	}

	if (atomic_read(&amp;_stp_relay_data.transport_state) == STP_TRANSPORT_RUNNING)
        	mod_timer(&amp;_stp_relay_data.timer, jiffies + STP_RELAY_TIMER_INTERVAL);
        else
		dbug_trans(0, &quot;relay_v2 wakeup timer expiry\n&quot;);
}

static void __stp_relay_timer_init(void)
{
	atomic_set(&amp;_stp_relay_data.wakeup, 0);
	timer_setup(&amp;_stp_relay_data.timer, __stp_relay_wakeup_timer, 0);
	_stp_relay_data.timer.expires = jiffies + STP_RELAY_TIMER_INTERVAL;
	add_timer(&amp;_stp_relay_data.timer);
	smp_mb();
}

static enum _stp_transport_state _stp_transport_get_state(void)
{
	return atomic_read (&amp;_stp_relay_data.transport_state);
}

static void _stp_transport_data_fs_overwrite(int overwrite)
{
	_stp_relay_data.overwrite_flag = overwrite;
}


/*
 * Keep track of how many times we encountered a full subbuffer, to aid
 * the user space app in telling how many lost events there were.
 */
static int __stp_relay_subbuf_start_callback(struct rchan_buf *buf,
                                             void *subbuf, void *prev_subbuf,
                                             size_t prev_padding)
{
        if (_stp_relay_data.overwrite_flag || !relay_buf_full(buf))
                return 1;
        
#ifdef _STP_USE_DROPPED_FILE
        atomic_inc(&amp;_stp_relay_data.dropped);
#endif
        return 0;
}


// PR26665: demultiplex debugfs vs procfs host

static int __stp_relay_remove_buf_file_callback(struct dentry *dentry)
{
        if (debugfs_p)
                return __stp_debugfs_relay_remove_buf_file_callback(dentry);
        if (procfs_p)
                return __stp_procfs_relay_remove_buf_file_callback(dentry);
	return 0;
}


static struct dentry *
__stp_relay_create_buf_file_callback(const char *filename,
				     struct dentry *parent,
#ifdef STAPCONF_RELAY_UMODE_T
				     umode_t mode,
#else
				     int mode,
#endif
				     struct rchan_buf *buf,
				     int *is_global)
{
        if (debugfs_p)
                return __stp_debugfs_relay_create_buf_file_callback(filename, parent, mode, buf, is_global);
        if (procfs_p)
                return __stp_procfs_relay_create_buf_file_callback(filename, parent, mode, buf, is_global);
        return NULL;
}


static struct rchan_callbacks __stp_relay_callbacks = {
	.subbuf_start		= __stp_relay_subbuf_start_callback,
	.create_buf_file	= __stp_relay_create_buf_file_callback,
	.remove_buf_file	= __stp_relay_remove_buf_file_callback,
};


static void _stp_transport_data_fs_start(void)
{
	if (atomic_read (&amp;_stp_relay_data.transport_state) == STP_TRANSPORT_INITIALIZED) {
		atomic_set (&amp;_stp_relay_data.transport_state, STP_TRANSPORT_RUNNING);
		/* We're initialized.  Now start the timer. */
		__stp_relay_timer_init();
	}
}

static void _stp_transport_data_fs_stop(void)
{

	if (atomic_read (&amp;_stp_relay_data.transport_state) == STP_TRANSPORT_RUNNING) {
		atomic_set (&amp;_stp_relay_data.transport_state, STP_TRANSPORT_STOPPED);
		del_timer_sync(&amp;_stp_relay_data.timer);
		dbug_trans(0, &quot;flushing...\n&quot;);
		if (_stp_relay_data.rchan)
			relay_flush(_stp_relay_data.rchan);
	}
}

static void _stp_transport_data_fs_close(void)
{
	_stp_transport_data_fs_stop();
	if (_stp_relay_data.rchan) {
		relay_close(_stp_relay_data.rchan);
		_stp_relay_data.rchan = NULL;
	}
}

static int _stp_transport_data_fs_init(void)
{
	int rc;
	u64 npages;
	struct sysinfo si;

	atomic_set(&amp;_stp_relay_data.transport_state, STP_TRANSPORT_STOPPED);
	_stp_relay_data.overwrite_flag = 0;
	_stp_relay_data.rchan = NULL;

	/* Create &quot;trace&quot; file. */
	npages = _stp_subbuf_size * _stp_nsubbufs;
	npages *= num_online_cpus();
	npages &gt;&gt;= PAGE_SHIFT;
	si_meminfo(&amp;si);
#define MB(i) (unsigned long)((i) &gt;&gt; (20 - PAGE_SHIFT))
	if (npages &gt; (si.freeram + si.bufferram)) {
		errk(&quot;Not enough free+buffered memory(%luMB) for log buffer(%luMB)\n&quot;,
		     MB(si.freeram + si.bufferram),
		     MB(npages));
		rc = -ENOMEM;
		goto err;
	}
	else if (npages &gt; si.freeram) {
		/* exceeds freeram, but below freeram+bufferram */
		printk(KERN_WARNING
		       &quot;log buffer size exceeds free memory(%luMB)\n&quot;,
		       MB(si.freeram));
	}
	relay_file_operations_w_owner = relay_file_operations;
	relay_file_operations_w_owner.owner = THIS_MODULE;
	relay_file_operations_w_owner.poll = __stp_relay_file_poll;
	relay_file_operations_w_owner.read = __stp_relay_file_read;
#if (RELAYFS_CHANNEL_VERSION &gt;= 7)
	_stp_relay_data.rchan = relay_open(&quot;trace&quot;, _stp_get_module_dir(),
					   _stp_subbuf_size, _stp_nsubbufs,
					   &amp;__stp_relay_callbacks, NULL);
#else  /* (RELAYFS_CHANNEL_VERSION &lt; 7) */
	_stp_relay_data.rchan = relay_open(&quot;trace&quot;, _stp_get_module_dir(),
					   _stp_subbuf_size, _stp_nsubbufs,
					   &amp;__stp_relay_callbacks);
#endif  /* (RELAYFS_CHANNEL_VERSION &lt; 7) */
	if (!_stp_relay_data.rchan) {
		rc = -ENOENT;
		errk(&quot;%s: relay_open() failed: %d\n&quot;, THIS_MODULE-&gt;name, rc);
		goto err;
	}
        /* Increment _stp_allocated_memory and _stp_allocated_net_memory to account for buffers
           allocated by relay_open. */
        {
                u64 relay_mem;
                relay_mem = _stp_subbuf_size * _stp_nsubbufs;
                relay_mem *= num_online_cpus();
                _stp_allocated_net_memory += relay_mem;
                _stp_allocated_memory += relay_mem;
        }

	dbug_trans(1, &quot;returning 0...\n&quot;);
	atomic_set (&amp;_stp_relay_data.transport_state, STP_TRANSPORT_INITIALIZED);

	return 0;

err:
	_stp_transport_data_fs_close();
	return rc;
}


/**
 *      _stp_data_write_reserve - try to reserve size_request bytes
 *      @size_request: number of bytes to attempt to reserve
 *      @entry: entry is returned here
 *
 *      Returns number of bytes reserved, 0 if full.  On return, entry
 *      will point to allocated opaque pointer.  Use
 *      _stp_data_entry_data() to get pointer to copy data into.
 *
 *	(For this code's purposes, entry is filled in with the actual
 *	data pointer, but the caller doesn't know that.)
 */
static size_t
_stp_data_write_reserve(size_t size_request, void **entry)
{
	struct rchan_buf *buf;

	if (entry == NULL)
		return -EINVAL;

	buf = _stp_get_rchan_subbuf(_stp_relay_data.rchan-&gt;buf,
				    smp_processor_id());
	if (buf-&gt;offset &gt;= buf-&gt;chan-&gt;subbuf_size) {
		size_request = __stp_relay_switch_subbuf(buf, size_request);
		if (!size_request)
			return 0;
	} else if (buf-&gt;offset + size_request &gt; buf-&gt;chan-&gt;subbuf_size) {
		size_request = buf-&gt;chan-&gt;subbuf_size - buf-&gt;offset;
	}
	*entry = (char*)buf-&gt;data + buf-&gt;offset;
	buf-&gt;offset += size_request;

	return size_request;
}

static unsigned char *_stp_data_entry_data(void *entry)
{
	/* Nothing to do here. */
	return entry;
}

static int _stp_data_write_commit(void *entry)
{
	atomic_set(&amp;_stp_relay_data.wakeup, 1);
	return 0;
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fshare%2Fsystemtap%2Fruntime%2Ftransport'>Back to Directory</a>