about summary refs log tree commit diff
path: root/src/libstd/sys
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/sys')
-rw-r--r--src/libstd/sys/common/thread_local.rs8
-rw-r--r--src/libstd/sys/unix/os.rs1
-rw-r--r--src/libstd/sys/unix/pipe.rs11
-rw-r--r--src/libstd/sys/unix/tcp.rs11
-rw-r--r--src/libstd/sys/unix/timer.rs4
-rw-r--r--src/libstd/sys/windows/mutex.rs16
-rw-r--r--src/libstd/sys/windows/pipe.rs27
-rw-r--r--src/libstd/sys/windows/tcp.rs11
8 files changed, 46 insertions, 43 deletions
diff --git a/src/libstd/sys/common/thread_local.rs b/src/libstd/sys/common/thread_local.rs
index 158fd3a8382..e9af796c674 100644
--- a/src/libstd/sys/common/thread_local.rs
+++ b/src/libstd/sys/common/thread_local.rs
@@ -58,7 +58,7 @@
 
 use prelude::v1::*;
 
-use sync::atomic::{self, AtomicUint};
+use sync::atomic::{self, AtomicUint, Ordering};
 use sync::{Mutex, Once, ONCE_INIT};
 
 use sys::thread_local as imp;
@@ -166,7 +166,7 @@ impl StaticKey {
     /// Note that this does *not* run the user-provided destructor if one was
     /// specified at definition time. Doing so must be done manually.
     pub unsafe fn destroy(&self) {
-        match self.inner.key.swap(0, atomic::SeqCst) {
+        match self.inner.key.swap(0, Ordering::SeqCst) {
             0 => {}
             n => { imp::destroy(n as imp::Key) }
         }
@@ -174,7 +174,7 @@ impl StaticKey {
 
     #[inline]
     unsafe fn key(&self) -> imp::Key {
-        match self.inner.key.load(atomic::Relaxed) {
+        match self.inner.key.load(Ordering::Relaxed) {
             0 => self.lazy_init() as imp::Key,
             n => n as imp::Key
         }
@@ -199,7 +199,7 @@ impl StaticKey {
             key2
         };
         assert!(key != 0);
-        match self.inner.key.compare_and_swap(0, key as uint, atomic::SeqCst) {
+        match self.inner.key.compare_and_swap(0, key as uint, Ordering::SeqCst) {
             // The CAS succeeded, so we've created the actual key
             0 => key as uint,
             // If someone beat us to the punch, use their key instead
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index 690574301d7..181b8fdd0f8 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -20,7 +20,6 @@ use libc::{self, c_int, c_char, c_void};
 use os;
 use path::{BytesContainer};
 use ptr;
-use sync::atomic::{AtomicInt, SeqCst};
 use sys::fs::FileDesc;
 
 use os::TMPBUF_SZ;
diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs
index fcbfb383d3c..9063fbc2ba9 100644
--- a/src/libstd/sys/unix/pipe.rs
+++ b/src/libstd/sys/unix/pipe.rs
@@ -13,7 +13,8 @@ use prelude::v1::*;
 use libc;
 use c_str::CString;
 use mem;
-use sync::{atomic, Arc, Mutex};
+use sync::{Arc, Mutex};
+use sync::atomic::{AtomicBool, Ordering};
 use io::{self, IoResult, IoError};
 
 use sys::{self, timer, retry, c, set_nonblocking, wouldblock};
@@ -242,7 +243,7 @@ impl UnixListener {
                         listener: self,
                         reader: reader,
                         writer: writer,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -260,7 +261,7 @@ struct AcceptorInner {
     listener: UnixListener,
     reader: FileDesc,
     writer: FileDesc,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 impl UnixAcceptor {
@@ -269,7 +270,7 @@ impl UnixAcceptor {
     pub fn accept(&mut self) -> IoResult<UnixStream> {
         let deadline = if self.deadline == 0 {None} else {Some(self.deadline)};
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             unsafe {
                 let mut storage: libc::sockaddr_storage = mem::zeroed();
                 let storagep = &mut storage as *mut libc::sockaddr_storage;
@@ -297,7 +298,7 @@ impl UnixAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let fd = FileDesc::new(self.inner.writer.fd(), false);
         match fd.write(&[0]) {
             Ok(..) => Ok(()),
diff --git a/src/libstd/sys/unix/tcp.rs b/src/libstd/sys/unix/tcp.rs
index 13ccf685fd7..59eebd3f28e 100644
--- a/src/libstd/sys/unix/tcp.rs
+++ b/src/libstd/sys/unix/tcp.rs
@@ -16,7 +16,8 @@ use libc;
 use mem;
 use ptr;
 use super::{last_error, last_net_error, retry, sock_t};
-use sync::{Arc, atomic};
+use sync::Arc;
+use sync::atomic::{AtomicBool, Ordering};
 use sys::fs::FileDesc;
 use sys::{set_nonblocking, wouldblock};
 use sys;
@@ -74,7 +75,7 @@ impl TcpListener {
                         listener: self,
                         reader: reader,
                         writer: writer,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -96,7 +97,7 @@ struct AcceptorInner {
     listener: TcpListener,
     reader: FileDesc,
     writer: FileDesc,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Sync for AcceptorInner {}
@@ -121,7 +122,7 @@ impl TcpAcceptor {
         // self-pipe is never written to unless close_accept() is called.
         let deadline = if self.deadline == 0 {None} else {Some(self.deadline)};
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             match retry(|| unsafe {
                 libc::accept(self.fd(), ptr::null_mut(), ptr::null_mut())
             }) {
@@ -145,7 +146,7 @@ impl TcpAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let fd = FileDesc::new(self.inner.writer.fd(), false);
         match fd.write(&[0]) {
             Ok(..) => Ok(()),
diff --git a/src/libstd/sys/unix/timer.rs b/src/libstd/sys/unix/timer.rs
index 80f93dd2f61..11f29232a92 100644
--- a/src/libstd/sys/unix/timer.rs
+++ b/src/libstd/sys/unix/timer.rs
@@ -54,7 +54,7 @@ use libc;
 use mem;
 use os;
 use ptr;
-use sync::atomic;
+use sync::atomic::{mod, Ordering};
 use sync::mpsc::{channel, Sender, Receiver, TryRecvError};
 use sys::c;
 use sys::fs::FileDesc;
@@ -212,7 +212,7 @@ impl Timer {
         HELPER.boot(|| {}, helper);
 
         static ID: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
-        let id = ID.fetch_add(1, atomic::Relaxed);
+        let id = ID.fetch_add(1, Ordering::Relaxed);
         Ok(Timer {
             id: id,
             inner: Some(box Inner {
diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs
index f561e0121b3..1def99a3741 100644
--- a/src/libstd/sys/windows/mutex.rs
+++ b/src/libstd/sys/windows/mutex.rs
@@ -10,7 +10,7 @@
 
 use prelude::v1::*;
 
-use sync::atomic;
+use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
 use alloc::{self, heap};
 
 use libc::DWORD;
@@ -18,9 +18,9 @@ use sys::sync as ffi;
 
 const SPIN_COUNT: DWORD = 4000;
 
-pub struct Mutex { inner: atomic::AtomicUint }
+pub struct Mutex { inner: AtomicUint }
 
-pub const MUTEX_INIT: Mutex = Mutex { inner: atomic::ATOMIC_UINT_INIT };
+pub const MUTEX_INIT: Mutex = Mutex { inner: ATOMIC_UINT_INIT };
 
 unsafe impl Sync for Mutex {}
 
@@ -32,7 +32,7 @@ pub unsafe fn raw(m: &Mutex) -> ffi::LPCRITICAL_SECTION {
 impl Mutex {
     #[inline]
     pub unsafe fn new() -> Mutex {
-        Mutex { inner: atomic::AtomicUint::new(init_lock() as uint) }
+        Mutex { inner: AtomicUint::new(init_lock() as uint) }
     }
     #[inline]
     pub unsafe fn lock(&self) {
@@ -47,22 +47,22 @@ impl Mutex {
         ffi::LeaveCriticalSection(self.get())
     }
     pub unsafe fn destroy(&self) {
-        let lock = self.inner.swap(0, atomic::SeqCst);
+        let lock = self.inner.swap(0, Ordering::SeqCst);
         if lock != 0 { free_lock(lock as ffi::LPCRITICAL_SECTION) }
     }
 
     unsafe fn get(&self) -> ffi::LPCRITICAL_SECTION {
-        match self.inner.load(atomic::SeqCst) {
+        match self.inner.load(Ordering::SeqCst) {
             0 => {}
             n => return n as ffi::LPCRITICAL_SECTION
         }
         let lock = init_lock();
-        match self.inner.compare_and_swap(0, lock as uint, atomic::SeqCst) {
+        match self.inner.compare_and_swap(0, lock as uint, Ordering::SeqCst) {
             0 => return lock as ffi::LPCRITICAL_SECTION,
             _ => {}
         }
         free_lock(lock);
-        return self.inner.load(atomic::SeqCst) as ffi::LPCRITICAL_SECTION;
+        return self.inner.load(Ordering::SeqCst) as ffi::LPCRITICAL_SECTION;
     }
 }
 
diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs
index 0edae75a9ce..9057515cad2 100644
--- a/src/libstd/sys/windows/pipe.rs
+++ b/src/libstd/sys/windows/pipe.rs
@@ -90,7 +90,8 @@ use libc;
 use c_str::CString;
 use mem;
 use ptr;
-use sync::{atomic, Arc, Mutex};
+use sync::{Arc, Mutex};
+use sync::atomic::{AtomicBool, Ordering};
 use io::{self, IoError, IoResult};
 
 use sys_common::{self, eof};
@@ -126,8 +127,8 @@ impl Drop for Event {
 struct Inner {
     handle: libc::HANDLE,
     lock: Mutex<()>,
-    read_closed: atomic::AtomicBool,
-    write_closed: atomic::AtomicBool,
+    read_closed: AtomicBool,
+    write_closed: AtomicBool,
 }
 
 impl Inner {
@@ -135,8 +136,8 @@ impl Inner {
         Inner {
             handle: handle,
             lock: Mutex::new(()),
-            read_closed: atomic::AtomicBool::new(false),
-            write_closed: atomic::AtomicBool::new(false),
+            read_closed: AtomicBool::new(false),
+            write_closed: AtomicBool::new(false),
         }
     }
 }
@@ -334,11 +335,11 @@ impl UnixStream {
     pub fn handle(&self) -> libc::HANDLE { self.inner.handle }
 
     fn read_closed(&self) -> bool {
-        self.inner.read_closed.load(atomic::SeqCst)
+        self.inner.read_closed.load(Ordering::SeqCst)
     }
 
     fn write_closed(&self) -> bool {
-        self.inner.write_closed.load(atomic::SeqCst)
+        self.inner.write_closed.load(Ordering::SeqCst)
     }
 
     fn cancel_io(&self) -> IoResult<()> {
@@ -517,14 +518,14 @@ impl UnixStream {
         // and 2 with a lock with respect to close_read(), we're guaranteed that
         // no thread will erroneously sit in a read forever.
         let _guard = unsafe { self.inner.lock.lock() };
-        self.inner.read_closed.store(true, atomic::SeqCst);
+        self.inner.read_closed.store(true, Ordering::SeqCst);
         self.cancel_io()
     }
 
     pub fn close_write(&mut self) -> IoResult<()> {
         // see comments in close_read() for why this lock is necessary
         let _guard = unsafe { self.inner.lock.lock() };
-        self.inner.write_closed.store(true, atomic::SeqCst);
+        self.inner.write_closed.store(true, Ordering::SeqCst);
         self.cancel_io()
     }
 
@@ -586,7 +587,7 @@ impl UnixListener {
             deadline: 0,
             inner: Arc::new(AcceptorState {
                 abort: try!(Event::new(true, false)),
-                closed: atomic::AtomicBool::new(false),
+                closed: AtomicBool::new(false),
             }),
         })
     }
@@ -614,7 +615,7 @@ unsafe impl Sync for UnixAcceptor {}
 
 struct AcceptorState {
     abort: Event,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Send for AcceptorState {}
@@ -658,7 +659,7 @@ impl UnixAcceptor {
 
         // If we've had an artificial call to close_accept, be sure to never
         // proceed in accepting new clients in the future
-        if self.inner.closed.load(atomic::SeqCst) { return Err(eof()) }
+        if self.inner.closed.load(Ordering::SeqCst) { return Err(eof()) }
 
         let name = try!(to_utf16(self.listener.name.as_str()));
 
@@ -734,7 +735,7 @@ impl UnixAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let ret = unsafe {
             c::SetEvent(self.inner.abort.handle())
         };
diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs
index 1c8ec2a80a7..77139b52efa 100644
--- a/src/libstd/sys/windows/tcp.rs
+++ b/src/libstd/sys/windows/tcp.rs
@@ -15,7 +15,8 @@ use mem;
 use ptr;
 use prelude::v1::*;
 use super::{last_error, last_net_error, retry, sock_t};
-use sync::{Arc, atomic};
+use sync::Arc;
+use sync::atomic::{AtomicBool, Ordering};
 use sys::fs::FileDesc;
 use sys::{self, c, set_nonblocking, wouldblock, timer};
 use sys_common::{self, timeout, eof, net};
@@ -91,7 +92,7 @@ impl TcpListener {
                         listener: self,
                         abort: try!(Event::new()),
                         accept: accept,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -122,7 +123,7 @@ struct AcceptorInner {
     listener: TcpListener,
     abort: Event,
     accept: Event,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Send for AcceptorInner {}
@@ -154,7 +155,7 @@ impl TcpAcceptor {
         // stolen, so we do all of this in a loop as well.
         let events = [self.inner.abort.handle(), self.inner.accept.handle()];
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             let ms = if self.deadline == 0 {
                 c::WSA_INFINITE as u64
             } else {
@@ -214,7 +215,7 @@ impl TcpAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let ret = unsafe { c::WSASetEvent(self.inner.abort.handle()) };
         if ret == libc::TRUE {
             Ok(())
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-07-11 19:37:54 +0000