Table Name Acronym Expandedx$bh buffer header

x$k2gte,

x$k2gte2x$kcbbf

x$kcbfwait

x$kcbkpfs

x$kcbobh

x$kcboqh

x$kcbsw

x$kcbwait

x$kcbwbpd

x$kcbwds

x$kcbwh

x$kcccf

kernel 2-phase commit, global transaction entry

kernel cache, buffer buffer_handles

kernel cache, buffer file wait

kernel cache, buffer ckpt prefetch statistics

kernel cache, buffer, objectqueue buffer header

kernel cache, buffer, object queue header

kernel cache, buffer statistics why

kernel cache, buffer wait

kernel cache, buffer workingset buffer pool descriptor

kernel cache, buffer workingset descriptors

kernel cache, buffer where/why

kernel cache, controlfilemanagement control file

x$kcccp

x$kccdi

x$kccle

x$kccnrs, x$kccrsp

x$kcfio kernel cache, file I/Ox$kclcrst

x$kclfh

x$kclfi

x$kclfx

x$kcluh

x$kclui

x$kcrfstrand

x$kcrfx

x$kdxst

x$kdxhs

x$kewrtb

x$kfdat

x$kghlu

x$kglcursor

kernel cache, controlfile checkpoint progress

kernel cache, controlfilemanagement database information

kernel cache, controlfile logfile entry

kernel cache, controlfile non-guaranteed restorepoint; kernel cache, controlfile restore point

kernel cache, (RAC) lock, consistent read statistics

kernel cache, (RAC) lock file hashtable

kernel cache, (RAC) lock file index

kernel cache, (RAC) lock freelist statistics

kernel cache, (RAC) lock undo header

kernel cache, (RAC) lock undo index

kernel cache, redo file strand

kernel cache, redo file context

kernel data, index status

kernel data, index histogram

kernel event?, workload repository tables

kernel file, disk allocation table?

kernel generic, heap LRUs

kernel generic, librarycache cursor

x$kgllk

x$kglob

x$kglpn

x$kglrd

x$kglst

x$kgskvft

x$kqdpg

x$kqfco

x$kqfdt

x$kqfp

x$kqfsz

x$kqfta

x$kqfvi

x$kqfvt

x$kqrpd

kernel generic, librarycache lock

kernel generic, librarycache object

kernel generic, librarycache pin

kernel generic, librarycache readonly dependency

kernel generic, librarycache status

kernel generic, service, ?? fixed table

kernel query, dictionary PGA

kernel query, fixed table columns

kernel query, fixed derived table

kernel query, fixed procedure

kernel query, fixed size (size of fixed objects in current version of Oracle)

kernel query, fixed table

kernel query, fixed view

kernel query, fixed view table (how fixed view is built on fixed tables)

kernel query, rowcache parent definition

x$kqrsd

x$kslemap

x$ksllclass

x$kslpo

x$ksmfs

x$ksmfsv

x$ksmhp

x$ksmjs

x$ksmlru

x$ksmls

x$ksmmem

x$ksmpp

kernel query, rowcache subordinate definition

x$krcfh, x$krcfde, x$krcfbh, x$krcbit

kernel recovery, changetracking file, header, descriptor, bitmap header, bitmap block

x$ksled, x$kslei, x$ksles

kernel service, latch event descriptor, latch events for instance, latch events for session

kernel service, latch event map

kernel service, latch, latch class

kernel service, latch posting

kernel service, memory fixed SGA

kernel service, memory fixed SGA variables

kernel service, memory heap

kernel service, memory java_pool statistics

kernel service, memory LRU

kernel service, memory large_pool statistics

kernel service, memory

kernel service, memory pga heap

x$ksmsd

x$ksmsp

x$ksmspr

x$ksmss

x$ksmup

x$ksolsfts

x$ksppcv

x$ksppi

x$ksppsv

x$ksqeq

x$ksqrs

x$ksqst

x$ksulv

x$ksulop

x$ksupgp

x$ksupr

x$ksuse

x$ksuvmstat

kernel service, memory sga definition

kernel service, memory sga heap

kernel service, memory shared pool reserved

kernel service, memory sga statistics

kernel service, memory uga heap

kernel service, object level statistics, fts?

kernel service, parameter, current (session) value

kernel service, parameter, parameter info

kernel service, parameter, system value

kernel service, enqueue en-queue

kernel service, enqueue resource

kernel service, enqueue_management statistics types

