Vue 函数

add_range(range_t range_data, String S1, String S2, ..., String Sn);

range_data

range_t 数据类型。

S1, S2,...

要添加到 range_data 参数的字符串。

void append ( List listvar, long long val );

append 函数是 Vue中唯一可用的列表并置函数。 它会将第二个参数指定的值追加到第一个参数指定的列表变量。 每次调用 append 函数时都会将新值添加到已保存在列表变量中的值集合，因此列表变量的大小会增加。 append 函数也接受使用其他列表作为参数，从而允许您连接两个列表。

append 函数没有返回值。

有关列表数据类型的更多信息，请参阅 列表类型。 前面的 list 部分有一个使用 append 函数的示例脚本。

int atoi( String str ); 

atoi 函数将返回整数，该整数的值由 str 参数指定的字符串表示。 它会读取字符串，直到读取到第一个非数字 (0-9) 字符为止，然后将扫描的字符转换为等效的整数。 将忽略前导空格字符，可选的符号指示符可位于数字的前面。

当运行将所有参数都用双引号引起的 sprobevue shell 脚本时，atoi 函数在将字符串转换回整数时会很有用。 以下脚本是比预期更快捕获进程派生的示例。

/* File: ffork.e 
 *
 * Usage: sprobevue ffork.e processname delta
 *
 *	Traces whenever a specified process is forking faster than
 *	the "delta" value passed. Specify a process name and the time
 *	in milliseconds as parameters.
 */

/* Ignore other parameters to execve */
int execve(char *path);

@@BEGIN
{
	int done;
	int pid;

	pname = $1;		/* name of process we are monitoring */

	/* 
	 * Since sprobevue is used, need to extract the integer value
	 * from the string (double quotes around the delta).
	 */
	delta = atoi($2);	/* minimum delta in millisecs between forks */
	printf("pname = %s, delta = %d\n", pname, delta);
}

@@syscall:*:execve:entry
	when (done == 0)
{
	__auto String exec[128];
	__thread int myproc;

	/* Find process being 'exec'ed */
	exec = get_userstring(__arg1, 128);

	/* Got it. Set a thread-local and reset 'done' so that we 
	 * avoid entering this probe from now on.
	 */
	if (exec == pname) {
		pid = __pid;
		myproc = 1;
		done = 1;
		printf("Process name = %s, pid = %d\n", __pname, pid);
	}
}

@@syscall:*:fork:entry
	when (thread:myproc == 1)
{
	/* old_ts is initialized to zero */
	probev_timestamp_t old_ts, new_ts;
	unsigned long long interval;

	/* Get current time stamp */
	new_ts = timestamp();

	/* Find time from last fork */
	if (old_ts != 0) {
		interval = diff_time(old_ts, new_ts, MILLISECONDS);

		/* if below the specified limit, trace that */
		if (interval < delta)
			printf("%s (%ld) forking too fast (%d milliseconds)\n",
					pname, __pid, interval);
	}

	/* Save current fork timestamp */
	old_ts = new_ts;
}

@@syscall:*:exit:entry
	when (__pid == pid)
{
	/* Catch process exit and terminate ourselves */
	printf("Process '%s' exited.\n", pname);
	exit();
}

long long avg ( List listvar );

avg 函数返回已追加到列表变量（由 listvar 参数指定）的所有元素的平均值。

void commit_tentative( String bufID );
void discard_tentative( String bufID );

commit_tentative 函数落实与 bufID 参数标识的试探性跟踪缓冲区相关联的跟踪数据。 这将保存数据并将其提供给跟踪使用程序。

discard_tentative 函数废弃 bufID 参数表示的试探性跟踪缓冲区中的所有数据。 这样将释放跟踪缓冲区中由试探性跟踪数据所占据的空间。

在将试探性跟踪数据与常规跟踪数据一起保存的情况下，会先将试探性跟踪数据以时间戳记顺序提供给跟踪使用程序，然后将已落实的跟踪数据与常规跟踪数据以时间戳记的顺序提供给跟踪使用程序。 因此，较早地落实或废弃试探数据以释放跟踪缓冲区是较好的做法。

当 ProbeVue 会话结束时，将废弃所有尚未落实的暂定跟踪数据。

试探性跟踪 主题更详细地描述试探性跟踪，并包含使用试探性跟踪的示例 Vue 脚本。

ipv4_data

指定需要转换为 ip_addr_t 格式的 IPv4 地址数据。

ip_addr_t convert_ip6_addr (int *ipv6_data);

ipv6_data

指定需要转换为 ip_addr_t 格式的 IPv6 地址数据。

/* Declare the Function prototype */
int sendto(int s,  char * uap_buf,   int len,  int flags,  char * uap_to,  int tolen);

typedef unsigned int in_addr_t;

/* Structure Declarations */

/* Declare the in_addr structure */
struct in_addr {
        in_addr_t        s_addr;
};

