/* "NOOP" scheduler: the best scheduler, recommended for all interfaces
   under all circumstances. It is difficult to invent anything faster or
   cheaper.
 */

static int noop_enqueue(struct sk_buff *skb, struct Qdisc *qdisc)
{
	kfree_skb(skb);
	return NET_XMIT_CN;
}

static struct sk_buff *noop_dequeue(struct Qdisc *qdisc)
{
	return NULL;
}

struct Qdisc_ops noop_qdisc_ops __read_mostly = {
	.id		=	"noop",
	.priv_size	=	0,
	.enqueue	=	noop_enqueue,
	.dequeue	=	noop_dequeue,
	.peek		=	noop_dequeue,
	.owner		=	THIS_MODULE,
};

static struct netdev_queue noop_netdev_queue = {
	.qdisc		=	&noop_qdisc,
	.qdisc_sleeping	=	&noop_qdisc,
};

struct Qdisc noop_qdisc = {
	.enqueue	=	noop_enqueue,
	.dequeue	=	noop_dequeue,
	.flags		=	TCQ_F_BUILTIN,
	.ops		=	&noop_qdisc_ops,
	.list		=	LIST_HEAD_INIT(noop_qdisc.list),
	.q.lock		=	__SPIN_LOCK_UNLOCKED(noop_qdisc.q.lock),
	.dev_queue	=	&noop_netdev_queue,
	.busylock	=	__SPIN_LOCK_UNLOCKED(noop_qdisc.busylock),
};
//此时网络设备还不能发送任何数据包，必须等网络设备启用之后才能发送数据包
void dev_init_scheduler(struct net_device *dev)
{
	dev->qdisc = &noop_qdisc;
	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
	dev_init_scheduler_queue(dev, &dev->rx_queue, &noop_qdisc);

	setup_timer(&dev->watchdog_timer, dev_watchdog, (unsigned long)dev);
}

/*
tc可以使用以下命令对QDisc、类和过滤器进行操作：
add，在一个节点里加入一个QDisc、类或者过滤器。添加时，需要传递一个祖先作为参数，传递参数时既可以使用ID也可以直接传递设备的根。如果要建立一个QDisc或者过滤器，可以使用句柄(handle)来命名；如果要建立一个类，可以使用类识别符(classid)来命名。
remove，删除有某个句柄(handle)指定的QDisc，根QDisc(root)也可以删除。被删除QDisc上的所有子类以及附属于各个类的过滤器都会被自动删除。
change，以替代的方式修改某些条目。除了句柄(handle)和祖先不能修改以外，change命令的语法和add命令相同。换句话说，change命令不能一定节点的位置。
replace，对一个现有节点进行近于原子操作的删除／添加。如果节点不存在，这个命令就会建立节点。
link，只适用于DQisc，替代一个现有的节点。
tc qdisc [ add | change | replace | link ] dev DEV [ parent qdisc-id | root ] [ handle qdisc-id ] qdisc [ qdisc specific parameters ]
tc class [ add | change | replace ] dev DEV parent qdisc-id [ classid class-id ] qdisc [ qdisc specific parameters ]
tc filter [ add | change | replace ] dev DEV [ parent qdisc-id | root ] protocol protocol prio priority filtertype [ filtertype specific parameters ] flowid flow-id
tc [-s | -d ] qdisc show [ dev DEV ]
tc [-s | -d ] class show dev DEV tc filter show dev DEV
*/
/*
（四）用户空间如何和内核通信
iproute2是一个用户空间的程序，它的功能是解释以tc开头的命令，如果解释成功，把它们通过AF_NETLINK的socket传给Linux的内核空间，使用的netlink协议类型是NETLINK_ROUTE。
发送的netlink数据包都必须包含两个字段：protocol和msgtype，内核根据这两个字段来定位接收函数。
在系统初始化的时候将会调用如下函数：
*/
static int __init pktsched_init(void)
{
	int err;

	err = register_pernet_subsys(&psched_net_ops);
	if (err) {
		pr_err("pktsched_init: "
		       "cannot initialize per netns operations\n");
		return err;
	}

	register_qdisc(&pfifo_fast_ops);
	register_qdisc(&pfifo_qdisc_ops);
	register_qdisc(&bfifo_qdisc_ops);
	register_qdisc(&pfifo_head_drop_qdisc_ops);
	register_qdisc(&mq_qdisc_ops);
	register_qdisc(&noqueue_qdisc_ops);
 //tc filer 的注册在tc_filter_init
//通过rtnetlink_rcv_msg和应用层netlink方式交互
//其中的rtnl_register()函数用于注册TC要接收的消息类型以及对应的接收函数。
//每个表头rtnl_msg_handlers[i]上面存储RTM_NR_MSGTYPES个rtnl_link，图解见TC流量控制实现分析
	rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, NULL); //tc qdisc add和tc calss change的时候会调用tc_modify_qdisc
	rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, NULL);//tc qdisc del的时候会调用tc_modify_qdisc
	rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc, NULL);//tc qdisc ls 的时候会调用tc_modify_qdisc
	rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, NULL); //tc class add 的时候会调用这个
	rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, NULL);//tc class del 的时候会调用这个
	rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass, NULL);//tc class ls的时候调用这个

	return 0;
}

