erl_check_io.c

来自「OTP是开放电信平台的简称」· C语言 代码 · 共 1,430 行 · 第 1/3 页

	case ERTS_EV_TYPE_NONE: /* Deselected ... */
	    break;

	default: { /* Error */
	    erts_dsprintf_buf_t *dsbufp;
	    dsbufp = erts_create_logger_dsbuf();
	    erts_dsprintf(dsbufp,
			  "Invalid event request type for fd in erts_poll()! "
			  "fd=%d, event request type=%sd\n", fd,
			  (int) drv_ev_state[fd].type);
	    ASSERT(0);
	    deselect(fd, 0);
	    break;
	}
	}

    }

    reset_ignores();

    erts_smp_mtx_unlock(&drv_ev_state_mtx);
}

static void
bad_fd_in_pollset(int fd, Eterm inport, Eterm outport, ErtsPollEvents events)
{
    erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();

    if (events & (ERTS_POLL_EV_IN|ERTS_POLL_EV_OUT)) {
	char *io_str;
	Eterm port = NIL;
	if ((events & ERTS_POLL_EV_IN) && (events & ERTS_POLL_EV_OUT)) {
	    io_str = "input/output";
	    if (inport == outport)
		port = inport;
	}
	else {
	    if (events & ERTS_POLL_EV_IN) {
		io_str = "input";
		port = inport;
	    }
	    else {
		io_str = "output";
		port = outport;
	    }
	}
	erts_dsprintf(dsbufp,
		      "Bad %s fd in erts_poll()! fd=%d, ",
		      io_str, fd);
	if (is_nil(port)) {
	    ErtsPortNames *ipnp = erts_get_port_names(inport);
	    ErtsPortNames *opnp = erts_get_port_names(outport);
	    erts_dsprintf(dsbufp, "ports=%T/%T, drivers=%s/%s, names=%s/%s\n",
			  is_nil(inport) ? am_undefined : inport,
			  is_nil(outport) ? am_undefined : outport,
			  ipnp->driver_name ? ipnp->driver_name : "<unknown>",
			  opnp->driver_name ? opnp->driver_name : "<unknown>",
			  ipnp->name ? ipnp->name : "<unknown>",
			  opnp->name ? opnp->name : "<unknown>");
	    erts_free_port_names(ipnp);
	    erts_free_port_names(opnp);
	}
	else {
	    ErtsPortNames *pnp = erts_get_port_names(port);
	    erts_dsprintf(dsbufp, "port=%T, driver=%s, name=%s\n",
			  is_nil(port) ? am_undefined : port,
			  pnp->driver_name ? pnp->driver_name : "<unknown>",
			  pnp->name ? pnp->name : "<unknown>");
	    erts_free_port_names(pnp);
	}
    }
    else {
	erts_dsprintf(dsbufp, "Bad fd in erts_poll()! fd=%d\n", fd);
    }
    erts_send_error_to_logger_nogl(dsbufp);

    /* unmap entry */
    deselect(fd, 0);
}

static void
stale_drv_select(Eterm id, int fd, int mode)
{
    erts_stale_drv_select(id, (ErlDrvEvent) fd, mode, 0);
    deselect(fd, mode);
}

void
ERTS_CIO_EXPORT(erts_init_check_io)(void)
{
    init_fd_list_alloc();
    ignored_list = NULL;
    erts_smp_atomic_init(&in_poll_wait, 0);
    ERTS_CIO_POLL_INIT();
    max_fds = ERTS_CIO_POLL_MAX_FDS();
    pollset = ERTS_CIO_NEW_POLLSET();
    erts_smp_mtx_init(&drv_ev_state_mtx, "drv_ev_state");
    drv_ev_state_len = 0;
    drv_ev_state = NULL;
}

int
ERTS_CIO_EXPORT(erts_check_io_max_files)(void)
{
    return max_fds;
}

