This file is indexed.

/usr/include/sptrace.h is in libion-dev 3.2.1+dfsg-1.1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*

	sptrace.h:	API for using the sptrace space utilization
			trace system.  sptrace is designed to monitor
			space utilization in a generic heap, i.e., a
			region of "space" (nominally memory; possibly
			shared and possibly persistent) with a flat
			address space.  Its main purpose is finding
			leaks.

	Copyright (c) 2002 California Institute of Technology.
	ALL RIGHTS RESERVED.  U.S. Government Sponsorship
	acknowledged.

	Author: Scott Burleigh, JPL
	
	Modification History:
	Date      Who	What
	11-30-02  SCB   Original development.

									*/
#include "psm.h"

#ifndef _SPTRACE_H_
#define _SPTRACE_H_

#ifdef __cplusplus
extern "C" {
#endif

extern PsmPartition	sptrace_start(int key, int size, char *region,
					PsmPartition psm, char *name);
			/*	Begins an episode of heap usage
				tracing.  The shared memory key
				specifies the region of shared memory
				to use for the operations of this
				trace episode; a shared memory region
				of the indicated size will be dynamically
				allocated (unless the region argument
				is non-NULL) and the PSM space
				management structure for that region
				will also be dynamically allocated
				unless the psm argument is non-NULL.
				The name argument specifies an episode
				label that will be used in messages
				issued by the trace operations; it
				may be helpful to use a name that
				meaningfully describes the heap that's
				being traced (you can trace in multiple
				heaps at the same time) or the trace
				episode's purpose.  If the sptrace
				episode uniquely identified by the
				shared memory key already exists, the
				effect is the same as sptrace_join
				(below).  On success, returns a space
				management handle for the episode's
				PSM-managed shared memory region.
				Returns NULL on any error.		*/

extern PsmPartition	sptrace_join(int key, int size, char *region,
					PsmPartition psm, char *name);
			/*	Locates the sptrace episode identified
				by key (see sptrace_start), verifies
				size, region, and name against that
				episode, and returns a space management
				handle for the episode's PSM-managed
				shared memory region; the PSM space
				management structure that the handle
				points to will be be dynamically
				allocated as needed unless the psm
				argument is non-NULL.  If no such
				sptrace episode exists, or on any
				other error, returns NULL.		*/

extern void		sptrace_log_alloc(PsmPartition trace,
					unsigned long addr, int size,
					char *fileName, int lineNbr);
			/*	Causes sptrace to log a space allocation
				event in the indicated sptrace episode.
				addr and size are the address and size
				of the newly allocated object.  fileName
				and lineNbr identify the line of
				application source code at which the
				activity being logged was initiated.	*/

extern void		sptrace_log_free(PsmPartition trace, unsigned long addr,
					char *fileName, int lineNbr);
			/*	Causes sptrace to log a space release
				event.  addr is the address of the newly
				freed object.  fileName and lineNbr
				identify the line of application source
				code at which the activity being logged
				was initiated.				*/

extern void		sptrace_log_memo(PsmPartition trace, unsigned long addr,
					char *msg, char *fileName, int lineNbr);
			/*	Causes sptrace to log a heap management
				memo.  addr is the address to which the
				memo refers; msg is the memo text.
				fileName and lineNbr identify the line
				of application source code at which the
				activity being logged was initiated.	*/

extern void		sptrace_report(PsmPartition trace, int verbose);
			/*	Prints a report from the trace log,
				starting at the beginning of the trace
				episode, using the writeMemo function
				in 'platform'.  If the 'verbose' flag
				is zero, only exceptions (e.g., objects
				that have been allocated but not yet
				freed) and memos are printed; if it is
				non-zero, the entire log is printed.	*/

extern void		sptrace_clear(PsmPartition trace);
			/*	Deletes from the trace log all
				allocation events for which matching
				release events have been logged, and
				also deletes those matching release
				events, leaving only events that would
				be reportable as exceptions.  Enables
				trace to run for a long time without
				running out of log space.		*/

extern void		sptrace_stop(PsmPartition trace);
			/*	Ends the current episode of Sptrace
				space management tracing and releases
				the shared memory allocated to the
				trace operations.			*/

#ifdef __cplusplus
}
#endif

#endif  /* _SPTRACE_H_ */