/* Declare the sockaddr_in structure */
struct sockaddr_in {
        unsigned char           sin_len;
        unsigned char           sin_family;
        unsigned short          sin_port;
        struct in_addr          sin_addr;
        unsigned char           sin_zero[8];
};
/* Declare the in6_addr structure */
struct in6_addr {
        union {
                int s6_addr32[4];
                unsigned short s6_addr16[8];
                unsigned char  s6_addr8[16];
        } s6_addr;
};
/* Declare the sockaddr_in6 structure */
struct sockaddr_in6 {
        unsigned char          sin6_len;
        unsigned char          sin6_family;
        unsigned short         sin6_port;
        unsigned int           sin6_flowinfo;
        struct   in6_addr      sin6_addr;
        unsigned int           sin6_scope_id;  /* set of interfaces for a scope */
};


/* Print the information about to whom it is sending data */
@@syscall:*:sendto:entry
{
        struct sockaddr_in6 in6;
        struct sockaddr_in in4;
        ip_addr_t ip;

                /* Copy the arg5 data into sockaddr_storage variable */
                /* using copy_userdata( ) Vue function */
        copy_userdata(__arg5, in4);

       /*
        * Verify  whether the destination address is IPv4 or IPv6 and based on that call the
        * corresponding IPv4 or IPV6 conversion routine.
        */
       if (in4.sin_family == AF_INET)
       {
               /* Copy the ipv4 data into sockaddr_in structure using copy_userdata routine */
                copy_userdata(__arg5, in4);

               /* Convert Ipv4 data into ip_addr_t format */
                ip = convert_ip4_addr(in4.sin_addr.s_addr);

               /* Print the destination address and hostname  using %H and %I format specifier */
               printf("It is sending the data to node %H(%I)\n",ip,ip);
        }
        else if(in4.sin_family == AF_INET6)
        {
              /* Copy the ipv6 data into sockaddr_in6 structure using copy_userdata routine */
               copy_userdata(__arg5, in6);

              /* Convert Ipv6 data into ip_addr_t format */
               ip = convert_ip6_addr(in6.sin6_addr.s6_addr.s6_addr32);

              /* Print the destination address and hostname using %H and %I format specifier */
              printf("It is sending the data to node %H(%I)\n", ip,ip);
        }
}

long long count ( List listvar );

count 函数返回已追加到列表变量（由 listvar 参数指定）的元素数目。

有关列表数据类型的更多信息，请参阅 Vue 中的数据类型。 前面的 list 部分有一个使用 count 函数的示例脚本。

void copy_kdata( <type> *kaddr,<type>svar);

copy_kdata 函数将数据从内核内存读取到 Vue 脚本变量中。 该变量可以是 Vue 支持的任何 C-89 类型 (指针类型除外)。 所复制的长度等于变量的大小。 例如，如果目标 Vue 脚本变量的类型为 int ，那么将复制 4 个字节，如果它的类型为 long long ，那么将复制 8 个字节，如果它是由 12 个整数或 int [12] 组成的数组，那么将复制 48 个字节。

必须先复制内核空间中的数据，然后才能在表达式中使用该数据或将其作为参数传递到 Vue 函数。

如果在进程运行此函数时发生异常，例如，将错误的内核地址传递到该函数时， ProbeVue 会话将异常中止并返回错误消息。

kaddr

指定内核空间数据的地址。

svar

指定在其中复制内核数据的脚本变量。 脚本变量类型可以是“内核数据”类型。

void copy_userdata( <type> *uaddr,<type>svar);

copy_userdata 函数将数据从用户内存读取到 Vue 脚本变量中。 该变量可以是 Vue 支持的任何 C-89 类型。 所复制的长度等于变量类型的大小。 例如，如果目标 Vue 脚本变量的类型为 int ，那么将复制 4 个字节，如果它的类型为 long long ，那么将复制 8 个字节，如果它是由 12 个整数或 int [12] 组成的数组，那么将复制 48 个字节。

必须先复制用户空间中的数据，然后才能在表达式中使用该数据或将其作为参数传递到 Vue 函数。

如果在进程运行此函数时发生异常 (例如，将错误的用户地址传递到该函数时) ，那么 ProbeVue 会话将异常中止，并返回错误消息。

uaddr

指定用户空间数据的地址。

svar

指定在其中复制用户数据的脚本变量。 脚本变量类型必须是“用户数据”类型。

unsigned long long diff_time( probev_timestamp_t ts1, probev_timestamp_t ts2, intformat );

diff_time 函数返回使用 timestamp 函数记录的两个时间戳记之间的时间差。 此函数可返回由 format 参数指定的时间差（以微秒或毫秒计）。

get_location_point 和 list 部分具有使用 diff_time 函数的示例脚本。

void eprintf ( String format[ , data, ... ]);

eprintf 函数与 printf 函数类似，只是将输出发送到标准错误。 eprintf 函数在格式参数的控制下，对数据参数值进行转换，设置格式并且将其复制到跟踪缓冲区。 正如语法所示，不断变化的参数列表可作为数据参数传送至 eprintf 函数。 Vue 支持 C 库提供的 printf 子例程支持的所有转换说明符，%p 转换说明符除外。