int dev_open(struct net_device *dev)
{
       ..............................  
	ret = __dev_open(dev);
       ..............................  
}
static int __dev_open(struct net_device *dev)
{
	...................
    dev_activate(dev);
    add_device_randomness(dev->dev_addr, dev->addr_len);
	......................
}

void dev_activate(struct net_device *dev)
{
       ..................................
	/* No queueing discipline is attached to device;
	 * create default one for devices, which need queueing
	 * and noqueue_qdisc for virtual interfaces
	 */
/*如果没有Qdisc的规则设置到device，就给设备create一个默认的规则*/
	if (dev->qdisc == &noop_qdisc)
		attach_default_qdiscs(dev);//设置默认qdisc算法

	.........................
}

static void attach_default_qdiscs(struct net_device *dev)
{
	struct netdev_queue *txq;
	struct Qdisc *qdisc;
 
	txq = netdev_get_tx_queue(dev, 0);
         
        /*这个地方判断dev是否是多Q的设备，如果是不是多Q的设备，或者tx_queue_len为0 就会进入if判断
         *这个地方比较疑惑，if内部使用的是一个循环去遍历tx_queue 感觉是要处理multiqueue的状况，现在
         *却用来处理一个的...*/
	if (!netif_is_multiqueue(dev) || dev->tx_queue_len == 0) {
		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
		dev->qdisc = txq->qdisc_sleeping;
		atomic_inc(&dev->qdisc->refcnt);
	} else {
	
	/*如果不满足上述条件，就创建一个默认的，mq_qdisc_ops，从他的注释来看 mq 的Qdisc只使用与多Q状况*/
		qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT);//调用mq_init
		if (qdisc) {
			dev->qdisc = qdisc;
			qdisc->ops->attach(qdisc);//mq_attach
		}
	}
}

truct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
				const struct Qdisc_ops *ops,
				unsigned int parentid)
{
	struct Qdisc *sch;
	if (!try_module_get(ops->owner))
		return NULL;
	sch = qdisc_alloc(dev_queue, ops);
	if (IS_ERR(sch)) {
		module_put(ops->owner);
		return NULL;
	}
	sch->parent = parentid;
	if (!ops->init || ops->init(sch, NULL) == 0)	//mq_init
		return sch;
	qdisc_destroy(sch);
	return NULL;
}
struct mq_sched {
	struct Qdisc		**qdiscs;
};
static int mq_init(struct Qdisc *sch, struct nlattr *opt)
{
	struct net_device *dev = qdisc_dev(sch);
	struct mq_sched *priv = qdisc_priv(sch);
	struct netdev_queue *dev_queue;
	struct Qdisc *qdisc;
	unsigned int ntx;
	if (sch->parent != TC_H_ROOT)
		return -EOPNOTSUPP;
	if (!netif_is_multiqueue(dev))
		return -EOPNOTSUPP;
	/* pre-allocate qdiscs, attachment can‘t fail */
	priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),
			       GFP_KERNEL);
	if (priv->qdiscs == NULL)
		return -ENOMEM;
	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
		dev_queue = netdev_get_tx_queue(dev, ntx);
		qdisc = qdisc_create_dflt(dev_queue, get_default_qdisc_ops(dev, ntx),	//为每个队列分配默认的qdisc算法
					  TC_H_MAKE(TC_H_MAJ(sch->handle),
						    TC_H_MIN(ntx + 1)));
		if (qdisc == NULL)
			goto err;
		priv->qdiscs[ntx] = qdisc;
		qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
	}
	sch->flags |= TCQ_F_MQROOT;
	return 0;
