Fix a ton of unused import warnings

acpid/src/acpi.rs

@@ -1,6 +1,5 @@
 use rustc_hash::FxHashMap;
 use std::convert::{TryFrom, TryInto};
-use std::fmt::Write;
 use std::ops::Deref;
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem};

audio/ac97d/src/device.rs

@@ -1,7 +1,6 @@
 #![allow(dead_code)]
 
 use std::collections::BTreeMap;
-use std::mem;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use common::io::Pio;

audio/ac97d/src/main.rs

@@ -5,17 +5,15 @@ extern crate event;
 extern crate spin;
 extern crate syscall;
 
-use std::cell::RefCell;
 use std::fs::File;
-use std::io::{ErrorKind, Read, Result, Write};
+use std::io::{ErrorKind, Read, Write};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::sync::Arc;
 use std::usize;
 
 use event::{user_data, EventQueue};
 use libredox::flag;
-use pcid_interface::{PciBar, PciFunctionHandle};
-use syscall::{EventFlags, Packet, SchemeBlockMut};
+use pcid_interface::PciFunctionHandle;
+use syscall::{Packet, SchemeBlockMut};
 
 pub mod device;
 
@@ -69,7 +67,7 @@ fn main() {
             }
         }
 
-        let mut event_queue =
+        let event_queue =
             EventQueue::<Source>::new().expect("ac97d: Could not create event queue.");
         event_queue
             .subscribe(

audio/ihdad/src/hda/stream.rs

@@ -1,7 +1,6 @@
 use common::dma::Dma;
 use common::io::{Io, Mmio};
 use std::cmp::min;
-use std::ptr;
 use std::ptr::copy_nonoverlapping;
 use std::result;
 use syscall::error::{Error, Result, EIO};

audio/ihdad/src/main.rs

@@ -7,13 +7,11 @@ extern crate spin;
 extern crate syscall;
 
 use libredox::flag;
-use std::cell::RefCell;
 use std::fs::File;
-use std::io::{ErrorKind, Read, Result, Write};
+use std::io::{ErrorKind, Read, Write};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::sync::Arc;
 use std::usize;
-use syscall::{EventFlags, Packet, SchemeBlockMut};
+use syscall::{Packet, SchemeBlockMut};
 
 use event::{user_data, EventQueue};
 #[cfg(target_arch = "x86_64")]
@@ -136,7 +134,7 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
             }
         }
 