eprintf 函数不能用于显示类型为 list 的变量。 但是，类型为 string 的变量可使用 %s 转换说明符进行显示。 类型为 probev_timestamp_t 的变量以数字格式（通过使用 %lld 或 %16llx 说明符）显示。 类型为 probev_timestamp_t 的变量以日期格式（通过使用 %A 或 %W 说明符）显示。

格式

一个字符串，它包含不经任何更改就直接复制到跟踪缓冲区的纯字符。 另外一个或多个转换说明符用于指示如何设置数据参数格式。

数据

指定与格式参数中的转换说明符相对应的零个或多个参数。

void exit();

exit 函数终止 Vue 脚本。 这将禁用在动态跟踪会话中启用的所有调查、废弃任何试探性跟踪数据、发出在 @@END 调查中指示的操作并将所有捕获的跟踪数据放入跟踪使用程序中。 跟踪使用程序显示在 @@END 调查中所跟踪的所有输出后，跟踪会话将终止且 probevue 进程将退出。

如果该进程作为前台任务运行，那么在发出 probevue 命令的终端上输入 Ctrl-C 可获得相同的效果。 或者，可以使用 kill 命令或 kill 系统调用来直接将 SIGINT 发送到 probevue 进程。

list 部分具有使用 exit 函数的示例脚本。 atoi 部分包含一个示例脚本，用于说明如何在您正在探测的进程终止的同时退出。

char * fd_fname(int fd); 

此函数获取特定文件描述符的文件的名称。 此函数返回的值与 __file->fname（指 I/O 探针管理器的 __file 内置项）针对同一文件返回的值相同。

fd

文件或套接字描述符值

int fd_fstype(int fd);

fd

文件描述符值

int fd_ftype(int fd);

此函数获取特定文件描述符的文件类型。 此函数返回的值与 __file->f_type（指 I/O 探针管理器的 __file 内置项）返回的值相同。

fd

文件描述符值

unsigned long long fd_inodeid(int fd);

此函数返回与特定文件描述符相关的文件的索引节点标识。 此索引节点标识是系统范围唯一的 unsigned long long 值（它与文件系统索引节点号不同，系统重新引导时可更改值）。 此值与 fpath_inodeid() 函数针对同一文件返回的值相匹配。

fd

文件描述符值

char * fd_mpath(int fd);

此函数获取特定文件描述符的文件所属文件系统的安装路径。 此函数返回的值与 __file->mount_path（指 I/O 探针管理器的 __file 内置项）针对同一文件返回的值相同。

fd

文件描述符值

path_t fd_path(int fd); 

此函数返回特定文件描述符的文件的绝对路径。 返回值的类型为 path_t。 对于同一文件，它返回与 __file-> path (请参阅 I/O 探针管理器的 __file 内置文件) 的值相同的值。

fd

文件描述符值

unsigned long long fpath_inodeid(String file_path); 

此函数返回特定文件路径的索引节点标识。 此索引节点标识是系统范围唯一的 unsigned long long 值（它与文件系统索引节点号不同，系统重新启动时可更改值）。 如果该文件路径不存在，那么 Vue 脚本被 probevue 命令拒绝。 索引节点标识值与相同文件 (请参阅 I/O 探针管理器的 __file 内置文件) 的 vfs 探针事件中的 __file-> inode_id 提供的值相同。

file_path

带双引号的文字串，表示现有文件。 例如，"/usr/lib/boot/unix_64"。 它不能是变量。

String get_function ( );

get_function 函数返回被探测函数的名称，被探测函数是包括当前探针点的函数。 通常，被探测函数的名称是位置字段前的探针点元组字段。

前面的 get_probe 部分具有使用 get_function 函数的示例脚本。

当从时间间隔探针管理器进行调用时，get_function 函数会返回空字符串。

get_function 函数不采用任何参数。

String get_kstring( char *kaddr,int len);

get_kstring 函数将内核存储器中的数据读取到类型为 String 的变量中。

必须先复制内核空间中的字符串，然后才能在表达式中使用这些字符串或将其作为参数传递到 Vue 函数。

get_kstring 函数的目标必须始终是类型为 String 的变量。 如果为 len 参数指定值 -1 ，那么将从内核内存复制数据，直到读取 NULL 字节 (使用 NULL 字节来停止 C 语言的文本字符串)。 如果字符串长度大于目标 String 变量的声明大小，那么仅会将变量大小以内的字符串字符复制到该变量。 但是，整条字符串（即读取到 NULL 字节之前的字符串）最初将复制到临时字符串缓冲区。 函数的用户必须注意内核地址指向以 NULL 结束的字符串，以避免临时字符串缓冲区溢出，这将导致 ProbeVue 会话停止。

可以通过指定 len 参数的非负值来修改从内核存储器读取的字符串的最大长度。 在这种情况下，直到读取到 NULL 字节或者直到读取了指定的字节数之前，复制都会继续进行。 该功能允许更安全地复制内核内存中的长字符串，因为复制受到 "len参数值的限制，不会导致ProbeVue 内部临时字符串缓冲区溢出。

