Linux ソースコードの解析 epoll

int init_reactor(int listen_fd,int ワーカーカウント){
	......
	// マルチコアを最大限に活用するために複数のepoll fdを作成します for(i=0;i<worker_count;i++){
		リアクター->worker_fd = epoll_create(EPOLL_MAX_EVENTS);
	}
	/* epoll は listen_fd を追加し、受け入れます */
	// accept 後のイベントを対応する epoll fd に追加します int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
	// 対応するワーカーに接続記述子を登録します epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);
}
//リアクターのワーカースレッド static void* rw_thread_func(void* arg){
	......

	のために（;;）{
		  // epoll_wait はイベントトリガーを待機します int retval = epoll_wait(epfd,events,EPOLL_MAX_EVENTS,500);
        if(戻り値 > 0){
        	for(j=0; j < retval; j++){
        		// 読み取りイベントを処理する if(event & EPOLLIN){
                 handle_ready_read_connection(接続);
                 続く;
             }
             /* その他のイベントを処理する */
        	}
        }
	}
	......
}

SYSCALL_DEFINE1(epoll_create、int、サイズ)
{
	(サイズ <= 0)の場合
		-EINVAL を返します。

	sys_epoll_create1(0) を返します。
}

SYSCALL_DEFINE1(epoll_create1、int、フラグ)
{
	// kzalloc(sizeof(*ep), GFP_KERNEL)、カーネル空間を使用します error = ep_alloc(&ep);
	// 使用されていないファイル記述子、つまり記述子配列内のスロットを取得します。 fd = get_unused_fd_flags(O_RDWR | (flags & O_CLOEXEC));
	// 匿名 inode ファイルシステムに inode を割り当て、そのファイル構造を取得します // そして file->f_op = &eventpoll_fops
	// そして file->private_data = ep;
	ファイル = anon_inode_getfile("[eventpoll]", &eventpoll_fops, ep,
				 O_RDWR | (フラグ & O_CLOEXEC));
	// ファイル記述子配列の対応するスロットにファイルを埋め込む fd_install(fd,file);			 
	ep->file = ファイル;
	fd を返します。
}

/*
 * この構造はfile->private_data*/に保存されます
構造体イベントポーリング{
	// スピンロック、カーネル内のスピンロックを使用してロックし、複数のスレッド（プロセス）がこの構造体を同時に操作できるようにします // 主に ready_list を保護します
	spinlock_t ロック;
	// このミューテックスは、イベントループが対応するファイル記述子を使用するときに、ファイル記述子が削除されないようにするためのものです。struct mutex mtx;
	// epoll_wait によって使用される待機キューは、プロセスのウェイクアップに関連しています wait_queue_head_t wq;
	// file->poll によって使用される待機キューは、プロセスのウェイクアップに関連しています wait_queue_head_t poll_wait;
	// 準備完了記述子キュー struct list_head rdllist;
	// epoll が現在追跡しているファイル記述子を赤黒ツリー struct rb_root rbr で整理します。
	// 準備完了イベントをユーザー空間に送信するときに、同時に発生するイベントのファイル記述子をこのリンクリストにリンクします struct epitem *ovflist;
	// 対応するユーザー
	構造体 user_struct *ユーザー;
	//対応するファイル記述子 struct file *file;
	// 次の 2 つはループ検出の最適化です int visits;
	構造体 list_head 訪問リストリンク;
};

SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
		構造体 epoll_event __user *、イベント)
{
	/* epfd が epoll 記述子であるかどうかを確認します */
	// ここでのミューテックスは、epoll_ctl への同時呼び出しを防ぐためのもので、つまり、内部データ構造を保護するためのものです。// 同時追加、変更、削除によって破壊されることはありません。mutex_lock_nested(&ep->mtx, 0);
	スイッチ（op）{
		EPOLL_CTL_ADDの場合:
			...
			// 赤黒木に挿入 error = ep_insert(ep, &epds, tfile, fd);
			...
			壊す;
		......
	}
	mutex_unlock(&ep->mtx);	
}