kernel service, user locale value

kernel service, user long operation

kernel service, user process group

kernel service, user process

kernel service, user session

kernel service, user virtual memory statistics

x$kswsastab

x$ktcxb

x$ktfbfe

x$ktfbhc

x$ktfbue

x$ktprxrt

x$ktuxe

x$kxfpsds

x$kxsbd

x$kzsprv

x$kzsro

x$le lock element

x$le_stat lock element statusx$messages

x$targetrba target RBA

kernel service, workgroup services,

kernel transaction, control object

kernel transaction, file bitmap free extent

kernel transaction, file bitmap header control

kernel transaction, file bitmap used extent

x$ktifb, x$ktiff, x$ktifp, x$ktifv

kernel transaction, ? flush ?

kernel transaction, parallel transaction rollback

kernel transaction, undo transaction entry

kernel execution, fast process slave dequeue statistics

kernel execution, SQL bind data

kernel security, session privilege

kernel security, session role

(background process) messages

x$qksceses, x$qkscesys

query compilation service, compilation environment, session or system

x$trace

x$uganco user global area, network connection

Note 1 x$kglcursor columns

Comments

See above

See x$kcbsw for SQL. Ref1 ("different functions that may be used to perform different types of logical I/O"), Ref2

The most common use of this table is to find the object and the file# and block# of its header when there's high cache buffers chains latch contention: select obj, dbarfil, dbablk from x$bh a, v$latch_children b where a.hladdr = b.addr for the said latch (whose sleeps you think are too high). You can also use this table to see if a specific buffer has too many clones: select dbarfil, dbablk, count(*) from x$bh group by dbarfil, dbablk having count(*) > 2. Note that obj column matches dba_objects.data_object_id, not object_id. For performance reason, don't merge dba_extents with the query of x$bh

that has a group by, unless you use in-line view and no_merge hint (see J. Lewis Practical Oracle8i, p.215) The tch column, touch count, records how many times a particular buffer has been accessed. Its flag column is explained by J. Lewis; explanation of state, mode and indx can be found in Anjo Kolk's paper. Tim is time the buffer touch happened (276392.996). Lru_flag is about the buffer's hot/cold feature (Ref and 221860.999); 8 is often used to find hot blocks.Mark Bobak's query (originally in Metalink forum thread 524821.994, where he further attributed authorship) uses this table to find sessions coming from or going to a remote database; in short, x$k2gte.k2gtdses matches v$session.saddr, .k2gtdxcb matches v$transaction.addr. select /*+ ordered */ substr(s.ksusemnm,1,10)||'-'|| substr(s.ksusepid,1,10) origin, substr(g.k2gtitid_ora,1,35) gtxid, substr(s.indx,1,4)||'.'|| substr(s.ksuseser,1,5) lsession, s.ksuudlna username, substr(decode(bitand(ksuseidl,11), 1,'ACTIVE', 0, decode( bitand(ksuseflg,4096) , 0,'INACTIVE','CACHED'), 2,'SNIPED', 3,'SNIPED', 'KILLED'),1,1) status, e.kslednam waiting from x$k2gte g, x$ktcxb t, x$ksuse s, x$ksled e where g.k2gtdxcb=t.ktcxbxba and g.k2gtdses=t.ktcxbses and s.addr=g.k2gtdses and e.indx=s.ksuseopc; It's more robust than this query, and better than checking for DX locks for outgoing sessions (since a DX lock only shows up in v$lock for the current distributed transaction session). X$k2gte2 is the same as x$k2gte except on k2gtetyp which may show 2 for 'TIGHTLY COUPLED' instead of 0 for 'FREE'. One use of x$k2gte[2] is the clearly translated global transaction ID in k2gtitid_ora as opposed to the hex numbers in v$global_transaction.globalid.

Jonathan Lewis ("_db_handles")

A commonly used query breaks down the contents of v$waitstat into per-datafile statistics: select name, count, time from v$datafile df, x$kcbfwait fw where fw.indx+1 = df.file#

Tanel Poder

10g and up. Tanel Poder

Note:34405.1 (select kcbwhdes, why0+why1+why2 "Gets", "OTHER_WAIT" from x$kcbsw s, x$kcbwh w where s.indx=w.indx and s."OTHER_WAIT">0 order by 3), Ref1 ("statistics about the way these [x$kcbwh] functions have been used")