如果在此函数运行时发生异常 (例如，将错误的内核地址传递到该函数时) ，那么 ProbeVue 会话将异常中止并返回错误消息。

addr

指定内核空间数据的地址。

len

指定要复制的内核数据的字节数。 值 -1 表示会将内核数据视作“C”字符串且复制继续进行，直到读取到 NULL 字节（“\0”字符）为止。 将 -1 指定为 len 参数的值时须谨慎。

int get_location_point ( );

get_location_point 函数返回从外层函数入口点开始的当前调查位置点。 具体地说，如果探针点位于函数的入口点，那么它将返回 FUNCTION_ENTRY 或零；如果探针点位于任何出口点，那么它将返回 FUNCTION_EXIT 或 -1；其他情况将返回实际的地址偏移量。

以下脚本显示使用 get_location_point 函数的示例：

@@syscall:$1:read:entry, @@syscall:$1:read:exit
	{
		probev_timestamp_t ts1, ts2;
		int diff;

		if (get_location_point() == FUNCTION_ENTRY) 
			ts1 = timestamp();
		else if (get_location_point() == FUNCTION_EXIT) {
			ts2 = timestamp();
			diff = diff_time(ts1, ts2, MICROSECONDS);
			printf("Time for read system call = %d\n", diff);
		}
	}

不支持从时间间隔探针管理器调用此函数。

get_location_point 函数不采用任何参数。

String get_probe ( );

get_probe 函数返回当前探针点规范的内部说明。 当在内部保存时，探针点不会包括初始的 @@ 前缀或进程标识（如果有的话）。

以下脚本显示了使用 get_probe 函数的示例：

#cat get_probe.e 
	@@uft:312678:*:run_prog:entry
	{
		printf("function '%s' probe '%s'\n", get_function(), get_probe());
	}

	#probevue get_probe.e
	function 'run_prog' probe 'uft:*:*:run_prog:entry'

get_probe 函数不采用任何参数。

stktrace_t get_stktrace(int level); 

get_stktrace 函数返回当前线程的堆栈跟踪。 此堆栈跟踪存储在 stktrace_t 类型变量中，或者在使用 ProbeVue 内置 printf 函数中的 %t 或 %T 说明符时打印。 level 参数表示堆栈跟踪显示至的层次编号。 在 printf 函数内使用的 get_stktrace 函数的行为与 stktrace 内置函数类似。 唯一的区别是，当 %t 说明符用于正在运行的线程时，将打印带有地址的符号，否则将打印原始地址。 而且，它会通过遍历所有机器状态来显示完整 CPU 堆栈。

以下脚本显示了使用 get_stktrace 函数的示例：

t1 = get_stktrace(3)                // Returns the current stack trace & stores in stktrace_t 
                                   // type variable t1.
printf('%t\n', get_stktrace(4));  // Prints the current stack trace up to level 4.                                                          
                                 // Prints symbol with addresses.

printf(“%T\n”, get_stktrace(4));  // Prints the current stack trace up to level 4
                                  // Prints raw addresses.

int get_ubytes(void *src, char *dest, int len); 

get_ubytes 函数将 len 字节的数据从用户内存读取到 Vue 脚本变量中。 变量可以是字符指针类型。 复制的数据的长度等于传递给此函数的 len 参数或目标 Vue 变量的大小。 如果 len 值大于目标 Vue 变量的大小，那么复制的数据长度等于目标变量的大小。 必须先将用户空间中的数据复制到 Vue 变量，然后才能在表达式中使用数据或将数据作为参数传递到 Vue 函数。

get_ubytes函数返回成功复制的字节总数，失败时返回-1。 如果函数运行时出现异常，例如向函数传递了错误的用户地址，ProbeVue会话将以错误信息结束。

int get_kbytes(void *src, char *dest, int len);

get_kdata 函数将 len 字节的数据从内核内存读取到 Vue 脚本变量中。 变量可以是字符指针类型。 复制的数据的长度等于传递给此函数的 len 参数或目标 Vue 变量的大小。 如果 len 值大于目标 Vue 变量的大小，那么复制的数据长度等于目标变量的大小。 必须先将用户空间中的数据复制到 Vue 变量，然后才能在表达式中使用数据或将数据作为参数传递到 Vue 函数。

get_kbytes函数返回成功复制的字节总数，失败时返回-1。 如果函数运行时出现异常，例如向函数传递了错误的内核地址，ProbeVue会话将以错误信息结束。

String get_userstring( char * addr, int len );

get_userstring 函数将用户内存中的数据读取到类型为 String 的变量中。

必须先复制用户空间中的数据，然后才能在表达式中使用该数据或将其作为参数传递到 Vue 函数。 get_userstring 函数的目标通常是类型为 String 的变量。 如果为 len 参数指定了值 -1，那么将从用户内存中复制数据，直到读取到 NULL 字节为止（NULL 字节将用于结束 C 语言中的文本字符串）。 如果字符串长度大于目标 String 变量的声明大小，那么仅会将变量大小以内的字符串字符复制到该变量。 但是，整条字符串（即读取到 NULL 字节之前的字符串）最初将需要复制到临时字符串缓冲区。 该函数的用户需要注意用户地址是否指向以 NULL 结尾的字符串，以避免临时字符串缓冲区溢出而导致ProbeVue会话中止。

