type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | mrs_cmd_t ddr3_get_mr0(enum ddr3_mr0_precharge precharge_pd,
u8 write_recovery,
enum ddr3_mr0_dll_reset dll_reset,
enum ddr3_mr0_mode mode,
u8 cas,
enum ddr3_mr0_burst_type burst_type,
enum ddr3_mr0_burst_length burst_length)
{
mrs_cmd_t cmd = 0 << 16;
if (precha... |
functions | u16 ddr3_rtt_nom_to_mr1_map(enum ddr3_mr1_rtt_nom rtt_nom)
{
u16 mask = 0;
/* A9 <-> rtt_nom[2] */
if (rtt_nom & (1 << 2))
mask |= (1 << 9);
/* A6 <-> rtt_nom[1] */
if (rtt_nom & (1 << 1))
mask |= (1 << 6);
/* A2 <-> rtt_nom[0] */
if (rtt_nom & (1 << 0))
mask |= (1 << 2);
return mask;
} |
functions | u16 ddr3_ods_to_mr1_map(enum ddr3_mr1_ods ods)
{
u16 mask = 0;
/* A5 <-> ods[1] */
if (ods & (1 << 1))
mask |= (1 << 5);
/* A1 <-> ods[0] */
if (ods & (1 << 0))
mask |= (1 << 1);
return mask;
} |
functions | mrs_cmd_t ddr3_get_mr1(enum ddr3_mr1_qoff qoff,
enum ddr3_mr1_tqds tqds,
enum ddr3_mr1_rtt_nom rtt_nom,
enum ddr3_mr1_write_leveling write_leveling,
enum ddr3_mr1_ods ods,
enum ddr3_mr1_additive_latency additive_latency,
enum ddr3_mr1_dll dll_disable)
{
mrs_cmd_t c... |
functions | mrs_cmd_t ddr3_get_mr2(enum ddr3_mr2_rttwr rtt_wr,
enum ddr3_mr2_srt_range extended_temp,
enum ddr3_mr2_asr self_refresh, u8 cas_cwl)
{
mrs_cmd_t cmd = 2 << 16;
cmd |= (rtt_wr & 0x03) << 9;
if (extended_temp == DDR3_MR2_SRT_EXTENDED)
cmd |= (1 << 7);
if (self_refresh == DDR3_MR2_ASR_AUTO)
c... |
functions | mrs_cmd_t ddr3_get_mr3(char dataflow_from_mpr)
{
mrs_cmd_t cmd = 3 << 16;
if (dataflow_from_mpr)
cmd |= (1 << 2);
return cmd;
} |
functions | mrs_cmd_t ddr3_mrs_mirror_pins(mrs_cmd_t cmd)
{
u32 downshift, upshift;
/* High bits= A4 | A6 | A8 | BA1 */
/* Low bits = A3 | A5 | A7 | BA0 */
u32 lowbits = (1 << 3) | (1 << 5) | (1 << 7) | (1 << 16);
downshift = (cmd & (lowbits << 1));
upshift = (cmd & lowbits);
cmd &=... |
includes |
#include <linux/time.h> |
includes | #include <linux/string.h> |
includes | #include <linux/pagemap.h> |
includes | #include <linux/reiserfs_fs.h> |
includes | #include <linux/smp_lock.h> |
includes | #include <linux/buffer_head.h> |
includes | #include <linux/quotaops.h> |
defines |
#define SEARCH_BY_KEY_READA 16 |
defines | #define held_by_others(bh) (atomic_read(&(bh)->b_count) > 1) |
defines | #define block_in_use(bh) (buffer_locked(bh) || (held_by_others(bh))) |
defines |
#define JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD (2 * JOURNAL_PER_BALANCE_CNT + 1) |
functions | int B_IS_IN_TREE(const struct buffer_head *p_s_bh)
{
RFALSE(B_LEVEL(p_s_bh) > MAX_HEIGHT,
"PAP-1010: block (%b) has too big level (%z)", p_s_bh, p_s_bh);
return (B_LEVEL(p_s_bh) != FREE_LEVEL);
} |
functions | void copy_item_head(struct item_head *p_v_to,
const struct item_head *p_v_from)
{
memcpy(p_v_to, p_v_from, IH_SIZE);
} |
functions | int comp_short_keys(const struct reiserfs_key *le_key,
const struct cpu_key *cpu_key)
{
__u32 n;
n = le32_to_cpu(le_key->k_dir_id);
if (n < cpu_key->on_disk_key.k_dir_id)
return -1;
if (n > cpu_key->on_disk_key.k_dir_id)
return 1;
n = le32_to_cpu(le_key->k_objectid);
if (n < cpu_key->on_disk_key.k_objec... |
functions | int comp_keys(const struct reiserfs_key *le_key,
const struct cpu_key *cpu_key)
{
int retval;
retval = comp_short_keys(le_key, cpu_key);
if (retval)
return retval;
if (le_key_k_offset(le_key_version(le_key), le_key) <
cpu_key_k_offset(cpu_key))
return -1;
if (le_key_k_offset(le_key_version(le_key)... |
functions | int comp_short_le_keys(const struct reiserfs_key *key1,
const struct reiserfs_key *key2)
{
__u32 *p_s_1_u32, *p_s_2_u32;
int n_key_length = REISERFS_SHORT_KEY_LEN;
p_s_1_u32 = (__u32 *) key1;
p_s_2_u32 = (__u32 *) key2;
for (; n_key_length--; ++p_s_1_u32, ++p_s_2_u32) {
if (le32_to_cpu(*p_s_1_u32) < le... |
functions | void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from)
{
int version;
to->on_disk_key.k_dir_id = le32_to_cpu(from->k_dir_id);
to->on_disk_key.k_objectid = le32_to_cpu(from->k_objectid);
// find out version of the key
version = le_key_version(from);
to->version = version;
to->on_disk_key.k_offs... |
functions | int comp_le_keys(const struct reiserfs_key *k1,
const struct reiserfs_key *k2)
{
return memcmp(k1, k2, sizeof(struct reiserfs_key));
} |
functions | int bin_search(const void *p_v_key, /* Key to search for. */
const void *p_v_base, /* First item in the array. */
int p_n_num, /* Number of items in the array. */
int p_n_width, /* Item size in the array.
searched. Lest the reader be
confuse... |
functions | int key_in_buffer(struct path *p_s_chk_path, /* Path which should be checked. */
const struct cpu_key *p_s_key, /* Key which should be checked. */
struct super_block *p_s_sb /* Super block pointer. */
)
{
RFALSE(!p_s_key || p_s_chk_path->path_length < FIRST_PATH_ELEMENT_OFFSET
|| p_s_... |
functions | void decrement_bcount(struct buffer_head *p_s_bh)
{
if (p_s_bh) {
if (atomic_read(&(p_s_bh->b_count))) {
put_bh(p_s_bh);
return;
} |
functions | void decrement_counters_in_path(struct path *p_s_search_path)
{
int n_path_offset = p_s_search_path->path_length;
RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET ||
n_path_offset > EXTENDED_MAX_HEIGHT - 1,
"PAP-5080: invalid path offset of %d", n_path_offset);
while (n_path_offset > ILLEGAL_PATH... |
functions | int reiserfs_check_path(struct path *p)
{
RFALSE(p->path_length != ILLEGAL_PATH_ELEMENT_OFFSET,
"path not properly relsed");
return 0;
} |
functions | void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path)
{
int n_path_offset = p_s_search_path->path_length;
RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
"clm-4000: invalid path offset");
while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
reiserfs_restore_prepared_buffer(... |
functions | void pathrelse(struct path *p_s_search_path)
{
int n_path_offset = p_s_search_path->path_length;
RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
"PAP-5090: invalid path offset");
while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
p_s_s... |
functions | int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
{
struct block_head *blkh;
struct item_head *ih;
int used_space;
int prev_location;
int i;
int nr;
blkh = (struct block_head *)buf;
if (blkh_level(blkh) != DISK_LEAF_NODE_LEVEL) {
reiserfs_warning(NULL,
"is_leaf: this should be caught earlier... |
functions | int is_internal(char *buf, int blocksize, struct buffer_head *bh)
{
struct block_head *blkh;
int nr;
int used_space;
blkh = (struct block_head *)buf;
nr = blkh_level(blkh);
if (nr <= DISK_LEAF_NODE_LEVEL || nr > MAX_HEIGHT) {
/* this level is not possible for internal nodes */
reiserfs_warning(NULL,
"is... |
functions | int is_tree_node(struct buffer_head *bh, int level)
{
if (B_LEVEL(bh) != level) {
reiserfs_warning(NULL,
"is_tree_node: node level %d does not match to the expected one %d",
B_LEVEL(bh), level);
return 0;
} |
functions | void search_by_key_reada(struct super_block *s,
struct buffer_head **bh,
unsigned long *b, int num)
{
int i, j;
for (i = 0; i < num; i++) {
bh[i] = sb_getblk(s, b[i]);
} |
functions | int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /* Key to search. */
struct path *p_s_search_path, /* This structure was
allocated and initialized
by the calling
function. It is filled up
by this function. */
int n_stop_level /* How far down the ... |
functions | CONFIG_REISERFS_CHECK
if (cur_tb) {
print_cur_tb("5140");
reiserfs_panic(p_s_sb,
"PAP-5140: search_by_key: schedule occurred in do_balance!");
} |
functions | int comp_items(const struct item_head *stored_ih, const struct path *p_s_path)
{
struct buffer_head *p_s_bh;
struct item_head *ih;
/* Last buffer at the path is not in the tree. */
if (!B_IS_IN_TREE(p_s_bh = PATH_PLAST_BUFFER(p_s_path)))
return 1;
/* Last path position is invalid. */
if (PATH_LAST_POSITION(p_... |
functions | int prepare_for_direct_item(struct path *path,
struct item_head *le_ih,
struct inode *inode,
loff_t new_file_length, int *cut_size)
{
loff_t round_len;
if (new_file_length == max_reiserfs_offset(inode)) {
/* item has to be deleted */
*cut_size = -(IH_SIZE + ih_item_len(le_ih));
return M_DE... |
functions | int prepare_for_direntry_item(struct path *path,
struct item_head *le_ih,
struct inode *inode,
loff_t new_file_length,
int *cut_size)
{
if (le_ih_k_offset(le_ih) == DOT_OFFSET &&
new_file_length == max_reiserfs_offset(inode)) {
RFALSE(ih_entry_count(le_ih) != 2,
"PAP... |
functions | char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct path *p_s_path, const struct cpu_key *p_s_item_key, int *p_n_removed, /* Number of unformatted nodes which were removed
from end of the file. */
int *p_n_cut_size, unsigned long long n_n... |
functions | int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
{
int n_del_size;
struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_tb->tb_path);
if (is_statdata_le_ih(p_le_ih))
return 0;
n_del_size =
(c_mode ==
M_DELETE) ? ih_item_len(p_le_ih) : -p_s_tb->insert_size[0];
if (is_direntry_le_ih(... |
functions | void init_tb_struct(struct reiserfs_transaction_handle *th,
struct tree_balance *p_s_tb,
struct super_block *p_s_sb,
struct path *p_s_path, int n_size)
{
BUG_ON(!th->t_trans_id);
memset(p_s_tb, '\0', sizeof(struct tree_balance));
p_s_tb->transaction_handle = th;
p_s_tb->tb_sb = p_s_sb;
p_s_tb->... |
functions | void padd_item(char *item, int total_length, int length)
{
int i;
for (i = total_length; i > length;)
item[--i] = 0;
} |
functions | char key2type(struct reiserfs_key *ih)
{
if (is_direntry_le_key(2, ih))
return 'd';
if (is_direct_le_key(2, ih))
return 'D';
if (is_indirect_le_key(2, ih))
return 'i';
if (is_statdata_le_key(2, ih))
return 's';
return 'u';
} |
functions | char head2type(struct item_head *ih)
{
if (is_direntry_le_ih(ih))
return 'd';
if (is_direct_le_ih(ih))
return 'D';
if (is_indirect_le_ih(ih))
return 'i';
if (is_statdata_le_ih(ih))
return 's';
return 'u';
} |
functions | int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the deleted item. */
const struct cpu_key *p_s_item_key, /* Key to search for the deleted item. */
struct inode *p_s_inode, /* inode is here just to update i_blocks and quotas */
struct buffer_head *p_s_un_bh... |
functions | void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
struct inode *inode, struct reiserfs_key *key)
{
struct tree_balance tb;
INITIALIZE_PATH(path);
int item_len = 0;
int tb_init = 0;
struct cpu_key cpu_key;
int retval;
int quota_cut_bytes = 0;
BUG_ON(!th->t_trans_id);
le_key2cpu_key(&... |
functions | int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
struct inode *inode)
{
int err;
inode->i_size = 0;
BUG_ON(!th->t_trans_id);
/* for directory this deletes item containing "." and ".." */
err =
reiserfs_do_truncate(th, inode, NULL, 0 /*no timestamp updates */ );
if (err)
return err;... |
functions | void unmap_buffers(struct page *page, loff_t pos)
{
struct buffer_head *bh;
struct buffer_head *head;
struct buffer_head *next;
unsigned long tail_index;
unsigned long cur_index;
if (page) {
if (page_has_buffers(page)) {
tail_index = pos & (PAGE_CACHE_SIZE - 1);
cur_index = 0;
head = page_buffers(page... |
functions | int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
struct inode *p_s_inode,
struct page *page,
struct path *p_s_path,
const struct cpu_key *p_s_item_key,
loff_t n_new_file_size, char *p_c_mode)
{
struct super_block *p_s_sb = p_s_inode->i_sb;
int n_block_size =... |
functions | void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
struct inode *inode, struct path *path)
{
struct cpu_key tail_key;
int tail_len;
int removed;
BUG_ON(!th->t_trans_id);
make_cpu_key(&tail_key, inode, inode->i_size + 1, TYPE_DIRECT, 4); // !!!!
tail_key.key_length = 4;
tail_len =
... |
functions | int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
struct path *p_s_path,
struct cpu_key *p_s_item_key,
struct inode *p_s_inode,
struct page *page, loff_t n_new_file_size)
{
struct super_block *p_s_sb = p_s_inode->i_sb;
/* Every function which is going to call do_balance must f... |
functions | CONFIG_REISERFS_CHECK
if (n_is_inode_locked) {
struct item_head *le_ih =
PATH_PITEM_HEAD(s_cut_balance.tb_path);
/* we are going to complete indirect2direct conversion. Make
sure, that we exactly remove last unformatted node pointer
of the item */
if (!is_indirect_le_ih(le_ih))
reiserfs_panic(... |
functions | void truncate_directory(struct reiserfs_transaction_handle *th,
struct inode *inode)
{
BUG_ON(!th->t_trans_id);
if (inode->i_nlink)
reiserfs_warning(inode->i_sb,
"vs-5655: truncate_directory: link count != 0");
set_le_key_k_offset(KEY_FORMAT_3_5, INODE_PKEY(inode), DOT_OFFSET);
set_le_key_k_type(K... |
functions | int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p_s_inode, /* ->i_size contains new
size */
struct page *page, /* up to date for last block */
int update_timestamps /* when it is called by
file_release to convert
the tail - no timestamps
s... |
functions | void check_research_for_paste(struct path *path,
const struct cpu_key *p_s_key)
{
struct item_head *found_ih = get_ih(path);
if (is_direct_le_ih(found_ih)) {
if (le_ih_k_offset(found_ih) +
op_bytes_number(found_ih,
get_last_bh(path)->b_size) !=
cpu_key_k_offset(p_s_key)
|| op_byt... |
functions | int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct path *p_s_search_path, /* Path to the pasted item. */
const struct cpu_key *p_s_key, /* Key to search for the needed item. */
struct inode *inode, /* Inode item belongs to */
const char *p_c_body, /* Pointer to ... |
functions | int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the inserteded item. */
const struct cpu_key *key, struct item_head *p_s_ih, /* Pointer to the item header to insert. */
struct inode *inode, const char *p_c_body)
{ /* Pointer to the bytes to insert. ... |
includes |
#include <linux/kernel.h> |
includes | #include <linux/init.h> |
includes | #include <linux/tty.h> |
includes | #include <linux/module.h> |
includes | #include <linux/usb.h> |
includes | #include <linux/usb/serial.h> |
functions | __init funsoft_init(void)
{
int retval;
retval = usb_serial_register(&funsoft_device);
if (retval)
return retval;
retval = usb_register(&funsoft_driver);
if (retval)
usb_serial_deregister(&funsoft_device);
return retval;
} |
functions | __exit funsoft_exit(void)
{
usb_deregister(&funsoft_driver);
usb_serial_deregister(&funsoft_device);
} |
functions | bool api_policyagent_Dummy(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct policyagent_Dummy *r;
call = &ndr_table_policyagent.calls[NDR_POLICYAGENT_DUMMY];
r = talloc(talloc_tos(), struct policyagent_Dummy);
if (... |
functions | void policyagent_get_pipe_fns(struct api_struct **fns, int *n_fns)
{
*fns = api_policyagent_cmds;
*n_fns = sizeof(api_policyagent_cmds) / sizeof(struct api_struct);
} |
functions | NTSTATUS rpc_policyagent_init(const struct rpc_srv_callbacks *rpc_srv_cb)
{
return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "policyagent", "policyagent", &ndr_table_policyagent, api_policyagent_cmds, sizeof(api_policyagent_cmds) / sizeof(struct api_struct), rpc_srv_cb);
} |
functions | NTSTATUS rpc_policyagent_shutdown(void)
{
return rpc_srv_unregister(&ndr_table_policyagent);
} |
includes |
#include <sol-util-internal.h> |
includes | #include <math.h> |
includes | #include <time.h> |
defines |
#define ALL_PORTS_INITIALIZED ((int)pow(2, SOL_FLOW_NODE_TYPE_TIMESTAMP_MAKE_TIME__IN_LAST + 1) - 1) |
structs | struct make_time_data {
struct tm received_time;
time_t nsec;
int16_t initialized;
}; |
structs | struct timestamp_comparison_node_type {
struct sol_flow_node_type base;
bool (*func) (struct timespec *var0, struct timespec *var1);
}; |
structs | struct timestamp_comparison_data {
struct timespec val[2];
bool val_initialized[2];
}; |
functions | int
timestamp_time_open(struct sol_flow_node *node,
void *data,
const struct sol_flow_node_options *options)
{
const struct sol_flow_node_type_timestamp_time_options *opts;
SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options,
SOL_FLOW_NODE_TYPE_TIMESTAMP_TIME_OPTIONS_API_VERSION,
-EINVAL);
... |
functions | int
time_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct timespec current_time;
int r;
r = sol_util_timespec_get_realtime(¤t_time);
if (r < 0) {
sol_flow_send_error_packet(node, r,
"Could not fetch... |
functions | int
timestamp_make_time_open(struct sol_flow_node *node,
void *data,
const struct sol_flow_node_options *options)
{
struct make_time_data *mdata = data;
/* Always check for daylight saving when assembling a time
* packet */
mdata->received_time.tm_isdst = -1;
return 0;
} |
functions | int
send_timestamp(struct sol_flow_node *node, uint16_t port, struct make_time_data *mdata)
{
struct timespec timestamp;
time_t timestamp_sec;
mdata->initialized |= 1 << port;
if (mdata->initialized != ALL_PORTS_INITIALIZED)
return 0;
timestamp_sec = mktime(&mdata->received_time);
if ... |
functions | int
make_year(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 1970) {
... |
functions | int
make_month(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 1 || value > 12... |
functions | int
make_day(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 1 || value > 31) ... |
functions | int
make_hour(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 0 || value > 23)... |
functions | int
make_minute(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 0 || value > 5... |
functions | int
make_second(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 0 || value > 5... |
functions | int
make_nano_second(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct make_time_data *mdata = data;
int32_t value;
int r;
r = sol_flow_packet_get_irange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (value < 0 || valu... |
functions | int
localtime_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct timespec value;
struct tm split_time;
struct sol_irange year = { 0, 0, INT32_MAX, 1 } |
functions | bool
timestamp_val_eq(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec != var1->tv_sec)
return false;
return var0->tv_nsec == var1->tv_nsec;
} |
functions | bool
timestamp_val_less(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec == var1->tv_sec)
return var0->tv_nsec < var1->tv_nsec;
return var0->tv_sec < var1->tv_sec;
} |
functions | bool
timestamp_val_less_or_eq(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec == var1->tv_sec)
return var0->tv_nsec <= var1->tv_nsec;
return var0->tv_sec <= var1->tv_sec;
} |
functions | bool
timestamp_val_greater(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec == var1->tv_sec)
return var0->tv_nsec > var1->tv_nsec;
return var0->tv_sec > var1->tv_sec;
} |
functions | bool
timestamp_val_greater_or_eq(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec == var1->tv_sec)
return var0->tv_nsec >= var1->tv_nsec;
return var0->tv_sec >= var1->tv_sec;
} |
functions | bool
timestamp_val_not_eq(struct timespec *var0, struct timespec *var1)
{
if (var0->tv_sec != var1->tv_sec)
return true;
return var0->tv_nsec != var1->tv_nsec;
} |
functions | bool
two_vars_get_value(struct timestamp_comparison_data *mdata, uint16_t port, const struct sol_flow_packet *packet)
{
int r;
r = sol_flow_packet_get_timestamp(packet, &mdata->val[port]);
SOL_INT_CHECK(r, < 0, r);
mdata->val_initialized[port] = true;
if (!(mdata->val_initialized[0] && mdata->val_... |
functions | int
comparison_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct timestamp_comparison_data *mdata = data;
const struct timestamp_comparison_node_type *type;
bool output;
if (!two_vars_get_value(mdata, port, packet))
r... |
functions | int
delta_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct timestamp_comparison_data *mdata = data;
struct timespec sub_result;
time_t result;
int r;
int32_t output;
if (!two_vars_get_value(mdata, port, packet))
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.