err:
	mq_destroy(sch);
	return -ENOMEM;
}
static inline const struct Qdisc_ops *
get_default_qdisc_ops(const struct net_device *dev, int ntx)
{
	return ntx < dev->real_num_tx_queues ?
			default_qdisc_ops : &pfifo_fast_ops;
}
static void mq_attach(struct Qdisc *sch)
{
	struct net_device *dev = qdisc_dev(sch);
	struct mq_sched *priv = qdisc_priv(sch);
	struct Qdisc *qdisc, *old;
	unsigned int ntx;
	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
		qdisc = priv->qdiscs[ntx];
		old = dev_graft_qdisc(qdisc->dev_queue, qdisc);	//设置qdisc到设备队列的qdisc_sleeping中
		if (old)
			qdisc_destroy(old);
#ifdef CONFIG_NET_SCHED
		if (ntx < dev->real_num_tx_queues)
			qdisc_hash_add(qdisc);
#endif
	}
	kfree(priv->qdiscs);
	priv->qdiscs = NULL;
}
/* Attach toplevel qdisc to device queue. */
struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
			      struct Qdisc *qdisc)
{
	struct Qdisc *oqdisc = dev_queue->qdisc_sleeping;
	spinlock_t *root_lock;
	root_lock = qdisc_lock(oqdisc);
	spin_lock_bh(root_lock);
	/* Prune old scheduler */
	if (oqdisc && atomic_read(&oqdisc->refcnt) <= 1)
		qdisc_reset(oqdisc);
	/* ... and graft new one */
	if (qdisc == NULL)
		qdisc = &noop_qdisc;
	dev_queue->qdisc_sleeping = qdisc;
	rcu_assign_pointer(dev_queue->qdisc, &noop_qdisc);
	spin_unlock_bh(root_lock);
	return oqdisc;
}

/*pfifo_fast_ops pfifo_qdisc_ops tbf_qdisc_ops sfq_qdisc_ops prio_class_ops这几个都为出口，ingress_qdisc_ops为入口 */
struct Qdisc_ops pfifo_fast_ops { //;//__read_mostly = {
	.id		=	"pfifo_fast",
	.priv_size	=	sizeof(struct pfifo_fast_priv),
	.enqueue	=	pfifo_fast_enqueue,
	.dequeue	=	pfifo_fast_dequeue,
	.peek		=	pfifo_fast_peek,
	.init		=	pfifo_fast_init,
	.reset		=	pfifo_fast_reset,
	.dump		=	pfifo_fast_dump,
	.owner		=	THIS_MODULE,
};

//通过skb->priority计算出band,从而来确定把该SKB加入到pfifo_fast_priv的q[i]队列中
static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc* qdisc) //和下面的pfifo_fast_enqueue结合使用
{/*先是要判断一下在Q中的数据包的数量，是否超过了tx_queue_len的值*/
	if (skb_queue_len(&qdisc->q) < qdisc_dev(qdisc)->tx_queue_len) {
		int band = prio2band[skb->priority & TC_PRIO_MAX];
		struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
		struct sk_buff_head *list = band2list(priv, band);

        //例如0 1 2频道都有数据，则bitmap=二进制0111，也就是7，bitmap2band[7]对应0，也就是首先发送第0频道pfifo_fast_priv->q[0]skb队列数据，
        //同理如果0发送完毕，则bitmap变为0x0110,也就是6，bitmap2band[6]对应1，也就是发送第1频道pfifo_fast_priv->q[1]skb队列数据，
		priv->bitmap |= (1 << band);
		qdisc->q.qlen++;
		return __qdisc_enqueue_tail(skb, qdisc, list);
	}

	return qdisc_drop(skb, qdisc);
}

