Lines Matching refs:fs
580 struct dn_pipe *p = q->fs->pipe ;
670 struct dn_flow_set *fs = q->fs;
681 fs->backlogged-- ;
689 q->F += (len<<MY_M)/(u_int64_t) fs->weight ;
815 pe->sum -= q->fs->weight ;
874 expire_queues(struct dn_flow_set *fs)
877 int i, initial_elements = fs->rq_elements ;
882 if (fs->last_expired == timenow.tv_sec)
884 fs->last_expired = timenow.tv_sec ;
885 for (i = 0 ; i <= fs->rq_size ; i++) /* last one is overflow */
886 for (prev=NULL, q = fs->rq[i] ; q != NULL ; )
896 fs->rq[i] = q = q->next ;
897 fs->rq_elements-- ;
900 return initial_elements - fs->rq_elements ;
908 create_queue(struct dn_flow_set *fs, int i)
912 if (fs->rq_elements > fs->rq_size * dn_max_ratio &&
913 expire_queues(fs) == 0) {
917 i = fs->rq_size ;
918 if ( fs->rq[i] != NULL )
919 return fs->rq[i] ;
926 q->fs = fs ;
928 q->next = fs->rq[i] ;
930 fs->rq[i] = q ;
931 fs->rq_elements++ ;
941 find_queue(struct dn_flow_set *fs, struct ipfw_flow_id *id)
946 if ( !(fs->flags_fs & DN_HAVE_FLOW_MASK) )
947 q = fs->rq[0] ;
950 id->dst_ip &= fs->flow_mask.dst_ip ;
951 id->src_ip &= fs->flow_mask.src_ip ;
952 id->dst_port &= fs->flow_mask.dst_port ;
953 id->src_port &= fs->flow_mask.src_port ;
954 id->proto &= fs->flow_mask.proto ;
963 i = i % fs->rq_size ;
966 for (prev=NULL, q = fs->rq[i] ; q ; ) {
982 fs->rq[i] = q = q->next ;
983 fs->rq_elements-- ;
992 q->next = fs->rq[i] ;
993 fs->rq[i] = q ;
997 q = create_queue(fs, i);
1005 red_drops(struct dn_flow_set *fs, struct dn_flow_queue *q, int len)
1027 u_int q_size = (fs->flags_fs & DN_QSIZE_IS_BYTES) ? q->len_bytes : q->len;
1037 int64_t v = SCALE_MUL((int64_t) diff, (int64_t) fs->w_q);
1049 u_int t = (curr_time - q->q_time) / fs->lookup_step;
1051 q->avg = (t < fs->lookup_depth) ?
1052 SCALE_MUL(q->avg, fs->w_q_lookup[t]) : 0;
1059 if (q->avg < fs->min_th) {
1063 if (q->avg >= fs->max_th) { /* average queue >= max threshold */
1064 if (fs->flags_fs & DN_IS_GENTLE_RED) {
1071 p_b = SCALE_MUL((int64_t) fs->c_3, (int64_t) q->avg) - fs->c_4;
1077 } else if (q->avg > fs->min_th) {
1083 p_b = SCALE_MUL((int64_t) fs->c_1, (int64_t) q->avg) - fs->c_2;
1085 if (fs->flags_fs & DN_QSIZE_IS_BYTES)
1086 p_b = (p_b * len) / fs->max_pkt_size;
1110 struct dn_flow_set *fs;
1116 bcopy(& ((ipfw_insn_pipe *)cmd)->pipe_ptr, &fs, sizeof(fs));
1118 if (fs != NULL)
1119 return fs;
1122 for (fs=all_flow_sets; fs && fs->fs_nr != pipe_nr; fs=fs->next)
1130 fs = &(p1->fs) ;
1133 bcopy(&fs, & ((ipfw_insn_pipe *)cmd)->pipe_ptr, sizeof(fs));
1135 return fs ;
1159 struct dn_flow_set *fs;
1191 fs = locate_flowset(pipe_nr, fwa->rule);
1192 if (fs == NULL)
1194 pipe = fs->pipe ;
1196 for (pipe = all_pipes; pipe && pipe->pipe_nr != fs->parent_nr;
1200 fs->pipe = pipe ;
1203 fs->parent_nr, fs->fs_nr);
1207 q = find_queue(fs, &(fwa->f_id));
1215 if ( fs->plr && (MY_RANDOM < fs->plr) )
1217 if ( fs->flags_fs & DN_QSIZE_IS_BYTES) {
1218 if (q->len_bytes > fs->qsize)
1221 if (q->len >= fs->qsize)
1224 if ( fs->flags_fs & DN_IS_RED && red_drops(fs, q, len) )
1300 pipe->sum += fs->weight ; /* add weight of new queue */
1305 q->F = q->S + ( len<<MY_M )/(u_int64_t) fs->weight;
1310 fs->backlogged++ ;
1357 return ( (fs && (fs->flags_fs & DN_NOERROR)) ? 0 : ENOBUFS);
1384 purge_flow_set(struct dn_flow_set *fs, int all)
1391 for (i = 0 ; i <= fs->rq_size ; i++ ) {
1392 for (q = fs->rq[i] ; q ; q = qn ) {
1403 fs->rq[i] = NULL ;
1405 fs->rq_elements = 0 ;
1408 if (fs->w_q_lookup)
1409 FREE(fs->w_q_lookup, M_DUMMYNET);
1410 if (fs->rq)
1411 FREE(fs->rq, M_DUMMYNET);
1412 /* if this fs is not part of a pipe, free it */
1413 if (fs->pipe && fs != &(fs->pipe->fs) )
1414 FREE(fs, M_DUMMYNET);
1428 purge_flow_set( &(pipe->fs), 1 );
1449 struct dn_flow_set *fs, *curr_fs;
1458 fs = all_flow_sets ;
1469 for ( ; fs ; ) {
1470 curr_fs = fs ;
1471 fs = fs->next ;
1486 dn_rule_delete_fs(struct dn_flow_set *fs, void *r)
1492 for (i = 0 ; i <= fs->rq_size ; i++) /* last one is ovflow */
1493 for (q = fs->rq[i] ; q ; q = q->next )
1508 struct dn_flow_set *fs ;
1519 for ( fs = all_flow_sets ; fs ; fs = fs->next )
1520 dn_rule_delete_fs(fs, r);
1522 fs = &(p->fs) ;
1523 dn_rule_delete_fs(fs, r);
1641 struct dn_flow_set *pfs = &(p->fs);
1672 x->fs.pipe = x ;
1680 for (i = 0; i <= x->fs.rq_size; i++)
1681 for (q = x->fs.rq[i]; q; q = q->next)
1690 set_fs_parms(&(x->fs), pfs);
1693 if ( x->fs.rq == NULL ) { /* a new pipe */
1694 r = alloc_hash(&(x->fs), pfs) ;
1766 fs_remove_from_heap(struct dn_heap *h, struct dn_flow_set *fs)
1770 if ( ((struct dn_flow_queue *)h->p[i].object)->fs == fs) {
1805 struct dn_flow_set *fs;
1815 for (fs = all_flow_sets; fs; fs= fs->next )
1816 purge_flow_set(fs, 0);
1819 purge_flow_set(&(p->fs), 0);
1836 if (p->pipe_nr == 0 && p->fs.fs_nr == 0)
1838 if (p->pipe_nr != 0 && p->fs.fs_nr != 0)
1842 struct dn_flow_set *fs;
1859 flush_pipe_ptrs(&(b->fs));
1862 for (fs = all_flow_sets; fs; fs= fs->next )
1863 if (fs->pipe == b) {
1864 printf("dummynet: ++ ref to pipe %d from fs %d\n",
1865 p->pipe_nr, fs->fs_nr);
1866 fs->pipe = NULL ;
1867 purge_flow_set(fs, 0);
1869 fs_remove_from_heap(&ready_heap, &(b->fs));
1882 for (a = NULL, b = all_flow_sets ; b && b->fs_nr < p->fs.fs_nr ;
1884 if (b == NULL || (b->fs_nr != p->fs.fs_nr) ) {
1927 if (q->fs != set)
1928 printf("dummynet: ++ at %d: wrong fs ptr (have %p, should be %p)\n",
1929 i, q->fs, set);
1935 qp->fs = NULL ;
1957 p->fs.rq_elements * sizeof(struct dn_flow_queue);
2012 pipe_bp->fs.next = NULL ;
2013 pipe_bp->fs.pipe = NULL ;
2014 pipe_bp->fs.rq = NULL ;
2017 bp = dn_copy_set( &(p->fs), bp );