bfq_update_fin_time

static void bfq_update_fin_time_enqueue(struct bfq_entity *entity,
                    struct bfq_service_tree *st,
                    bool backshifted)
{
    struct bfq_queue *bfqq = bfq_entity_to_bfqq(entity);
 
    /*
     * When this function is invoked, entity is not in any service
     * tree, then it is safe to invoke next function with the last
     * parameter set (see the comments on the function).
     */
    st = __bfq_entity_update_weight_prio(st, entity, true);
    bfq_calc_finish(entity, entity->budget);
 
    /*
     * If some queues enjoy backshifting for a while, then their
     * (virtual) finish timestamps may happen to become lower and
     * lower than the system virtual time.  In particular, if
     * these queues often happen to be idle for short time
     * periods, and during such time periods other queues with
     * higher timestamps happen to be busy, then the backshifted
     * timestamps of the former queues can become much lower than
     * the system virtual time. In fact, to serve the queues with
     * higher timestamps while the ones with lower timestamps are
     * idle, the system virtual time may be pushed-up to much
     * higher values than the finish timestamps of the idle
     * queues. As a consequence, the finish timestamps of all new
     * or newly activated queues may end up being much larger than
     * those of lucky queues with backshifted timestamps. The
     * latter queues may then monopolize the device for a lot of
     * time. This would simply break service guarantees.
     *
     * To reduce this problem, push up a little bit the
     * backshifted timestamps of the queue associated with this
     * entity (only a queue can happen to have the backshifted
     * flag set): just enough to let the finish timestamp of the
     * queue be equal to the current value of the system virtual
     * time. This may introduce a little unfairness among queues
     * with backshifted timestamps, but it does not break
     * worst-case fairness guarantees.
     *
     * As a special case, if bfqq is weight-raised, push up
     * timestamps much less, to keep very low the probability that
     * this push up causes the backshifted finish timestamps of
     * weight-raised queues to become higher than the backshifted
     * finish timestamps of non weight-raised queues.
     */
    if (backshifted && bfq_gt(st->vtime, entity->finish)) {
        unsigned long delta = st->vtime - entity->finish;
 
        if (bfqq)
            delta /= bfqq->wr_coeff;
 
        entity->start += delta;
        entity->finish += delta;
    }
 
    bfq_active_insert(st, entity);
}
函数源码
