pipe.c - OpenGrok cross reference for /third

Lines Matching defs:loop
114 int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
115   uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
389 int uv__create_stdio_pipe_pair(uv_loop_t* loop,
429                              loop->iocp,
458 static int uv__set_pipe_handle(uv_loop_t* loop,
521                                loop->iocp,
536 static int pipe_alloc_accept(uv_loop_t* loop, uv_pipe_t* handle,
553                              loop->iocp,
569   uv_loop_t* loop;
577   loop = handle->loop;
578   assert(loop);
583   POST_COMPLETION_FOR_REQ(loop, req);
589 void uv__pipe_shutdown(uv_loop_t* loop, uv_pipe_t* handle, uv_shutdown_t *req) {
601     uv__insert_pending_req(loop, (uv_req_t*) req);
615     uv__insert_pending_req(loop, (uv_req_t*) req);
622     uv__insert_pending_req(loop, (uv_req_t*) req);
633     uv__insert_pending_req(loop, (uv_req_t*) req);
639 void uv__pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
713   uv_loop_t* loop = handle->loop;
782   if (!pipe_alloc_accept(loop,
815   uv_loop_t* loop;
825   loop = handle->loop;
826   assert(loop);
850   POST_COMPLETION_FOR_REQ(loop, req);
860   uv_loop_t* loop;
866     loop = handle->loop;
869     uv__insert_pending_req(loop, (uv_req_t*) req);
871     REGISTER_HANDLE_REQ(loop, handle, req);
882   uv_loop_t* loop;
889   loop = handle->loop;
962       REGISTER_HANDLE_REQ(loop, handle, req);
975   uv__insert_pending_req(loop, (uv_req_t*) req);
977   REGISTER_HANDLE_REQ(loop, handle, req);
993   uv__insert_pending_req(loop, (uv_req_t*) req);
995   REGISTER_HANDLE_REQ(loop, handle, req);
1049   DECREASE_ACTIVE_COUNT(handle->loop, handle);
1056 void uv__pipe_close(uv_loop_t* loop, uv_pipe_t* handle) {
1062     DECREASE_ACTIVE_COUNT(loop, handle);
1067     DECREASE_ACTIVE_COUNT(loop, handle);
1103     uv__want_endgame(loop, (uv_handle_t*) handle);
1107 static void uv__pipe_queue_accept(uv_loop_t* loop, uv_pipe_t* handle,
1111   if (!firstInstance && !pipe_alloc_accept(loop, handle, req, FALSE)) {
1113     uv__insert_pending_req(loop, (uv_req_t*) req);
1133     uv__insert_pending_req(loop, (uv_req_t*) req);
1144   uv_loop_t* loop = server->loop;
1194       uv__pipe_queue_accept(loop, server, req, FALSE);
1204   uv_loop_t* loop = handle->loop;
1228   INCREASE_ACTIVE_COUNT(loop, handle);
1235     uv__pipe_queue_accept(loop, handle, &handle->pipe.serv.accept_reqs[i], i == 0);
1245   uv_loop_t* loop = handle->loop;
1309   POST_COMPLETION_FOR_REQ(loop, req);
1320   uv_loop_t* loop = handle->loop;
1336   POST_COMPLETION_FOR_REQ(loop, req);
1351   if (!PostQueuedCompletionStatus(handle->loop->iocp,
1370   if (!PostQueuedCompletionStatus(handle->loop->iocp,
1379 static void uv__pipe_queue_read(uv_loop_t* loop, uv_pipe_t* handle) {
1438   uv__insert_pending_req(loop, (uv_req_t*)req);
1447   uv_loop_t* loop = handle->loop;
1450   INCREASE_ACTIVE_COUNT(loop, handle);
1464     uv__pipe_queue_read(loop, handle);
1579 static int uv__pipe_write_data(uv_loop_t* loop,
1641     REGISTER_HANDLE_REQ(loop, handle, req);
1644     POST_COMPLETION_FOR_REQ(loop, req);
1689     REGISTER_HANDLE_REQ(loop, handle, req);
1722   REGISTER_HANDLE_REQ(loop, handle, req);
1747 int uv__pipe_write_ipc(uv_loop_t* loop,
1838   err = uv__pipe_write_data(loop, req, handle, bufs, buf_count, cb, 1);
1849 int uv__pipe_write(uv_loop_t* loop,
1858     return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb);
1862     return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0);
1867 static void uv__pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle,
1879 static void uv__pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error,
1891 static void uv__pipe_read_error_or_eof(uv_loop_t* loop, uv_pipe_t* handle,
1894     uv__pipe_read_eof(loop, handle, buf);
1896     uv__pipe_read_error(loop, handle, error, buf);
1943 static DWORD uv__pipe_read_data(uv_loop_t* loop,
1955     return 0; /* Break out of read loop. */
1967     uv__pipe_read_error_or_eof(loop, handle, GetLastError(), buf);
1968     return 0; /* Break out of read loop. */
1978 static DWORD uv__pipe_read_ipc(uv_loop_t* loop, uv_pipe_t* handle) {
1985         uv__pipe_read_data(loop, handle, *data_remaining, *data_remaining);
2054   uv__pipe_read_error_or_eof(loop, handle, err, uv_null_buf_);
2055   return 0; /* Break out of read loop. */
2059 void uv__process_pipe_read_req(uv_loop_t* loop,
2082       uv__pipe_read_error_or_eof(loop, handle, err, uv_null_buf_);
2092       uv__pipe_read_error_or_eof(loop, handle, GetLastError(), uv_null_buf_);
2099           handle->ipc ? uv__pipe_read_ipc(loop, handle)
2100                       : uv__pipe_read_data(loop, handle, avail, (DWORD) -1);
2103        * occurred, and break out of the read loop. */
2108        * available. To prevent `avail` from underflowing, break out of the loop
2121     uv__pipe_queue_read(loop, handle);
2126 void uv__process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle,
2135   UNREGISTER_HANDLE_REQ(loop, handle, req);
2173     uv__pipe_shutdown(loop, handle, handle->stream.conn.shutdown_req);
2179 void uv__process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
2206       uv__pipe_queue_accept(loop, handle, req, FALSE);
2214 void uv__process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
2222   UNREGISTER_HANDLE_REQ(loop, handle, req);
2231       err = uv__set_pipe_handle(loop, handle, pipeHandle, -1, duplex_flags);
2246 void uv__process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
2254   UNREGISTER_HANDLE_REQ(loop, handle, req);
2297   r = uv_timer_init(pipe->loop, pipe->pipe.conn.eof_timer);
2325   uv_loop_t* loop = timer->loop;
2353   uv__pipe_read_eof(loop, pipe, uv_null_buf_);
2433   err = uv__set_pipe_handle(pipe->loop,