静的 int ep_insert(構造体eventpoll *ep, 構造体epoll_event *event,
		     構造体ファイル *tfile、int fd)
{
	/* エピテムを初期化する */
	// &epq.pt->qproc = ep_ptable_queue_proc
	init_poll_funcptr(&epq.pt、ep_ptable_queue_proc);
	// ここでコールバック関数を挿入します revents = tfile->f_op->poll(tfile, &epq.pt);
	// 準備が整ったイベントがある場合は、最初に準備完了リストに追加されます
	// たとえば、書き込み可能なイベント // さらに、TCP 内部 ack の後に tcp_check_space を呼び出し、最後に sock_def_write_space を呼び出して、epoll_wait の下で対応するプロセスを起動します if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) {
		リストの末尾に&epi->rdllink、&ep->rdllistを追加します。
		// wake_up epはepoll_wait下のプロセスに対応するif (waitqueue_active(&ep->wq)){
			ウェイクアップロックされました(&ep->wq);
		}
		......
	}	
	//epitem を赤黒木に挿入します ep_rbtree_insert(ep, epi);
	......
}

// accept 後のイベントを対応する epoll fd に追加します int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
// 対応するワーカーに接続記述子を登録します epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);

静的 void ep_ptable_queue_proc(構造体ファイル *file、wait_queue_head_t *whead、
				 ポーリングテーブル *pt)
{
	// 現在の client_fd に対応する epitem を取得します
	構造体epitem *epi = ep_item_from_epqueue(pt);
	// &pwq->wait->func=ep_poll_callback、コールバックウェイクアップに使用 // これは init_waitqueue_entry ではないことに注意してください。つまり、現在の KSE (現在のプロセス/スレッド) は wait_queue に書き込まれません。これは、現在インストールされている KSE からウェイクアップされる必要はなく、epoll_wait をウェイクアップする KSE である必要があるためです。
	init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
	// ここでの whead は sk->sk_sleep であり、現在のウェイトキューをソケットに対応するスリープ リストにリンクします。add_wait_queue(whead, &pwq->wait);	
}

SYSCALL_DEFINE4(epoll_wait、int、epfd、struct epoll_event __user *、イベント、
		int、maxevents、int、タイムアウト)
{
	/* epfd が epoll_create によって作成された fd であるかどうかを確認します */
	//ep_pollを呼び出す
	エラー = ep_poll(ep、イベント、最大イベント、タイムアウト);
	...
}

静的 int ep_poll(構造体eventpoll *ep, 構造体epoll_event __user *events,
		   int maxevents、長いタイムアウト)
{
	......
リトライ：
	// スピンロックを取得
	spin_lock_irqsave(&ep->lock, フラグ);
	// 現在の task_struct をウェイクアップの待機キューに書き込みます // wq_entry->func = default_wake_function;
	init_waitqueue_entry(&wait, 現在の値);
	// WQ_FLAG_EXCLUSIVE、排他的ウェイクアップ、SO_REUSEPORT と連携して受け入れパニック問題を解決します wait.flags |= WQ_FLAG_EXCLUSIVE;
	// ep の waitqueue へのリンク __add_wait_queue(&ep->wq, &wait);
	のために （;;） {
		// 現在のプロセス状態を割り込み可能に設定します。set_current_state(TASK_INTERRUPTIBLE);
		// 現在のスレッドに処理すべきシグナルがあるかどうかを確認し、ある場合は -EINTR を返します。
		if (signal_pending(現在)) {
			解像度 = -EINTR;
			壊す;
		}
		spin_unlock_irqrestore(&ep->lock, フラグ);
		// スケジュールをスケジュールし、CPU を放棄する
		jtimeout = schedule_timeout(jtimeout);
		spin_lock_irqsave(&ep->lock, フラグ);
	}
	// ここでは、タイムアウトまたはイベントのトリガーによってプロセスが再スケジュールされたことを示します __remove_wait_queue(&ep->wq, &wait);
	// プロセスステータスを実行中に設定する
	TASK_RUNNING の現在の状態を設定します。
	......
	// 利用可能なイベントがあるかどうかを確認します eavail = !list_empty(&ep->rdllist) || ep->ovflist != EP_UNACTIVE_PTR;
	......
	//準備完了イベントをユーザー空間にコピー ep_send_events(ep, events, maxevents)
}