Uint
ERTS_CIO_EXPORT(erts_check_io_size)(void)
{
    Uint res;
    ErtsPollInfo pi;
    erts_smp_mtx_lock(&drv_ev_state_mtx);
    ERTS_CIO_POLL_INFO(pollset, &pi);
    res = pi.memory_size;
    res += sizeof(ErtsDrvEventState)*drv_ev_state_len;
    erts_smp_mtx_unlock(&drv_ev_state_mtx);
    return res;
}

Eterm
ERTS_CIO_EXPORT(erts_check_io_info)(void *proc)
{
    Process *p = (Process *) proc;
    Eterm tags[15], values[15], res;
    Uint sz, *szp, *hp, **hpp, memory_size;
    Sint i;
    ErtsPollInfo pi;

    erts_smp_mtx_lock(&drv_ev_state_mtx);
    ERTS_CIO_POLL_INFO(pollset, &pi);
    memory_size = pi.memory_size;
    memory_size += sizeof(ErtsDrvEventState)*drv_ev_state_len;
    erts_smp_mtx_unlock(&drv_ev_state_mtx);

    hpp = NULL;
    szp = &sz;
    sz = 0;

 bld_it:
    i = 0;

    tags[i] = erts_bld_atom(hpp, szp, "name");
    values[i++] = erts_bld_atom(hpp, szp, "erts_poll");

    tags[i] = erts_bld_atom(hpp, szp, "primary");
    values[i++] = erts_bld_atom(hpp, szp, pi.primary);

    tags[i] = erts_bld_atom(hpp, szp, "fallback");
    values[i++] = erts_bld_atom(hpp, szp, pi.fallback ? pi.fallback : "false");

    tags[i] = erts_bld_atom(hpp, szp, "kernel_poll");
    values[i++] = erts_bld_atom(hpp, szp,
				pi.kernel_poll ? pi.kernel_poll : "false");

    tags[i] = erts_bld_atom(hpp, szp, "memory_size");
    values[i++] = erts_bld_uint(hpp, szp, memory_size);

    tags[i] = erts_bld_atom(hpp, szp, "total_poll_set_size");
    values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.poll_set_size);

    if (pi.fallback) {
	tags[i] = erts_bld_atom(hpp, szp, "fallback_poll_set_size");
	values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.fallback_poll_set_size);
    }

    tags[i] = erts_bld_atom(hpp, szp, "lazy_updates");
    values[i++] = pi.lazy_updates ? am_true : am_false;

    if (pi.lazy_updates) {
	tags[i] = erts_bld_atom(hpp, szp, "pending_updates");
	values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.pending_updates);
    }

    tags[i] = erts_bld_atom(hpp, szp, "batch_updates");
    values[i++] = pi.batch_updates ? am_true : am_false;

    tags[i] = erts_bld_atom(hpp, szp, "concurrent_updates");
    values[i++] = pi.concurrent_updates ? am_true : am_false;

    tags[i] = erts_bld_atom(hpp, szp, "max_fds");
    values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.max_fds);

#ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
    tags[i] = erts_bld_atom(hpp, szp, "no_avoided_wakeups");
    values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.no_avoided_wakeups);

    tags[i] = erts_bld_atom(hpp, szp, "no_avoided_interrupts");
    values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.no_avoided_interrupts);

    tags[i] = erts_bld_atom(hpp, szp, "no_interrupt_timed");
    values[i++] = erts_bld_uint(hpp, szp, (Uint) pi.no_interrupt_timed);
#endif

    res = erts_bld_2tup_list(hpp, szp, i, tags, values);

    if (!hpp) {
	hp = HAlloc(p, sz);
	hpp = &hp;
	szp = NULL;
	goto bld_it;
    }

    return res;
}