仅在用户空间调查（如 uft 调查类型）或 syscall 探针管理器提供的调查中允许使用此函数。 如果在复制数据时发生缺页故障，那么复制操作将终止且字符串变量将仅包含已成功复制的数据。 如果在发出此函数时发生异常 (例如，将错误的用户地址传递到该函数时) ，那么 ProbeVue 会话将异常中止并返回错误消息。

ProbeVue 动态跟踪工具 具有使用 get_userstring 函数的示例脚本。

/* File: string2int.e
 *
 * Reads an integer passed in a pointer using get_userstring()
 *
 */
int get_file_sizep(int *fd);

@@BEGIN
{
	
	int i;
}

@@uft:$1:*:get_file_sizep:entry
{
	i = *(int *)(get_userstring(__arg1, 4));

	printf("fd = %d\n", i);
}

group_output_start() 函数对子句的输出进行分组。 在 group_output_start() 函数调用之后和 group_output_end() 函数调用之前由子句的 VUE 语句生成的输出消息不会被从可能同时在其他 CPU 中运行的子句生成的消息所交织。

void group_output_end();

停止对子句的输出进行分组。 任何后续 VUE 语句 (如果有) 都将没有分组输出，并且可以通过来自在其他 CPU 中同时运行的子句的输出消息进行交织。 对 group_output_end() 函数的调用必须以 group_output_start() 调用开头。 调用 group_output_start() 函数后，调用 group_output_end() 函数是可选的。 如果未调用 group_output_end() 函数，那么将对输出进行分组，直到子句结束为止。

List list ( );

list 函数是列表数据类型的构造函数。 它会返回空列表并将目标自动声明为列表数据类型。 不存在将变量声明为列表数据类型的显式方法。 列表变量总是创建为全局类的变量。

list 函数可从任何子句进行调用。 如果在调用 list 函数时指定了现有的列表名称，那么会清除现有列表。

列表变量可用于收集整数类型的值。 存储在列表中的任何值将自动提升为 long long（或 64 位整数）数据类型。

以下脚本显示使用 list 函数的示例。 它假定 sprobevue shell 程序 (将每个自变量括在双引号内) 调用 Vue 脚本。

/* File: list.e
 * 
 * Collect execution time for read system call statistics
 *
 * Usage: sprobevue list.e <-s|-d>
 *
 *	Pass -s for summary and -d for detailed information
 */

int read(int fd, void *buf, int n);

@@BEGIN
{
	String s[10];
	int detail;
	times = list();		/* declare and create a list */

	/* Check for parameters */
	s = $1;
	if (s == "-d") 
		detail = 1;
	else if (s == "-s")
		detail = 0;
	else {
		printf("Usage: sprobevue list.e <-s|-d>\n");
		exit();
	}
}

@@syscall:*:read:entry
{
	/*
	 * Save entry time in a thread-local to ensure that 
	 * in the read:exit probe point we can access our thread's value for 
	 * entry timestamp. If we use a global, then the variable can be
	 * overlaid by the next thread to enter read and this can give
	 * wrong values when we try to find the difference at read:exit
	 * time since we use this later value instead of the original value.
	 */

	__thread probev_timestamp_t t1;
	t1 = timestamp();
}

@@syscall:*:read:exit
	when (thread:t1 != 0)
{
	__auto t2;
	__auto long difft;

	/* Get exit time */
	t2 = timestamp();
	difft = diff_time(t1, t2, MICROSECONDS);

	/* Append read time to list */
	append(times, difft);

	/* print detail data if "-d" was passed to script */
	if (detail)
		printf("%s (%ld) read time = %d micros\n", __pname, __pid, difft);
}

@@interval:*:clock:10000
{
	/* Print statistics every 10 seconds */
	printf("Read calls so far = %d, total time = %d, max time = %d, " +
	       "min = %d, avg = %d\n",
			count(times),
			sum(times),
			max(times),
			min(times),
			avg(times));
}

list 函数不采用任何参数。

void lquantize( aso-name ,int num-of-entries, int flags, sort_key_ind)

此函数根据关联数组值的对数值以图形格式显示关联数组的条目。 如果要仅打印具有特定键集的元素，那么可以在第一个自变量中随关联数组变量名一起指定这些键。 要仅限制特定维度键并允许其他键的任何值，可以使用 ANY 关键字。 例如，请参阅 "参考 print() 函数" 部分。

第一个参数是必需的，所有其他参数都是可选的。 如果不指定可选参数，那么将使用缺省打印选项。

aso-name

要打印的关联数组变量的名称。 您还可以在方括号中指定所有维度的键。 您可以使用 ANY 关键字来匹配键维度中的所有键。

条目数

