urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-20 09:21:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

u3: restages #6062 for release

Browse Source
This commit is contained in:
Joe Bryan 2022-11-17 23:44:12 -05:00
parent 5c3daa265d
commit 97e7a14123
14 changed files with 329 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pkg/urbit/Makefile
View File

@ -2,6 +2,7 @@ include config.mk
compat_mks := $(foreach dir,$(compat),$(wildcard compat/$(dir)/*.mk))
include $(compat_mks)
c = $(wildcard c/*.c)
jets = jets/tree.c $(wildcard jets/*/*.c)
noun = $(wildcard noun/*.c)
ur = $(wildcard ur/*.c)
@ -13,7 +14,7 @@ bench = $(wildcard bench/*.c)
compat := $(foreach dir,$(compat),$(wildcard compat/$(dir)/*.c))
common = $(jets) $(noun) $(ur) $(vere) $(compat)
common = $(c) $(jets) $(noun) $(ur) $(vere) $(compat)
headers = $(shell find include -type f)
common_objs = $(shell echo $(common) | sed 's/\.c/.o/g')

96
pkg/urbit/c/defs.c Normal file
View File

@ -0,0 +1,96 @@
/// @file defs.c
#include "c/defs.h"
/* c3_pread(): full positioned read(), up to eof, retrying errors.
*/
ssize_t
c3_pread(c3_i fid_i, void* buf_v, size_t len_i, off_t off_i)
{
c3_w max_w = 128;
c3_w try_w = 0;
size_t rem_i = len_i;
ssize_t ret_i;
do {
if ( (0 > (ret_i = pread(fid_i, buf_v, rem_i, off_i)))
&& ( (++try_w == max_w)
|| ( (EINTR != errno)
&& (EAGAIN != errno)
&& (EWOULDBLOCK != errno) )))
{
return -1;
}
else if ( 0 == ret_i ) {
break;
}
else {
buf_v = (void*)((c3_c*)buf_v + ret_i);
rem_i -= ret_i;
off_i += ret_i;
}
}
while ( rem_i );
return len_i - rem_i;
}
/* c3_pwrite(): full positioned write(), retrying errors.
*/
ssize_t
c3_pwrite(c3_i fid_i, const void* buf_v, size_t len_i, off_t off_i)
{
c3_w max_w = 128;
c3_w try_w = 0;
size_t rem_i = len_i;
ssize_t ret_i;
do {
if ( (0 > (ret_i = pwrite(fid_i, buf_v, rem_i, off_i)))
&& ( (++try_w == max_w)
|| ( (EINTR != errno)
&& (EAGAIN != errno)
&& (EWOULDBLOCK != errno) )))
{
return -1;
}
else {
buf_v = (void*)((c3_c*)buf_v + ret_i);
rem_i -= ret_i;
off_i += ret_i;
}
}
while ( rem_i );
return len_i;
}
/* c3_write(): full write(), retrying errors.
*/
ssize_t
c3_write(c3_i fid_i, const void* buf_v, size_t len_i)
{
c3_w max_w = 128;
c3_w try_w = 0;
size_t rem_i = len_i;
ssize_t ret_i;
do {
if ( (0 > (ret_i = write(fid_i, buf_v, rem_i)))
&& ( (++try_w == max_w)
|| ( (EINTR != errno)
&& (EAGAIN != errno)
&& (EWOULDBLOCK != errno) )))
{
return -1;
}
else {
buf_v = (void*)((c3_c*)buf_v + ret_i);
rem_i -= ret_i;
}
}
while ( rem_i );
return len_i;
}

57
pkg/urbit/compat/mingw/compat.c
View File

@ -144,6 +144,63 @@ int link(const char *path1, const char *path2)
return -1;
}
ssize_t pread(int fd, void *buf, size_t count, off_t offset)
{
DWORD len = 0;
OVERLAPPED overlapped = {0};
overlapped.OffsetHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
(DWORD)0 : (DWORD)((offset >> 32) & 0xFFFFFFFFL);
overlapped.Offset = (sizeof(off_t) <= sizeof(DWORD)) ?
(DWORD)offset : (DWORD)(offset & 0xFFFFFFFFL);
HANDLE h = (HANDLE)_get_osfhandle(fd);
if ( INVALID_HANDLE_VALUE == h ) {
errno = EBADF;
return -1;
}
if ( !ReadFile(h, buf, count, &len, &overlapped) ) {
DWORD err = GetLastError();
if ( ERROR_HANDLE_EOF != err ) {
errno = err_win_to_posix(err);
return -1;
}
}
return (ssize_t)len;
}
ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset)
{
DWORD len = 0;
OVERLAPPED overlapped = {0};
overlapped.OffsetHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
(DWORD)0 : (DWORD)((offset >> 32) & 0xFFFFFFFFL);
overlapped.Offset = (sizeof(off_t) <= sizeof(DWORD)) ?
(DWORD)offset : (DWORD)(offset & 0xFFFFFFFFL);
HANDLE h = (HANDLE)_get_osfhandle(fd);
if ( INVALID_HANDLE_VALUE == h ) {
errno = EBADF;
return -1;
}
if ( !WriteFile(h, buf, count, &len, &overlapped) ) {
errno = err_win_to_posix(GetLastError());
return -1;
}
return (ssize_t)len;
}
// from msys2 mingw-packages-dev patches
// -----------------------------------------------------------------------