-        let mut event_queue =
+        let event_queue =
             EventQueue::<Source>::new().expect("ihdad: Could not create event queue.");
         let mut device = unsafe {
             hda::IntelHDA::new(address, vend_prod).expect("ihdad: failed to allocate device")

input/usbhidd/src/main.rs

@@ -1,10 +1,9 @@
-use std::collections::VecDeque;
 use std::env;
 
 use inputd::ProducerHandle;
 use orbclient::KeyEvent as OrbKeyEvent;
 use rehid::{
-    report_desc::{self, ReportTy, REPORT_DESC_TY},
+    report_desc::{ReportTy, REPORT_DESC_TY},
     report_handler::ReportHandler,
     usage_tables::{GenericDesktopUsage, UsagePage},
 };

pcid/src/cfg_access/mod.rs

@@ -2,7 +2,6 @@ use std::sync::Mutex;
 use std::{fs, io, mem};
 
 use common::{MemoryType, PhysBorrowed, Prot};
-use fdt::node::CellSizes;
 use fdt::Fdt;
 use pci_types::{ConfigRegionAccess, PciAddress};
 

pcid/src/driver_interface/mod.rs

@@ -4,7 +4,6 @@ use std::io::prelude::*;
 use std::ptr::NonNull;
 use std::{env, io};
 
-use log::info;
 use std::os::unix::io::{FromRawFd, RawFd};
 
 use serde::{de::DeserializeOwned, Deserialize, Serialize};

storage/ided/src/main.rs

@@ -3,23 +3,17 @@ use driver_block::Disk;
 use event::{EventFlags, RawEventQueue};
 use libredox::flag;
 use log::{error, info};
-use pcid_interface::{PciBar, PciFunctionHandle};
+use pcid_interface::PciFunctionHandle;
 use redox_scheme::{RequestKind, Response, SignalBehavior, Socket};
 use std::{
     fs::File,
-    io::{ErrorKind, Read, Write},
+    io::{Read, Write},
     os::unix::io::{FromRawFd, RawFd},
     sync::{Arc, Mutex},
     thread::{self, sleep},
     time::Duration,
 };
-use syscall::{
-    data::{Event, Packet},
-    error::{Error, ENODEV},
-    flag::EVENT_READ,
-    scheme::SchemeBlockMut,
-    EAGAIN, EINTR, EWOULDBLOCK,
-};
+use syscall::error::{Error, EAGAIN, EINTR, ENODEV, EWOULDBLOCK};
 
 use crate::{
     ide::{AtaCommand, AtaDisk, Channel},

storage/nvmed/src/main.rs

@@ -2,18 +2,13 @@
 #![cfg_attr(target_arch = "riscv64", feature(riscv_ext_intrinsics))] // Required for pause instruction
 #![feature(int_roundings)]
 
-use std::convert::TryInto;
-use std::fs::File;
-use std::io::{ErrorKind, Read, Write};
-use std::os::unix::io::{FromRawFd, RawFd};
 use std::ptr::NonNull;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::{slice, usize};
 
-use libredox::flag;
 use pcid_interface::{PciFeature, PciFeatureInfo, PciFunction, PciFunctionHandle};
-use redox_scheme::{CallRequest, RequestKind, SignalBehavior, Socket};
-use syscall::{Event, Packet, Result, SchemeBlockMut, PAGE_SIZE};
+use redox_scheme::{RequestKind, SignalBehavior, Socket};
+use syscall::Result;
 
 use self::nvme::{InterruptMethod, InterruptSources, Nvme};
 use self::scheme::DiskScheme;

storage/nvmed/src/nvme/mod.rs

@@ -1,16 +1,14 @@
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 use std::fs::File;
-use std::ptr;
-use std::sync::atomic::{AtomicU16, AtomicU64, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicU16, AtomicU64};
 use std::sync::{Mutex, RwLock};
-use std::thread;
 
 use crossbeam_channel::Sender;
 use smallvec::{smallvec, SmallVec};
 
 use common::io::{Io, Mmio};
-use syscall::error::{Error, Result, EINVAL, EIO};
+use syscall::error::{Error, Result, EIO};
 
 use common::dma::Dma;
 
@@ -526,7 +524,7 @@ impl Nvme {
                     return entry;
                 }
             }
-            thread::yield_now();
+            std::thread::yield_now();
         }
     }
 

storage/nvmed/src/scheme.rs

@@ -10,7 +10,7 @@ use redox_scheme::{CallerCtx, OpenResult, SchemeBlock};
 use syscall::schemev2::NewFdFlags;
 use syscall::{
     Error, Result, Stat, EACCES, EBADF, EINVAL, EISDIR, ENOENT, ENOLCK, EOVERFLOW, MODE_DIR,
-    MODE_FILE, O_DIRECTORY, O_STAT, SEEK_CUR, SEEK_END, SEEK_SET,
+    MODE_FILE, O_DIRECTORY, O_STAT,
 };
 
 use crate::nvme::{Nvme, NvmeNamespace};

storage/usbscsid/src/scheme.rs

@@ -1,15 +1,14 @@
 use std::collections::BTreeMap;
-use std::{cmp, str};
+use std::str;
 
 use crate::protocol::Protocol;
 use crate::scsi::Scsi;
 
 use redox_scheme::{CallerCtx, OpenResult, Scheme};
 use syscall::error::{Error, Result};
