vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup and format

Browse Source
This commit is contained in:
Jeremy Soller
2019-01-14 21:07:24 -07:00
parent 8dabff129a
commit c71088e768
26 changed files with 507 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/header/dlfcn/mod.rs
+4 -2
View File
@@ -1,7 +1,7 @@
//! dlfcn implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html
use core::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use core::{ptr, str};
use core::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use c_str::CStr;
use platform::types::*;
@@ -38,7 +38,9 @@ pub unsafe extern "C" fn dlopen(filename: *const c_char, flags: c_int) -> *mut c
let filename_opt = if filename.is_null() {
None
} else {
Some(str::from_utf8_unchecked(CStr::from_ptr(filename).to_bytes()))
Some(str::from_utf8_unchecked(
CStr::from_ptr(filename).to_bytes(),
))
};
eprintln!("dlopen({:?}, {:#>04x})", filename_opt, flags);
src/header/mod.rs
+2 -2
View File
@@ -1,4 +1,5 @@
pub mod _aio;
pub mod _fenv;
pub mod arpa_inet;
pub mod assert;
pub mod ctype;
@@ -6,7 +7,6 @@ pub mod dirent;
pub mod dlfcn;
pub mod errno;
pub mod fcntl;
pub mod _fenv;
pub mod float;
pub mod fnmatch;
pub mod getopt;
@@ -39,6 +39,7 @@ pub mod sys_statvfs;
pub mod sys_time;
pub mod sys_timeb;
//pub mod sys_times;
pub mod _wctype;
pub mod sys_uio;
pub mod sys_un;
pub mod sys_utsname;
@@ -48,4 +49,3 @@ pub mod time;
pub mod unistd;
pub mod utime;
pub mod wchar;
pub mod _wctype;
src/header/netdb/db.rs
+31
View File
@@ -0,0 +1,31 @@
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use c_str::CStr;
use fs::File;
use header::fcntl;
use io::{self, BufRead, BufReader};
pub struct Db(BufReader<File>);
impl Db {
pub fn new(path: &CStr) -> io::Result<Self> {
File::open(path, fcntl::O_RDONLY)
.map(BufReader::new)
.map(Db)
}
pub fn read(&mut self) -> io::Result<Vec<String>> {
let mut parts = Vec::new();
let mut line = String::new();
self.0.read_line(&mut line)?;
if let Some(not_comment) = line.split('#').next() {
for part in not_comment.split_whitespace() {
parts.push(part.to_string());
}
}
Ok(parts)
}
}
src/header/netdb/lookup.rs
+252
View File
@@ -0,0 +1,252 @@
use alloc::boxed::Box;
use alloc::string::{String, ToString};
use alloc::vec::{IntoIter, Vec};
use core::mem;
use platform::types::*;
use platform::{Pal, Sys};
use header::arpa_inet::htons;
use header::errno::*;
use header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
use header::sys_socket;
use header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
use header::sys_socket::{sockaddr, socklen_t};
use header::time;
use header::time::timespec;
use super::dns::{Dns, DnsQuery};
use super::sys::get_dns_server;
pub struct LookupHost(IntoIter<in_addr>);
impl Iterator for LookupHost {
type Item = in_addr;
fn next(&mut self) -> Option<Self::Item> {
self.0.next()
}
}
pub fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
let dns_string = get_dns_server();
let dns_vec: Vec<u8> = dns_string
.trim()
.split(".")
.map(|octet| octet.parse::<u8>().unwrap_or(0))
.collect();
if dns_vec.len() == 4 {
let mut dns_arr = [0u8; 4];
for (i, octet) in dns_vec.iter().enumerate() {
dns_arr[i] = *octet;
}
let dns_addr = unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) };
let mut timespec = timespec::default();
Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
let tid = (timespec.tv_nsec >> 16) as u16;
let packet = Dns {
transaction_id: tid,
flags: 0x0100,
queries: vec![DnsQuery {
name: host.to_string(),
q_type: 0x0001,
q_class: 0x0001,
}],
answers: vec![],
};
let packet_data = packet.compile();
let packet_data_len = packet_data.len();
let packet_data_box = packet_data.into_boxed_slice();
let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
let dest = sockaddr_in {
sin_family: AF_INET as u16,
sin_port: htons(53),
sin_addr: in_addr { s_addr: dns_addr },
..Default::default()
};
let dest_ptr = &dest as *const _ as *const sockaddr;
let sock = unsafe {
let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
return Err(EIO);
}
if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
Box::from_raw(packet_data_ptr);
return Err(EIO);
}
sock
};
unsafe {
Box::from_raw(packet_data_ptr);
}
let i = 0 as socklen_t;
let mut buf = [0u8; 65536];
let buf_ptr = buf.as_mut_ptr() as *mut c_void;
let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
if count < 0 {
return Err(EIO);
}
match Dns::parse(&buf[..count as usize]) {
Ok(response) => {
let mut addrs = vec![];
for answer in response.answers.iter() {
if answer.a_type == 0x0001 && answer.a_class == 0x0001 && answer.data.len() == 4
{
let addr = in_addr {
s_addr: unsafe {
mem::transmute::<[u8; 4], u32>([
answer.data[0],
answer.data[1],
answer.data[2],
answer.data[3],
])
},
};
addrs.push(addr);
}
}
Ok(LookupHost(addrs.into_iter()))
}
Err(_err) => Err(EINVAL),
}
} else {
Err(EINVAL)
}
}
pub fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
let dns_string = get_dns_server();
let dns_vec: Vec<u8> = dns_string
.trim()
.split('.')
.map(|octet| octet.parse::<u8>().unwrap_or(0))
.collect();
let mut dns_arr = [0u8; 4];
for (i, octet) in dns_vec.iter().enumerate() {
dns_arr[i] = *octet;
}
let mut addr_vec: Vec<u8> = unsafe { mem::transmute::<u32, [u8; 4]>(addr.s_addr).to_vec() };
addr_vec.reverse();
let mut name: Vec<u8> = vec![];
for octet in addr_vec {
for ch in format!("{}", octet).as_bytes() {
name.push(*ch);
}
name.push(b"."[0]);
}
name.pop();
for ch in b".IN-ADDR.ARPA" {
name.push(*ch);
}
if dns_vec.len() == 4 {
let mut timespec = timespec::default();
Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
let tid = (timespec.tv_nsec >> 16) as u16;
let packet = Dns {
transaction_id: tid,
flags: 0x0100,
queries: vec![DnsQuery {
name: String::from_utf8(name).unwrap(),
q_type: 0x000C,
q_class: 0x0001,
}],
answers: vec![],
};
let packet_data = packet.compile();
let packet_data_len = packet_data.len();
let packet_data_box = packet_data.into_boxed_slice();
let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
let dest = sockaddr_in {
sin_family: AF_INET as u16,
sin_port: htons(53),
sin_addr: in_addr {
s_addr: unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) },
},
..Default::default()
};
let dest_ptr = &dest as *const _ as *const sockaddr;
let sock = unsafe {
let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
return Err(EIO);
}
sock
};
unsafe {
if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
return Err(EIO);
}
}
unsafe {
Box::from_raw(packet_data_ptr);
}
let i = mem::size_of::<sockaddr_in>() as socklen_t;
let mut buf = [0u8; 65536];
let buf_ptr = buf.as_mut_ptr() as *mut c_void;
let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
if count < 0 {
return Err(EIO);
}
match Dns::parse(&buf[..count as usize]) {
Ok(response) => {
let mut names = vec![];
for answer in response.answers.iter() {
if answer.a_type == 0x000C && answer.a_class == 0x0001 {
// answer.data is encoded kinda weird.
// Basically length-prefixed strings for each
// subsection of the domain.
// We need to parse this to insert periods where
// they belong (ie at the end of each string)
let data = parse_revdns_answer(&answer.data);
names.push(data);
}
}
Ok(names)
}
Err(_err) => Err(EINVAL),
}
} else {
Err(EINVAL)
}
}
fn parse_revdns_answer(data: &[u8]) -> Vec<u8> {
let mut cursor = 0;
let mut index = 0;
let mut output = data.to_vec();
while index < data.len() - 1 {
let offset = data[index] as usize;
index = cursor + offset + 1;
output[index] = b'.';
cursor = index;
}
//we don't want an extra period at the end
output.pop();
output
}
src/header/netdb/mod.rs
+21 -259
View File
@@ -7,8 +7,7 @@ use core::{mem, ptr, slice, str};
use alloc::boxed::Box;
use alloc::str::SplitWhitespace;
use alloc::string::{String, ToString};
use alloc::vec::{IntoIter, Vec};
use alloc::vec::Vec;
use c_str::{CStr, CString};
@@ -17,19 +16,14 @@ use platform::rlb::{Line, RawLineBuffer};
use platform::types::*;
use platform::{Pal, Sys};
use self::dns::{Dns, DnsQuery};
use header::arpa_inet::{htons, inet_aton};
use header::errno::*;
use header::fcntl::O_RDONLY;
use header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
use header::netinet_in::{in_addr, sockaddr_in};
use header::stdlib::atoi;
use header::strings::strcasecmp;
use header::sys_socket;
use header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
use header::sys_socket::constants::AF_INET;
use header::sys_socket::{sockaddr, socklen_t};
use header::time;
use header::time::timespec;
use header::unistd::SEEK_SET;
#[cfg(target_os = "linux")]
@@ -40,18 +34,15 @@ pub mod sys;
#[path = "redox.rs"]
pub mod sys;
//TODO: use self::db::Db;
pub mod db;
use self::lookup::{lookup_addr, lookup_host};
pub mod lookup;
const MAXADDRS: usize = 35;
const MAXALIASES: usize = 35;
struct LookupHost(IntoIter<in_addr>);
impl Iterator for LookupHost {
type Item = in_addr;
fn next(&mut self) -> Option<Self::Item> {
self.0.next()
}
}
#[repr(C)]
pub struct hostent {
h_name: *mut c_char,
@@ -69,6 +60,13 @@ pub struct netent {
n_net: c_ulong, /* network # */
}
#[repr(C)]
pub struct protoent {
p_name: *mut c_char, /* official protocol name */
p_aliases: *mut *mut c_char, /* alias list */
p_proto: c_int, /* protocol # */
}
#[repr(C)]
pub struct servent {
s_name: *mut c_char, /* official service name */
@@ -77,13 +75,6 @@ pub struct servent {
s_proto: *mut c_char, /* protocol to use */
}
#[repr(C)]
pub struct protoent {
p_name: *mut c_char, /* official protocol name */
p_aliases: *mut *mut c_char, /* alias list */
p_proto: c_int, /* protocol # */
}
#[repr(C)]
pub struct addrinfo {
ai_flags: c_int, /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
@@ -196,230 +187,6 @@ fn bytes_to_box_str(bytes: &[u8]) -> Box<str> {
Box::from(core::str::from_utf8(bytes).unwrap_or(""))
}
fn lookup_host(host: &str) -> Result<LookupHost, c_int> {
let dns_string = sys::get_dns_server();
let dns_vec: Vec<u8> = dns_string
.trim()
.split(".")
.map(|octet| octet.parse::<u8>().unwrap_or(0))
.collect();
if dns_vec.len() == 4 {
let mut dns_arr = [0u8; 4];
for (i, octet) in dns_vec.iter().enumerate() {
dns_arr[i] = *octet;
}
let dns_addr = unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) };
let mut timespec = timespec::default();
Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
let tid = (timespec.tv_nsec >> 16) as u16;
let packet = Dns {
transaction_id: tid,
flags: 0x0100,
queries: vec![DnsQuery {
name: host.to_string(),
q_type: 0x0001,
q_class: 0x0001,
}],
answers: vec![],
};
let packet_data = packet.compile();
let packet_data_len = packet_data.len();
let packet_data_box = packet_data.into_boxed_slice();
let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
let dest = sockaddr_in {
sin_family: AF_INET as u16,
sin_port: htons(53),
sin_addr: in_addr { s_addr: dns_addr },
..Default::default()
};
let dest_ptr = &dest as *const _ as *const sockaddr;
let sock = unsafe {
let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
return Err(EIO);
}
if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
Box::from_raw(packet_data_ptr);
return Err(EIO);
}
sock
};
unsafe {
Box::from_raw(packet_data_ptr);
}
let i = 0 as socklen_t;
let mut buf = [0u8; 65536];
let buf_ptr = buf.as_mut_ptr() as *mut c_void;
let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
if count < 0 {
return Err(EIO);
}
match Dns::parse(&buf[..count as usize]) {
Ok(response) => {
let mut addrs = vec![];
for answer in response.answers.iter() {
if answer.a_type == 0x0001 && answer.a_class == 0x0001 && answer.data.len() == 4
{
let addr = in_addr {
s_addr: unsafe {
mem::transmute::<[u8; 4], u32>([
answer.data[0],
answer.data[1],
answer.data[2],
answer.data[3],
])
},
};
addrs.push(addr);
}
}
Ok(LookupHost(addrs.into_iter()))
}
Err(_err) => Err(EINVAL),
}
} else {
Err(EINVAL)
}
}
fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
let dns_string = sys::get_dns_server();
let dns_vec: Vec<u8> = dns_string
.trim()
.split('.')
.map(|octet| octet.parse::<u8>().unwrap_or(0))
.collect();
let mut dns_arr = [0u8; 4];
for (i, octet) in dns_vec.iter().enumerate() {
dns_arr[i] = *octet;
}
let mut addr_vec: Vec<u8> = unsafe { mem::transmute::<u32, [u8; 4]>(addr.s_addr).to_vec() };
addr_vec.reverse();
let mut name: Vec<u8> = vec![];
for octet in addr_vec {
for ch in format!("{}", octet).as_bytes() {
name.push(*ch);
}
name.push(b"."[0]);
}
name.pop();
for ch in b".IN-ADDR.ARPA" {
name.push(*ch);
}
if dns_vec.len() == 4 {
let mut timespec = timespec::default();
Sys::clock_gettime(time::constants::CLOCK_REALTIME, &mut timespec);
let tid = (timespec.tv_nsec >> 16) as u16;
let packet = Dns {
transaction_id: tid,
flags: 0x0100,
queries: vec![DnsQuery {
name: String::from_utf8(name).unwrap(),
q_type: 0x000C,
q_class: 0x0001,
}],
answers: vec![],
};
let packet_data = packet.compile();
let packet_data_len = packet_data.len();
let packet_data_box = packet_data.into_boxed_slice();
let packet_data_ptr = Box::into_raw(packet_data_box) as *mut _ as *mut c_void;
let dest = sockaddr_in {
sin_family: AF_INET as u16,
sin_port: htons(53),
sin_addr: in_addr {
s_addr: unsafe { mem::transmute::<[u8; 4], u32>(dns_arr) },
},
..Default::default()
};
let dest_ptr = &dest as *const _ as *const sockaddr;
let sock = unsafe {
let sock = sys_socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP as i32);
if sys_socket::connect(sock, dest_ptr, mem::size_of_val(&dest) as socklen_t) < 0 {
return Err(EIO);
}
sock
};
unsafe {
if sys_socket::send(sock, packet_data_ptr, packet_data_len, 0) < 0 {
return Err(EIO);
}
}
unsafe {
Box::from_raw(packet_data_ptr);
}
let i = mem::size_of::<sockaddr_in>() as socklen_t;
let mut buf = [0u8; 65536];
let buf_ptr = buf.as_mut_ptr() as *mut c_void;
let count = unsafe { sys_socket::recv(sock, buf_ptr, 65536, 0) };
if count < 0 {
return Err(EIO);
}
match Dns::parse(&buf[..count as usize]) {
Ok(response) => {
let mut names = vec![];
for answer in response.answers.iter() {
if answer.a_type == 0x000C && answer.a_class == 0x0001 {
// answer.data is encoded kinda weird.
// Basically length-prefixed strings for each
// subsection of the domain.
// We need to parse this to insert periods where
// they belong (ie at the end of each string)
let data = parse_revdns_answer(&answer.data);
names.push(data);
}
}
Ok(names)
}
Err(_err) => Err(EINVAL),
}
} else {
Err(EINVAL)
}
}
fn parse_revdns_answer(data: &[u8]) -> Vec<u8> {
let mut cursor = 0;
let mut index = 0;
let mut output = data.to_vec();
while index < data.len() - 1 {
let offset = data[index] as usize;
index = cursor + offset + 1;
output[index] = b'.';
cursor = index;
}
//we don't want an extra period at the end
output.pop();
output
}
#[no_mangle]
pub unsafe extern "C" fn endhostent() {
Sys::close(HOSTDB);
@@ -800,10 +567,7 @@ pub unsafe extern "C" fn getprotoent() -> *mut protoent {
}
#[no_mangle]
pub unsafe extern "C" fn getservbyname(
name: *const c_char,
proto: *const c_char,
) -> *mut servent {
pub unsafe extern "C" fn getservbyname(name: *const c_char, proto: *const c_char) -> *mut servent {
setservent(SERV_STAYOPEN);
let mut p: *mut servent;
if proto.is_null() {
@@ -1012,11 +776,7 @@ pub unsafe extern "C" fn getaddrinfo(
Some(CStr::from_ptr(service))
};
let hints_opt = if hints.is_null() {
None
} else {
Some(&*hints)
};
let hints_opt = if hints.is_null() { None } else { Some(&*hints) };
eprintln!(
"getaddrinfo({:?}, {:?})",
@@ -1038,6 +798,7 @@ pub unsafe extern "C" fn getnameinfo(
servlen: socklen_t,
flags: c_int,
) -> c_int {
//TODO: getnameinfo
if addrlen as usize != mem::size_of::<sockaddr_in>() {
return EAI_FAMILY;
}
@@ -1088,5 +849,6 @@ pub extern "C" fn gai_strerror(errcode: c_int) -> *const c_char {
EAI_SYSTEM => c_str!("System error"),
EAI_OVERFLOW => c_str!("Overflow"),
_ => c_str!("Unknown error"),
}.as_ptr()
}
.as_ptr()
}
src/header/netinet_in/mod.rs
+2 -2
View File
@@ -66,10 +66,10 @@ pub const INADDR_MAX_LOCAL_GROUP: u32 = 0xE000_00FF;
#[no_mangle]
pub static in6addr_any: in6_addr = in6_addr {
s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
};
#[no_mangle]
pub static in6addr_loopback: in6_addr = in6_addr {
s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
};
src/header/pwd/mod.rs
+6 -6
View File
@@ -169,15 +169,15 @@ pub unsafe extern "C" fn getpwnam_r(
OptionPasswd::Error => {
*result = ptr::null_mut();
-1
},
}
OptionPasswd::NotFound => {
*result = ptr::null_mut();
0
},
}
OptionPasswd::Found(_) => {
*result = out;
0
},
}
}
}
@@ -199,15 +199,15 @@ pub unsafe extern "C" fn getpwuid_r(
OptionPasswd::Error => {
*result = ptr::null_mut();
-1
},
}
OptionPasswd::NotFound => {
*result = ptr::null_mut();
0
},
}
OptionPasswd::Found(_) => {
*result = out;
0
},
}
}
}
src/header/regex/mod.rs
+7 -2
View File
@@ -74,7 +74,7 @@ pub unsafe extern "C" fn regcomp(out: *mut regex_t, pat: *const c_char, cflags:
};
mem::forget(branches);
0
},
}
Err(CompileError::EmptyRepetition)
| Err(CompileError::IntegerOverflow)
| Err(CompileError::IllegalRange) => REG_BADBR,
@@ -146,7 +146,12 @@ pub unsafe extern "C" fn regexec(
#[no_mangle]
#[linkage = "weak"] // redefined in GIT
pub extern "C" fn regerror(code: c_int, _regex: *const regex_t, out: *mut c_char, max: size_t) -> size_t {
pub extern "C" fn regerror(
code: c_int,
_regex: *const regex_t,
out: *mut c_char,
max: size_t,
) -> size_t {
let string = match code {
0 => "No error\0",
REG_NOMATCH => "No match\0",
src/header/signal/mod.rs
+6 -5
View File
@@ -49,7 +49,11 @@ pub extern "C" fn killpg(pgrp: pid_t, sig: c_int) -> c_int {
}
#[no_mangle]
pub extern "C" fn pthread_sigmask(how: c_int, set: *const sigset_t, oldset: *mut sigset_t) -> c_int {
pub extern "C" fn pthread_sigmask(
how: c_int,
set: *const sigset_t,
oldset: *mut sigset_t,
) -> c_int {
// On Linux and Redox, pthread_sigmask and sigprocmask are equivalent
if sigprocmask(how, set, oldset) == 0 {
0
@@ -165,10 +169,7 @@ extern "C" {
}
#[no_mangle]
pub extern "C" fn signal(
sig: c_int,
func: extern "C" fn(c_int),
) -> extern "C" fn(c_int) {
pub extern "C" fn signal(sig: c_int, func: extern "C" fn(c_int)) -> extern "C" fn(c_int) {
let sa = sigaction {
sa_handler: func,
sa_flags: SA_RESTART as c_ulong,
src/header/stdio/mod.rs
+14 -8
View File
@@ -3,9 +3,9 @@
use alloc::borrow::{Borrow, BorrowMut};
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::{fmt, mem, ptr, slice, str};
use core::fmt::Write as WriteFmt;
use core::ops::{Deref, DerefMut};
use core::{fmt, mem, ptr, slice, str};
use va_list::VaList as va_list;
use c_str::CStr;
@@ -291,7 +291,11 @@ pub unsafe extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t) -> c_int {
/// Get a string from the stream
#[no_mangle]
pub unsafe extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) -> *mut c_char {
pub unsafe extern "C" fn fgets(
original: *mut c_char,
max: c_int,
stream: *mut FILE,
) -> *mut c_char {
let mut stream = (*stream).lock();
let mut out = original;
let max = max as usize;
@@ -343,9 +347,7 @@ pub unsafe extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut F
if max >= 1 {
// Write the NUL byte
unsafe {
*out = 0;
}
*out = 0;
}
if wrote {
original
@@ -570,7 +572,7 @@ pub unsafe extern "C" fn fwrite(
stream: *mut FILE,
) -> size_t {
if size == 0 || nitems == 0 {
return 0
return 0;
}
let mut stream = (*stream).lock();
let buf = slice::from_raw_parts_mut(ptr as *mut u8, size as usize * nitems as usize);
@@ -865,7 +867,7 @@ pub unsafe extern "C" fn setvbuf(
Buffer::Owned(vec![0; size as usize])
// }
} else {
unsafe { Buffer::Borrowed(slice::from_raw_parts_mut(buf as *mut u8, size)) }
Buffer::Borrowed(slice::from_raw_parts_mut(buf as *mut u8, size))
};
stream.flags |= F_SVB;
0
@@ -928,7 +930,11 @@ pub unsafe extern "C" fn vprintf(format: *const c_char, ap: va_list) -> c_int {
}
#[no_mangle]
pub unsafe extern "C" fn vasprintf(strp: *mut *mut c_char, format: *const c_char, ap: va_list) -> c_int {
pub unsafe extern "C" fn vasprintf(
strp: *mut *mut c_char,
format: *const c_char,
ap: va_list,
) -> c_int {
let mut alloc_writer = platform::AllocStringWriter(ptr::null_mut(), 0);
let ret = printf::printf(&mut alloc_writer, format, ap);
*strp = alloc_writer.0 as *mut c_char;
src/header/stdlib/sort.rs
+1 -3
View File
@@ -137,9 +137,7 @@ fn heap_sift_down(
swap_idx = child;
swap_ptr = first_child_ptr;
}
if child < end
&& comp(swap_ptr as *const c_void, second_child_ptr as *const c_void) < 0
{
if child < end && comp(swap_ptr as *const c_void, second_child_ptr as *const c_void) < 0 {
swap_idx = child + 1;
swap_ptr = second_child_ptr;
}
src/header/sys_statvfs/mod.rs
+1 -1
View File
@@ -1,7 +1,7 @@
//! statvfs implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/sysstatvfs.h.html
use c_str::CStr;
use header::fcntl::{O_PATH};
use header::fcntl::O_PATH;
use platform::types::*;
use platform::{Pal, Sys};
src/header/sys_timeb/mod.rs
+1 -1
View File
@@ -21,7 +21,7 @@ pub unsafe extern "C" fn ftime(tp: *mut timeb) -> c_int {
}
(*tp).time = tv.tv_sec;
(*tp).millitm = (tv.tv_usec/1000) as c_ushort;
(*tp).millitm = (tv.tv_usec / 1000) as c_ushort;
(*tp).timezone = tz.tz_minuteswest as c_short;
(*tp).dstflag = tz.tz_dsttime as c_short;
src/header/sys_uio/mod.rs
+1 -4
View File
@@ -17,10 +17,7 @@ pub struct iovec {
impl iovec {
unsafe fn to_slice(&self) -> &mut [u8] {
slice::from_raw_parts_mut(
self.iov_base as *mut u8,
self.iov_len as usize
)
slice::from_raw_parts_mut(self.iov_base as *mut u8, self.iov_len as usize)
}
}
src/header/unistd/mod.rs
+5 -1
View File
@@ -486,7 +486,11 @@ pub extern "C" fn read(fildes: c_int, buf: *const c_void, nbyte: size_t) -> ssiz
}
#[no_mangle]
pub unsafe extern "C" fn readlink(path: *const c_char, buf: *mut c_char, bufsize: size_t) -> ssize_t {
pub unsafe extern "C" fn readlink(
path: *const c_char,
buf: *mut c_char,
bufsize: size_t,
) -> ssize_t {
let path = CStr::from_ptr(path);
let buf = slice::from_raw_parts_mut(buf as *mut u8, bufsize as usize);
Sys::readlink(path, buf)
src/header/unistd/sysconf.rs
+3 -1
View File
@@ -44,7 +44,9 @@ pub extern "C" fn sysconf(name: c_int) -> c_long {
_SC_SYMLOOP_MAX => -1,
_SC_HOST_NAME_MAX => 64,
_ => {
unsafe { platform::errno = errno::EINVAL; }
unsafe {
platform::errno = errno::EINVAL;
}
-1
}
}
src/header/wchar/mod.rs
+31 -12
View File
@@ -169,12 +169,7 @@ pub unsafe extern "C" fn mbsnrtowcs(
while (dst_ptr.is_null() || dst_offset < dst_len) && src_offset < src_len {
let ps_copy = *ps;
let mut wc: wchar_t = 0;
let amount = mbrtowc(
&mut wc,
src.add(src_offset),
src_len - src_offset,
ps,
);
let amount = mbrtowc(&mut wc, src.add(src_offset), src_len - src_offset, ps);
// Stop in the event a decoding error occured.
if amount == -1isize as usize {
@@ -363,7 +358,11 @@ pub unsafe extern "C" fn wcslen(ws: *const wchar_t) -> c_ulong {
}
#[no_mangle]
pub unsafe extern "C" fn wcsncat(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
pub unsafe extern "C" fn wcsncat(
ws1: *mut wchar_t,
ws2: *const wchar_t,
n: size_t,
) -> *mut wchar_t {
let len = wcslen(ws1);
let dest = ws1.add(len as usize);
let mut i = 0;
@@ -396,7 +395,11 @@ pub unsafe extern "C" fn wcsncmp(ws1: *const wchar_t, ws2: *const wchar_t, n: si
}
#[no_mangle]
pub unsafe extern "C" fn wcsncpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
pub unsafe extern "C" fn wcsncpy(
ws1: *mut wchar_t,
ws2: *const wchar_t,
n: size_t,
) -> *mut wchar_t {
let mut i = 0;
while i < n {
let wc = *ws2.add(i);
@@ -523,13 +526,29 @@ pub unsafe extern "C" fn wmemcmp(ws1: *const wchar_t, ws2: *const wchar_t, n: si
}
#[no_mangle]
pub unsafe extern "C" fn wmemcpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
string::memcpy(ws1 as *mut c_void, ws2 as *const c_void, n * mem::size_of::<wchar_t>()) as *mut wchar_t
pub unsafe extern "C" fn wmemcpy(
ws1: *mut wchar_t,
ws2: *const wchar_t,
n: size_t,
) -> *mut wchar_t {
string::memcpy(
ws1 as *mut c_void,
ws2 as *const c_void,
n * mem::size_of::<wchar_t>(),
) as *mut wchar_t
}
#[no_mangle]
pub unsafe extern "C" fn wmemmove(ws1: *mut wchar_t, ws2: *const wchar_t, n: size_t) -> *mut wchar_t {
string::memmove(ws1 as *mut c_void, ws2 as *const c_void, n * mem::size_of::<wchar_t>()) as *mut wchar_t
pub unsafe extern "C" fn wmemmove(
ws1: *mut wchar_t,
ws2: *const wchar_t,
n: size_t,
) -> *mut wchar_t {
string::memmove(
ws1 as *mut c_void,
ws2 as *const c_void,
n * mem::size_of::<wchar_t>(),
) as *mut wchar_t
}
#[no_mangle]
src/lib.rs
-1
View File
@@ -15,7 +15,6 @@
#![feature(stmt_expr_attributes)]
#![feature(str_internals)]
#![feature(thread_local)]
#![allow(clippy::cast_lossless)]
#![allow(clippy::cast_ptr_alignment)]
#![allow(clippy::derive_hash_xor_eq)]
src/macros.rs
+1 -3
View File
@@ -3,9 +3,7 @@ macro_rules! c_str {
($lit:expr) => {
#[allow(unused_unsafe)]
unsafe {
$crate::c_str::CStr::from_bytes_with_nul_unchecked(
concat!($lit, "\0").as_bytes()
)
$crate::c_str::CStr::from_bytes_with_nul_unchecked(concat!($lit, "\0").as_bytes())
}
};
}
src/platform/linux/mod.rs
+19 -11
View File
@@ -36,16 +36,16 @@ const CLONE_SIGHAND: usize = 0x0800;
#[repr(C)]
#[derive(Default)]
struct linux_statfs {
f_type: c_long, /* type of file system (see below) */
f_bsize: c_long, /* optimal transfer block size */
f_type: c_long, /* type of file system (see below) */
f_bsize: c_long, /* optimal transfer block size */
f_blocks: fsblkcnt_t, /* total data blocks in file system */
f_bfree: fsblkcnt_t, /* free blocks in fs */
f_bfree: fsblkcnt_t, /* free blocks in fs */
f_bavail: fsblkcnt_t, /* free blocks available to unprivileged user */
f_files: fsfilcnt_t, /* total file nodes in file system */
f_ffree: fsfilcnt_t, /* free file nodes in fs */
f_fsid: c_long, /* file system id */
f_namelen: c_long, /* maximum length of filenames */
f_frsize: c_long, /* fragment size (since Linux 2.6) */
f_files: fsfilcnt_t, /* total file nodes in file system */
f_ffree: fsfilcnt_t, /* free file nodes in fs */
f_fsid: c_long, /* file system id */
f_namelen: c_long, /* maximum length of filenames */
f_frsize: c_long, /* fragment size (since Linux 2.6) */
f_flags: c_long,
f_spare: [c_long; 4],
}
@@ -64,7 +64,6 @@ fn e(sys: usize) -> usize {
pub struct Sys;
impl Sys {
// fn getrusage(who: c_int, r_usage: *mut rusage) -> c_int {
// e(unsafe { syscall!(GETRUSAGE, who, r_usage) }) as c_int
// }
@@ -163,7 +162,7 @@ impl Pal for Sys {
let res = e(unsafe { syscall!(FSTATFS, fildes, kbuf_ptr) }) as c_int;
if res == 0 {
unsafe {
if ! buf.is_null() {
if !buf.is_null() {
(*buf).f_bsize = kbuf.f_bsize as c_ulong;
(*buf).f_frsize = if kbuf.f_frsize != 0 {
kbuf.f_frsize
@@ -327,7 +326,16 @@ impl Pal for Sys {
}
fn pte_clone() -> pid_t {
e(unsafe { syscall!(CLONE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, 0, 0, 0, 0) }) as pid_t
e(unsafe {
syscall!(
CLONE,
CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
0,
0,
0,
0
)
}) as pid_t
}
fn read(fildes: c_int, buf: &mut [u8]) -> ssize_t {
src/platform/mod.rs
+2 -4
View File
@@ -104,13 +104,11 @@ impl Read for FileReader {
pub struct AllocStringWriter(pub *mut u8, pub usize);
impl Write for AllocStringWriter {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let ptr = unsafe {
realloc(self.0 as *mut c_void, self.1 + buf.len() + 1) as *mut u8
};
let ptr = unsafe { realloc(self.0 as *mut c_void, self.1 + buf.len() + 1) as *mut u8 };
if ptr.is_null() {
return Err(io::Error::new(
io::ErrorKind::Other,
"AllocStringWriter::write failed to allocate"
"AllocStringWriter::write failed to allocate",
));
}
self.0 = ptr;
src/platform/pte.rs
+40 -17
View File
@@ -2,13 +2,13 @@
use alloc::boxed::Box;
use alloc::collections::BTreeMap;
use core::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use core::{intrinsics, ptr};
use core::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use header::time::timespec;
use mutex::{FUTEX_WAIT, FUTEX_WAKE};
use platform::{Pal, Sys};
use platform::types::{c_int, c_uint, c_void, pid_t};
use platform::{Pal, Sys};
pub struct Semaphore {
lock: i32,
@@ -28,7 +28,7 @@ pub enum pte_osResult {
PTE_OS_GENERAL_FAILURE,
PTE_OS_TIMEOUT,
PTE_OS_INTERRUPTED,
PTE_OS_INVALID_PARAM
PTE_OS_INVALID_PARAM,
}
use self::pte_osResult::*;
@@ -55,12 +55,13 @@ pub unsafe extern "C" fn pte_osInit() -> pte_osResult {
}
#[no_mangle]
pub unsafe extern "C" fn pte_osThreadCreate(entryPoint: pte_osThreadEntryPoint,
_stackSize: c_int,
_initialPriority: c_int,
argv: *mut c_void,
ppte_osThreadHandle: *mut pte_osThreadHandle
) -> pte_osResult {
pub unsafe extern "C" fn pte_osThreadCreate(
entryPoint: pte_osThreadEntryPoint,
_stackSize: c_int,
_initialPriority: c_int,
argv: *mut c_void,
ppte_osThreadHandle: *mut pte_osThreadHandle,
) -> pte_osResult {
// XXX error handling
let id = Sys::pte_clone();
if id < 0 {
@@ -166,7 +167,10 @@ pub unsafe extern "C" fn pte_osThreadGetPriority(threadHandle: pte_osThreadHandl
}
#[no_mangle]
pub unsafe extern "C" fn pte_osThreadSetPriority(threadHandle: pte_osThreadHandle, newPriority: c_int) -> pte_osResult {
pub unsafe extern "C" fn pte_osThreadSetPriority(
threadHandle: pte_osThreadHandle,
newPriority: c_int,
) -> pte_osResult {
PTE_OS_OK
}
@@ -237,7 +241,10 @@ pub unsafe extern "C" fn pte_osMutexUnlock(handle: pte_osMutexHandle) -> pte_osR
}
#[no_mangle]
pub unsafe extern "C" fn pte_osSemaphoreCreate(initialValue: c_int, pHandle: *mut pte_osSemaphoreHandle) -> pte_osResult {
pub unsafe extern "C" fn pte_osSemaphoreCreate(
initialValue: c_int,
pHandle: *mut pte_osSemaphoreHandle,
) -> pte_osResult {
*pHandle = Box::into_raw(Box::new(Semaphore {
lock: 0,
count: initialValue,
@@ -252,7 +259,10 @@ pub unsafe extern "C" fn pte_osSemaphoreDelete(handle: pte_osSemaphoreHandle) ->
}
#[no_mangle]
pub unsafe extern "C" fn pte_osSemaphorePost(handle: pte_osSemaphoreHandle, count: c_int) -> pte_osResult {
pub unsafe extern "C" fn pte_osSemaphorePost(
handle: pte_osSemaphoreHandle,
count: c_int,
) -> pte_osResult {
let semaphore = &mut *handle;
pte_osMutexLock(&mut semaphore.lock);
intrinsics::atomic_xadd(&mut semaphore.count, 1);
@@ -261,11 +271,14 @@ pub unsafe extern "C" fn pte_osSemaphorePost(handle: pte_osSemaphoreHandle, coun
}
#[no_mangle]
pub unsafe extern "C" fn pte_osSemaphorePend(handle: pte_osSemaphoreHandle, pTimeout: *mut c_uint) -> pte_osResult {
pub unsafe extern "C" fn pte_osSemaphorePend(
handle: pte_osSemaphoreHandle,
pTimeout: *mut c_uint,
) -> pte_osResult {
//TODO: pTimeout
let semaphore = &mut *handle;
let mut acquired = false;
while ! acquired {
while !acquired {
pte_osMutexLock(&mut semaphore.lock);
if intrinsics::atomic_load(&mut semaphore.count) > 0 {
intrinsics::atomic_xsub(&mut semaphore.count, 1);
@@ -278,7 +291,10 @@ pub unsafe extern "C" fn pte_osSemaphorePend(handle: pte_osSemaphoreHandle, pTim
}
#[no_mangle]
pub unsafe extern "C" fn pte_osSemaphoreCancellablePend(handle: pte_osSemaphoreHandle, pTimeout: *mut c_uint) -> pte_osResult {
pub unsafe extern "C" fn pte_osSemaphoreCancellablePend(
handle: pte_osSemaphoreHandle,
pTimeout: *mut c_uint,
) -> pte_osResult {
//TODO
pte_osSemaphorePend(handle, pTimeout)
}
@@ -289,7 +305,11 @@ pub unsafe extern "C" fn pte_osAtomicExchange(ptarg: *mut c_int, val: c_int) ->
}
#[no_mangle]
pub unsafe extern "C" fn pte_osAtomicCompareExchange(pdest: *mut c_int, exchange: c_int, comp: c_int) -> c_int {
pub unsafe extern "C" fn pte_osAtomicCompareExchange(
pdest: *mut c_int,
exchange: c_int,
comp: c_int,
) -> c_int {
intrinsics::atomic_cxchg(pdest, comp, exchange).0
}
@@ -316,7 +336,10 @@ pub unsafe extern "C" fn pte_osTlsSetValue(index: c_uint, value: *mut c_void) ->
#[no_mangle]
pub unsafe extern "C" fn pte_osTlsGetValue(index: c_uint) -> *mut c_void {
locals().get_mut(&index).map(|x| *x).unwrap_or(ptr::null_mut())
locals()
.get_mut(&index)
.map(|x| *x)
.unwrap_or(ptr::null_mut())
}
#[no_mangle]
src/platform/redox/extra.rs
+16 -5
View File
@@ -5,7 +5,10 @@ use platform::types::*;
#[no_mangle]
pub unsafe extern "C" fn redox_fpath(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t {
e(syscall::fpath(fd as usize, slice::from_raw_parts_mut(buf as *mut u8, count))) as ssize_t
e(syscall::fpath(
fd as usize,
slice::from_raw_parts_mut(buf as *mut u8, count),
)) as ssize_t
}
#[no_mangle]
@@ -14,7 +17,7 @@ pub unsafe extern "C" fn redox_physalloc(size: size_t) -> *mut c_void {
if res == !0 {
return ptr::null_mut();
} else {
return res as *mut c_void
return res as *mut c_void;
}
}
@@ -24,12 +27,20 @@ pub unsafe extern "C" fn redox_physfree(physical_address: *mut c_void, size: siz
}
#[no_mangle]
pub unsafe extern "C" fn redox_physmap(physical_address: *mut c_void, size: size_t, flags: c_int) -> *mut c_void {
let res = e(syscall::physmap(physical_address as usize, size, flags as usize));
pub unsafe extern "C" fn redox_physmap(
physical_address: *mut c_void,
size: size_t,
flags: c_int,
) -> *mut c_void {
let res = e(syscall::physmap(
physical_address as usize,
size,
flags as usize,
));
if res == !0 {
return ptr::null_mut();
} else {
return res as *mut c_void
return res as *mut c_void;
}
}
src/platform/redox/mod.rs
+29 -8
View File
@@ -599,14 +599,22 @@ impl Pal for Sys {
}
fn mkdir(path: &CStr, mode: mode_t) -> c_int {
match File::create(path, fcntl::O_DIRECTORY | fcntl::O_EXCL | fcntl::O_CLOEXEC, 0o777) {
match File::create(
path,
fcntl::O_DIRECTORY | fcntl::O_EXCL | fcntl::O_CLOEXEC,
0o777,
) {
Ok(_fd) => 0,
Err(_) => -1,
}
}
fn mkfifo(path: &CStr, mode: mode_t) -> c_int {
match File::create(path, fcntl::O_CREAT | fcntl::O_CLOEXEC, syscall::MODE_FIFO as mode_t | (mode & 0o777)) {
match File::create(
path,
fcntl::O_CREAT | fcntl::O_CLOEXEC,
syscall::MODE_FIFO as mode_t | (mode & 0o777),
) {
Ok(fd) => 0,
Err(_) => -1,
}
@@ -623,11 +631,14 @@ impl Pal for Sys {
let map = Map {
offset: off as usize,
size: len,
flags: ((prot as usize) << 16) | ((flags as usize) & 0xFFFF)
flags: ((prot as usize) << 16) | ((flags as usize) & 0xFFFF),
};
if flags & MAP_ANON == MAP_ANON {
let fd = e(syscall::open("memory:", syscall::O_STAT | syscall::O_CLOEXEC)); // flags don't matter currently
let fd = e(syscall::open(
"memory:",
syscall::O_STAT | syscall::O_CLOEXEC,
)); // flags don't matter currently
if fd == !0 {
return !0 as *mut c_void;
}
@@ -815,7 +826,14 @@ impl Pal for Sys {
}
fn pte_clone() -> pid_t {
e(unsafe { syscall::clone(syscall::CLONE_VM | syscall::CLONE_FS | syscall::CLONE_FILES | syscall::CLONE_SIGHAND) }) as pid_t
e(unsafe {
syscall::clone(
syscall::CLONE_VM
| syscall::CLONE_FS
| syscall::CLONE_FILES
| syscall::CLONE_SIGHAND,
)
}) as pid_t
}
fn read(fd: c_int, buf: &mut [u8]) -> ssize_t {
@@ -823,7 +841,10 @@ impl Pal for Sys {
}
fn readlink(pathname: &CStr, out: &mut [u8]) -> ssize_t {
let file = match File::open(pathname, fcntl::O_PATH | fcntl::O_SYMLINK | fcntl::O_CLOEXEC) {
let file = match File::open(
pathname,
fcntl::O_PATH | fcntl::O_SYMLINK | fcntl::O_CLOEXEC,
) {
Ok(ok) => ok,
Err(_) => return -1,
};
@@ -1084,7 +1105,7 @@ impl Pal for Sys {
fn uname(utsname: *mut utsname) -> c_int {
fn gethostname(name: &mut [u8]) -> io::Result<()> {
if name.is_empty() {
return Ok(())
return Ok(());
}
let mut file = File::open(
@@ -1108,7 +1129,7 @@ impl Pal for Sys {
match gethostname(unsafe {
slice::from_raw_parts_mut(
(*utsname).nodename.as_mut_ptr() as *mut u8,
(*utsname).nodename.len()
(*utsname).nodename.len(),
)
}) {
Ok(_) => (),
src/platform/redox/signal.rs
+10 -14
View File
@@ -1,13 +1,13 @@
use core::mem;
use syscall;
use platform::errno;
use super::super::types::*;
use super::super::{Pal, PalSignal};
use super::{e, Sys};
use header::errno::EINVAL;
use header::signal::{sigaction, sigset_t};
use header::sys_time::{ITIMER_REAL, itimerval};
use header::sys_time::{itimerval, ITIMER_REAL};
use platform::errno;
impl PalSignal for Sys {
fn getitimer(which: c_int, out: *mut itimerval) -> c_int {
@@ -16,7 +16,7 @@ impl PalSignal for Sys {
_ => unsafe {
errno = EINVAL;
return -1;
}
},
};
let fd = e(syscall::open(path, syscall::O_RDONLY | syscall::O_CLOEXEC));
@@ -35,9 +35,9 @@ impl PalSignal for Sys {
unsafe {
(*out).it_interval.tv_sec = spec.it_interval.tv_sec;
(*out).it_interval.tv_usec = spec.it_interval.tv_nsec/1000;
(*out).it_interval.tv_usec = spec.it_interval.tv_nsec / 1000;
(*out).it_value.tv_sec = spec.it_value.tv_sec;
(*out).it_value.tv_usec = spec.it_value.tv_nsec/1000;
(*out).it_value.tv_usec = spec.it_value.tv_nsec / 1000;
}
0
@@ -61,7 +61,7 @@ impl PalSignal for Sys {
_ => unsafe {
errno = EINVAL;
return -1;
}
},
};
let fd = e(syscall::open(path, syscall::O_RDWR | syscall::O_CLOEXEC));
@@ -75,11 +75,11 @@ impl PalSignal for Sys {
if count != !0 {
unsafe {
if ! old.is_null() {
if !old.is_null() {
(*old).it_interval.tv_sec = spec.it_interval.tv_sec;
(*old).it_interval.tv_usec = spec.it_interval.tv_nsec/1000;
(*old).it_interval.tv_usec = spec.it_interval.tv_nsec / 1000;
(*old).it_value.tv_sec = spec.it_value.tv_sec;
(*old).it_value.tv_usec = spec.it_value.tv_nsec/1000;
(*old).it_value.tv_usec = spec.it_value.tv_nsec / 1000;
}
spec.it_interval.tv_sec = (*new).it_interval.tv_sec;
@@ -136,11 +136,7 @@ impl PalSignal for Sys {
} else {
Some([unsafe { *set as u64 }, 0])
};
let mut old_opt = if oset.is_null() {
None
} else {
Some([0, 0])
};
let mut old_opt = if oset.is_null() { None } else { Some([0, 0]) };
let ret = e(syscall::sigprocmask(
how as usize,
new_opt.as_ref(),
src/start.rs
+2 -6
View File
@@ -67,7 +67,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
// Set up envp
let envp = sp.envp();
let mut len = 0;
while ! (*envp.add(len)).is_null() {
while !(*envp.add(len)).is_null() {
len += 1;
}
platform::inner_environ = copy_string_array(envp, len);
@@ -102,11 +102,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
}
// not argv or envp, because programs like bash try to modify this *const* pointer :|
stdlib::exit(main(
argc,
platform::argv,
platform::environ,
));
stdlib::exit(main(argc, platform::argv, platform::environ));
unreachable!();
}