2
pkg/urbit/compat/mingw/compat.h
View File

@ -4,6 +4,8 @@
#define mkdir(A, B) mkdir(A)
int link(const char *path1, const char *path2);
ssize_t pread(int fd, void *buf, size_t count, off_t offset);
ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);
char *realpath(const char *path, char *resolved_path);
int fdatasync(int fd);
int utimes(const char *path, const struct timeval times[2]);

29
pkg/urbit/include/c/defs.h
View File

@ -1,6 +1,11 @@
#ifndef C3_DEFS_H
#define C3_DEFS_H
#include "c/portable.h"
#include "c/types.h"
#include <errno.h>
/** Loobeans - inverse booleans to match nock.
**/
# define c3y 0
@ -157,4 +162,28 @@
# define c3_fopen(a, b) ({ \
fopen(a, b);})
/** i/o wrappers
***
*** these handle partial success and retry ephemeral errors
*** up to hardcoded max try count, either reading/writing fully
*** (up to EOF on read) or returning on error.
***
*** a wrapper for read() is not provided, as file cursor position
*** is undefined on error. use pread() or loop yourself.
**/
/* c3_pread(): full positioned read(), up to eof, retrying errors.
*/
ssize_t
c3_pread(c3_i fid_i, void* buf_v, size_t len_i, off_t off_i);
/* c3_pwrite(): full positioned write(), retrying errors.
*/
ssize_t
c3_pwrite(c3_i fid_i, const void* buf_v, size_t len_i, off_t off_i);
/* c3_write(): full write(), retrying errors.
*/
ssize_t
c3_write(c3_i fid_i, const void* buf_v, size_t len_i);
#endif /* ifndef C3_DEFS_H */

5
pkg/urbit/include/vere/vere.h
View File

@ -1461,11 +1461,6 @@
void
u3_daemon_init();
/* u3_write_fd(): retry interrupts, continue partial writes, assert errors.
*/
void
u3_write_fd(c3_i fid_i, const void* buf_v, size_t len_i);
c3_w
u3_readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);

158
pkg/urbit/noun/events.c
View File

