自学教程：C++ trace_mark函数代码示例

/** * handle_IRQ_event - irq action chain handler * @irq:	the interrupt number * @action:	the interrupt action chain for this irq * * Handles the action chain of an irq event */irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action){	irqreturn_t ret, retval = IRQ_NONE;	unsigned int status = 0;	struct pt_regs *regs = get_irq_regs();	trace_mark(kernel_irq_entry, "irq_id %u kernel_mode %u", irq,		(regs)?(!user_mode(regs)):(1));	handle_dynamic_tick(action);	if (!(action->flags & IRQF_DISABLED))		local_irq_enable_in_hardirq();	do {		ret = action->handler(irq, action->dev_id);		if (ret == IRQ_HANDLED)			status |= action->flags;		retval |= ret;		action = action->next;	} while (action);	if (status & IRQF_SAMPLE_RANDOM)		add_interrupt_randomness(irq);	local_irq_disable();	trace_mark(kernel_irq_exit, MARK_NOARGS);	return retval;}

intmain (void){  /* Some code to make sure that breakpoints on `main' and `ust/bar' marker     are set at different addresses.  */  int a = 0;  int b = a;  trace_mark(ust, bar, "str %s", "FOOBAZ");  trace_mark(ust, bar2, "number1 %d number2 %d", 53, 9800);  end ();  return 0;}

void xnintr_clock_handler(void){	xnstat_exectime_t *prev;	struct xnsched *sched;	unsigned cpu;	cpu = xnarch_current_cpu();	if (!cpumask_test_cpu(cpu, &xnarch_supported_cpus)) {		xnarch_relay_tick();		return;	}	sched = xnpod_sched_slot(cpu);	prev = xnstat_exectime_switch(sched,		&nkclock.stat[xnsched_cpu(sched)].account);	xnstat_counter_inc(&nkclock.stat[xnsched_cpu(sched)].hits);	trace_mark(xn_nucleus, irq_enter, "irq %u", XNARCH_TIMER_IRQ);	trace_mark(xn_nucleus, tbase_tick, "base %s", nktbase.name);	++sched->inesting;	__setbits(sched->lflags, XNINIRQ);	xnlock_get(&nklock);	xntimer_tick_aperiodic();	xnlock_put(&nklock);	xnstat_exectime_switch(sched, prev);	if (--sched->inesting == 0) {		__clrbits(sched->lflags, XNINIRQ);		xnpod_schedule();		sched = xnpod_current_sched();	}	/*	 * If the clock interrupt preempted a real-time thread, any	 * transition to the root thread has already triggered a host	 * tick propagation from xnpod_schedule(), so at this point,	 * we only need to propagate the host tick in case the	 * interrupt preempted the root thread.	 */	if (testbits(sched->lflags, XNHTICK) &&	    xnthread_test_state(sched->curr, XNROOT))		xnintr_host_tick(sched);	trace_mark(xn_nucleus, irq_exit, "irq %u", XNARCH_TIMER_IRQ);}

int xnsynch_flush(struct xnsynch *synch, xnflags_t reason){	struct xnpholder *holder;	int status;	spl_t s;	xnlock_get_irqsave(&nklock, s);	trace_mark(xn_nucleus, synch_flush, "synch %p reason %lu",		   synch, reason);	status = emptypq_p(&synch->pendq) ? XNSYNCH_DONE : XNSYNCH_RESCHED;	while ((holder = getpq(&synch->pendq)) != NULL) {		struct xnthread *sleeper = link2thread(holder, plink);		xnthread_set_info(sleeper, reason);		sleeper->wchan = NULL;		xnpod_resume_thread(sleeper, XNPEND);	}	if (testbits(synch->status, XNSYNCH_CLAIMED)) {		xnsynch_clear_boost(synch, synch->owner);		status = XNSYNCH_RESCHED;	}	xnlock_put_irqrestore(&nklock, s);	xnarch_post_graph_if(synch, 0, emptypq_p(&synch->pendq));	return status;}

xnflags_t xnsynch_sleep_on(struct xnsynch *synch, xnticks_t timeout,			   xntmode_t timeout_mode){	struct xnthread *thread = xnpod_current_thread();	spl_t s;	XENO_BUGON(NUCLEUS, testbits(synch->status, XNSYNCH_OWNER));	xnlock_get_irqsave(&nklock, s);	trace_mark(xn_nucleus, synch_sleepon,		   "thread %p thread_name %s synch %p",		   thread, xnthread_name(thread), synch);	if (!testbits(synch->status, XNSYNCH_PRIO)) /* i.e. FIFO */		appendpq(&synch->pendq, &thread->plink);	else /* i.e. priority-sorted */		insertpqf(&synch->pendq, &thread->plink, w_cprio(thread));	xnpod_suspend_thread(thread, XNPEND, timeout, timeout_mode, synch);	xnlock_put_irqrestore(&nklock, s);	return xnthread_test_info(thread, XNRMID|XNTIMEO|XNBREAK);}