static ERTS_INLINE ErtsPollEvents
print_events(ErtsPollEvents ev)
{
    int first = 1;
    if(ev & ERTS_POLL_EV_IN) {
	ev &= ~ERTS_POLL_EV_IN;
	erts_printf("%s%s", first ? "" : "|", "IN");
	first = 0;
    }
    if(ev & ERTS_POLL_EV_OUT) {
	ev &= ~ERTS_POLL_EV_OUT;
	erts_printf("%s%s", first ? "" : "|", "OUT");
	first = 0;
    }
    /* The following should not appear... */
    if(ev & ERTS_POLL_EV_NVAL) {
	erts_printf("%s%s", first ? "" : "|", "NVAL");
	first = 0;
    }
    if(ev & ERTS_POLL_EV_ERR) {
	erts_printf("%s%s", first ? "" : "|", "ERR");
	first = 0;
    }
    if(ev & ERTS_POLL_EV_1SHOT) {
	erts_printf("%s%s", first ? "" : "|", "1SHOT");
	first = 0;
    }
    if(ev & ERTS_POLL_EV_FULL_1SHOT) {
	erts_printf("%s%s", first ? "" : "|", "FULL_1SHOT");
	first = 0;
    }
    if (ev)
	erts_printf("%s0x%b32x", first ? "" : "|", (Uint32) ev);
    return ev;
}