静的int ep_scan_ready_list(構造体eventpoll *ep,
			      int (*sproc)(構造体eventpoll *,
					   構造体 list_head *、void *)、
			      void *priv、
			      整数の深さ)
{
	...
	// epfd の rdllist を txlist にリンクする
	list_splice_init(&ep->rdllist, &txlist);
	...
	/* sproc = ep_send_events_proc */
	エラー = (*sproc)(ep, &txlist, priv);
	...
	// プロセス ovflist、つまり上記の sproc プロセスで発生するイベント...
}

静的 int ep_send_events_proc(構造体eventpoll *ep、構造体list_head *head、
			       void *priv)
{
	(eventcnt = 0、uevent = esed->events;の場合
	     !list_empty(head) && eventcnt < esed->maxevents;) {
	   // 準備完了リストを走査する 
		epi = list_first_entry(head、構造体epitem、rdllink);
		list_del_init(&epi->rdllink);
		// readylist は現在のエピにイベントがあることのみを示します。特定のイベント情報については、対応するファイルのポーリングを呼び出す必要があります。
		// ここでのポーリングは tcp_poll であり、tcp 自体の情報に従ってマスクとその他の情報を設定し、現在のイベントが興味のあるイベントであるかどうかを知るために興味のあるイベントマスクを設定します。epoll_wait revents = epi->ffd.file->f_op->poll(epi->ffd.file, NULL) &
			epi->event.events;
		if(revents){
			/* イベントをユーザー空間に配置する */
			/* ONESHOTロジックを処理 */
			// エッジ トリガーでない場合は、現在のエピを使用可能なリストに追加して、次回ポーリングをトリガーできるようにします。次のポーリングの revents が 0 でない場合、ユーザー スペースはそれを認識できます*/
			そうでない場合 (!(epi->event.events & EPOLLET)){
				リストの末尾に&epi->rdllink、&ep->rdllistを追加します。
			}
			/* エッジ トリガーの場合は、使用可能なリストに追加されません。そのため、対応するエピは、次の使用可能なイベントがトリガーされたときにのみ使用可能なリストに追加されます */
			イベントcnt++
		}
		/* epoll_wait がポーリングされた revents イベントに興味がない場合 (またはイベントがまったくない場合)、そのイベントは利用可能なリストに追加されません */
		......
	}
	eventcnt を返します。
}

静的 int ep_poll_callback(wait_queue_t *wait、符号なしモード、int sync、void *key)
{
	// waitに対応するエピテムを取得する	
	構造体epitem *epi = ep_item_from_wait(wait);
	// epitem に対応する eventpoll 構造体 struct eventpoll *ep = epi->ep;
	// ready_list およびその他の構造体を保護するためにスピン ロックを取得します spin_lock_irqsave(&ep->lock, flags);
	// 現在の epi が ep の準備完了リストにリンクされていない場合は、リンクします // このようにして、現在利用可能なイベントが epoll の利用可能なリストに追加されます if (!ep_is_linked(&epi->rdllink))
		リストの末尾に&epi->rdllink、&ep->rdllistを追加します。
	// epoll_wait 待ちがある場合は、epoll_wait プロセスを起動します // 対応する &ep->wq は、epoll_wait が呼び出されたときに init_waitqueue_entry(&wait, current) によって生成されます // current は、epoll_wait の呼び出しに対応するプロセス情報 task_struct です
	waitqueue_active(&ep->wq) の場合
		ウェイクアップロックされました(&ep->wq);
}

void sk_stream_write_space(構造体 sock *sk)
{
	// つまり、書き込み可能イベントは書き込み可能なスペースが 1/3 ある場合にのみトリガーされます if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
		clear_bit(SOCK_NOSPACE, &sock->flags);

		if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
			wake_up_interruptible_poll(sk->sk_sleep、POLLOUT |
						ポルワーノーム | ポルワーバンド)
		......
	}
}