/*! * /fn int xnintr_detach (xnintr_t *intr) * /brief Detach an interrupt object. * * Detach an interrupt object previously attached by * xnintr_attach(). After this operation is completed, no more IRQs * are directed to the object's ISR, but the interrupt object itself * remains valid. A detached interrupt object can be attached again by * a subsequent call to xnintr_attach(). * * @param intr The descriptor address of the interrupt object to * detach. * * @return 0 is returned on success. Otherwise: * * - -EINVAL is returned if a low-level error occurred while detaching * the interrupt, or if the interrupt object was not attached. In both * cases, no action is performed. * * @note The caller <b>must not</b> hold nklock when invoking this service, * this would cause deadlocks. * * Environments: * * This service can be called from: * * - Kernel module initialization/cleanup code * - Kernel-based task * * Rescheduling: never. */int xnintr_detach(xnintr_t *intr){	int ret;	trace_mark(xn_nucleus, irq_detach, "irq %u", intr->irq);	down(&intrlock);	if (!__testbits(intr->flags, XN_ISR_ATTACHED)) {		ret = -EINVAL;		goto out;	}	__clrbits(intr->flags, XN_ISR_ATTACHED);	ret = xnintr_irq_detach(intr);	if (ret)		goto out;	xnintr_stat_counter_dec(); out:	up(&intrlock);	return ret;}

void trace_mark_begin(		const char* title,		const char* args) {	if (trace_mark_enabled()) {		trace_mark('B', current->tgid, title, args, current->comm);	}}