指定要打印的条目数。 此参数是可选的。 指定 0 以显示所有条目。 如果未指定任何值，那么将使用会话的缺省打印选项。 任何负值都等同于 0。

标志

指定 sort-type、sort-by 和 list-value 标记。 此参数是可选的。 在 "关联数组类型" 部分下描述了标记排序类型，排序依据和列表值。 如果指定 0 ，那么将使用会话的缺省打印选项。

sort_key_ind

用于对输出进行排序的键 (键维度) 的索引。 如果指定-1，则使用第一个键进行排序。 如果第一个键不是可排序类型，那么不会对输出进行排序。

long long max ( List listvar );

max 函数返回已追加到列表变量（由 listvar 参数指定）的最大元素数目。

有关列表数据类型的更多信息，请参阅 ProbeVue 动态跟踪工具 主题。 前面的 listvar 部分具有使用 max 函数的示例脚本。

listvar：指定类型为 list 的变量。

long long min ( List listvar );

min 函数返回已追加到列表变量（由 listvar 参数指定）的最小元素数目。

前面的 listvar 部分具有使用 min 函数的示例脚本。

listvar：指定类型为 list 的变量。

void print_args(); 

print_args 函数可显示圆括号中括起的以逗号分隔的函数参数后面的函数名。 将根据函数的可跟踪表中可用的参数类型信息来显示参数值。 uft/uftxlc++ 和 syscall/syscallx 调查的入口调查中允许此例程。 当调查位置指定为正则表达式时，这在调查中很有用。

print_args 函数不采用任何参数。

void print ( aso-name , int num-of-entires , int flags, int sort_key_ind );

此函数打印由变量 aso-name指定的关联数组的元素。 要仅打印具有一组特定键的元素，可以在第一个自变量中指定具有关联数组变量名称的键。 要仅限制特定维度键并允许所有其他键的任何值，请使用 ANY 关键字。

print(aso_var[0][ANY][ANY]);    // print all elements having first key as 0 (other keys can be anything)
print(aso_var[ANY][ANY][ANY]);  // print all; equivalent to print(aso_var);

第一个参数是必需的，所有其他参数都是可选的。 如果未指定可选参数，那么将使用缺省打印选项。

aso1[0][“a”][2.5] = 100;
aso1[1][“b”][3.5] = 101;
print(aso1);
The output from previous print() function follows:
[key1               |    key2                |    key3]               |    value
0                   |    a                   |    2.5000000           |    100
1                   |    b                   |    3.5000000           |    101

aso2[0][get_stktrace(-1)] = “abc”;
print(aso2);

The output from print() function above will be similar to:
[key1               |    key2]                                   |    value
0
                    |
                         0x100001b8
                         0x10003328
                         0x1000166c
                         0x10000c30
                         .read+0x288
                         sc_entry_etrc_point+0x4
                         .kread+0x0
                                                                 |
                                                                      abc

aso-name

要打印的关联数组变量的名称。 您还可以在方括号中指定所有维度的键。 您可以使用 ANY 关键字来匹配键维度中的所有键。

实体数

指定要打印的条目数。 此参数是可选的。 指定 0 以显示所有条目。 如果未指定任何值，那么将使用会话的缺省打印选项。 任何负值都等同于 0。

标志

指定 sort-type、sort-by 和 list-value 标记。 此参数是可选的。 在 "关联数组类型" 部分下描述了标记排序类型，排序依据和列表值。 如果指定 0 ，那么将使用会话的缺省打印选项。

sort_key_ind

键索引 (键维度) 用于对输出进行排序。 如果指定-1，则使用第一个键进行排序。 如果第一个键不是可排序类型，那么不会对输出进行排序。

void printf ( String format[ , data, ... ]);

printf 函数在格式参数的控制下，对 data 参数值进行转换、设置格式并将其复制到跟踪缓冲区。 正如语法所示，不断变化的参数列表可作为 data 参数传送至 printf 函数。 Vue 支持 C 库提供的 printf 子例程支持的所有转换说明符，但 %p 转换说明符除外。

除了 C 库的 printf() 说明符外，Vue 语言还支持另外两个说明符：%A 和 %W。

%A

以缺省日期格式打印 probev_timestamp_t "t"。 可使用 set_date_format() 函数更改此格式。

%W

打印相对于 probevue 会话启动的 probev_timestamp_t 't' (以秒和微秒为单位)。

%p

打印与指定 path_t 值的绝对文件路径对应的字符串。

%M

打印指定的 mac_addr_t 值的 MAC 地址。

%I

打印 ipv4 地址的点分十进制格式的 IP 地址，以及指定 ip_addr_t 值的 IPV6 地址的点分十六进制格式的 IP 地址

%H

以字符串或指定 ip_addr_t 值的点分十进制或十六进制格式显示主机名。

printf 函数不能用于显示类型为 list 的变量。 但是，可以使用 %s 转换说明符来打印类型为 string 的变量。 类型为 probev_timestamp_t 的变量通过使用 %lld 或 %16llx 说明符以数字格式显示。 probev_timestamp_t 通过使用 %A 或 %W 说明符以日期格式显示。