/*
__QDISC_STATE_RUNNING标志用于保证一个流控对象不会同时被多个例程运行。
软中断线程的动作：运行加入到output_queue链表中的所有流控对象，如果试图运行某个流控对象时，发现已经有其他内核路径在运行这个对象，直接返回，并试图运行下一个流控对象。
*/
void __qdisc_run(struct Qdisc *q)
{
	int quota = weight_p;
	int packets;
/*这个函数是调用qdisc_restart去发送Q中的数据包，packet记录这次发送了多少...*/
	while (qdisc_restart(q, &packets)) {
		/*
		 * Ordered by possible occurrence: Postpone processing if
		 * 1. we‘ve exceeded packet quota
		 * 2. another process needs the CPU;
		 *//* 这边会有限定额度64个封包，如果超过64个就不能再次连续发了，
		 *  需要以后执行softirq去发送了*/

		quota -= packets;
		if (quota <= 0 || need_resched()) {//将本队列加入软中断的output_queue链表中。
        /*将队列加入发送软中断NET_TX_SOFTIRQ的处理队列，当软中断被执行时，队列又会继续发送数据包。*/
			__netif_schedule(q);//激活发送软件中的，最终调用net_tx_action
			break;
		}
	}

	qdisc_run_end(q);
}

/*
  * 激活数据包输出软中断有多个接口，而
  * __netif_schedule()是最常用的。
  *///激活发送软件中的，最终调用net_tx_action
void __netif_schedule(struct Qdisc *q)
{
	/*
	  * 如果输出网络设备没有处于流量
	  * 控制的调度中，则调用__netif_reschedule()
	  * 激活输出软中断
	  */
	if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
		__netif_reschedule(q);
}

//把Qdisc中的数据放入cpu sd的output_queue_tailp输出队列，将队列加入发送软中断NET_TX_SOFTIRQ的处理队列，当软中断被执行时，队列又会继续发送数据包。__netif_reschedule
/*
由于软中断被激活，软中断的优先级仅次于硬中断，这样就保证了队列会被及时的运行，即保证了数据包会被及时的发送。
*///激活发送软件中的，最终调用net_tx_action
//dev_queue_xmit -> __dev_xmit_skb -> __qdisc_run最终调用到该函数，把流控对象Qdisc添加到CPU软中断的output_queue
static inline void __netif_reschedule(struct Qdisc *q)
{
	struct softnet_data *sd;
	unsigned long flags;

    /*
      * 将网络设备链接到softnet_data中的output_queu
      * 队列上，然后激活网络输出软中断对该
      * 队列进行处理。
      */
	local_irq_save(flags);
	sd = &__get_cpu_var(softnet_data);
	q->next_sched = NULL;
	////在net_dev_init中，sd->output_queue_tailp = &sd->output_queue;所以相当于把q添加到了output_queue队列中
	*sd->output_queue_tailp = q;
	sd->output_queue_tailp = &q->next_sched;
	raise_softirq_irqoff(NET_TX_SOFTIRQ); //激活发送软件中的，最终调用net_tx_action
	local_irq_restore(flags);
}

/*
  * net_tx_action()是数据包输出软中断的例程，
  * 一旦激活便会遍历output_queue队列中
  * 待处理的输出网络设备，然后调用
  * qdisc_run()在合适的时机发送数据包。
  * 数据包输出软中断通常有netif_schedule()激活。
  */ //qos tc 流量控制的时候会用到
