深入理解select的行为

    while (1) {       
        fd_set rfds;
        fd_set wfds;
        int32_t maxfd = 0, res = 0;
        struct timeval timeout;
        
        timeout.tv_sec = 0;
        timeout.tv_usec = 500;
        
        FD_ZERO(&rfds);
        FD_ZERO(&wfds);
        
        FD_SET(socket1, &rfds);
        FD_SET(socket2, &rfds);
        
        maxfd = socket1 > socket2 ? socket1 : socket2;
        
        res = select(maxfd + 1, &rfds, NULL, NULL, &timeout);
        
        if (res < 0 && errno != EINTR && errno != 0) {
            // log it
            return;
        }
        
        if (FD_ISSET(socket1, &rfds)) {
            // do something 
        }
        if (FD_ISSET(socket2, &rfds)) {
            // do something 
        }
     }

typedef __kernel_fd_set		fd_set;

#define __FD_SETSIZE	1024

typedef struct {
	unsigned long fds_bits[__FD_SETSIZE / (8 * sizeof(long))];
} __kernel_fd_set;

	/* max_fds can increase, so grab it once to avoid race */
	rcu_read_lock();
	fdt = files_fdtable(current->files);
	max_fds = fdt->max_fds;
	rcu_read_unlock();
	if (n > max_fds)
		n = max_fds;

	/*
	 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
	 * since we used fdset we need to allocate memory in units of
	 * long-words. 
	 */
	size = FDS_BYTES(n);
	bits = stack_fds;
	if (size > sizeof(stack_fds) / 6) {
		/* Not enough space in on-stack array; must use kmalloc */
		ret = -ENOMEM;
		bits = kmalloc(6 * size, GFP_KERNEL);
		if (!bits)
			goto out_nofds;
	}
	fds.in      = bits;
	fds.out     = bits +   size;
	fds.ex      = bits + 2*size;
	fds.res_in  = bits + 3*size;
	fds.res_out = bits + 4*size;
	fds.res_ex  = bits + 5*size;
  if ((ret = get_fd_set(n, inp, fds.in)) ||
	    (ret = get_fd_set(n, outp, fds.out)) ||
	    (ret = get_fd_set(n, exp, fds.ex)))
		goto out;
	zero_fd_set(n, fds.res_in);
	zero_fd_set(n, fds.res_out);
	zero_fd_set(n, fds.res_ex);

	ret = do_select(n, &fds, end_time);

for (;;) {
    ...
    for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
        ...
        for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
            ...
            if (!(bit & all_bits))
                continue;
            file = fget_light(i, &fput_needed);
            if (file) {
            		f_op = file->f_op;
								mask = DEFAULT_POLLMASK;
								if (f_op && f_op->poll) {
										wait_key_set(wait, in, out, bit);
										mask = (*f_op->poll)(file, wait);
								}
								fput_light(file, fput_needed);
								if ((mask & POLLIN_SET) && (in & bit)) {
										res_in |= bit;
										retval++;
										wait->_qproc = NULL;
								}
								if ((mask & POLLOUT_SET) && (out & bit)) {
										res_out |= bit;
									  retval++;
									  wait->_qproc = NULL;
								}
								if ((mask & POLLEX_SET) && (ex & bit)) {
						        res_ex |= bit;
						        retval++;
						        wait->_qproc = NULL;
					      }
					 }
					 cond_resched();
				}
			  wait->_qproc = NULL;
				if (retval || timed_out || signal_pending(current))
					 break;
				if (table.error) {
			     retval = table.error;
			     break;
		    }

				/*
		 				* If this is the first loop and we have a timeout
						* given, then we convert to ktime_t and set the to
		 				* pointer to the expiry value.
		 		*/
				if (end_time && !to) {
					 expire = timespec_to_ktime(*end_time);
			     to = &expire;
				}

				if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
					   		to, slack))
							timed_out = 1;
}