以下脚本演示了使用 printf 函数的一些示例：

@@BEGIN
{
	String s[128];
	int i;
	float f;
	f = 2.3;

	s = "Test: %d, float = %f\n";
	i = 44;

	printf(s, i, f);

	s = "Note:";
	printf("%s Value of i (left justified) = %-12d and right-justified = %12d\n",
				s, i, i);

	printf("With a long format string that may span multiple lines, you " +
			"can use the '+' operator to concatenate the strings " +
			"in multiple lines into a single string: 0x%08x\n", i); 

	exit();
}

格式

一种字符串，它包含不经任何更改就直接复制到跟踪缓冲区的纯字符以及一个或多个指示如何对 data 参数进行格式化的转换说明符。

DATA

指定与 format 参数中的转换说明符相对应的零个或多个参数。

void ptree ( int depth );

ptree 函数显示被探测的进程的进程树。 此函数同时显示父层次结构和子层次结构。 作为参数传递的深度有助于控制需要显示的子进程的深度。 此函数无法在 BEGIN 或 END 或 systrace 调查中使用。 此外，仅当指定了 PID 时，该函数才能用于时间间隔调查中。

void quantize ( aso-name, int num-of-entries, int flags, int sort_key_ind)

此函数根据关联数组值的线性值，以图形格式显示关联数组的条目。 要仅打印具有一组特定键的元素，可以将这些键与第一个自变量中关联数组的变量名配合使用。 要仅限制特定维度键并允许其余维度中的所有键，可以使用 ANY 关键字。

除第一个参数外，其他参数都是可选参数。 如果未提供这些可选参数，那么将使用缺省打印选项。

aso-name

要打印的关联数组变量的名称。 您还可以在方括号中指定所有维度的键。 您可以使用 ANY 关键字来匹配键维度中的所有键。

条目数

指定要打印的条目数。 此参数是可选的。 指定 0 以显示所有条目。 如果未指定任何值，那么将使用会话的缺省打印选项。 任何负值都等同于 0。

标志

指定 sort-type、sort-by 和 list-value 标记。 此参数是可选的。 在 "关联数组类型" 部分下描述了标记排序类型，排序依据和列表值。 如果指定 0 ，那么将使用会话的缺省打印选项。

sort_key_ind

用于对输出进行排序的键 (键维度) 的索引。 如果指定-1，则使用第一个键进行排序。 如果第一个键不是可排序类型，那么不会对输出进行排序。

void qrange(aso[key], range_t range_data, int value);
void qrange(aso[key], range_t range_data, String value);

qrange 例程可以查找整数范围类型和字符串范围类型的时段编号。 如果范围类型是整数类型，那么第三个参数的类型应该是整数类型；否则，如果是字符串范围数据类型，那么第三个参数的类型应该是字符串类型。 qrange 例程将查找传递的值所属的时段编号。 对于作为值存储在关联数组中的范围类型，该时段编号的计数将增加。

aso[key]

具有指定键的关联数组。

range_data

range_t 数据类型。

值

值可以是整数类型，也可以是字符串类型。

int round_trip_time(int sock_fd);

round_trip_time 函数将获取特定套接字描述符的平滑往返时间 (srtt)。 它提供流套接字描述符的有效往返值，并返回 -1 作为无效或非流套按字描述符的平滑往返时间值。 此函数仅在 uft 和 syscall 探针管理器中可用。

fd

文件或套接字描述符值。

void set_aso_print_options( int num-of-entries, int flags);

set_aso_print_options() 函数更改关联数组的缺省显示选项。 用户可以提供的打印选项及其初始值列在 "关联数组类型" 部分下。 此函数只能在 BEGIN 探针中使用。

条目数

指定此项以显示前“n”个键/值对。 如果它为 0，那么将显示所有条目。

标志

指定 sort-type， sort-by， list-value 和 stack-raw 标志。 在 "关联数组类型" 部分下描述了这些标志。 这些参数为可选参数。

void set_range(range_t range_data, LINEAR, int min, int max, int step);
void set_range(range_t range_data, POWER, 2);

set_range 有两种不同的变体。 具有 min、max 和 step 的标记 LINEAR 将作为参数来传递，以将范围数据初始化为线性范围。 对于初始化电源范围，将传递带有两个的 POWER 标志作为自变量。 此例程将根据传递的自变量将范围类型初始化为 "线性" 或 "幂"。 线性范围类型数据将使用传递的 min、max 和 step 值进行初始化，而幂范围类型数据将初始化为幂值 2。

参数（对于线性范围类型）：

range_data

range_t 数据类型。

LINEAR

整数一致标记，表明 range_data 的分布是线性分布。

min

表明 range_data 的下边界。

最大值

表明 range_data 的上边界。

步进

表明每行 range_data 的值的指定范围大小。 min、max 和 step 只能是整数类型（Int、short、long 和 long long）。 不允许使用其他类型。

参数 (针对幂范围类型):

range_data

