std: ignore EINTR error during syscalls if possible

Author: mertcandav

std/internal/os/proc_posix.jule

@@ -0,0 +1,43 @@
+// Copyright 2025 The Jule Programming Language.
+// Use of this source code is governed by a BSD 3-Clause
+// license that can be found in the LICENSE file.
+
+#build unix || windows
+
+use "std/sys"
+
+// Implementation adopted from the Go programming language.
+//
+// It makes a function call and repeats it if it returns an
+// EINTR error. This appears to be required even though we install all
+// signal handlers with SA_RESTART: see Go's #22838, #38033, #38836, #40846.
+// Also #20400 and #36644 are issues in which a signal handler is
+// installed without setting SA_RESTART. None of these are the common case,
+// but there are enough of them that it seems that we can't avoid
+// an EINTR loop.
+fn ignoringEINTR(f: fn()!)! {
+	for {
+		f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		break
+	}
+}
+
+// Implementation adopted from the Go programming language.
+//
+// This is ignoringEINTR, but returning an additional value.
+fn ignoringEINTR2[T](f: fn()!: T)!: T {
+	for {
+		mut v := f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		ret v
+	}
+}

std/internal/os/proc_unix.jule

@@ -7,7 +7,10 @@ use "std/unsafe"
 
 fn Getwd()!: str {
 	let mut buf: [sys::PATH_MAX]byte
-	n := sys::Getcwd(unsafe::Slice(&buf[0], len(buf), len(buf))) else { error(error) }
+	mut sbuf := unsafe::Slice(&buf[0], len(buf), len(buf))
+	n := ignoringEINTR2(fn()!: int {
+		ret sys::Getcwd(sbuf) else { error(error) }
+	}) else { error(error) }
 	ret unsafe::StrFromBytes(buf[:n])
 }
 

std/internal/poll/fd_darwin.jule renamed to std/internal/poll/fd_fsync_darwin.jule