-use syscall::error::{EACCES, EBADF, EINVAL, EIO, ENOENT, ENOSYS};
+use syscall::error::{EACCES, EBADF, EINVAL, EIO, ENOSYS};
 use syscall::flag::{MODE_CHR, MODE_DIR};
 use syscall::flag::{O_DIRECTORY, O_STAT};
-use syscall::flag::{SEEK_CUR, SEEK_END, SEEK_SET};
 use syscall::schemev2::NewFdFlags;
 
 // TODO: Only one disk, right?

storage/usbscsid/src/scsi/mod.rs

@@ -1,5 +1,5 @@
 use std::convert::TryFrom;
-use std::{mem, ops};
+use std::mem;
 
 pub mod cmds;
 pub mod opcodes;
@@ -8,8 +8,7 @@ use thiserror::Error;
 use xhcid_interface::DeviceReqData;
 
 use crate::protocol::{Protocol, ProtocolError, SendCommandStatus, SendCommandStatusKind};
-use cmds::{SenseKey, StandardInquiryData};
-use opcodes::Opcode;
+use cmds::StandardInquiryData;
 
 pub struct Scsi {
     command_buffer: [u8; 16],

storage/virtio-blkd/src/main.rs

@@ -1,20 +1,14 @@
 #![deny(trivial_numeric_casts, unused_allocation)]
 #![feature(int_roundings)]
 
-use std::fs::File;
-use std::io::{Read, Write};
-use std::os::fd::{FromRawFd, RawFd};
 use std::sync::{Arc, Weak};
 
-use libredox::flag;
 use redox_scheme::{RequestKind, SignalBehavior, Socket};
 use static_assertions::const_assert_eq;
 
 use pcid_interface::*;
 use virtio_core::spec::*;
 
-use syscall::{Packet, SchemeBlockMut};
-
 use virtio_core::transport::Transport;
 use virtio_core::utils::VolatileCell;
 

storage/virtio-blkd/src/scheme.rs

@@ -1,4 +1,3 @@
-use std::cmp;
 use std::collections::BTreeMap;
 use std::io::Read;
 use std::io::Result as IoResult;

usbhubd/src/main.rs

@@ -1,11 +1,7 @@
-use std::collections::VecDeque;
 use std::env;
-use std::fs::File;
-use std::io::{Read, Write};
 
 use xhcid_interface::{
-    plain, usb, ConfigureEndpointsReq, DevDesc, DeviceReqData, EndpDirection, EndpointTy,
-    PortReqRecipient, PortReqTy, XhciClientHandle,
+    plain, usb, DevDesc, DeviceReqData, PortReqRecipient, PortReqTy, XhciClientHandle,
 };
 
 fn main() {

vboxd/src/main.rs

@@ -2,13 +2,12 @@
 
 use event::{user_data, EventQueue};
 use std::fs::File;
-use std::io::{Read, Result, Write};
+use std::io::{Read, Write};
 use std::os::unix::io::AsRawFd;
 use std::{iter, mem};
 
 use common::io::{Io, Mmio, Pio};
-use pcid_interface::{PciBar, PciFunctionHandle};
-use syscall::flag::EventFlags;
+use pcid_interface::PciFunctionHandle;
 
 use common::dma::Dma;
 

virtio-core/src/transport.rs

@@ -2,7 +2,7 @@ use crate::spec::*;
 use crate::utils::align;
 
 use common::dma::Dma;
-use event::{EventQueue, RawEventQueue};
+use event::RawEventQueue;
 
 use core::mem::size_of;
 use core::sync::atomic::{AtomicU16, Ordering};

xhcid/src/main.rs

@@ -26,13 +26,9 @@
 #[macro_use]
 extern crate bitflags;
 
-use std::convert::{TryFrom, TryInto};
-use std::env;
-use std::fs::{self, File};
-use std::future::Future;
-use std::io::{self, Read, Write};
-use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::pin::Pin;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::os::unix::io::{FromRawFd, RawFd};
 use std::ptr::NonNull;
 use std::sync::{Arc, Mutex};
 
@@ -45,12 +41,8 @@ use pcid_interface::{
     MsiSetFeatureInfo, PciFeature, PciFeatureInfo, PciFunctionHandle, SetFeatureInfo,
 };
 
-use common::io::Io;
-use event::{Event, RawEventQueue};
-use log::info;
 use syscall::data::Packet;
 use syscall::error::EWOULDBLOCK;
-use syscall::flag::EventFlags;
 use syscall::scheme::Scheme;
 
 use crate::xhci::{InterruptMethod, Xhci};

xhcid/src/xhci/device_enumerator.rs

@@ -1,11 +1,9 @@
 use crate::xhci::port::PortFlags;
-use crate::xhci::scheme::Handle::Port;
 use crate::xhci::Xhci;
 use common::io::Io;
 use crossbeam_channel;
-use crossbeam_channel::RecvError;
-use log::{debug, error, info, trace, warn};
-use std::sync::{Arc, Mutex};
+use log::{debug, info, warn};
+use std::sync::Arc;
 use std::time::Duration;
 use syscall::EAGAIN;
 

xhcid/src/xhci/irq_reactor.rs

@@ -1,28 +1,24 @@
-use std::collections::BTreeMap;
 use std::fs::File;
 use std::future::Future;
 use std::io::prelude::*;
 use std::pin::Pin;
-use std::sync::atomic::{self, AtomicUsize};
 use std::sync::{Arc, Mutex};
-use std::{io, mem, task, thread};
+use std::task;
 
 use std::os::unix::io::AsRawFd;
 
 use crossbeam_channel::{Receiver, Sender};
-use futures::Stream;
 use log::{debug, error, info, trace, warn};
 
 use super::doorbell::Doorbell;
 use super::event::EventRing;
 use super::ring::Ring;
 use super::trb::{Trb, TrbCompletionCode, TrbType};
-use super::{port, Xhci};
+use super::Xhci;
 use crate::xhci::device_enumerator::DeviceEnumerationRequest;
 use crate::xhci::port::PortFlags;
-use crate::xhci::scheme::AnyDescriptor::Device;
 use common::io::Io as _;
-use event::{Event, EventQueue, RawEventQueue};
+use event::RawEventQueue;
 
 /// Short-term states (as in, they are removed when the waker is consumed, but probably pushed back
 /// by the future unless it completed).

xhcid/src/xhci/mod.rs

@@ -12,28 +12,24 @@
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 use std::fs::File;
-use std::future::Future;
-use std::pin::Pin;
 use std::ptr::NonNull;
-use std::sync::atomic::{AtomicBool, AtomicUsize};
-use std::sync::{Arc, Mutex, MutexGuard, Weak};
+use std::sync::atomic::AtomicUsize;
+use std::sync::{Arc, Mutex, MutexGuard};
 
-use std::time::Duration;
-use std::{mem, process, slice, sync::atomic, task, thread};
+use std::{mem, process, slice, thread};
 use syscall::error::{Error, Result, EBADF, EBADMSG, EIO, ENOENT};
 use syscall::{EAGAIN, PAGE_SIZE};
 
 use chashmap::CHashMap;
 use common::{dma::Dma, io::Io};
 use crossbeam_channel::{Receiver, Sender};
-use futures::AsyncReadExt;
 use log::{debug, error, info, trace, warn};
 use serde::Deserialize;
 
 use crate::usb;
 
 use pcid_interface::msi::{MsixInfo, MsixTableEntry};
-use pcid_interface::{PciFeature, PciFunctionHandle};
+use pcid_interface::PciFunctionHandle;
 
 mod capability;
 mod context;
@@ -58,8 +54,8 @@ use self::irq_reactor::{EventDoorbell, IrqReactor, NewPendingTrb, RingId};
 use self::operational::OperationalRegs;
 use self::port::Port;
 use self::ring::Ring;
-use self::runtime::{Interrupter, RuntimeRegs};
-use self::trb::{TransferKind, Trb, TrbCompletionCode, TrbType};
+use self::runtime::RuntimeRegs;
+use self::trb::{TransferKind, Trb, TrbCompletionCode};
 
 use self::scheme::EndpIfState;
 

xhcid/src/xhci/operational.rs

@@ -1,8 +1,4 @@
 use common::io::{Io, Mmio};
-use std::num::NonZeroU8;
-use std::slice;
-
-use super::CapabilityRegs;
 
 /// The XHCI Operational Registers
 ///

xhcid/src/xhci/scheme.rs

@@ -20,38 +20,30 @@ use std::convert::TryFrom;
 use std::io::prelude::*;
 use std::ops::Deref;
 use std::sync::atomic;
-use std::{cmp, fmt, io, mem, path, str};
+use std::{cmp, fmt, io, mem, str};
 
 use common::dma::Dma;
 use futures::executor::block_on;
 use log::{debug, error, info, trace, warn};
-use serde::{Deserialize, Serialize};
-use smallvec::{smallvec, SmallVec};
+use smallvec::SmallVec;
 
 use common::io::Io;
 use syscall::scheme::Scheme;
 use syscall::{
-    Error, Result, Stat, EACCES, EBADF, EBADFD, EBADMSG, EEXIST, EINVAL, EIO, EISDIR, ENOENT,
-    ENOSYS, ENOTDIR, ENXIO, EOPNOTSUPP, EOVERFLOW, EPERM, EPROTO, ESPIPE, MODE_CHR, MODE_DIR,
-    MODE_FILE, O_CREAT, O_DIRECTORY, O_RDONLY, O_RDWR, O_STAT, O_WRONLY, SEEK_CUR, SEEK_END,
-    SEEK_SET,
+    Error, Result, Stat, EACCES, EBADF, EBADFD, EBADMSG, EINVAL, EIO, EISDIR, ENOENT, ENOSYS,
+    ENOTDIR, EPROTO, ESPIPE, MODE_CHR, MODE_DIR, MODE_FILE, O_DIRECTORY, O_RDWR, O_STAT, O_WRONLY,
+    SEEK_CUR, SEEK_END, SEEK_SET,
 };
 
 use super::{port, usb};
 use super::{EndpointState, Xhci};
 
-use super::context::{
-    InputContext, SlotState, StreamContext, StreamContextArray, StreamContextType,
-    ENDPOINT_CONTEXT_STATUS_MASK,
-};
-use super::doorbell::Doorbell;
+use super::context::{SlotState, StreamContextArray, StreamContextType};
 use super::extended::ProtocolSpeed;
 use super::irq_reactor::{EventDoorbell, RingId};
-use super::operational::OperationalRegs;
 use super::ring::Ring;
-use super::runtime::RuntimeRegs;
 use super::trb::{TransferKind, Trb, TrbCompletionCode, TrbType};
-use super::usb::endpoint::{EndpointTy, ENDP_ATTR_TY_MASK};
+use super::usb::endpoint::EndpointTy;
 
 use crate::driver_interface::*;
 use regex::Regex;
@@ -2696,7 +2688,6 @@ pub fn handle_transfer_event_trb(name: &str, event_trb: &Trb, transfer_trb: &Trb
 }
 use lazy_static::lazy_static;
 use std::ops::{Add, Div, Rem};
-use std::path::Path;
 
 pub fn div_round_up<T>(a: T, b: T) -> T
 where

xhcid/src/xhci/trb.rs

@@ -1,6 +1,5 @@
 use super::context::StreamContextType;
 use crate::usb;
-use crate::xhci::trb::TrbType::PortStatusChange;
 use common::io::{Io, Mmio};
 use log::trace;
 use std::{fmt, mem};