range_t 数据类型。

电源

一个整数常量标志，指示值的分布是 POWER 分布。

常量，表明幂的值。 到目前为止，仅支持幂值 2。

void set_date_format(String s);

更新日期格式。

此函数支持 C 库的 strftime() 支持对日期格式使用的所有转换说明符。 strftime() 不支持的任何说明符无效，系统将使用缺省格式。

缺省格式

MM:DD:YYYY hh:mm:ss TZ

MM

当年月份，以十进制数（01 到 12）表示。

DD

当月日期，以十进制数（01 到 31）表示。

YYYY

年份，以十进制数（例如，1989）表示。

hh

24 小时制小时，以十进制数（00 到 23）表示。

mm

一小时内的分钟数，以十进制数（00 到 59）表示。

ss

一分钟内的秒数，以十进制数（00 到 59）表示。

TZ

时区名，如果能够确定（例如，CDT）。

void sockfd_netinfo(int sock_fd,  net_info_t ninfo);

sockfd_netinfo 函数将获取输入套接字描述符的本地 IP 地址、远程 IP 地址、本地端口号和远程端口号信息。 此函数获取有效套接字描述符的有效本地和远程端口号及 IP 地址信息。 如果描述符无效或不是套接字类型，那么它获取的值为 0。

fd

文件或套接字描述符值。

ninfo

指定脚本变量 net_info_t，将在此变量中复制特定文件描述符的网络四元组（本地和远程 IP 地址和端口号）信息。

void start_tentative( String bufID );
void end_tentative( String bufID );

这些函数指示 Vue 子句中试探性跟踪部分的开始和结束。 试探性保存试探性跟踪部分中包括的跟踪输出函数所生成的跟踪数据，直到调用 commit_tentative 或 discard_tentative 函数以落实或废弃此数据为止。 end_tentative 函数是可选的，如果未指定该函数，那么隐式假定 Vue 子句的结束以表示试探性跟踪部分的结束。

生成的试探性跟踪数据由 bufID 参数标识，该参数必须是字符串常量或字符串文字，而不能是变量。 可同时使用不同的标识来收集试探性跟踪数据，然后可将每个试探性跟踪数据作为独立的块进行落实或废弃。 ProbeVue 在同一动态跟踪会话中最多支持 16 个暂定跟踪缓冲区，因此最多可以在 Vue 脚本中使用 16 个不同的跟踪标识。 单个 Vue 子句可包含具有不同标识的多个试探性跟踪部分。

bufID

指定表示试探性跟踪缓冲区标识的字符串常量。

void stktrace ( int flags, int levels );

stktrace 函数显示当前探针点的堆栈跟踪。 缺省情况下，以压缩格式生成堆栈跟踪并且仅使用最多两个层次的调用链地址。 可使用 flags 和 levels 参数修改堆栈跟踪的格式和内容。 ProbeVue 无法读取分页数据，因此如果在访问堆栈时迂到缺页故障，那么会截断堆栈跟踪。

stktrace 函数不会返回任何值。

String strstr( String s1, String s2 ); 

strstr 函数在 s1 参数指定的字符串中查找 s2 参数指定的字符串在何处首次出现，并返回一个新字符串，该新字符串包含 s1 参数中从此位置开始的字符。 此操作无法修改 s1 参数和 s2 参数。 如果 s2 参数指定的字符序列在 s1 参数中一次也没出现，那么此函数将返回空字符串。

long long sum ( List listvar );

利斯塔瓦

指定类型为 list 的变量。

probev_timestamp_t timestamp( );

timestamp 函数以 probev_timestamp_t 抽象数据类型返回当前的时间戳记。 虽然抽象，但该值具有以下属性：

• 从不同的 CPU 同时调用时，它将返回相等值或近似值。
• 如果调用了 timestamp 函数两次，且在体系结构上可保证第二次调用在较晚的时间进行，那么第二次调用返回的值大于或等于第一次调用返回的值（条件是在两次调用之间未重新引导系统）。

在两个不同的系统上，timestamp 函数返回的值之间没有关系。 虽然编译器会让您将返回的值视为 64 位整数，但是这会带来兼容性问题。

typedef long long time_t;
	__kernel time_t lbolt;   	/* number of ticks since last boot     */
	__kernel time_t time;    	/* memory mapped time in secs since epoch  */

void trace ( data );

trace 函数采用必须是变量的单个参数。 trace 函数不接受表达式。

trace 函数将传送进来的参数值复制到跟踪缓冲区。 参数可以为任何数据类型，复制到跟踪缓冲区的数据大小以其固有的大小为基础。 因此，对于整数参数，复制 4 个字节；对于指针，根据是以 32 位方式还是 64 位方式进行执行来复制 4 个或 8 个字节；对于类型为 struct 的参数，复制结构大小。 对于类型为 String 的变量，复制的字节数是声明的字符串长度（它与变量中包含的字符串长度不同）。 类型为 probev_timestamp_t 的变量最少为 8 个字节。

数据

要复制到跟踪缓冲区的数据参数。