int xnintr_attach(xnintr_t *intr, void *cookie){	int ret;	trace_mark(xn_nucleus, irq_attach, "irq %u name %s",		   intr->irq, intr->name);	intr->cookie = cookie;	memset(&intr->stat, 0, sizeof(intr->stat));#ifdef CONFIG_SMP	xnarch_set_irq_affinity(intr->irq, nkaffinity);#endif /* CONFIG_SMP */	down(&intrlock);	if (__testbits(intr->flags, XN_ISR_ATTACHED)) {		ret = -EBUSY;		goto out;	}	ret = xnintr_irq_attach(intr);	if (ret)		goto out;	__setbits(intr->flags, XN_ISR_ATTACHED);	xnintr_stat_counter_inc();out:	up(&intrlock);	return ret;}

struct xnthread *xnsynch_wakeup_one_sleeper(struct xnsynch *synch){	struct xnthread *thread = NULL;	struct xnpholder *holder;	spl_t s;	XENO_BUGON(NUCLEUS, testbits(synch->status, XNSYNCH_OWNER));	xnlock_get_irqsave(&nklock, s);	holder = getpq(&synch->pendq);	if (holder) {		thread = link2thread(holder, plink);		thread->wchan = NULL;		trace_mark(xn_nucleus, synch_wakeup_one,			   "thread %p thread_name %s synch %p",			   thread, xnthread_name(thread), synch);		xnpod_resume_thread(thread, XNPEND);	}	xnlock_put_irqrestore(&nklock, s);	xnarch_post_graph_if(synch, 0, emptypq_p(&synch->pendq));	return thread;}

/*! * /fn int xnintr_detach (xnintr_t *intr) * /brief Detach an interrupt object. * * Detach an interrupt object previously attached by * xnintr_attach(). After this operation is completed, no more IRQs * are directed to the object's ISR, but the interrupt object itself * remains valid. A detached interrupt object can be attached again by * a subsequent call to xnintr_attach(). * * @param intr The descriptor address of the interrupt object to * detach. * * @return 0 is returned on success. Otherwise: * * - -EINVAL is returned if a low-level error occurred while detaching * the interrupt, or if the interrupt object was not attached. In both * cases, no action is performed. * * @note The caller <b>must not</b> hold nklock when invoking this service, * this would cause deadlocks. * * Environments: * * This service can be called from: * * - Kernel module initialization/cleanup code * - Kernel-based task * * Rescheduling: never. */int xnintr_detach(xnintr_t *intr){	int ret;	spl_t s;	trace_mark(xn_nucleus, irq_detach, "irq %u", intr->irq);	xnlock_get_irqsave(&intrlock, s);	if (!__testbits(intr->flags, XN_ISR_ATTACHED)) {		ret = -EINVAL;		goto out;	}	__clrbits(intr->flags, XN_ISR_ATTACHED);	ret = xnintr_irq_detach(intr);	if (ret)		goto out;	xnintr_stat_counter_dec(); out:	xnlock_put_irqrestore(&intrlock, s);	return ret;}

static struct xnthread *xnsynch_release_thread(struct xnsynch *synch, struct xnthread *lastowner){	const int use_fastlock = xnsynch_fastlock_p(synch);	xnhandle_t lastownerh, newownerh;	struct xnthread *newowner;	struct xnpholder *holder;	spl_t s;	XENO_BUGON(NUCLEUS, !testbits(synch->status, XNSYNCH_OWNER));#ifdef CONFIG_XENO_OPT_PERVASIVE	if (xnthread_test_state(lastowner, XNOTHER)) {		if (xnthread_get_rescnt(lastowner) == 0)			xnshadow_send_sig(lastowner, SIGDEBUG,					  SIGDEBUG_MIGRATE_PRIOINV, 1);		else			xnthread_dec_rescnt(lastowner);	}#endif	lastownerh = xnthread_handle(lastowner);	if (use_fastlock &&	    likely(xnsynch_fast_release(xnsynch_fastlock(synch), lastownerh)))		return NULL;	xnlock_get_irqsave(&nklock, s);	trace_mark(xn_nucleus, synch_release, "synch %p", synch);	holder = getpq(&synch->pendq);	if (holder) {		newowner = link2thread(holder, plink);		newowner->wchan = NULL;		newowner->wwake = synch;		synch->owner = newowner;		xnthread_set_info(newowner, XNWAKEN);		xnpod_resume_thread(newowner, XNPEND);		if (testbits(synch->status, XNSYNCH_CLAIMED))			xnsynch_clear_boost(synch, lastowner);		newownerh = xnsynch_fast_set_claimed(xnthread_handle(newowner),						     xnsynch_pended_p(synch));	} else {		newowner = NULL;		synch->owner = NULL;		newownerh = XN_NO_HANDLE;	}	if (use_fastlock) {		xnarch_atomic_t *lockp = xnsynch_fastlock(synch);		xnarch_atomic_set(lockp, newownerh);	}	xnlock_put_irqrestore(&nklock, s);	xnarch_post_graph_if(synch, 0, emptypq_p(&synch->pendq));	return newowner;}

void xnintr_affinity(xnintr_t *intr, xnarch_cpumask_t cpumask){	trace_mark(xn_nucleus, irq_affinity, "irq %u %lu",		   intr->irq, *(unsigned long *)&cpumask);	xnarch_set_irq_affinity(intr->irq, cpumask);}

static notrace voidltt_tracer_call(unsigned long ip, unsigned long parent_ip){	int cpu = raw_smp_processor_id();	if (likely(!per_cpu(tracing_cpu, cpu)			&& !atomic_read(&system_trace_refcount)))		return;	trace_mark(ftrace_entry, "ip 0x%lX parent_ip 0x%lX", ip, parent_ip);}

int ext4_sync_file(struct file *file, struct dentry *dentry, int datasync){	struct inode *inode = dentry->d_inode;	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;	int ret = 0;	J_ASSERT(ext4_journal_current_handle() == NULL);	trace_mark(ext4_sync_file, "dev %s datasync %d ino %ld parent %ld",		   inode->i_sb->s_id, datasync, inode->i_ino,		   dentry->d_parent->d_inode->i_ino);	/*	 * data=writeback:	 *  The caller's filemap_fdatawrite()/wait will sync the data.	 *  sync_inode() will sync the metadata	 *	 * data=ordered:	 *  The caller's filemap_fdatawrite() will write the data and	 *  sync_inode() will write the inode if it is dirty.  Then the caller's	 *  filemap_fdatawait() will wait on the pages.	 *	 * data=journal:	 *  filemap_fdatawrite won't do anything (the buffers are clean).	 *  ext4_force_commit will write the file data into the journal and	 *  will wait on that.	 *  filemap_fdatawait() will encounter a ton of newly-dirtied pages	 *  (they were dirtied by commit).  But that's OK - the blocks are	 *  safe in-journal, which is all fsync() needs to ensure.	 */	if (ext4_should_journal_data(inode)) {		ret = ext4_force_commit(inode->i_sb);		goto out;	}	if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))		goto out;	/*	 * The VFS has written the file data.  If the inode is unaltered	 * then we need not start a commit.	 */	if (inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC)) {		struct writeback_control wbc = {			.sync_mode = WB_SYNC_ALL,			.nr_to_write = 0, /* sys_fsync did this */		};		ret = sync_inode(inode, &wbc);		if (journal && (journal->j_flags & JBD2_BARRIER))			blkdev_issue_flush(inode->i_sb->s_bdev, NULL);	}out:	return ret;}