@@ -9,13 +9,16 @@ impl FD {
 	// on OS X, SYS_FSYNC doesn't fully flush contents to disk.
 	// See the man page for fsync on OS X.
 	fn Fsync(mut self)! {
-		sys::Fcntl(int(self.File), sys::F_FULLFSYNC, 0) else {
-			// There are scenarios such as SMB mounts where fcntl will fail
-			// with ENOTSUP. In those cases fallback to fsync.
-			if error != sys::ENOTSUP {
-				error(error)
+		fd := int(self.File)
+		ignoringEINTR(fn()! {
+			sys::Fcntl(fd, sys::F_FULLFSYNC, 0) else {
+				// There are scenarios such as SMB mounts where fcntl will fail
+				// with ENOTSUP. In those cases fallback to fsync.
+				if error != sys::ENOTSUP {
+					error(error)
+				}
+				sys::Fsync(fd) else { error(error) }
 			}
-			sys::Fsync(int(self.File)) else { error(error) }
-		}
+		}) else { error(error) }
 	}
 }

std/internal/poll/fd_fsync_posix.jule

@@ -0,0 +1,17 @@
+// Copyright 2025 The Jule Programming Language.
+// Use of this source code is governed by a BSD 3-Clause
+// license that can be found in the LICENSE file.
+
+#build linux
+
+use "std/sys"
+
+impl FD {
+	// Wraps sys::Fsync.
+	fn Fsync(mut self)! {
+		fd := int(self.File)
+		ignoringEINTR(fn()! {
+			sys::Fsync(fd) else { error(error) }
+		}) else { error(error) }
+	}
+}

std/internal/poll/fd_posix.jule

@@ -2,13 +2,42 @@
 // Use of this source code is governed by a BSD 3-Clause
 // license that can be found in the LICENSE file.
 
-#build linux
+#build unix || windows
 
 use "std/sys"
 
-impl FD {
-	// Wraps sys::Fsync.
-	fn Fsync(mut self)! {
-		sys::Fsync(int(self.File)) else { error(error) }
+// Implementation adopted from the Go programming language.
+//
+// It makes a function call and repeats it if it returns an
+// EINTR error. This appears to be required even though we install all
+// signal handlers with SA_RESTART: see Go's #22838, #38033, #38836, #40846.
+// Also #20400 and #36644 are issues in which a signal handler is
+// installed without setting SA_RESTART. None of these are the common case,
+// but there are enough of them that it seems that we can't avoid
+// an EINTR loop.
+fn ignoringEINTR(f: fn()!)! {
+	for {
+		f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		break
+	}
+}
+
+// Implementation adopted from the Go programming language.
+//
+// This is ignoringEINTR, but returning an additional value.
+fn ignoringEINTR2[T](f: fn()!: T)!: T {
+	for {
+		mut v := f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		ret v
 	}
 }

std/os/cmd_unix.jule

@@ -108,8 +108,12 @@ impl Cmd {
 	}
 
 	fn wait(self)!: int {
-		mut stat := i32(0)
-		sys::Waitpid(self.attrs.pid, stat, 0) else { error(error) }
+		pid := self.attrs.pid
+		stat := ignoringEINTR2(fn()!: i32 {
+			mut stat := i32(0)
+			sys::Waitpid(pid, stat, 0) else { error(error) }
+			ret stat
+		}) else { error(error) }
 		self.attrs.pid = invalidPid
 		ret cpp.WEXITSTATUS(stat)
 	}

std/os/dir_unix.jule

@@ -32,7 +32,9 @@ fn mkdir(path: str)! {
 	// NOTICE
 	// Also can has EMLINK error-code.
 	// Make sure this situation should documented or not.
-	sys::Mkdir(path, 0700) else { error(error) }
+	ignoringEINTR(fn()! {
+		sys::Mkdir(path, 0700) else { error(error) }
+	}) else { error(error) }
 }
 
 fn rmdir(path: str)! {

std/os/file_posix.jule

@@ -19,4 +19,40 @@ fn syscallMode(i: FileMode): (o: u32) {
 		o |= sys::S_ISVTX
 	}
 	ret
+}
+
+// Implementation adopted from the Go programming language.
+//
+// It makes a function call and repeats it if it returns an
+// EINTR error. This appears to be required even though we install all
+// signal handlers with SA_RESTART: see Go's #22838, #38033, #38836, #40846.
+// Also #20400 and #36644 are issues in which a signal handler is
+// installed without setting SA_RESTART. None of these are the common case,
+// but there are enough of them that it seems that we can't avoid
+// an EINTR loop.
+fn ignoringEINTR(f: fn()!)! {
+	for {
+		f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		break
+	}
+}
+
+// Implementation adopted from the Go programming language.
+//
+// This is ignoringEINTR, but returning an additional value.
+fn ignoringEINTR2[T](f: fn()!: T)!: T {
+	for {
+		mut v := f() else {
+			if error == sys::EINTR {
+				continue
+			}
+			error(error)
+		}
+		ret v
+	}
 }

std/os/stat_unix.jule

@@ -8,8 +8,11 @@ fn stat(path: str)!: FileInfo {
 	if path == "" {
 		error(sys::ENOENT)
 	}
-	mut handle := sys::SysStat{}
-	sys::Stat(path, handle) else { error(error) }
+	handle := ignoringEINTR2(fn()!: sys::SysStat {
+		mut handle := sys::SysStat{}
+		sys::Stat(path, handle) else { error(error) }
+		ret handle
+	}) else { error(error) }
 	mut stat := FileInfo{}
 	fillFileStatFromSys(stat, handle)
 	stat.sys = handle
@@ -20,8 +23,11 @@ fn lstat(path: str)!: FileInfo {
 	if path == "" {
 		error(sys::ENOENT)
 	}
-	mut handle := sys::SysStat{}
-	sys::Lstat(path, handle) else { error(error) }
+	handle := ignoringEINTR2(fn()!: sys::SysStat {
+		mut handle := sys::SysStat{}
+		sys::Lstat(path, handle) else { error(error) }
+		ret handle
+	}) else { error(error) }
 	mut stat := FileInfo{}
 	fillFileStatFromSys(stat, handle)
 	stat.sys = handle