df
free(df);
_citrus_db_factory_add(struct _citrus_db_factory *df, struct _region *key,
de->de_hashvalue = df->df_hashfunc(key);
STAILQ_INSERT_TAIL(&df->df_entries, de, de_entry);
df->df_total_key_size += _region_size(key);
df->df_total_data_size += ceilto(_region_size(data));
df->df_num_entries++;
_citrus_db_factory_add_by_string(struct _citrus_db_factory *df,
return _citrus_db_factory_add(df, &r, 1, data, datafree);
_citrus_db_factory_add8_by_string(struct _citrus_db_factory *df,
return (_citrus_db_factory_add_by_string(df, key, &r, 1));
_citrus_db_factory_add16_by_string(struct _citrus_db_factory *df,
return (_citrus_db_factory_add_by_string(df, key, &r, 1));
_citrus_db_factory_add32_by_string(struct _citrus_db_factory *df,
return (_citrus_db_factory_add_by_string(df, key, &r, 1));
_citrus_db_factory_add_string_by_string(struct _citrus_db_factory *df,
return (_citrus_db_factory_add_by_string(df, key, &r, 1));
_citrus_db_factory_calc_size(struct _citrus_db_factory *df)
sz += ceilto(_CITRUS_DB_ENTRY_SIZE * df->df_num_entries);
sz += ceilto(df->df_total_key_size);
sz += df->df_total_data_size;
_citrus_db_factory_serialize(struct _citrus_db_factory *df, const char *magic,
if (df->df_num_entries == 0) {
depp = calloc(df->df_num_entries, sizeof(*depp));
STAILQ_FOREACH(de, &df->df_entries, de_entry) {
de->de_hashvalue %= df->df_num_entries;
STAILQ_FOREACH(de, &df->df_entries, de_entry) {
ceilto(df->df_num_entries*_CITRUS_DB_ENTRY_SIZE);
dataofs = keyofs + ceilto(df->df_total_key_size);
dump_header(r, magic, &ofs, df->df_num_entries);
for (i = 0; i < df->df_num_entries; i++) {
struct _citrus_db_factory *df;
df = malloc(sizeof(*df));
if (df == NULL)
df->df_num_entries = 0;
df->df_total_key_size = df->df_total_data_size = 0;
STAILQ_INIT(&df->df_entries);
df->df_hashfunc = hashfunc;
df->df_hashfunc_closure = hashfunc_closure;
*rdf = df;
_citrus_db_factory_free(struct _citrus_db_factory *df)
while ((de = STAILQ_FIRST(&df->df_entries)) != NULL) {
STAILQ_REMOVE_HEAD(&df->df_entries, de_entry);
ret = _db_factory_create(&df, &_db_hash_std, NULL);
if ((ret = convert_line(df, line, size))) {
_db_factory_free(df);
ret = dump_db(df, &r);
_db_factory_free(df);
convert_line(struct _citrus_db_factory *df, const char *line, size_t len)
return (_db_factory_addstr_by_s(df, key, data));
dump_db(struct _citrus_db_factory *df, struct _region *r)
size = _db_factory_calc_size(df);
return (_db_factory_serialize(df, _CITRUS_LOOKUP_MAGIC, r));
struct _citrus_db_factory *df;
struct _db_factory *df;
ret = _db_factory_create(&df, &_db_hash_std, NULL);
ret = _db_factory_add_by_s(df, se->se_name, &subr, 1);
size = _db_factory_calc_size(df);
ret = _db_factory_serialize(df, _CITRUS_PIVOT_MAGIC, r);
_db_factory_free(df);
FILE *df;
if ((df = ftp_setup(conn, fetch_reopen(sd), mode)) == NULL)
return (df);
return 2.0*(df+w);
double z,p,q,r,w,s,c,df;
df = s;
SET_LOW_WORD(df,0);
c = (z-df*df)/(s+df);
float z,p,q,r,w,s,c,df;
df = s;
GET_FLOAT_WORD(idf,df);
SET_FLOAT_WORD(df,idf&0xfffff000);
c = (z-df*df)/(s+df);
return (float)2.0*(df+w);
long double z,p,q,r,w,s,c,df;
df = u.e;
c = (z-df*df)/(s+df);
return 2.0*(df+w);
if (getrecord(df, &(dtwalk->dt_value)) < 0) {
FILE *df;
if ((df = fopen(dumpdates, "r+")) == NULL)
fd = fileno(df);
readdumptimes(df);
if (fseek(df, 0L, 0) < 0)
dumprecout(df, dtwalk);
if (fflush(df))
if (ftruncate(fd, ftell(df)))
(void) fclose(df);
getrecord(FILE *df, struct dumpdates *ddatep)
if ( (fgets(tbuf, sizeof (tbuf), df)) != tbuf)
FILE *df;
if ((df = fopen(dumpdates, "r")) == NULL) {
if ((df = fopen(dumpdates, "w")) == NULL) {
(void) fclose(df);
if ((df = fopen(dumpdates, "r")) == NULL) {
(void) flock(fileno(df), LOCK_SH);
readdumptimes(df);
(void) fclose(df);
readdumptimes(FILE *df)
GET_INT(df, NULL, "don't fragment frag", 0, 1) ||
if (df)
int window, w_mod, ttl, df, psize, p_mod, mss, mss_mod, wscale,
int almost_done, ch, df, hold, i, icmp_len, mib[4], preload;
alarmtimeout = df = preload = tos = pcp = 0;
df = 1;
ip.ip_off = htons(df ? IP_DF : 0);
static FILE *df, *mf;
if (fd == -1 || (df = fdopen(fd, "w")) == NULL) {
if (fclose(df) != 0)
if (fwrite(dirbuf, DIRBLKSIZ, 1, df) != 1)
if (fwrite(dirbuf, (int)dirloc, 1, df) != 1)
seekpt = ftell(df);
DOS_FILE *df;
df = f->f_fsdata;
mnt->dos_fs = df->fs;
uint32_t df : 1;
ena_tx_ctx->df = 1;
ena_tx_ctx->df = 1;
U32 df;
df = mpt_req->Control & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
if (df != MPI_SCSIIO_CONTROL_NODATATRANSFER) {
(df == MPI_SCSIIO_CONTROL_READ)?
struct dpcpu_free *df;
df = malloc(sizeof(*df), M_PCPU, M_WAITOK | M_ZERO);
df->df_start = (uintptr_t)&DPCPU_NAME(modspace);
df->df_len = DPCPU_MODMIN;
TAILQ_INSERT_HEAD(&dpcpu_head, df, df_link);
struct dpcpu_free *df;
TAILQ_FOREACH(df, &dpcpu_head, df_link) {
if (df->df_len < size)
if (df->df_len == size) {
s = (void *)df->df_start;
TAILQ_REMOVE(&dpcpu_head, df, df_link);
free(df, M_PCPU);
s = (void *)df->df_start;
df->df_len -= size;
df->df_start = df->df_start + size;
struct dpcpu_free *df;
TAILQ_FOREACH(df, &dpcpu_head, df_link) {
if (df->df_start > end)
if (df->df_start + df->df_len == start) {
df->df_len += size;
dn = TAILQ_NEXT(df, df_link);
if (df->df_start + df->df_len == dn->df_start) {
df->df_len += dn->df_len;
if (df->df_start == end) {
df->df_start = start;
df->df_len += size;
dn = malloc(sizeof(*df), M_PCPU, M_WAITOK | M_ZERO);
if (df)
TAILQ_INSERT_BEFORE(df, dn, df_link);
bool df; /* IPv4 Don't fragment flag. */
struct vnet_data_free *df;
df = malloc(sizeof(*df), M_VNET_DATA_FREE, M_WAITOK | M_ZERO);
df->vnd_start = (uintptr_t)&VNET_NAME(modspace);
df->vnd_len = VNET_MODMIN;
TAILQ_INSERT_HEAD(&vnet_data_free_head, df, vnd_link);
struct vnet_data_free *df;
TAILQ_FOREACH(df, &vnet_data_free_head, vnd_link) {
if (df->vnd_len < size)
if (df->vnd_len == size) {
s = (void *)df->vnd_start;
TAILQ_REMOVE(&vnet_data_free_head, df, vnd_link);
free(df, M_VNET_DATA_FREE);
s = (void *)df->vnd_start;
df->vnd_len -= size;
df->vnd_start = df->vnd_start + size;
struct vnet_data_free *df;
TAILQ_FOREACH(df, &vnet_data_free_head, vnd_link) {
if (df->vnd_start > end)
if (df->vnd_start + df->vnd_len == start) {
df->vnd_len += size;
dn = TAILQ_NEXT(df, vnd_link);
if (df->vnd_start + df->vnd_len == dn->vnd_start) {
df->vnd_len += dn->vnd_len;
if (df->vnd_start == end) {
df->vnd_start = start;
df->vnd_len += size;
dn = malloc(sizeof(*df), M_VNET_DATA_FREE, M_WAITOK | M_ZERO);
if (df)
TAILQ_INSERT_BEFORE(df, dn, vnd_link);
pd->df = h->ip_off & htons(IP_DF);
pd.df && (*m0)->m_pkthdr.len > ifp->if_mtu) {
*block = df();
struct _db_factory *df;
CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
(df, _CITRUS_MAPPER_STD_SYM_TYPE, _CITRUS_MAPPER_STD_TYPE_ROWCOL));
(df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));
(df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));
(df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));
size = _db_factory_calc_size(df);
(df, _CITRUS_MAPPER_STD_MAGIC, &data));
struct _db_factory *df;
CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_VERSION,
CHKERR(ret, _db_factory_addstr_by_s, (df, _CITRUS_ESDB_SYM_ENCODING,
(df, _CITRUS_ESDB_SYM_VARIABLE, variable));
CHKERR(ret, _db_factory_add32_by_s, (df,
CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_NUM_CHARSETS,
(df, buf, csid->ci_symbol));
CHKERR(ret, _db_factory_add32_by_s, (df, buf, csid->ci_csid));
size = _db_factory_calc_size(df);
CHKERR(ret, _db_factory_serialize, (df, _CITRUS_ESDB_MAGIC, &data));