Changeset 2e5f808 in rtems-libbsd


Ignore:
Timestamp:
Sep 23, 2021, 5:42:12 AM (4 weeks ago)
Author:
Chris Johns <chrisj@…>
Branches:
6-freebsd-12
Children:
e6bd18c
Parents:
d9dd59d
Message:

rtemsbsd/syscalls: Remove pipe()

  • This call is provided by RTEMS and that is preferred

Closes #4518

Files:
2 edited

Legend:

Unmodified
Added
Removed
  • rtemsbsd/rtems/rtems-bsd-syscall-api.c

    rd9dd59d r2e5f808  
    439439        error = sys_listen(td, &ua);
    440440        rtems_bsd_libio_iop_drop(socket);
    441         return rtems_bsd_error_to_status_and_errno(error);
    442 }
    443 
    444 int
    445 pipe(int fildes[2])
    446 {
    447         struct thread *td = rtems_bsd_get_curthread_or_null();
    448         rtems_libio_t *iop[2];
    449         int error;
    450         if (RTEMS_BSD_SYSCALL_TRACE) {
    451                 printf("bsd: sys: pipe: %d\n", socket);
    452         }
    453         if (td == NULL) {
    454                 return rtems_bsd_error_to_status_and_errno(ENOMEM);
    455         }
    456         iop[0] = rtems_bsd_libio_iop_allocate();
    457         if (iop[0] == NULL) {
    458                 return rtems_bsd_error_to_status_and_errno(ENFILE);
    459         }
    460         iop[1] = rtems_bsd_libio_iop_allocate();
    461         if (iop[1] == NULL) {
    462                 rtems_bsd_libio_iop_free(iop[0]);
    463                 return rtems_bsd_error_to_status_and_errno(ENFILE);
    464         }
    465         error = kern_pipe(td, fildes, 0, NULL, NULL);
    466         if (error != 0) {
    467                 goto out;
    468         }
    469         error = rtems_bsd_libio_iop_set_bsd_fd(
    470             td, fildes[0], iop[0], &rtems_bsd_sysgen_nodeops);
    471         if (error != 0) {
    472                 goto out;
    473         }
    474         error = rtems_bsd_libio_iop_set_bsd_fd(
    475             td, fildes[1], iop[1], &rtems_bsd_sysgen_nodeops);
    476         if (error == 0) {
    477                 fildes[0] = rtems_libio_iop_to_descriptor(iop[0]);
    478                 fildes[1] = rtems_libio_iop_to_descriptor(iop[1]);
    479                 if (RTEMS_BSD_SYSCALL_TRACE) {
    480                         printf("bsd: sys: pipe: %d -> %d, %d -> %d\n",
    481                             fildes[0],
    482                             rtems_bsd_libio_iop_to_descriptor(iop[0]),
    483                             fildes[1],
    484                             rtems_bsd_libio_iop_to_descriptor(iop[1]));
    485                 }
    486                 return 0;
    487         }
    488 out:
    489         kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[0]));
    490         kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[1]));
    491         rtems_bsd_libio_iop_free(iop[0]);
    492         rtems_bsd_libio_iop_free(iop[1]);
    493441        return rtems_bsd_error_to_status_and_errno(error);
    494442}
  • testsuite/selectpollkqueue01/test_main.c

    rd9dd59d r2e5f808  
    10971097
    10981098static void
    1099 test_pipe_timeout(test_context *ctx)
    1100 {
    1101         struct pipe_poll_events
    1102         {
    1103                 short event;
    1104                 int rv;
    1105         };
    1106         const struct pipe_poll_events events[] = {
    1107                 { POLLIN, 0 },
    1108                 { POLLPRI, 0 },
    1109                 { POLLOUT, 1 },
    1110                 { POLLRDNORM, 0 },
    1111                 { POLLWRNORM, 1 },
    1112                 { POLLRDBAND, 0 },
    1113                 { POLLWRBAND, 0 },
    1114                 { POLLINIGNEOF, 0 }
    1115         };
    1116 
    1117         int timeout = 100;
    1118         struct pollfd pfd;
    1119         size_t i;
    1120         int rv;
    1121 
    1122         puts("test pipe timeout");
    1123 
    1124         rv = pipe(ctx->pfd);
    1125         assert(rv == 0);
    1126 
    1127         pfd.fd = ctx->pfd[1];
    1128 
    1129         for (i = 0; i < nitems(events); ++i) {
    1130                 int rv;
    1131 
    1132                 pfd.events = events[i].event;
    1133                 pfd.revents = 0;
    1134 
    1135                 rv = poll(&pfd, 1, timeout);
    1136                 assert(rv == events[i].rv);
    1137         }
    1138 }
    1139 
    1140 static void
    1141 test_pipe_read(test_context *ctx)
    1142 {
    1143         int rfd = ctx->pfd[0];
    1144         int wfd = ctx->pfd[1];
    1145         struct pollfd pfd = {
    1146                 .fd = rfd,
    1147                 .events = POLLIN
    1148         };
    1149         int timeout = -1;
    1150         int rv;
    1151         ssize_t n;
    1152 
    1153         puts("test pipe read");
    1154 
    1155         assert(rfd >= 0);
    1156         assert(wfd >= 0);
    1157 
    1158         ctx->wfd = wfd;
    1159         ctx->wbuf = &msg[0];
    1160         ctx->wn = sizeof(msg);
    1161         send_events(ctx, EVENT_WRITE);
    1162 
    1163         set_non_blocking(rfd, 1);
    1164 
    1165         errno = 0;
    1166         n = read(rfd, &ctx->buf[0], sizeof(ctx->buf));
    1167         assert(n == -1);
    1168         assert(errno == EAGAIN);
    1169 
    1170         rv = poll(&pfd, 1, timeout);
    1171         assert(rv == 1);
    1172         assert(pfd.revents == POLLIN);
    1173 
    1174         n = read(rfd, &ctx->buf[0], sizeof(ctx->buf));
    1175         assert(n == (ssize_t) sizeof(msg));
    1176         assert(memcmp(&msg[0], &ctx->buf[0], sizeof(msg)) == 0);
    1177 }
    1178 
    1179 static void
    1180 test_pipe_write(test_context *ctx)
    1181 {
    1182         int rfd = ctx->pfd[0];
    1183         int wfd = ctx->pfd[1];
    1184         struct pollfd pfd = {
    1185                 .fd = wfd,
    1186                 .events = POLLOUT
    1187         };
    1188         int timeout = -1;
    1189         int rv;
    1190         ssize_t n;
    1191 
    1192         puts("test pipe write");
    1193 
    1194         assert(rfd >= 0);
    1195         assert(wfd >= 0);
    1196 
    1197         ctx->rfd = rfd;
    1198         ctx->rbuf = &ctx->buf[0];
    1199         ctx->rn = sizeof(ctx->buf);
    1200         send_events(ctx, EVENT_READ);
    1201 
    1202         set_non_blocking(wfd, 1);
    1203 
    1204         do {
    1205                 errno = 0;
    1206                 n = write(wfd, &ctx->buf[0], sizeof(ctx->buf));
    1207                 if (n == -1) {
    1208                         assert(errno == EAGAIN);
    1209                 }
    1210         } while (n > 0);
    1211 
    1212         rv = poll(&pfd, 1, timeout);
    1213         assert(rv == 1);
    1214         assert(pfd.revents == POLLOUT);
    1215 }
    1216 
    1217 static void
    1218 test_pipe_close(test_context *ctx)
    1219 {
    1220         int rfd = ctx->pfd[0];
    1221         struct pollfd pfd = {
    1222                 .fd = rfd,
    1223                 .events = POLLIN
    1224         };
    1225         int timeout = -1;
    1226         int rv;
    1227 
    1228         puts("test pipe close");
    1229 
    1230         assert(ctx->pfd[0] >= 0);
    1231         assert(ctx->pfd[1] >= 0);
    1232 
    1233         send_events(ctx, EVENT_CLOSE_PIPE);
    1234 
    1235         set_non_blocking(rfd, 0);
    1236 
    1237         assert(ctx->pfd[0] >= 0);
    1238         assert(ctx->pfd[1] >= 0);
    1239 
    1240         rv = poll(&pfd, 1, timeout);
    1241         assert(rv == 1);
    1242         assert(pfd.revents == (POLLIN | POLLHUP));
    1243 
    1244         assert(ctx->pfd[0] == -1);
    1245         assert(ctx->pfd[1] == -1);
    1246 }
    1247 
    1248 static void
    12491099test_main(void)
    12501100{
     
    12801130        test_kqueue_user(ctx);
    12811131
    1282         test_pipe_timeout(ctx);
    1283         test_pipe_read(ctx);
    1284         test_pipe_write(ctx);
    1285         test_pipe_close(ctx);
    1286 
    12871132        exit(0);
    12881133}
Note: See TracChangeset for help on using the changeset viewer.