See 183770.999 for relationship to x$bh and x$kcbwds. Some people use this query to find how many blocks of a segment are in each buffer pool: select decode(pd.bp_id,1,'KEEP',2,'RECYCLE',3,'DEFAULT',4,'2K SUBCACHE',5,'4K SUBCACHE',6,'8K SUBCACHE',7,'16K SUBCACHE',8,'32K SUBCACHE','UNKNOWN') subcache, bh.object_name,bh.blocks from x$kcbwds ds, x$kcbwbpd pd, (select /*+ use_hash(x) */ set_ds, o.name object_name, count(*) BLOCKS from obj$ o, x$bh x where o.dataobj#=x.obj and x.state!=0 and o.owner#!=0 and o.name='&mytable' group by set_ds, o.name) bh where ds.set_id>=pd.bp_lo_sid and ds.set_id<=pd.bp_hi_sid and pd.bp_size!=0 and ds.addr=bh.set_ds

See above. Also see Ref1, Ref2, Ref3. Total row count in this table is _db_block_lru_latches, although only db_writer_processes rows have real numbers.

In 10gR1, to find controlfile size as viewed at OS level but from inside Oracle, select cfnam, (cffsz+1)*cfbsz from x$kcccf. cfbsz is the controlfile log block size; should report the same as the command dbfsize controlfile ($ORACLE_HOME/bin/dbfsize is available on UNIX, regardless Oracle version.) In 10gR2, block size and file size are both in v$controlfile although Reference manual misses them.

base table of v$cr_block_server or v$bsp, used to troubleshoot global cache cr requests

See Ref1, Ref2. If lwm is too low, you may see 'gc freelist' wait.

used in catalog.sql to create index_stats

used in catalog.sql to create index_histogram

S. Adams and K Gopalakrishnan use this view to find how much the current redo log is filled. Eygle studied instance heartbeat, column cphbt.

lebsz may be used to show redo logfile block size, usually 512; should report the same as the command dbfsize redologfile ($ORACLE_HOME/bin/dbfsize is available on UNIX only)

Base tables of v$restore_point, for non-guaranteed and guaranteed restore points. Retain records of them after they were dropped

10g and up. Info about redo strands. Non-zero pvt_strand_state_kcrfa_cln means a transaction is using this private strand. (Private strands may be disabled in RAC or if supplemental logging is on, but multistrand redo is still used.) Strand_size_kcrfa is the strand size (meaningful only if last_buf_kcrfa<>'00'; Ref).

"columns bfs (buffer size) and bsz (block size). Dividing bfs by bsz gives mxr (the maximum number of blocks to read size)" (from Anjo Kolk's paper)

See Note:555124.1

Only populated in ASM instance. See Note:351117.1 and Julian Dyke et al Pro Oracle Database 10g RAC on Linux, pp.232-3. Column v_kfdat is 'V' for allocated and 'F' for free. For most ASM-related x$ tables, read Luca Canali.

Base table for v$sql, v$sqlarea. Fixed view based on x$kglob according to x$kqfdt. See Note 1 or x$kglob for more details. One use of this table is for finding partially parsed SQLs because they cause parse failures (viewable in v$sysstat or v$sesstat). Their kglobt02 (command type) is 0, kglobt09 (child number) is 65535 for the child, SQL text length is cut to 20 chars, kglobt17 and kglobt18 (parsing and user schema) are 0 or 2147483644 (for 32-bit Oracle) depending on if it's parent or child, and obviously miss heap 6 (cursor body). Find them by select kglnaobj, kglnatim, kglobts0, kglnahsh from x$kglcursor where kglobt02 = 0 (kglobts0 is module; you can further restrict by kglnatim i.e. first_load_time).

used in catblock.sql to build dba_kgllock. Some columns are simiarly explained for x$kgllk.

x$kqfco.kqfcotab=x$kqfta.indx

used in catprc.sql to build disk_and_fixed_objects view

Used in catblock.sql to build dba_kgllock. kgllkuse or kgllkses maps to v$session.saddr, kgllkpnc call pin, kgllkpns session pin, kgllkmod lock held (0: no lock; 1: null; 2: shared; 3: exclusive), kgllkflg (allegedly 8 for pre-10g or 2048 for 10g meaning SQL being run, Ref; 256 for broken kgl lock in 10g or 1 in 9i, Ref), kgllkspn savepoint. If you get library cache lock or pin wait, kgllkhdl matches v$session_wait.p1raw (handle address), and kglnaobj is the first 80 characters of the object name. Note:122793.1 has this SQL for our convenience: select * from x$kgllk lock_a where kgllkreq = 0 and exists (select lock_b. kgllkhdl from x$kgllk lock_b where kgllkses = '&saddr_from_v$session' /* blocked session */ and lock_a.kgllkhdl = lock_b.kgllkhdl and kgllkreq > 0). Kgllkadr column is shown in event 10270 trace files to find SQLs in session cursor cache (Ref)

To find library cache object for wait events library cache pin or lock and pipe get or put, match kglhdadr with v$session_wait.p1raw. kglhdflg is partially explained in Note:311689.1 (for permanent keeping). kglhddmk may be data object load mask; can be used to identify the number of the loaded heap, counted from 0 (see comment of 06/12/01 in Bug:1164709). Steve Adams' objects_on_hot_latches.sql finds the way Oracle links a library cache object (based on kglnahsh) to a specific library cache child latch. x$kglob, and in case of cursors x$kglcursor too, can be used to find library cache objects that are partially built therefore not visible in v$sql(XXX), v$open_cursor, v$object_dependency. (Try typing select *; and enter, then check these views!)

kglnacnm (container name?) is PL/SQL program unit or anonymous block while kglnadnm (dependent name?) is the individual SQLs inside the PL/SQL unit. Ref; this may be the way to differentiate between user recursive SQLs (code in PL/SQL, trigger, etc.) from system-generated recursive SQLs (data dictionary check etc.). (See also v$object_dependency, but that doesn't show relation between PL/SQL block and its contents.) In 11g, v$sql.program_id may be used to tie the constituent SQL to its containing PL/SQL stored object (not anonymous block).

Base table of v$blocking_quiesce. If the blocking session is not in SYS_GROUP consumer group according to v$rsrc_session_info, v$blocking_quiesce ignores it. Workaround is to directly query x$kgskvft. (Ref; Bug 7832504)

Row cache cursor statistics, columns explained in "How can you tune it?" section of Tuning the _row_cache_cursors Parameter. Note this is PGA. Need to dump another process's PGA to view it.

acronym explained by Julian Dyke: it contains x$kglcursor, x$kgltable etc. which are based on x$kglob; effectively these are views of other x$ tables, but Oracle couldn't call them views because they already had x$kqfvi

Base table of v$fixed_table, whose object_id (indx of x$kqfta) matches obj# of tab_stats$, the table dbms_stats.gather_fixed_objects_stats inserts stats into.

Column kqrpdosz is size of this parent rowcache object, not exposed in v$rowcache_parent although shown in rowcache dump.

also contains db_block_buffers and log_buffer sizes for some reason

select (to_number('9CD3F5D0','xxxxxxxx') - to_number('60000000','xxxxxxxx')) /8 from dual;select ksmmmval from x$ksmmem where indx = 127565498;

Column kqrsdosz is size of this subordinate rowcache object, not exposed in v$rowcache_subordinate although shown in rowcache dump.

Alex Gorbachev

Base tables for v$event_name, v$system_event, and v$session_event, respectively. Benefit of querying x$ksles: (1) When ksleswts (wait count) is 0, v$session_event won't have the row but x$ksles still has them with non-zero kslestim (time waited micro) or kslesmxt (max wait time in micro); (2) Since kslesmxt is in microsec, it could be non-zero even if v$session_event.max_wait is 0. x$kslei has benefit (2) over v$system_event.

"Indx = event number...Basically map events to a small number of useful classes like I/O waits" (Ref)

"describes the 8 classes", "Specify which latch belongs to which class" with _latch_class_ (Ref)

Note:653299 says it "tracks which function is posting smon". Ksllwnam column (the part before semicolon if it exists) can match v$latch_misses.location to identify the latch that uses this function.

detailing fixed SGA: select a.ksmfsnam, a.ksmfstyp, a.ksmfssiz, b.ksmmmval from x$ksmfsv a, x$ksmmem b where a.ksmfsadr = b.addr and a.ksmfsnam like... (Ref. p.82, Oracle Internal Services). For a latch, get ksmfsnam by matching x$ksmfsv.ksmfadr with x$kslld.kslldadr. You can see SGA parameters in ksmfsnam column and get their values with oradebug dumpvar varname or all values with oradebug dumpsga

S. Adams, "What it returns depends on which heap descriptor you join to it. It is effectively a function returning the contents of an arbitrary heap that takes the heap descriptor as its argument." You need to join this table to another one on heap descriptor ksmchds, such as in v$sql_shared_memory (joining to x$kglcursor), or to x$ksmsp (ksmchds=x$ksmsp.ksmchpar), and use use_nl hint. Example.

Refer to Metalink Notes 61623.1 and 43600.1 for details. Note that query on this table can only be done once; subsequent query returns no rows unless large chunk shared pool allocations happened in the interim.

Entire SGA memory map. You can find your database version by select ksmmmval from x$ksmmem where indx = 2 (if it's 64-bit Oracle, try 1), regardless machine architecture endian-ness. Note that the 4 bytes containing the version are delimited as XX.X.XX.X.XX so 09200300 is 9.2.0.3.0. Due to memory guard pages, you can only select from x$ksmmem specifying rownum < some number or indx = some value; otherwise the session may hang or throws ORA-3113 (Windows doesn't seem to have this problem). Indx is SGA index, i.e. SGA address minus sgabeg (which is x$ksmmem.addr where indx = 0), divided by architecture word size (4 for 32-bit, 8 for 64-bit machines); e.g., the value stored at address 0x9CD3F5D0 on a 64-bit machine (which is really address 0x000000009CD3F5B0) whose sgabeg is 0x60000000 can be calculated as:

PGA heap (variable area). PGA subheaps: select /*+use_nl(h,p)*/ h.ksmchds,p.ksmchcom, h.ksmchcom ksmchnam,h.ksmchsiz, h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmpp p where h.ksmchds = p.ksmchpar and p.ksmchcls like '%recr' and p.ksmchpar != hextoraw('00');

Base table of v$parameter and v$parameter2. See comments on x$ksppi.

Base table of v$system_parameter and v$system_parameter2. See comments on x$ksppi.

The 3rd argument of ORA-4031 tells you which section of shared (or java or large) pool is short of memory. It matches x$ksmsp.ksmchcom (or v$sgastat.name). SGA heaps: select /*+use_nl(h,s)*/ sess.sid, sess.username, h.ksmchds, h.ksmchcom ksmchnam, h.ksmchsiz, h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmsp s,v$session sess where h.ksmchds = s.ksmchpar and s.ksmchcls like '%recr' and s.ksmchpar != hextoraw('00') and h.ksmchown = sess.saddr; SGA subheaps: select /*+use_nl(h,s)*/ h.ksmchds,s.ksmchcom,h.ksmchcom ksmchnam, h.ksmchsiz,h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmsp s where h.ksmchds = s.ksmchpar and s.ksmchcls like '%recr'and s.ksmchpar != hextoraw('00');

The 3rd argument of ORA-4031 tells you which section of shared (or java or large) pool is short of memory. It matches x$ksmss.ksmssnam (or v$sgastat.name).

UGA heap (variable area). UGA subheaps: select /*+use_nl(h,s)*/ h.ksmchds,u.ksmchcom,h.ksmchcom ksmchnam,h.ksmchsiz,h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmup u where h.ksmchds = u.ksmchpar and u.ksmchcls like '%recr' and u.ksmchpar != hextoraw('00');

Base table of v$segstat and v$segment_statistics. Fts_stmp records the last time fts_staval was updated, fts_preval the previously recorded value. Fts_inte greater than 0 reveals some less known types of statistics. Note that value in v$segstat or v$segment_statistics is cumulative; e.g., if "row lock waits" is non-zero, the waits may not be happening right now.

Base table of v$parameter, v$system_parameter and v$system_parameter2. Often used to see undocumented parameters: select a.ksppinm Parameter, a.ksppdesc Description, b.ksppstvl "Session Value", c.ksppstvl "Instance Value" from x$ksppi a, x$ksppcv b, x$ksppsv c where a.indx = b.indx and a.indx = c.indx and a.ksppinm like '\_%' escape '\' order by 1

"shows all outstanding enqueues with an additional flag. It basically shows the same information as the v$lock table." from Note1, which also gives the meanings of the flags.

Acronym explained by K Gopalakrishnan. You can find how many times each type of enqueue lock has been taken since instance startup by select * from x$ksqst where ksqstget > 0 or in 9i select * from x$ksqst where ksqstsgt > 0 or ksqstfgt > 0. But v$enqueue_stat in 9i can also be used instead.

Ksupgpnm!='DEFAULT' may suggest session leaking (Ref)

T. Poder finds hidden recursive session based on ksuseflg.

In 10g and up, base table providing physical_memory_bytes to v$osstat (and VM paging stats on Windows). But on Linux up to Oracle 10.2.0.3, this number is system free memory in kilobytes (grep MemFree /proc/meminfo); on other OSes or 10.2.0.4 or up on Linux, it is "Total number of bytes of physical memory".

Free extent bitmap in file header for LMT (equivalent to fet$ in DMT); check dba_free_space view definition

Used extent bitmap in file header for LMT (equivalent to uet$ in DMT)

Session-specific. Base table for v$enabledprivilege, which is base table of session_privs

used in many SQL scripts in ?/rdbms/admin

Base table of v$services and a few other service-related views. v$services may need x$kswsastab.kswsastabpflg=0 restriction; otherwise stopped services linger in the view till instance bounce.

Base table of v$transaction. Four bits of ktcxbflg column, exposed as v$transaction.flag, are explained in v$fixed_view_definition. Metalink Mark Bobak and Melissa Holman explain the bit for isolation level. Since v$transaction is empty without a transaction, you can directly query x$ktcxb to find sessions with serializable isolation level: select * from v$session where taddr in (select ktcxbxba from x$ktcxb where bitand(ktcxbflg,268435456) <> 0). Other bits of ktcxbflg not shown in v$fixed_view_definition are: bit 1 read write and read committed, 4(?) read only, 13 using private strand (Ref).

Summarizes free space with one row per datafile (Ref); check dba_data_files or dba_temp_files view definition

Probably related to in-memory undo. See 7th bullet of IMU.txt.

Fairlie Rego

"get the SCN of the most recently committed (local) transaction" with select max(ktuxescnw * power(2, 32) + ktuxescnb) from x$ktuxe (Ref); select * from x$ktuxe where ktuxecfl = 'DEAD' and ktuxesta = 'ACTIVE' "shows transaction dead waiting for cleanup" (Ref)

Current list of reasons for parallel execution dequeuing, as explained for wait event "parallel query dequeue wait" in Anjo Kolk's paper.

Base table of v$sql_bind_data. Column kxsbdof2 (or shared_flag2 of v$sql_bind_data) is oacfl2 (not oacflg2 as in Note:39817.1) in SQL trace. "System-generated binds have a value of 256 in the SHARED_FLAG2 column". According to Bug 4359367, when it's 0x300, the bind variable is marked as unsafe (affecting cursor_sharing=similar). Note:296377.1 has more on its value.

See the definition of GV$BH for its relationship with x$bh. Note that v$gc_element differs slightly from v$lock_element and documentation for v$gc_element is really for v$lock_element.

May be the place where processes store and fetch messages. Related to _messages parameter, messages latch, and "rdbms ipc (message|reply)" wait events.

Base tables for v$ses_optimizer_env and v$sys_optimizer_env, respectively. There're so many optimizer parameters the two documented views are missing that sometimes you need to query these base tables directly. Select pname_qksceserow from x$qksceses minus select name from v$ses_optimizer_env to have a feel of the missing ones. Or subtract v$sys_optimizer_env.name from x$qkscesys.pname_qkscesyrow.

Ref

Beginning with 9i, x$trace records event tracing info. 10g RAC bdump/cdmp_time directory has trw files that contain the same info (the trace file seems to have columns TimeInMicroSec:?, OraclePid, SID, event, OpCode, TraceData). select event, count(*) from x$trace group by event shows what events are enabled internally (not shown in v$parameter). oerr ora eventID on UNIX shows the event name. RAC databases should have GES and GCS related events set. select pid, count(*) from x$trace group by pid shows how many events have been trapped by each oracle process (including those that exited). select sid, pid, count(*) from x$trace where (sid, pid) in (select sid, pid from v$session s, v$process p where s.paddr = p.addr) group by sid, pid order by 1, 2 shows the numbers for each currently existing session (I think without the where clause, exited sessions would be included). select event, op, time, seq#, data from x$trace where sid = &sid and pid = &pid order by time shows traced events for a session in question.

Base table of v$dblink. Since it's about UGA, each session has different content. After you end your distributed transactions (which includes distributed queries) and close database links, v$dblink no longer shows the entries. But x$uganco still has them, with ncoflg set to 8320 and hstflg set to 0. Unfortunately this is not very useful because you can't see the UGA content from a different session.