kotovalexarian-likes-gitlab/sortix--sortix
1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
Code Releases Activity
sortix--sortix/libc/x64/fork.S

78 lines
2.2 KiB
ArmAsm
Raw Normal View History

Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
/*******************************************************************************
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
Copyright(C) Jonas 'Sortie' Termansen 2012, 2014.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Update copyright headers of old files to the current format.
2013-07-10 09:26:01 -04:00
This file is part of the Sortix C Library.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Update copyright headers of old files to the current format.
2013-07-10 09:26:01 -04:00
The Sortix C Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Update copyright headers of old files to the current format.
2013-07-10 09:26:01 -04:00
The Sortix C Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Update copyright headers of old files to the current format.
2013-07-10 09:26:01 -04:00
You should have received a copy of the GNU Lesser General Public License
along with the Sortix C Library. If not, see <http://www.gnu.org/licenses/>.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Preprocess assembly files with the C preprocessor.
2013-12-28 15:00:15 -05:00
x64/fork.S
Update copyright headers of old files to the current format.
2013-07-10 09:26:01 -04:00
Assembly functions related to forking x64 processes.
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
*******************************************************************************/
Maintain fsbase and gsbase as per-thread registers. Note: This is an incompatible ABI change.
2013-09-14 12:59:15 -04:00
#define MSRID_FSBASE 0xC0000100
#define MSRID_GSBASE 0xC0000101
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
.section .text
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
.globl __sfork
.type __sfork, @function
__sfork:
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
pushq %rbp
movq %rsp, %rbp
Maintain fsbase and gsbase as per-thread registers. Note: This is an incompatible ABI change.
2013-09-14 12:59:15 -04:00
pushq %rdi
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
pushq %rsi
Maintain fsbase and gsbase as per-thread registers. Note: This is an incompatible ABI change.
2013-09-14 12:59:15 -04:00
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
movq $.Lafter_fork, (0 * 8)(%rsi) # rip
movq $0, (1 * 8)(%rsi) # rax, result is 0 for child
movq %rbx, (2 * 8)(%rsi)
movq %rcx, (3 * 8)(%rsi)
movq %rdx, (4 * 8)(%rsi)
movq %rdi, (5 * 8)(%rsi)
movq %rsi, (6 * 8)(%rsi)
movq %rsp, (7 * 8)(%rsi)
movq %rbp, (8 * 8)(%rsi)
movq %r8, (9 * 8)(%rsi)
movq %r9, (10 * 8)(%rsi)
movq %r10, (11 * 8)(%rsi)
movq %r11, (12 * 8)(%rsi)
movq %r12, (13 * 8)(%rsi)
movq %r13, (14 * 8)(%rsi)
movq %r14, (15 * 8)(%rsi)
movq %r15, (16 * 8)(%rsi)
pushfq
popq %rax
movq %rax, (17 * 8)(%rsi) # rflags
Add rdmsr(2) and wrmsr(2).
2013-09-14 14:05:17 -04:00
movl $MSRID_FSBASE, %edi
call rdmsr
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
movq 0(%rsp), %rsi
movq %rax, (18 * 8)(%rsi) # fsbase
movl $MSRID_GSBASE, %edi
call rdmsr
movq 0(%rsp), %rsi
movq %rax, (19 * 8)(%rsi) # gsbase
movq 8(%rsp), %rdi
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Renamed sforkr(2) to tfork(2). It's a much better name if you think of it as task-fork or thread-fork in the sense that it either modifies this task or creates a new one. This call will be used to provide user-space threads as well as fork(2).
2012-08-05 11:35:19 -04:00
call tfork
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
Improve ix86 and x86_64 data types ABI. Increase gid_t to an unsigned 64-bit integer. Increase id_t to an unsigned 64-bit integer. Increase pid_t to a signed 64-bit integer. Increase time_t to a signed 64-bit integer. Increase uid_t to an unsigned 64-bit integer. Note: This is an incompatible ABI change.
2013-12-29 16:51:52 -05:00
.Lafter_fork:
Added sforkr(2) that controls the child registers as well. sfork(2) now calls sforkr(2) with the current registers. This will prove useful in creating threads, where user-space now can fully control what state the child will start in. This is unlike the Linux clone system call that accepts a pointer to the child stack; this is more powerful and somehow simpler. Note that this will create a rather raw thread; no thread initization has been done by the standard thread API (when it is implemented), so this feature shouldn't be used by programmers unless they know what they are doing. fork(2) now calls sfork(2) directly. Also removed fork(2) and sfork(2) from the kernel as they are done using sforkr(2) now. So technically they aren't system calls right now, but that could always change.
2012-04-05 17:00:47 -04:00
# The value in %rax determines whether we are child or parent. There is no
# need to clean up the stack from the above pushes, leaveq sets %rsp to %rbp
# which does that for us.
leaveq
retq
Implement signals. Note: This is an incompatible ABI change.
2013-08-04 14:24:59 -04:00
.size __sfork, . - __sfork
Copy permalink