@ -354,17 +354,11 @@ _ce_image_open(u3e_image* img_u)
static void
_ce_patch_write_control(u3_ce_patch* pat_u)
{
ssize_t ret_i;
c3_w len_w = sizeof(u3e_control) +
(pat_u->con_u->pgs_w * sizeof(u3e_line));
if ( len_w != (ret_i = write(pat_u->ctl_i, pat_u->con_u, len_w)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: patch ctl partial write: %zu\r\n", (size_t)ret_i);
}
else {
fprintf(stderr, "loom: patch ctl write: %s\r\n", strerror(errno));
}
if ( 0 > c3_pwrite(pat_u->ctl_i, pat_u->con_u, len_w, 0) ) {
fprintf(stderr, "loom: patch write: %s\r\n", strerror(errno));
c3_assert(0);
}
}
@ -388,8 +382,9 @@ _ce_patch_read_control(u3_ce_patch* pat_u)
}
pat_u->con_u = c3_malloc(len_w);
if ( (len_w != read(pat_u->ctl_i, pat_u->con_u, len_w)) ||
(len_w != sizeof(u3e_control) +
if ( (len_w != c3_pread(pat_u->ctl_i, pat_u->con_u, len_w, 0))
|| (len_w != sizeof(u3e_control) +
(pat_u->con_u->pgs_w * sizeof(u3e_line))) )
{
c3_free(pat_u->con_u);
@ -450,8 +445,10 @@ _ce_patch_delete(void)
static c3_o
_ce_patch_verify(u3_ce_patch* pat_u)
{
c3_w i_w, pag_w, mug_w;
c3_w mem_w[pag_wiz_i];
size_t off_i, siz_i = pag_siz_i;
ssize_t ret_i;
c3_w i_w;
if ( u3e_version != pat_u->con_u->ver_y ) {
fprintf(stderr, "loom: patch version mismatch: have %u, need %u\r\n",
@ -461,15 +458,11 @@ _ce_patch_verify(u3_ce_patch* pat_u)
}
for ( i_w = 0; i_w < pat_u->con_u->pgs_w; i_w++ ) {
c3_w pag_w = pat_u->con_u->mem_u[i_w].pag_w;
c3_w mug_w = pat_u->con_u->mem_u[i_w].mug_w;
c3_w mem_w[1 << u3a_page];
pag_w = pat_u->con_u->mem_u[i_w].pag_w;
mug_w = pat_u->con_u->mem_u[i_w].mug_w;
off_i = i_w << (u3a_page + 2);
if ( -1 == lseek(pat_u->mem_i, (i_w << (u3a_page + 2)), SEEK_SET) ) {
fprintf(stderr, "loom: patch seek: %s\r\n", strerror(errno));
return c3n;
}
if ( pag_siz_i != (ret_i = read(pat_u->mem_i, mem_w, pag_siz_i)) ) {
if ( siz_i != (ret_i = c3_pread(pat_u->mem_i, mem_w, siz_i, off_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: patch partial read: %zu\r\n", (size_t)ret_i);
}
@ -562,21 +555,10 @@ _ce_patch_write_page(u3_ce_patch* pat_u,
c3_w pgc_w,
c3_w* mem_w)
{
ssize_t ret_i;
size_t off_i = pgc_w << (u3a_page + 2);
if ( -1 == lseek(pat_u->mem_i, pgc_w * pag_siz_i, SEEK_SET) ) {
fprintf(stderr, "loom: patch page seek: %s\r\n", strerror(errno));
c3_assert(0);
}
if ( pag_siz_i != (ret_i = write(pat_u->mem_i, mem_w, pag_siz_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: patch page partial write: %zu\r\n",
(size_t)ret_i);
}
else {
fprintf(stderr, "loom: patch page write: %s\r\n", strerror(errno));
}
if ( 0 > c3_pwrite(pat_u->mem_i, mem_w, pag_siz_i, off_i) ) {
fprintf(stderr, "loom: patch write: %s\r\n", strerror(errno));
c3_assert(0);
}
}
@ -753,31 +735,20 @@ _ce_image_resize(u3e_image* img_u, c3_w pgs_w)
static void
_ce_patch_apply(u3_ce_patch* pat_u)
{
c3_w i_w, pag_w, off_w, mem_w[pag_wiz_i];
c3_i fid_i;
size_t rof_i, wof_i, siz_i = pag_siz_i;
ssize_t ret_i;
c3_w i_w;
// resize images
//
_ce_image_resize(&u3P.nor_u, pat_u->con_u->nor_w);
_ce_image_resize(&u3P.sou_u, pat_u->con_u->sou_w);
// seek to begining of patch and images
//
if ( (-1 == lseek(pat_u->mem_i, 0, SEEK_SET))
|| (-1 == lseek(u3P.nor_u.fid_i, 0, SEEK_SET))
|| (-1 == lseek(u3P.sou_u.fid_i, 0, SEEK_SET)) )
{
fprintf(stderr, "loom: patch apply seek 0: %s\r\n", strerror(errno));
c3_assert(0);
}
// write patch pages into the appropriate image
//
for ( i_w = 0; i_w < pat_u->con_u->pgs_w; i_w++ ) {
c3_w pag_w = pat_u->con_u->mem_u[i_w].pag_w;
c3_w mem_w[pag_wiz_i];
c3_i fid_i;
c3_w off_w;
pag_w = pat_u->con_u->mem_u[i_w].pag_w;
if ( pag_w < pat_u->con_u->nor_w ) {
fid_i = u3P.nor_u.fid_i;
@ -788,7 +759,10 @@ _ce_patch_apply(u3_ce_patch* pat_u)
off_w = (u3P.pag_w - (pag_w + 1));
}
if ( pag_siz_i != (ret_i = read(pat_u->mem_i, mem_w, pag_siz_i)) ) {
rof_i = (size_t)i_w << (u3a_page + 2);
wof_i = (size_t)off_w << (u3a_page + 2);
if ( siz_i != (ret_i = c3_pread(pat_u->mem_i, mem_w, siz_i, rof_i))) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: patch apply partial read: %zu\r\n",
(size_t)ret_i);
@ -798,22 +772,11 @@ _ce_patch_apply(u3_ce_patch* pat_u)
}
c3_assert(0);
}
else {
if ( -1 == lseek(fid_i, (off_w << (u3a_page + 2)), SEEK_SET) ) {
fprintf(stderr, "loom: patch apply seek: %s\r\n", strerror(errno));
c3_assert(0);
}
if ( pag_siz_i != (ret_i = write(fid_i, mem_w, pag_siz_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: patch apply partial write: %zu\r\n",
(size_t)ret_i);
}
else {
if ( 0 > c3_pwrite(fid_i, mem_w, siz_i, wof_i) ) {
fprintf(stderr, "loom: patch apply write: %s\r\n", strerror(errno));
}
c3_assert(0);
}
}
#if 0
u3l_log("apply: %d, %x\n", pag_w, u3r_mug_words(mem_w, pag_wiz_i));
#endif
@ -827,22 +790,18 @@ _ce_image_blit(u3e_image* img_u,
c3_w* ptr_w,
c3_ws stp_ws)
{
c3_w i_w;
size_t off_i, siz_i = pag_siz_i;
ssize_t ret_i;
if ( 0 == img_u->pgs_w ) {
return;
}
ssize_t ret_i;
c3_w i_w;
c3_w siz_w = pag_siz_i;
if ( -1 == lseek(img_u->fid_i, 0, SEEK_SET) ) {
fprintf(stderr, "loom: image (%s) blit seek 0: %s\r\n",
img_u->nam_c, strerror(errno));
c3_assert(0);
}
for ( i_w = 0; i_w < img_u->pgs_w; i_w++ ) {
if ( siz_w != (ret_i = read(img_u->fid_i, ptr_w, siz_w)) ) {
off_i = (size_t)i_w << (u3a_page + 2);
if ( siz_i != (ret_i = c3_pread(img_u->fid_i, ptr_w, siz_i, off_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: image (%s) blit partial read: %zu\r\n",
img_u->nam_c, (size_t)ret_i);
@ -854,7 +813,7 @@ _ce_image_blit(u3e_image* img_u,
c3_assert(0);
}
if ( 0 != mprotect(ptr_w, siz_w, PROT_READ) ) {
if ( 0 != mprotect(ptr_w, siz_i, PROT_READ) ) {
fprintf(stderr, "loom: live mprotect: %s\r\n", strerror(errno));
c3_assert(0);
}
@ -876,19 +835,15 @@ _ce_image_fine(u3e_image* img_u,
c3_w* ptr_w,
c3_ws stp_ws)
{
ssize_t ret_i;
c3_w i_w;
c3_w i_w, mem_w, fil_w;
c3_w buf_w[pag_wiz_i];
if ( -1 == lseek(img_u->fid_i, 0, SEEK_SET) ) {
fprintf(stderr, "loom: image fine seek 0: %s\r\n", strerror(errno));
c3_assert(0);
}
size_t off_i, siz_i = pag_siz_i;
ssize_t ret_i;
for ( i_w=0; i_w < img_u->pgs_w; i_w++ ) {
c3_w mem_w, fil_w;
off_i = (size_t)i_w << (u3a_page + 2);
if ( pag_siz_i != (ret_i = read(img_u->fid_i, buf_w, pag_siz_i)) ) {
if ( siz_i != (ret_i = c3_pread(img_u->fid_i, buf_w, siz_i, off_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: image (%s) fine partial read: %zu\r\n",
img_u->nam_c, (size_t)ret_i);
@ -899,6 +854,7 @@ _ce_image_fine(u3e_image* img_u,
}
c3_assert(0);
}
mem_w = u3r_mug_words(ptr_w, pag_wiz_i);
fil_w = u3r_mug_words(buf_w, pag_wiz_i);
@ -924,31 +880,21 @@ _ce_image_fine(u3e_image* img_u,
static c3_o
_ce_image_copy(u3e_image* fom_u, u3e_image* tou_u)
{
ssize_t ret_i;
c3_w i_w;
c3_w mem_w[pag_wiz_i];
size_t off_i, siz_i = pag_siz_i;
ssize_t ret_i;
// resize images
//
_ce_image_resize(tou_u, fom_u->pgs_w);
// seek to begining of patch and images
//
if ( (-1 == lseek(fom_u->fid_i, 0, SEEK_SET))
|| (-1 == lseek(tou_u->fid_i, 0, SEEK_SET)) )
{
fprintf(stderr, "loom: image (%s) copy seek: %s\r\n",
fom_u->nam_c,
strerror(errno));
return c3n;
}
// copy pages into destination image
//
for ( i_w = 0; i_w < fom_u->pgs_w; i_w++ ) {
c3_w mem_w[pag_wiz_i];
c3_w off_w = i_w;
off_i = (size_t)i_w << (u3a_page + 2);
if ( pag_siz_i != (ret_i = read(fom_u->fid_i, mem_w, pag_siz_i)) ) {
if ( siz_i != (ret_i = c3_pread(fom_u->fid_i, mem_w, siz_i, off_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: image (%s) copy partial read: %zu\r\n",
fom_u->nam_c, (size_t)ret_i);
@ -959,25 +905,13 @@ _ce_image_copy(u3e_image* fom_u, u3e_image* tou_u)
}
return c3n;
}
else {
if ( -1 == lseek(tou_u->fid_i, (off_w << (u3a_page + 2)), SEEK_SET) ) {
fprintf(stderr, "loom: image (%s) copy seek: %s\r\n",
tou_u->nam_c, strerror(errno));
return c3n;
}
if ( pag_siz_i != (ret_i = write(tou_u->fid_i, mem_w, pag_siz_i)) ) {
if ( 0 < ret_i ) {
fprintf(stderr, "loom: image (%s) copy partial write: %zu\r\n",
tou_u->nam_c, (size_t)ret_i);
}
else {
if ( 0 > c3_pwrite(tou_u->fid_i, mem_w, siz_i, off_i) ) {
fprintf(stderr, "loom: image (%s) copy write: %s\r\n",
tou_u->nam_c, strerror(errno));
}
return c3n;
}
}
}
return c3y;
}

6
pkg/urbit/noun/manage.c
View File

@ -435,7 +435,7 @@ u3m_file(c3_c* pas_c)
{
struct stat buf_b;
c3_i fid_i = c3_open(pas_c, O_RDONLY, 0644);
c3_w fln_w, red_w;
c3_w fln_w;
c3_y* pad_y;
if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) {
@ -445,10 +445,10 @@ u3m_file(c3_c* pas_c)
fln_w = buf_b.st_size;
pad_y = c3_malloc(buf_b.st_size);
red_w = read(fid_i, pad_y, fln_w);
ssize_t red_i = c3_pread(fid_i, pad_y, fln_w, 0);
close(fid_i);
if ( fln_w != red_w ) {
if ( red_i != fln_w ) {
c3_free(pad_y);
return u3m_bail(c3__fail);
}

50
pkg/urbit/noun/urth.c
View File

@ -564,56 +564,14 @@ _cu_rock_save(c3_c* dir_c, c3_d eve_d, c3_d len_d, c3_y* byt_y)
// write jam-buffer into [fid_i]
//
// XX deduplicate with _write() wrapper in term.c
//
{
ssize_t ret_i;
while ( len_d > 0 ) {
c3_w lop_w = 0;
// retry interrupt/async errors
//
do {
// abort pathological retry loop
//
if ( 100 == ++lop_w ) {
fprintf(stderr, "rock: write loop: %s\r\n", strerror(errno));
close(fid_i);
// XX unlink file?
//
return c3n;
}
ret_i = write(fid_i, byt_y, len_d);
}
while ( (ret_i < 0)
&& ( (errno == EINTR)
|| (errno == EAGAIN)
|| (errno == EWOULDBLOCK) ));
// assert on true errors
//
// NB: can't call u3l_log here or we would re-enter _write()
//
if ( ret_i < 0 ) {
fprintf(stderr, "rock: write failed %s\r\n", strerror(errno));
close(fid_i);
// XX unlink file?
//
return c3n;
}
// continue partial writes
//
else {
len_d -= ret_i;
byt_y += ret_i;
}
}
ssize_t rit_i = c3_pwrite(fid_i, byt_y, len_d, 0);
if ( rit_i < 0 ) {
fprintf(stderr, "rock: write failed: %s\r\n", strerror(errno));
}
close(fid_i);
return c3y;
return rit_i < 0 ? c3n : c3y;
}
/* u3u_cram(): globably deduplicate memory, and write a rock to disk.

31
pkg/urbit/vere/io/http.c
View File

@ -1677,24 +1677,30 @@ _http_init_tls(uv_buf_t key_u, uv_buf_t cer_u)
static void
_http_write_ports_file(u3_httd* htd_u, c3_c *pax_c)
{
c3_c* nam_c = ".http.ports";
c3_w len_w = 1 + strlen(pax_c) + 1 + strlen(nam_c);
c3_c* paf_c = c3_malloc(len_w);
snprintf(paf_c, len_w, "%s/%s", pax_c, nam_c);
c3_i por_i = c3_open(paf_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
c3_free(paf_c);
u3_http* htp_u = htd_u->htp_u;
u3_pier* pir_u = htd_u->car_u.pir_u;
size_t off_i = 0;
c3_i por_i;
{
c3_c* nam_c = ".http.ports";
c3_w len_w = 1 + strlen(pax_c) + 1 + strlen(nam_c);
c3_c* paf_c = c3_malloc(len_w);
snprintf(paf_c, len_w, "%s/%s", pax_c, nam_c);
por_i = c3_open(paf_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
c3_free(paf_c);
}
c3_c temp[32];
while ( 0 != htp_u ) {
if ( 0 < htp_u->por_s ) {
u3_write_fd(por_i, temp, snprintf(temp, 32, "%u %s %s\n", htp_u->por_s,
c3_c tmp_c[32];
c3_i len_i = snprintf(tmp_c, 32, "%u %s %s\n",
htp_u->por_s,
(c3y == htp_u->sec) ? "secure" : "insecure",
(c3y == htp_u->lop) ? "loopback" : "public"));
(c3y == htp_u->lop) ? "loopback" : "public");
c3_assert( 0 < len_i);
c3_assert( c3_pwrite(por_i, tmp_c, len_i, off_i) == len_i );
off_i += len_i;
}
htp_u = htp_u->nex_u;
@ -1715,7 +1721,6 @@ _http_release_ports_file(c3_c *pax_c)
c3_i wit_i;
wit_i = snprintf(paf_c, len_w, "%s/%s", pax_c, nam_c);
c3_assert(wit_i > 0);
c3_assert( len_w == (c3_w)wit_i + 1 );
c3_unlink(paf_c);

54
pkg/urbit/vere/io/term.c
View File

@ -17,48 +17,6 @@ static void _term_read_cb(uv_stream_t* tcp_u,
ssize_t siz_i,
const uv_buf_t* buf_u);
/* u3_write_fd(): retry interrupts, continue partial writes, assert errors.
*/
void
u3_write_fd(c3_i fid_i, const void* buf_v, size_t len_i)
{
ssize_t ret_i;
while ( len_i > 0 ) {
c3_w lop_w = 0;
// retry interrupt/async errors
//
do {
// abort pathological retry loop
//
if ( 100 == ++lop_w ) {
fprintf(stderr, "term: write loop: %s\r\n", strerror(errno));
return;
}
ret_i = write(fid_i, buf_v, len_i);
}
while ( (ret_i < 0)
&& ( (errno == EINTR)
|| (errno == EAGAIN)
|| (errno == EWOULDBLOCK) ));
// assert on true errors
//
// NB: can't call u3l_log here or we would re-enter u3_write_fd()
//
if ( ret_i < 0 ) {
fprintf(stderr, "term: write failed %s\r\n", strerror(errno));
c3_assert(0);
}
// continue partial writes
//
else {
len_i -= ret_i;
buf_v += ret_i;
}
}
}
/* _term_msc_out_host(): unix microseconds from current host time.
*/
static c3_d
@ -255,7 +213,7 @@ u3_term_log_exit(void)
if ( c3n == uty_u->sto_f(uty_u) ) {
c3_assert(!"exit-tcsetattr");
}
u3_write_fd(uty_u->fid_i, "\r\n", 2);
c3_assert(c3_write(uty_u->fid_i, "\r\n", 2) == 2);
}
}
@ -864,7 +822,7 @@ _term_spin_step(u3_utty* uty_u)
c3_w i_w;
for ( i_w = bac_w; i_w < sol_w; i_w++ ) {
if ( lef_u.len != write(fid_i, lef_u.base, lef_u.len) ) {
if ( c3_write(fid_i, lef_u.base, lef_u.len) < 0 ) {
return;
}
}
@ -874,7 +832,7 @@ _term_spin_step(u3_utty* uty_u)
{
c3_w len_w = cur_c - buf_c;
if ( len_w != write(fid_i, buf_c, len_w) ) {
if ( c3_write(fid_i, buf_c, len_w) < 0 ) {
return;
}
}
@ -882,7 +840,7 @@ _term_spin_step(u3_utty* uty_u)
// Cursor stays on spinner.
//
while ( sol_w-- ) {
if ( lef_u.len != write(fid_i, lef_u.base, lef_u.len) ) {
if ( c3_write(fid_i, lef_u.base, lef_u.len) < 0 ) {
return;
}
}
@ -1382,10 +1340,10 @@ u3_term_io_hija(void)
if ( c3y != uty_u->hij_f(uty_u) ) {
c3_assert(!"hija-tcsetattr");
}
u3_write_fd(uty_u->fid_i, "\r", 1);
c3_assert(c3_write(uty_u->fid_i, "\r", 1) == 1);
{
uv_buf_t* buf_u = &uty_u->ufo_u.out.el_u;
u3_write_fd(uty_u->fid_i, buf_u->base, buf_u->len);
c3_assert(c3_write(uty_u->fid_i, buf_u->base, buf_u->len) == buf_u->len);
}
}
}

55
pkg/urbit/vere/io/unix.c
View File

@ -342,11 +342,11 @@ u3_unix_save(c3_c* pax_c, u3_atom pad)
pad_y = c3_malloc(fln_w);
u3r_bytes(0, fln_w, pad_y, pad);
u3z(pad);
rit_w = write(fid_i, pad_y, fln_w);
ssize_t rit_i = c3_pwrite(fid_i, pad_y, fln_w, 0);
close(fid_i);
c3_free(pad_y);
if ( rit_w != fln_w ) {
if ( rit_i < 0 ) {
u3l_log("%s: %s\n", ful_c, strerror(errno));
c3_free(ful_c);
u3m_bail(c3__fail);
@ -427,7 +427,7 @@ static c3_w
_unix_write_file_hard(c3_c* pax_c, u3_noun mim)
{
c3_i fid_i = c3_open(pax_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
c3_w len_w, rit_w, siz_w, mug_w = 0;
c3_w len_w, siz_w, mug_w = 0;
c3_y* dat_y;
u3_noun dat = u3t(u3t(mim));
@ -446,11 +446,10 @@ _unix_write_file_hard(c3_c* pax_c, u3_noun mim)
u3r_bytes(0, len_w, dat_y, dat);
u3z(mim);
rit_w = write(fid_i, dat_y, siz_w);
ssize_t rit_i = c3_pwrite(fid_i, dat_y, siz_w, 0);
if ( rit_w != siz_w ) {
u3l_log("error writing %s: %s\r\n",
pax_c, strerror(errno));
if ( rit_i < 0 ) {
u3l_log("error writing %s: %s\r\n", pax_c, strerror(errno));
mug_w = 0;
}
else {
@ -470,7 +469,7 @@ _unix_write_file_soft(u3_ufil* fil_u, u3_noun mim)
{
struct stat buf_u;
c3_i fid_i = c3_open(fil_u->pax_c, O_RDONLY, 0644);
c3_ws len_ws, red_ws;
c3_ws len_ws;
c3_w old_w;
c3_y* old_y;
@ -489,21 +488,21 @@ _unix_write_file_soft(u3_ufil* fil_u, u3_noun mim)
len_ws = buf_u.st_size;
old_y = c3_malloc(len_ws);
red_ws = read(fid_i, old_y, len_ws);
ssize_t red_i = c3_pread(fid_i, old_y, len_ws, 0);
if ( close(fid_i) < 0 ) {
u3l_log("error closing file (soft) %s: %s\r\n",
fil_u->pax_c, strerror(errno));
}
if ( len_ws != red_ws ) {
if ( red_ws < 0 ) {
if ( red_i != len_ws ) {
if ( red_i < 0 ) {
u3l_log("error reading file (soft) %s: %s\r\n",
fil_u->pax_c, strerror(errno));
fil_u->pax_c, strerror(-red_i));
}
else {
u3l_log("wrong # of bytes read in file %s: %d %d\r\n",
fil_u->pax_c, len_ws, red_ws);
u3l_log("wrong # of bytes read in file %s: %u %zu\r\n",
fil_u->pax_c, len_ws, red_i);
}
c3_free(old_y);
u3z(mim);
@ -893,7 +892,7 @@ _unix_update_file(u3_unix* unx_u, u3_ufil* fil_u)
struct stat buf_u;
c3_i fid_i = c3_open(fil_u->pax_c, O_RDONLY, 0644);
c3_ws len_ws, red_ws;
c3_ws len_ws;
c3_y* dat_y;
if ( fid_i < 0 || fstat(fid_i, &buf_u) < 0 ) {
@ -910,21 +909,21 @@ _unix_update_file(u3_unix* unx_u, u3_ufil* fil_u)
len_ws = buf_u.st_size;
dat_y = c3_malloc(len_ws);
red_ws = read(fid_i, dat_y, len_ws);
ssize_t red_i = c3_pread(fid_i, dat_y, len_ws, 0);
if ( close(fid_i) < 0 ) {
u3l_log("error closing file %s: %s\r\n",
fil_u->pax_c, strerror(errno));
}
if ( len_ws != red_ws ) {
if ( red_ws < 0 ) {
if ( red_i != len_ws ) {
if ( red_i < 0 ) {
u3l_log("error reading file %s: %s\r\n",
fil_u->pax_c, strerror(errno));
fil_u->pax_c, strerror(-red_i));
}
else {
u3l_log("wrong # of bytes read in file %s: %d %d\r\n",
fil_u->pax_c, len_ws, red_ws);
u3l_log("wrong # of bytes read in file %s: %u %zu\r\n",
fil_u->pax_c, len_ws, red_i);
}
c3_free(dat_y);
return u3_nul;
@ -1159,7 +1158,7 @@ _unix_initial_update_file(c3_c* pax_c, c3_c* bas_c)
{
struct stat buf_u;
c3_i fid_i = c3_open(pax_c, O_RDONLY, 0644);
c3_ws len_ws, red_ws;
c3_ws len_ws;
c3_y* dat_y;
if ( fid_i < 0 || fstat(fid_i, &buf_u) < 0 ) {
@ -1176,21 +1175,21 @@ _unix_initial_update_file(c3_c* pax_c, c3_c* bas_c)
len_ws = buf_u.st_size;
dat_y = c3_malloc(len_ws);
red_ws = read(fid_i, dat_y, len_ws);
ssize_t red_i = c3_pread(fid_i, dat_y, len_ws, 0);
if ( close(fid_i) < 0 ) {
u3l_log("error closing initial file %s: %s\r\n",
pax_c, strerror(errno));
}
if ( len_ws != red_ws ) {
if ( red_ws < 0 ) {
if ( red_i != len_ws ) {
if ( red_i < 0 ) {
u3l_log("error reading initial file %s: %s\r\n",
pax_c, strerror(errno));
pax_c, strerror(-red_i));
}
else {
u3l_log("wrong # of bytes read in initial file %s: %d %d\r\n",
pax_c, len_ws, red_ws);
u3l_log("wrong # of bytes read in initial file %s: %u %zu\r\n",
pax_c, len_ws, red_i);
}
c3_free(dat_y);
return u3_nul;

80
pkg/urbit/vere/king.c
View File

@ -307,7 +307,7 @@ _king_get_pace(void)
{
struct stat buf_u;
c3_c* pat_c;
c3_w red_w, len_w;
c3_w len_w;
c3_i ret_i, fid_i;
ret_i = asprintf(&pat_c, "%s/.bin/pace", u3_Host.dir_c);
@ -324,10 +324,10 @@ _king_get_pace(void)
len_w = buf_u.st_size;
pat_c = c3_malloc(len_w + 1);
red_w = read(fid_i, pat_c, len_w);
ssize_t red_i = c3_pread(fid_i, pat_c, len_w, 0);
close(fid_i);
if ( len_w != red_w ) {
if ( red_i != len_w ) {
c3_free(pat_c);
u3l_log("unable to read pace file, "
"falling back to default (\"live\")\n");
@ -1038,9 +1038,6 @@ _king_make_pace(c3_c* pac_c)
return 0;
}
static c3_i
_king_write_raw(c3_i fid_i, c3_y* buf_y, size_t len_i);
/* _king_init_pace(): save pace file if not present
*/
static c3_i
@ -1064,8 +1061,11 @@ _king_init_pace(c3_c* pac_c)
}
}
if ( _king_write_raw(fid_i, (c3_y*)pac_c, strlen(pac_c)) ) {
u3l_log("dock: init pace (%s): write %s\n", pac_c, strerror(errno));
size_t len_i = strlen(pac_c);
ssize_t wit_i = c3_pwrite(fid_i, pac_c, len_i, 0);
if ( wit_i != len_i ) {
u3l_log("dock: init pace (%s) write failed: %s\n",
pac_c, strerror(errno));
close(fid_i);
c3_free(bin_c);
return -1;
@ -1239,62 +1239,24 @@ _king_do_upgrade(c3_c* pac_c, c3_c* ver_c)
// XX print restart instructions
}
/* _king_read_raw: read (up to) [len_i] from [fid_i] to [buf_y]
*/
static ssize_t
_king_read_raw(c3_i fid_i, c3_y* buf_y, size_t len_i)
{
ssize_t ret_i;
do {
ret_i = read(fid_i, buf_y, len_i);
}
while ( (ret_i < 0) && (errno == EINTR) );
return ret_i;
}
/* _king_read_raw: write [len_i] from [buf_y] to [fid_i].
*/
static c3_i
_king_write_raw(c3_i fid_i, c3_y* buf_y, size_t len_i)
{
ssize_t ret_i;
while ( len_i ) {
do {
ret_i = write(fid_i, buf_y, len_i);
}
while ( (ret_i < 0) && (errno == EINTR) );
if ( ret_i < 0 ) {
return -1;
}
else {
len_i -= ret_i;
buf_y += ret_i;
}
}
return 0;
}
static c3_i
_king_copy_raw(c3_i src_i, c3_i dst_i, c3_y* buf_y, size_t pag_i)
{
ssize_t red_i;
size_t off_i = 0;
ssize_t ret_i;
do {
if ( 0 > (red_i = _king_read_raw(src_i, buf_y, pag_i)) ) {
return -1;
if ( 0 > (ret_i = c3_pread(src_i, buf_y, pag_i, off_i)) ) {
return ret_i;
}
if ( _king_write_raw(dst_i, buf_y, (size_t)red_i) ) {
return -1;
if ( 0 > (ret_i = c3_pwrite(dst_i, buf_y, (size_t)ret_i, off_i)) ) {
return ret_i;
}
off_i += (size_t)ret_i;
}
while ( red_i );
while ( ret_i );
return 0;
}
@ -1337,6 +1299,8 @@ _king_copy_file(c3_c* src_c, c3_c* dst_c)
goto done1;
}
// XX O_TRUNC?
//
if ( -1 == (dst_i = open(dst_c, O_RDWR | O_CREAT, 0755)) ) {
err_i = errno;
ret_i = -1;
@ -1403,8 +1367,12 @@ _king_copy_file(c3_c* src_c, c3_c* dst_c)
{
size_t pag_i = 1 << 14;;
c3_y* buf_y = c3_malloc(pag_i);
ret_i = _king_copy_raw(src_i, dst_i, buf_y, pag_i);
if ( 0 > (ret_i = _king_copy_raw(src_i, dst_i, buf_y, pag_i)) ) {
err_i = errno;
ret_i = -1;
}
c3_free(buf_y);
}

2
pkg/urbit/vere/lord.c
View File

@ -1051,7 +1051,7 @@ _lord_on_serf_err_cb(uv_stream_t* pyp_u,
// serf used to write to 2 directly
// this can't be any worse than that
//
u3_write_fd(2, buf_u->base, siz_i);
c3_assert(c3_write(STDERR_FILENO, buf_u->base, siz_i) == siz_i);
} else {
uv_read_stop(pyp_u);