static void net_tx_action(struct softirq_action *h)
{
	struct softnet_data *sd = this_cpu_ptr(&softnet_data);
/*
	  * 如果当前CPU的softnet_data中存在已完成
	  * 输出待释放的数据包，则遍历
	  * completion_queue队列，释放该队列中所有
	  * 数据包，对于发送而言，硬中断只是通过网卡把包发走，但是回收内存的事情是通过软中断来做的，
          *设备驱动发送完数据之后，会调用dev_kfree_skb_irq，不过也有的设备比较个别
          *自己去free，这个其实也没有什么问题的...省掉了软中断的处理*/
	  */
	if (sd->completion_queue) {
		struct sk_buff *clist;

		local_irq_disable();
		clist = sd->completion_queue;
		sd->completion_queue = NULL;
		local_irq_enable();

		while (clist) {
			struct sk_buff *skb = clist;
			clist = clist->next;

			WARN_ON(atomic_read(&skb->users));
			if (likely(get_kfree_skb_cb(skb)->reason == SKB_REASON_CONSUMED))
				trace_consume_skb(skb);
			else
				trace_kfree_skb(skb, net_tx_action);

			if (skb->fclone != SKB_FCLONE_UNAVAILABLE)
				__kfree_skb(skb);
			else
				__kfree_skb_defer(skb);
		}

		__kfree_skb_flush();
	}
/*
	  * 如果当前CPU的softnet_data中存在待处理的输出网络
	  * 设备，则遍历output_queue队列，调用qdisc_run()来发送
	  * 数据包或者再次调度数据包输出软中断，在
	  * 合适的时机发送数据包。
	  */
	if (sd->output_queue) {
		struct Qdisc *head;

		local_irq_disable();
		head = sd->output_queue;
		sd->output_queue = NULL;
		sd->output_queue_tailp = &sd->output_queue;
		local_irq_enable();

		while (head) {
			struct Qdisc *q = head;
			spinlock_t *root_lock;

			head = head->next_sched;

			root_lock = qdisc_lock(q);
			if (spin_trylock(root_lock)) {
				smp_mb__before_atomic();
				clear_bit(__QDISC_STATE_SCHED,
					  &q->state);
				qdisc_run(q);
				spin_unlock(root_lock);
			} else {
				if (!test_bit(__QDISC_STATE_DEACTIVATED,
					      &q->state)) {
					__netif_reschedule(q);
				} else {
					smp_mb__before_atomic();
					clear_bit(__QDISC_STATE_SCHED,
						  &q->state);
				}
			}
		}
	}

enum netdev_tx {
	__NETDEV_TX_MIN	 = INT_MIN,	/* make sure enum is signed */
	NETDEV_TX_OK	 = 0x00,	/* driver took care of packet */
	NETDEV_TX_BUSY	 = 0x10,	/* driver tx path was busy*/
       NETDEV_TX_LOCKED = 0x20,	/* driver tx lock was already taken */
};
static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
					      struct sk_buff *skb, struct net_device *dev,
					      bool more)
{
	skb->xmit_more = more ? 1 : 0;
	return ops->ndo_start_xmit(skb, dev);
}
返回一个错误的值，表示这个数据包发送出现问题，但是目前Qdisc会进行拥塞处理，将数据包在放到queue中，下面的代码段是在sch_direct_xmit函数中返回值处理的部分
如果发送成功，就会返回Q的len，如果NETDEV_TX_LOCKED会说明driver去lock的时候失败，其他状况下一般认为是默认的错误即TX BUSY,这个时候会调用dev_requeue_skb把数据包重新放到Qdisc的队列中
/*进行返回值处理！ 如果ret < NET_XMIT_MASK 为true 否则 flase*/
	if (dev_xmit_complete(ret)) {
		/* Driver sent out skb successfully or skb was consumed */
		/*这个地方需要注意可能有driver的负数的case，也意味着这个skb被drop了*/
		ret = qdisc_qlen(q);//成功发送报文，如果缓存区中还有报文，则尝试继续发送报文
	} else {
		/* Driver returned NETDEV_TX_BUSY - requeue skb */
		if (unlikely(ret != NETDEV_TX_BUSY))
			net_warn_ratelimited("BUG %s code %d qlen %d\n",
					     dev->name, ret, q->q.qlen);
		 /*发生Tx Busy的时候，重新进行requeue*/
		ret = dev_requeue_skb(skb, q);//发送失败，则  入队重新进行发送
	}

/* Modifications to data participating in scheduling must be protected with
 * qdisc_lock(qdisc) spinlock.
 *
 * The idea is the following:
 * - enqueue, dequeue are serialized via qdisc root lock
 * - ingress filtering is also serialized via qdisc root lock
 * - updates to tree and tree walking are only done under the rtnl mutex.
 */

static inline int dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
{
	q->gso_skb = skb;
	q->qstats.requeues++;
	qdisc_qstats_backlog_inc(q, skb);
	q->q.qlen++;	/* it‘s still part of the queue */
	__netif_schedule(q);

	return 0;
}