nexoniarz/SchOS
nexoniarz/SchOS
Watch
1
0
Fork
You've already forked SchOS
 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Job control, function keys, and real sleeps

Browse source 
- SIGSTOP/SIGTSTP/SIGTTIN/SIGTTOU stop, SIGCONT resumes; the parent gets
  SIGCHLD and wait4 reports WUNTRACED/WCONTINUED; ps shows T. Ctrl-Z works,
  and mc no longer hangs waiting for its subshell to stop.
- Blocking reads (console, pty, pipe) and sleeps take a pending stop and
  carry on after SIGCONT; a caught signal without SA_RESTART ends them
  with EINTR.
- nanosleep reads tv_nsec (sleep 0.5 used to return at once), writes the
  remainder, and clock_nanosleep understands TIMER_ABSTIME.
- rt_sigaction uses the k_sigaction layout for Linux-ABI processes: the old
  action's restorer was written 112 bytes past the caller's struct. Flags
  are kept; SIGKILL and SIGSTOP cannot be caught.
- F1..F12 reach programs, as the Linux console sends them (PS/2, USB, I2C).
- TIOCLINUX subcode 6 answers "no modifiers" instead of echoing the 6 back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1giNvrHTrPMPw7V6x1kQ4
This commit is contained in:
Nexoniarz 2026-10-25 02:37:45 +01:00
commit 2372806862
13 changed files with 366 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

114
kernel/sys/sys_time.c
View file

@ -60,23 +60,65 @@ sys_gettimeofday(void)
return 0;
}
// Sleep for a timespec, in ticks, rounded up.
//
// Only tv_sec was ever read: `sleep 0.5` returned at once and every
// sub-second sleep -- cmatrix's frame delay, a game loop's -- was no sleep at
// all. And a signal could not end one: Ctrl-Z on `sleep 100` did nothing.
static addr_t
sleep_ticks(uint64 want, addr_t remaddr)
{
struct proc *p = myproc();
acquire(&tickslock);
uint t0 = ticks;
while ((uint64)(uint)(ticks - t0) < want) {
if (p->killed || sig_attention(p)) {
release(&tickslock);
int e = p->killed ? -EINTR : sig_blocking_check();
if (e) {
if (remaddr) {
uint64 left = want - (uint)(ticks - t0);
struct timespec r = { (long)(left / HZ),
(long)((left % HZ) * (1000000000 / HZ)) };
copy_to_user(remaddr, &r, sizeof(r));
}
return e;
}
acquire(&tickslock);
continue;
}
sleep(&ticks, &tickslock);
}
release(&tickslock);
return 0;
}
static int
timespec_ticks(const struct timespec *ts, uint64 *out)
{
if (ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000)
return -EINVAL;
uint64 sec = (uint64)ts->tv_sec;
if (sec > 0xFFFFFFFFULL / HZ)
sec = 0xFFFFFFFFULL / HZ; // a few years: forever enough
*out = sec * HZ + ((uint64)ts->tv_nsec * HZ + 999999999) / 1000000000;
return 0;
}
addr_t
sys_nanosleep(void)
{
addr_t tsaddr, raw;
if (argaddr(0, &tsaddr) < 0 || fetchaddr(tsaddr, &raw) < 0)
return -1;
int64 sec = (int64)raw;
if (sec > 0) {
acquire(&tickslock);
uint t0 = ticks;
while (ticks - t0 < (uint)(sec * HZ)) {
if (myproc()->killed) { release(&tickslock); return -EINTR; }
sleep(&ticks, &tickslock);
}
release(&tickslock);
}
return 0;
addr_t tsaddr, remaddr;
struct timespec ts;
uint64 want;
argaddr(0, &tsaddr);
argaddr(1, &remaddr);
if (copy_from_user(&ts, tsaddr, sizeof(ts)) < 0)
return -EFAULT;
int e = timespec_ticks(&ts, &want);
if (e)
return e;
return sleep_ticks(want, remaddr);
}
addr_t
@ -173,20 +215,34 @@ sys_clock_getres(void)
addr_t
sys_clock_nanosleep(void)
{
// Treat the same as nanosleep: arg2 is the timespec, arg1 is flags.
// Linux: clock_nanosleep(clockid, flags, rqtp, rmtp)
addr_t tsaddr, raw;
if (argaddr(2, &tsaddr) < 0 || fetchaddr(tsaddr, &raw) < 0)
return -1;
int64 sec = (int64)raw;
if (sec > 0) {
acquire(&tickslock);
uint t0 = ticks;
while (ticks - t0 < (uint)(sec * HZ)) {
if (myproc()->killed) { release(&tickslock); return -EINTR; }
sleep(&ticks, &tickslock);
}
release(&tickslock);
// clock_nanosleep(clockid, flags, rqtp, rmtp). TIMER_ABSTIME (1) makes
// rqtp a time on that clock rather than an interval.
int clkid, flags;
addr_t tsaddr, remaddr;
struct timespec ts;
uint64 want;
argint(0, &clkid);
argint(1, &flags);
argaddr(2, &tsaddr);
argaddr(3, &remaddr);
if (copy_from_user(&ts, tsaddr, sizeof(ts)) < 0)
return -EFAULT;
if (flags & 1) {
uint64 sec, usec;
wallclock(&sec, &usec);
if (clkid == 1)
sec -= boot_epoch;
long dsec = ts.tv_sec - (long)sec;
long dns = ts.tv_nsec - (long)(usec * 1000);
if (dns < 0) { dns += 1000000000; dsec--; }
if (dsec < 0)
return 0; // already past
ts.tv_sec = dsec;
ts.tv_nsec = dns;
remaddr = 0; // never written for an absolute sleep
}
return 0;
int e = timespec_ticks(&ts, &want);
if (e)
return e;
return sleep_ticks(want, remaddr);
}