libnd_tp

enum LND_TracePartObserverOp

typedef enum {  
  LND_TP_PACKET_SEL        = (1 << 0), /* Packet at certain index got selected */
  LND_TP_PACKET_UNSEL      = (1 << 1), /* Packet at certain index got deselected */
  LND_TP_SEL_CLR           = (1 << 2), /* All packets got deselected */
  LND_TP_SEL_ALL           = (1 << 3), /* All in-mem packets of trace part got selected */
  LND_TP_SEL_DEL           = (1 << 4), /* Selected in-mem packets got deleted */
  LND_TP_DIRTY_STATE       = (1 << 5), /* Trace part's dirty state got changed */
} LND_TracePartObserverOp;

libnd_tp_new ()

LND_TracePart* libnd_tp_new                 (LND_TPM *tpm,
                                             LND_TracePart *parent,
                                             off_t start_offset);

The function creates and returns a new trace part, sitting on top of parent, starting at start_offset. For the base part, the parent is NULL.

libnd_tp_free ()

void        libnd_tp_free                   (LND_TracePart *tp);

The function releases the memory occupied by the trace part pointed to by tp.

libnd_tp_set_input_file ()

gboolean    libnd_tp_set_input_file         (LND_TracePart *tp,
                                             const char *filename);

This function specifies the input trace file for tp. For a TPM's base trace, this is the original input trace.

libnd_tp_set_output_file ()

gboolean    libnd_tp_set_output_file        (LND_TracePart *tp,
                                             const char *filename);

The function sets the output trace file name for tp to filename. This means that when tp's packets are written out to disk, filename will be used.

libnd_tp_find_part_after_offset ()

LND_TracePart* libnd_tp_find_part_after_offset
                                            (const LND_TracePart *tp,
                                             off_t offset,
                                             const LND_TracePart *tp_dontuse);

In a scenario of multiple trace parts piled onto each other, the function finds the first trace part that sits upon the given one, starting at or after the offset given. If you want to make sure that a certain trace part is not selected (like the most recent one used), pass it as tp_last.

libnd_tp_write_packet ()

void        libnd_tp_write_packet           (LND_TracePart *tp,
                                             const LND_Packet *packet);

The function dumps the single given packet to the output trace file currently associated with tp.

libnd_tp_set_dirty ()

void        libnd_tp_set_dirty              (LND_TracePart *tp,
                                             gboolean dirty);

The function sets the modification status of tp to dirty.

libnd_tp_init_packets ()

void        libnd_tp_init_packets           (LND_TracePart *tp);

The function initializes all packets belonging to tp and loaded into memory (using libnd_tpm_load_packets()).

libnd_tp_insert_packets ()

void        libnd_tp_insert_packets         (LND_TracePart *tp,
                                             LND_Packet *packet,
                                             int index);

The function adds the chain of packets starting at packet to tp at index. The chain of packets is followed until a packet's next pointer is NULL, so make sure that last next pointer is correct. If index is < 0 or larger than the number of packets currently in the trace part, the packet is added at the end. Counting starts at zero, and the index is the index the packet will have when it is inserted. No limit checking is done; a trace part can grow arbitrarily large this way.

libnd_tp_remove_packet ()

LND_Packet* libnd_tp_remove_packet          (LND_TracePart *tp,
                                             int index);

The function removes the packet at index in tp from tp and returns the packet.

libnd_tp_sync ()

void        libnd_tp_sync                   (LND_TracePart *tp);

The function writes all packets the trace part has currently loaded into memory out to disk, using the currently existing output trace. After that, the input trace file is adjusted so that when packets are read from tp, the trace part that this function wrote packets into is used.

libnd_tp_clear_packetlists ()

LND_Packet* libnd_tp_clear_packetlists      (LND_TracePart *tp);

The function resets the internal loaded packet and selected packet lists.

libnd_tp_move_packet ()

void        libnd_tp_move_packet            (LND_TracePart *tp,
                                             int from_index,
                                             int to_index);

This function moves a single packet around in the trace part.

libnd_tp_packet_get_nth ()

LND_Packet* libnd_tp_packet_get_nth         (const LND_TracePart *tp,
                                             int n);

This function returns the nth packet of the trace part, if possible, NULL otherwise.

libnd_tp_clear_selection ()

void        libnd_tp_clear_selection        (LND_TracePart *tp);

The function clears the selection of any in-memory packets of the trace part pointed to by tp.

libnd_tp_full_selection ()

void        libnd_tp_full_selection         (LND_TracePart *tp);

The function selectes all in-memory packets of the trace part pointed to by tp.

libnd_tp_select_packet ()

LND_Packet* libnd_tp_select_packet          (LND_TracePart *tp,
                                             int index);

The function selects the indicated packet and marks it as the currently selected one.

libnd_tp_unselect_packet ()

LND_Packet* libnd_tp_unselect_packet        (LND_TracePart *tp,
                                             int index);

The function unselects the indicated packet in the trace part.

libnd_tp_get_sel_size ()

guint       libnd_tp_get_sel_size           (LND_TracePart *tp);

The function returns the number of packets currently selected in tp.

libnd_tp_sel_delete ()

void        libnd_tp_sel_delete             (LND_TracePart *tp);

The function deletes the selected packets from tp.

libnd_tp_sel_filter ()

void        libnd_tp_sel_filter             (LND_TracePart *tp);

The currently selected packets are filtered.

libnd_tp_sel_unfilter ()

void        libnd_tp_sel_unfilter           (LND_TracePart *tp);

The function unfilters packets in the current selection.

libnd_tp_observer_new ()

LND_TracePartObserver* libnd_tp_observer_new
                                            (void);

The function allocates a new, empty trace observer. You should then fill in callbacks for the events you're interested in, and register the thing using libnd_tp_add_observer().

libnd_tp_observer_free ()

void        libnd_tp_observer_free          (LND_TracePartObserver *ob);

The function releases all memory associated with ob.

libnd_tp_add_observer ()

void        libnd_tp_add_observer           (LND_TracePartObserver *ob);

The function registers the new observer for notifications about future changes to traces.

libnd_tp_del_observer ()

void        libnd_tp_del_observer           (LND_TracePartObserver *ob);

The function stops trace operations from being reported to ob. It does not release ob's memory, use libnd_tp_observer_free() for that.

libnd_tp_tell_observers ()

void        libnd_tp_tell_observers         (LND_TracePart *trace,
                                             LND_TracePartObserverOp op,
                                             void *data);