int
ERTS_CIO_EXPORT(erts_check_io_debug)(void)
{
    int res = 0;
    int fd;
    int used_fds = 0;
    int internal_fds = 0;
    ErtsPollEvents *epep;
    ErtsDrvEventState null_des;

    null_des.driver.select = NULL;
    null_des.events = 0;
    null_des.flags = 0;
    null_des.type = ERTS_EV_TYPE_NONE;

    erts_smp_mtx_lock(&drv_ev_state_mtx);

    erts_printf("--- fds in pollset --------------------------------------\n");

    epep = erts_alloc(ERTS_ALC_T_TMP, sizeof(ErtsPollEvents)*max_fds);

    ERTS_POLL_EXPORT(erts_poll_get_selected_events)(pollset, epep, max_fds);

    for (fd = 0; fd < max_fds; fd++) {
	int err = 0;
	ErtsDrvEventState *desp = ((fd < drv_ev_state_len)
				   ? &drv_ev_state[fd]
				   : &null_des);
	ErtsPollEvents cio_events = desp->events;
	ErtsPollEvents ep_events = epep[fd];
	int internal = 0;
#ifdef HAVE_FSTAT
	struct stat stat_buf;
#endif

	if (desp->events || ep_events) {
	    if (ep_events & ERTS_POLL_EV_NVAL) {
		ep_events &= ~ERTS_POLL_EV_NVAL;
		internal = 1;
		internal_fds++;
	    }
	    else
		used_fds++;

	    erts_printf("fd=%d ", fd);

#ifdef HAVE_FSTAT
	    if (fstat(fd, &stat_buf) < 0)
		erts_printf("type=unknown ");
	    else {
		erts_printf("type=");
#ifdef S_ISSOCK
		if (S_ISSOCK(stat_buf.st_mode))
		    erts_printf("sock ");
		else
#endif
#ifdef S_ISFIFO
		if (S_ISFIFO(stat_buf.st_mode))
		    erts_printf("fifo ");
		else
#endif
#ifdef S_ISCHR
		if (S_ISCHR(stat_buf.st_mode))
		    erts_printf("chr ");
		else
#endif
#ifdef S_ISDIR
		if (S_ISDIR(stat_buf.st_mode))
		    erts_printf("dir ");
		else
#endif
#ifdef S_ISBLK
		if (S_ISBLK(stat_buf.st_mode))
		    erts_printf("blk ");
		else
#endif
#ifdef S_ISREG
		if (S_ISREG(stat_buf.st_mode))
		    erts_printf("reg ");
		else
#endif
#ifdef S_ISLNK
		if (S_ISLNK(stat_buf.st_mode))
		    erts_printf("lnk ");
		else
#endif
#ifdef S_ISDOOR
		if (S_ISDOOR(stat_buf.st_mode))
		    erts_printf("door ");
		else
#endif
#ifdef S_ISWHT
		if (S_ISWHT(stat_buf.st_mode))
		    erts_printf("wht ");
		else
#endif
#ifdef S_ISXATTR
		if (S_ISXATTR(stat_buf.st_mode))
		    erts_printf("xattr ");
		else
#endif
		    erts_printf("unknown ");
	    }
#endif

	    if (desp->type == ERTS_EV_TYPE_DRV_SEL) {
		erts_printf("driver_select ");
		
		if (internal) {
		    erts_printf("internal ");
		    err = 1;		    
		}

		if (cio_events == ep_events) {
		    erts_printf("ev=");
		    if (print_events(cio_events) != 0)
			err = 1;
		}
		else {
		    err = 1;
		    erts_printf("cio_ev=");
		    print_events(cio_events);
		    erts_printf(" ep_ev=");
		    print_events(ep_events);
		}
		erts_printf(" ");
		if (cio_events & ERTS_POLL_EV_IN) {
		    Eterm id = desp->driver.select->inport;
		    if (is_nil(id)) {
			erts_printf("inport=none inname=none indrv=none ");
			err = 1;
		    }
		    else {
			ErtsPortNames *pnp = erts_get_port_names(id);
			erts_printf(" inport=%T inname=%s indrv=%s ",
				    id,
				    pnp->name ? pnp->name : "unknown",
				    (pnp->driver_name
				     ? pnp->driver_name
				     : "unknown"));
			erts_free_port_names(pnp);
		    }
		}
		if (cio_events & ERTS_POLL_EV_OUT) {
		    Eterm id = desp->driver.select->outport;
		    if (is_nil(id)) {
			erts_printf("outport=none outname=none outdrv=none ");
			err = 1;
		    }
		    else {
			ErtsPortNames *pnp = erts_get_port_names(id);
			erts_printf(" outport=%T outname=%s outdrv=%s ",
				    id,
				    pnp->name ? pnp->name : "unknown",
				    (pnp->driver_name
				     ? pnp->driver_name
				     : "unknown"));
			erts_free_port_names(pnp);
		    }
		}
	    }
	    else if (desp->type == ERTS_EV_TYPE_DRV_EV) {
		Eterm id;
		erts_printf("driver_event ");
		if (internal) {
		    erts_printf("internal ");
		    err = 1;		    
		}
		if (cio_events == ep_events) {
		    erts_printf("ev=0x%b32x", (Uint32) cio_events);
		}
		else {
		    err = 1;
		    erts_printf("cio_ev=0x%b32x", (Uint32) cio_events);
		    erts_printf(" ep_ev=0x%b32x", (Uint32) ep_events);
		}
		id = desp->driver.event->port;
		if (is_nil(id)) {
		    erts_printf(" port=none name=none drv=none ");
		    err = 1;
		}
		else {
		    ErtsPortNames *pnp = erts_get_port_names(id);
		    erts_printf(" port=%T name=%s drv=%s ",
				id,
				pnp->name ? pnp->name : "unknown",
				(pnp->driver_name
				 ? pnp->driver_name
				 : "unknown"));
		    erts_free_port_names(pnp);
		}
	    }
	    else if (internal) {
		erts_printf("internal ");
		if (cio_events) {
		    err = 1;
		    erts_printf("cio_ev=");
		    print_events(cio_events);
		}
		if (ep_events) {
		    erts_printf("ep_ev=");
		    print_events(ep_events);
		}
	    }
	    else {
		err = 1;
		erts_printf("control_type=%d ", desp->type);
		if (cio_events == ep_events) {
		    erts_printf("ev=0x%b32x", (Uint32) cio_events);
		}
		else {
		    erts_printf("cio_ev=0x%b32x", (Uint32) cio_events);
		    erts_printf(" ep_ev=0x%b32x", (Uint32) ep_events);
		}
	    }

	    if (err) {
		res++;
		erts_printf(" ERROR");
	    }
	    erts_printf("\n");
	}
    }
    erts_printf("\n");
    erts_printf("used fds=%d\n", used_fds);
    erts_printf("internal fds=%d\n", internal_fds);
    erts_printf("---------------------------------------------------------\n");
    fflush(stdout);
    erts_free(ERTS_ALC_T_TMP, (void *) epep);
    erts_smp_mtx_unlock(&drv_ev_state_mtx);
    return res;
}