void trace_mark_finish(		unsigned char* name,		unsigned long cookie) {	if (trace_mark_enabled()) {		char args[TRACE_MARK_STR_LEN];		snprintf(args, TRACE_MARK_STR_LEN, "%ld", cookie);		trace_mark('F', current->tgid, name, args, current->comm);	}}

static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,			     u32 pid){	struct in_device *in_dev = ifa->ifa_dev;	struct in_ifaddr *ifa1, **ifap, **last_primary;	ASSERT_RTNL();	if (!ifa->ifa_local) {		inet_free_ifa(ifa);		return 0;	}	ifa->ifa_flags &= ~IFA_F_SECONDARY;	last_primary = &in_dev->ifa_list;	for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;	     ifap = &ifa1->ifa_next) {		if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&		    ifa->ifa_scope <= ifa1->ifa_scope)			last_primary = &ifa1->ifa_next;		if (ifa1->ifa_mask == ifa->ifa_mask &&		    inet_ifa_match(ifa1->ifa_address, ifa)) {			if (ifa1->ifa_local == ifa->ifa_local) {				inet_free_ifa(ifa);				return -EEXIST;			}			if (ifa1->ifa_scope != ifa->ifa_scope) {				inet_free_ifa(ifa);				return -EINVAL;			}			ifa->ifa_flags |= IFA_F_SECONDARY;		}		trace_mark(net_insert_ifa_ipv4, "label %s address #4u%lu",			ifa->ifa_label,			(unsigned long)ifa->ifa_address);	}	if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {		net_srandom(ifa->ifa_local);		ifap = last_primary;	}	ifa->ifa_next = *ifap;	*ifap = ifa;	/* Send message first, then call notifier.	   Notifier will trigger FIB update, so that	   listeners of netlink will know about new ifaddr */	rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);	return 0;}

asmlinkage int printk(const char *fmt, ...){    va_list args;    int r;    va_start(args, fmt);    trace_mark(kernel_printk, "ip %p", __builtin_return_address(0));    r = vprintk(fmt, args);    va_end(args);    return r;}

void trace_mark_int(		unsigned long ppid,		const char* name,		unsigned long value,		const char* category) {	if (trace_mark_enabled()) {		char args[TRACE_MARK_STR_LEN];		snprintf(args, TRACE_MARK_STR_LEN, "%ld", value);		trace_mark('C', ppid, name, args, category);	}}

struct xnthread *xnsynch_release(struct xnsynch *synch){	const int use_fastlock = xnsynch_fastlock_p(synch);	struct xnthread *newowner, *lastowner;	xnhandle_t lastownerh, newownerh;	struct xnpholder *holder;	spl_t s;	XENO_BUGON(NUCLEUS, !testbits(synch->status, XNSYNCH_OWNER));	lastownerh = xnthread_handle(xnpod_current_thread());	if (use_fastlock &&	    likely(xnsynch_fast_release(xnsynch_fastlock(synch), lastownerh)))		return NULL;	xnlock_get_irqsave(&nklock, s);	trace_mark(xn_nucleus, synch_release, "synch %p", synch);	holder = getpq(&synch->pendq);	if (holder) {		newowner = link2thread(holder, plink);		newowner->wchan = NULL;		newowner->wwake = synch;		lastowner = synch->owner;		synch->owner = newowner;		xnthread_set_info(newowner, XNWAKEN);		xnpod_resume_thread(newowner, XNPEND);		if (testbits(synch->status, XNSYNCH_CLAIMED))			xnsynch_clear_boost(synch, lastowner);		newownerh = xnsynch_fast_set_claimed(xnthread_handle(newowner),						     xnsynch_pended_p(synch));	} else {		newowner = NULL;		synch->owner = NULL;		newownerh = XN_NO_HANDLE;	}	if (use_fastlock) {		xnarch_atomic_t *lockp = xnsynch_fastlock(synch);		xnarch_atomic_set(lockp, newownerh);	}	xnlock_put_irqrestore(&nklock, s);	xnarch_post_graph_if(synch, 0, emptypq_p(&synch->pendq));	return newowner;}