qiurui/DragonOS
1
0
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2026-09-08 23:57:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

chore(rootfs): remove deprecated default apps (#2146)

Browse Source 
Signed-off-by: longjin <longjin@dragonos.org>
This commit is contained in:
LoGin
2026-07-19 13:07:04 +08:00
committed by GitHub
parent e683b2062c
commit 45931ee3b3
28 changed files with 4 additions and 912 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/app-blocklist.toml
-1
View File
@@ -66,7 +66,6 @@ blocked_apps = [
{ name = "gvisor syscall tests", reason = "由于文件较大，因此屏蔽。如果要允许系统调用测试，则把这行取消注释即可" },
{ name = "test_ebpf_new", reason = "2025.11.17,aya上游发版有问题，导致ci过不了，暂时禁用" },
{ name = "test_ebpf_tp", reason = "2025.11.17,aya上游发版有问题，导致ci过不了，暂时禁用" },
{ name = "DragonReach", reason = "不再维护" },
{ name = "runcell", reason = "依赖项依赖github，可能网络问题导致编不过" },
]
kernel/src/init/initial_kthread.rs
+1 -2
View File
@@ -24,8 +24,7 @@ use crate::{
use super::{cmdline::kenrel_cmdline_param_manager, initcall::do_initcalls};
const INIT_PROC_TRYLIST: [(&str, Option<&str>); 6] = [
("/bin/dragonreach", None),
const INIT_PROC_TRYLIST: [(&str, Option<&str>); 5] = [
("/bin/busybox", Some("init")),
("/bin/init", None),
("/sbin/init", None),
tools/run-qemu.sh
-1
View File
@@ -546,7 +546,6 @@ while true;do
setup_kernel_init_program() {
if [ ${ARCH} == "x86_64" ]; then
KERNEL_CMDLINE+=" init=/bin/busybox init AUTO_TEST=${AUTO_TEST} SYSCALL_TEST_DIR=${SYSCALL_TEST_DIR} DUNITEST_DIR=${DUNITEST_DIR} "
# KERNEL_CMDLINE+=" init=/bin/dragonreach "
elif [ ${ARCH} == "riscv64" ]; then
KERNEL_CMDLINE+=" init=/bin/riscv_rust_init "
fi
tools/write_disk_image.sh
+1 -1
View File
@@ -238,7 +238,7 @@ cfg_content='set timeout=15
set default=0
insmod efi_gop
menuentry "DragonOS" {
multiboot2 /boot/kernel.elf init=/bin/dragonreach
multiboot2 /boot/kernel.elf init=/bin/busybox init
}'
# 增加insmod efi_gop防止32位uefi启动报错
echo "echo '${cfg_content}' > ${boot_folder}/grub/grub.cfg" | sh
user/apps/riscv_init/riscv_rust_init/Makefile
-3
View File
@@ -27,9 +27,6 @@ endif
build:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build --target $(RUST_TARGET)
run-dragonreach:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET) --bin DragonReach
clean:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean
user/apps/test_seqpacket/.gitignore
-3
View File
@@ -1,3 +0,0 @@
/target
Cargo.lock
/install/
user/apps/test_seqpacket/Cargo.toml
-12
View File
@@ -1,12 +0,0 @@
[package]
name = "test_seqpacket"
version = "0.1.0"
edition = "2021"
description = "测试seqpacket的socket"
authors = [ "Saga <1750226968@qq.com>" ]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
nix = "0.26"
libc = "0.2"
user/apps/test_seqpacket/Makefile
-56
View File
@@ -1,56 +0,0 @@
TOOLCHAIN=
RUSTFLAGS=
ifdef DADK_CURRENT_BUILD_DIR
# 如果是在dadk中编译，那么安装到dadk的安装目录中
INSTALL_DIR = $(DADK_CURRENT_BUILD_DIR)
else
# 如果是在本地编译，那么安装到当前目录下的install目录中
INSTALL_DIR = ./install
endif
ifeq ($(ARCH), x86_64)
export RUST_TARGET=x86_64-unknown-linux-musl
else ifeq ($(ARCH), riscv64)
export RUST_TARGET=riscv64gc-unknown-linux-gnu
else
# 默认为x86_86，用于本地编译
export RUST_TARGET=x86_64-unknown-linux-musl
endif
run:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET)
build:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build --target $(RUST_TARGET)
clean:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean --target $(RUST_TARGET)
test:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) test --target $(RUST_TARGET)
doc:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) doc --target $(RUST_TARGET)
fmt:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) fmt
fmt-check:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) fmt --check
run-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET) --release
build-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build --target $(RUST_TARGET) --release
clean-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean --target $(RUST_TARGET) --release
test-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) test --target $(RUST_TARGET) --release
.PHONY: install
install:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) install --target $(RUST_TARGET) --path . --no-track --root $(INSTALL_DIR) --force
user/apps/test_seqpacket/README.md
-14
View File
@@ -1,14 +0,0 @@
# DragonOS Rust-Application Template
您可以使用此模板来创建DragonOS应用程序。
## 使用方法
1. 使用DragonOS的tools目录下的`bootstrap.sh`脚本初始化环境
2. 在终端输入`cargo install cargo-generate`
3. 在终端输入`cargo generate --git https://github.com/DragonOS-Community/Rust-App-Template`即可创建项目
如果您的网络较慢，请使用镜像站`cargo generate --git https://git.mirrors.dragonos.org/DragonOS-Community/Rust-App-Template`
4. 使用`cargo run`来运行项目
5. 在DragonOS的`user/dadk/config`目录下，使用`dadk new`命令，创建编译配置,安装到DragonOS的`/`目录下。
(在dadk的编译命令选项处，请使用Makefile里面的`make install`配置进行编译、安装)
6. 编译DragonOS即可安装
user/apps/test_seqpacket/src/main.rs
-190
View File
@@ -1,190 +0,0 @@
mod seq_pair;
mod seq_socket;
use seq_pair::test_seq_pair;
use seq_socket::test_seq_socket;
fn main() -> Result<(), std::io::Error> {
if let Err(e) = test_seq_socket() {
println!("[ fault ] test_seq_socket, err: {}", e);
} else {
println!("[success] test_seq_socket");
}
if let Err(e) = test_seq_pair() {
println!("[ fault ] test_seq_pair, err: {}", e);
} else {
println!("[success] test_seq_pair");
}
Ok(())
}
// use nix::sys::socket::{socketpair, AddressFamily, SockFlag, SockType};
// use std::fs::File;
// use std::io::{Read, Write};
// use std::os::fd::FromRawFd;
// use std::{fs, str};
// use libc::*;
// use std::ffi::CString;
// use std::io::Error;
// use std::mem;
// use std::os::unix::io::RawFd;
// use std::ptr;
// const SOCKET_PATH: &str = "/test.seqpacket";
// const MSG: &str = "Hello, Unix SEQPACKET socket!";
// fn create_seqpacket_socket() -> Result<RawFd, Error> {
// unsafe {
// let fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
// if fd == -1 {
// return Err(Error::last_os_error());
// }
// Ok(fd)
// }
// }
// fn bind_socket(fd: RawFd) -> Result<(), Error> {
// unsafe {
// let mut addr = sockaddr_un {
// sun_family: AF_UNIX as u16,
// sun_path: [0; 108],
// };
// let path_cstr = CString::new(SOCKET_PATH).unwrap();
// let path_bytes = path_cstr.as_bytes();
// for (i, &byte) in path_bytes.iter().enumerate() {
// addr.sun_path[i] = byte as i8;
// }
// if bind(fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
// return Err(Error::last_os_error());
// }
// }
// Ok(())
// }
// fn listen_socket(fd: RawFd) -> Result<(), Error> {
// unsafe {
// if listen(fd, 5) == -1 {
// return Err(Error::last_os_error());
// }
// }
// Ok(())
// }
// fn accept_connection(fd: RawFd) -> Result<RawFd, Error> {
// unsafe {
// // let mut addr = sockaddr_un {
// // sun_family: AF_UNIX as u16,
// // sun_path: [0; 108],
// // };
// // let mut len = mem::size_of_val(&addr) as socklen_t;
// let client_fd = accept(fd, std::ptr::null_mut(), std::ptr::null_mut());
// if client_fd == -1 {
// return Err(Error::last_os_error());
// }
// Ok(client_fd)
// }
// }
// fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
// unsafe {
// let msg_bytes = msg.as_bytes();
// if send(fd, msg_bytes.as_ptr() as *const libc::c_void, msg_bytes.len(), 0) == -1 {
// return Err(Error::last_os_error());
// }
// }
// Ok(())
// }
// fn receive_message(fd: RawFd) -> Result<String, Error> {
// let mut buffer = [0; 1024];
// unsafe {
// let len = recv(fd, buffer.as_mut_ptr() as *mut libc::c_void, buffer.len(), 0);
// if len == -1 {
// return Err(Error::last_os_error());
// }
// Ok(String::from_utf8_lossy(&buffer[..len as usize]).into_owned())
// }
// }
// fn main() -> Result<(), Error> {
// // Create and bind the server socket
// fs::remove_file(&SOCKET_PATH).ok();
// let server_fd = create_seqpacket_socket()?;
// bind_socket(server_fd)?;
// listen_socket(server_fd)?;
// // Accept connection in a separate thread
// let server_thread = std::thread::spawn(move || {
// let client_fd = accept_connection(server_fd).expect("Failed to accept connection");
// // Receive and print message
// let received_msg = receive_message(client_fd).expect("Failed to receive message");
// println!("Server: Received message: {}", received_msg);
// // Close client connection
// unsafe { close(client_fd) };
// });
// // Create and connect the client socket
// let client_fd = create_seqpacket_socket()?;
// unsafe {
// let mut addr = sockaddr_un {
// sun_family: AF_UNIX as u16,
// sun_path: [0; 108],
// };
// let path_cstr = CString::new(SOCKET_PATH).unwrap();
// let path_bytes = path_cstr.as_bytes();
// // Convert u8 to i8
// for (i, &byte) in path_bytes.iter().enumerate() {
// addr.sun_path[i] = byte as i8;
// }
// if connect(client_fd, &addr as *const _ as *const sockaddr, mem::size_of_val(&addr) as socklen_t) == -1 {
// return Err(Error::last_os_error());
// }
// }
// send_message(client_fd, MSG)?;
// // Close client connection
// unsafe { close(client_fd) };
// // Wait for server thread to complete
// server_thread.join().expect("Server thread panicked");
// fs::remove_file(&SOCKET_PATH).ok();
// // 创建 socket pair
// let (sock1, sock2) = socketpair(
// AddressFamily::Unix,
// SockType::SeqPacket, // 使用 SeqPacket 类型
// None, // 协议默认
// SockFlag::empty(),
// ).expect("Failed to create socket pair");
// let mut socket1 = unsafe { File::from_raw_fd(sock1) };
// let mut socket2 = unsafe { File::from_raw_fd(sock2) };
// // sock1 写入数据
// let msg = b"hello from sock1";
// socket1.write_all(msg)?;
// println!("sock1 send: {:?}", String::from_utf8_lossy(&msg[..]));
// // 因os read和write时会调整file的offset,write会对offset和meta size(目前返回的都是0)进行比较，
// // 而read不会，故双socket都先send,后recv
// // sock2 回复数据
// let reply = b"hello from sock2";
// socket2.write_all(reply)?;
// println!("sock2 send: {:?}", String::from_utf8_lossy(reply));
// // sock2 读取数据
// let mut buf = [0u8; 128];
// let len = socket2.read(&mut buf)?;
// println!("sock2 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
// // sock1 读取回复
// let len = socket1.read(&mut buf)?;
// println!("sock1 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
// Ok(())
// }
user/apps/test_seqpacket/src/seq_pair.rs
-40
View File
@@ -1,40 +0,0 @@
use nix::sys::socket::{socketpair, AddressFamily, SockFlag, SockType};
use std::fs::File;
use std::io::{Error, Read, Write};
use std::os::fd::FromRawFd;
pub fn test_seq_pair() -> Result<(), Error> {
// 创建 socket pair
let (sock1, sock2) = socketpair(
AddressFamily::Unix,
SockType::SeqPacket, // 使用 SeqPacket 类型
None, // 协议默认
SockFlag::empty(),
)
.expect("Failed to create socket pair");
let mut socket1 = unsafe { File::from_raw_fd(sock1) };
let mut socket2 = unsafe { File::from_raw_fd(sock2) };
// sock1 写入数据
let msg = b"hello from sock1";
socket1.write_all(msg)?;
println!("sock1 send: {:?}", String::from_utf8_lossy(&msg[..]));
// 因os read和write时会调整file的offset,write会对offset和meta size(目前返回的都是0)进行比较，
// 而read不会，故双socket都先send,后recv
// sock2 回复数据
let reply = b"hello from sock2";
socket2.write_all(reply)?;
println!("sock2 send: {:?}", String::from_utf8_lossy(reply));
// sock2 读取数据
let mut buf = [0u8; 128];
let len = socket2.read(&mut buf)?;
println!("sock2 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
// sock1 读取回复
let len = socket1.read(&mut buf)?;
println!("sock1 receive: {:?}", String::from_utf8_lossy(&buf[..len]));
Ok(())
}
user/apps/test_seqpacket/src/seq_socket.rs
-181
View File
@@ -1,181 +0,0 @@
use libc::*;
use std::ffi::CString;
use std::io::Error;
use std::mem;
use std::os::unix::io::RawFd;
use std::{fs, str};
const SOCKET_PATH: &str = "/test.seqpacket";
const MSG1: &str = "Hello, Unix SEQPACKET socket from Client!";
const MSG2: &str = "Hello, Unix SEQPACKET socket from Server!";
fn create_seqpacket_socket() -> Result<RawFd, Error> {
unsafe {
let fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if fd == -1 {
return Err(Error::last_os_error());
}
Ok(fd)
}
}
fn bind_socket(fd: RawFd) -> Result<(), Error> {
unsafe {
let mut addr = sockaddr_un {
sun_family: AF_UNIX as u16,
sun_path: [0; 108],
};
let path_cstr = CString::new(SOCKET_PATH).unwrap();
let path_bytes = path_cstr.as_bytes();
for (i, &byte) in path_bytes.iter().enumerate() {
addr.sun_path[i] = byte as i8;
}
if bind(
fd,
&addr as *const _ as *const sockaddr,
mem::size_of_val(&addr) as socklen_t,
) == -1
{
return Err(Error::last_os_error());
}
}
Ok(())
}
fn listen_socket(fd: RawFd) -> Result<(), Error> {
unsafe {
if listen(fd, 5) == -1 {
return Err(Error::last_os_error());
}
}
Ok(())
}
fn accept_connection(fd: RawFd) -> Result<RawFd, Error> {
unsafe {
// let mut addr = sockaddr_un {
// sun_family: AF_UNIX as u16,
// sun_path: [0; 108],
// };
// let mut len = mem::size_of_val(&addr) as socklen_t;
// let client_fd = accept(fd, &mut addr as *mut _ as *mut sockaddr, &mut len);
let client_fd = accept(fd, std::ptr::null_mut(), std::ptr::null_mut());
if client_fd == -1 {
return Err(Error::last_os_error());
}
Ok(client_fd)
}
}
fn send_message(fd: RawFd, msg: &str) -> Result<(), Error> {
unsafe {
let msg_bytes = msg.as_bytes();
if send(
fd,
msg_bytes.as_ptr() as *const libc::c_void,
msg_bytes.len(),
0,
) == -1
{
return Err(Error::last_os_error());
}
}
Ok(())
}
fn receive_message(fd: RawFd) -> Result<String, Error> {
let mut buffer = [0; 1024];
unsafe {
let len = recv(
fd,
buffer.as_mut_ptr() as *mut libc::c_void,
buffer.len(),
0,
);
if len == -1 {
return Err(Error::last_os_error());
}
Ok(String::from_utf8_lossy(&buffer[..len as usize]).into_owned())
}
}
pub fn test_seq_socket() -> Result<(), Error> {
// Create and bind the server socket
fs::remove_file(&SOCKET_PATH).ok();
let server_fd = create_seqpacket_socket()?;
bind_socket(server_fd)?;
listen_socket(server_fd)?;
// Accept connection in a separate thread
let server_thread = std::thread::spawn(move || {
let client_fd = accept_connection(server_fd).expect("Failed to accept connection");
// Receive and print message
let received_msg = receive_message(client_fd).expect("Failed to receive message");
println!("Server: Received message: {}", received_msg);
send_message(client_fd, MSG2).expect("Failed to send message");
// Close client connection
unsafe { close(client_fd) };
});
// Create and connect the client socket
let client_fd = create_seqpacket_socket()?;
unsafe {
let mut addr = sockaddr_un {
sun_family: AF_UNIX as u16,
sun_path: [0; 108],
};
let path_cstr = CString::new(SOCKET_PATH).unwrap();
let path_bytes = path_cstr.as_bytes();
// Convert u8 to i8
for (i, &byte) in path_bytes.iter().enumerate() {
addr.sun_path[i] = byte as i8;
}
if connect(
client_fd,
&addr as *const _ as *const sockaddr,
mem::size_of_val(&addr) as socklen_t,
) == -1
{
return Err(Error::last_os_error());
}
}
send_message(client_fd, MSG1)?;
let received_msg = receive_message(client_fd).expect("Failed to receive message");
println!("Client: Received message: {}", received_msg);
// get peer_name
unsafe {
let mut addrss = sockaddr_un {
sun_family: AF_UNIX as u16,
sun_path: [0; 108],
};
let mut len = mem::size_of_val(&addrss) as socklen_t;
let res = getpeername(client_fd, &mut addrss as *mut _ as *mut sockaddr, &mut len);
if res == -1 {
return Err(Error::last_os_error());
}
let sun_path = addrss.sun_path.clone();
let peer_path: [u8; 108] = sun_path
.iter()
.map(|&x| x as u8)
.collect::<Vec<u8>>()
.try_into()
.unwrap();
println!(
"Client: Connected to server at path: {}",
String::from_utf8_lossy(&peer_path)
);
}
server_thread.join().expect("Server thread panicked");
let received_msg = receive_message(client_fd).expect("Failed to receive message");
println!("Client: Received message: {}", received_msg);
// Close client connection
unsafe { close(client_fd) };
fs::remove_file(&SOCKET_PATH).ok();
Ok(())
}
user/apps/test_sqlite3/.gitignore
-3
View File
@@ -1,3 +0,0 @@
sqlite*.zip
sqlite-*/
test_sqlite3
user/apps/test_sqlite3/Makefile
-32
View File
@@ -1,32 +0,0 @@
ifeq ($(ARCH), x86_64)
CROSS_COMPILE=x86_64-linux-musl-
else ifeq ($(ARCH), riscv64)
CROSS_COMPILE=riscv64-linux-musl-
endif
SQLITE_FILENAME=sqlite-amalgamation-3420000
SQLITE3_DIR=$(shell pwd)/$(SQLITE_FILENAME)
CC=$(CROSS_COMPILE)gcc
.PHONY: all
all: main.c $(SQLITE3_DIR)/sqlite3.c
$(CC) -I $(SQLITE3_DIR) -static -o test_sqlite3 main.c $(SQLITE3_DIR)/sqlite3.c
.PHONY: install clean download_sqlite3 __download_sqlite3
install: all
mv test_sqlite3 $(DADK_CURRENT_BUILD_DIR)/test_sqlite3
clean:
rm -f test_sqlite3 *.o
__download_sqlite3:
@echo "Download sqlite3 from https://mirrors.dragonos.org.cn/pub/third_party/sqlite/$(SQLITE_FILENAME).zip"
@wget https://mirrors.dragonos.org.cn/pub/third_party/sqlite/$(SQLITE_FILENAME).zip || (@echo "Download sqlite3 failed" && rm $(SQLITE_FILENAME).zip && exit 1)
@unzip -o $(SQLITE_FILENAME).zip || (@echo "Unzip sqlite3 failed" && exit 1)
@rm $(SQLITE_FILENAME).zip || (@echo "Remove $(SQLITE_FILENAME).zip failed" && exit 1)
download_sqlite3:
# 如果文件夹不存在，则下载，否则不下载
@test -d $(SQLITE3_DIR) || $(MAKE) __download_sqlite3
fmt:
user/apps/test_sqlite3/main.c
-99
View File
@@ -1,99 +0,0 @@
// This is a test program for sqlite3.
// We take it from rcore-os/arceos, thanks to @rcore-os community.
#include <sqlite3.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
int callback(void *NotUsed, int argc, char **argv, char **azColName)
{
NotUsed = NULL;
for (int i = 0; i < argc; ++i) {
printf("%s = %s\n", azColName[i], (argv[i] ? argv[i] : "NULL"));
}
printf("\n");
return 0;
}
void exec(sqlite3 *db, char *sql)
{
printf("sqlite exec:\n %s\n", sql);
char *errmsg = NULL;
int rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
printf("sqlite exec error: %s\n", errmsg);
}
}
void query(sqlite3 *db, char *sql)
{
printf("sqlite query:\n %s\n", sql);
char *errmsg = NULL;
int rc = sqlite3_exec(db, sql, callback, NULL, &errmsg);
if (rc != SQLITE_OK) {
printf("%s\n", errmsg);
}
}
void query_test(sqlite3 *db, const char *args)
{
puts("======== init user table ========");
exec(db, "create table user("
"id INTEGER PRIMARY KEY AUTOINCREMENT,"
"username TEXT,"
"password TEXT"
")");
puts("======== insert user 1, 2, 3 into user table ========");
char cmd[256] = {0};
sprintf(cmd,
"insert into user (username, password) VALUES ('%s_1', 'password1'), ('%s_2', "
"'password2'), ('%s_3', 'password3')",
args, args, args);
exec(db, cmd);
puts("======== select all ========");
query(db, "select * from user");
puts("======== select id = 2 ========");
query(db, "select * from user where id = 2");
}
void memory()
{
sqlite3 *db;
printf("sqlite open memory\n");
int ret = sqlite3_open(":memory:", &db);
printf("sqlite open memory status %d \n", ret);
query_test(db, "memory");
}
void file()
{
sqlite3 *db;
int ret = sqlite3_open("file.sqlite", &db);
printf("sqlite open /file.sqlite status %d \n", ret);
if (ret != 0) {
printf("sqlite open error");
return;
}
query_test(db, "file");
sqlite3_close(db);
}
int main()
{
printf("sqlite version: %s\n", sqlite3_libversion());
memory();
file();
return 0;
}
user/apps/test_tokio/.gitignore
-1
View File
@@ -1 +0,0 @@
target/*
user/apps/test_tokio/Cargo.toml
-13
View File
@@ -1,13 +0,0 @@
[package]
name = "test_tokio"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1.25", features = [
"macros",
"rt",
"rt-multi-thread",
"net",
"signal",
] }
user/apps/test_tokio/Makefile
-57
View File
@@ -1,57 +0,0 @@
TOOLCHAIN="+nightly-2026-02-24-x86_64-unknown-linux-gnu"
RUSTFLAGS+=""
ifdef DADK_CURRENT_BUILD_DIR
# 如果是在dadk中编译，那么安装到dadk的安装目录中
INSTALL_DIR = $(DADK_CURRENT_BUILD_DIR)
else
# 如果是在本地编译，那么安装到当前目录下的install目录中
INSTALL_DIR = ./install
endif
ifeq ($(ARCH), x86_64)
export RUST_TARGET=x86_64-unknown-linux-musl
export CC=x86_64-linux-musl-gcc
else ifeq ($(ARCH), riscv64)
export RUST_TARGET=riscv64gc-unknown-linux-musl
else
# 默认为x86_86，用于本地编译
export RUST_TARGET=x86_64-unknown-linux-musl
endif
run:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET)
build:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build --target $(RUST_TARGET)
clean:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean --target $(RUST_TARGET)
test:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) test --target $(RUST_TARGET)
doc:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) doc --target $(RUST_TARGET)
fmt:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) fmt
fmt-check:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) fmt --check
run-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET) --release
build-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build -Zbuild-std --target $(RUST_TARGET) --release
clean-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean --target $(RUST_TARGET) --release
test-release:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) test --target $(RUST_TARGET) --release
.PHONY: install
install:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) install --target $(RUST_TARGET) --path . --no-track --root $(INSTALL_DIR) --force
user/apps/test_tokio/src/main.rs
-15
View File
@@ -1,15 +0,0 @@
async fn say_world() {
println!("world");
}
#[tokio::main(flavor = "current_thread")]
async fn main() {
// Calling `say_world()` does not execute the body of `say_world()`.
let op = say_world();
// This println! comes first
println!("hello");
// Calling `.await` on `op` starts executing `say_world`.
op.await;
}
user/apps/user-manage/Makefile
-3
View File
@@ -24,9 +24,6 @@ endif
build:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) build --target $(RUST_TARGET)
run-dragonreach:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) run --target $(RUST_TARGET) --bin DragonReach
clean:
RUSTFLAGS=$(RUSTFLAGS) cargo $(TOOLCHAIN) clean
user/dadk/config/all/dragon_reach-0.1.0.toml
-50
View File
@@ -1,50 +0,0 @@
# 用户程序名称
name = "DragonReach"
# 版本号
version = "0.1.0"
# 用户程序描述信息
description = "init程序"
# 目标架构
target-arch = ["x86_64"]
# 是否只构建一次
build-once = false
# 是否只安装一次
install-once = false
# 任务源
[task-source]
# 构建类型
type = "build-from-source"
# 构建来源
source = "git"
# 路径或URL
source-path = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/DragonReach.git"
# git标签或分支
revision = "cc4e7ea35"
# 构建相关信息
[build]
# 构建命令
build-command = "make install"
# 安装相关信息
[install]
# 安装到DragonOS的路径
in-dragonos-path = "/"
# 清除相关信息
[clean]
# 清除命令
clean-command = "make clean"
# 依赖项
# 注意：因为没有依赖项，所以这里不包含[[depends]]部分
# 环境变量
# 注意：因为没有环境变量，所以这里不包含[[envs]]部分
user/dadk/config/all/test_seqpacket_0_1_0.toml
-41
View File
@@ -1,41 +0,0 @@
# 用户程序名称
name = "test_seqpacket"
# 版本号
version = "0.1.0"
# 用户程序描述信息
description = "对seqpacket_pair的简单测试"
# （可选）默认: false 是否只构建一次，如果为true，DADK会在构建成功后，将构建结果缓存起来，下次构建时，直接使用缓存的构建结果
build-once = false
# (可选) 默认: false 是否只安装一次，如果为true，DADK会在安装成功后，不再重复安装
install-once = false
# 目标架构
# 可选值："x86_64", "aarch64", "riscv64"
target-arch = ["x86_64"]
# 任务源
[task-source]
# 构建类型
# 可选值："build-from-source", "install-from-prebuilt"
type = "build-from-source"
# 构建来源
# "build_from_source" 可选值："git", "local", "archive"
# "install_from_prebuilt" 可选值："local", "archive"
source = "local"
# 路径或URL
source-path = "user/apps/test_seqpacket"
# 构建相关信息
[build]
# （可选）构建命令
build-command = "make install"
# 安装相关信息
[install]
# （可选）安装到DragonOS的路径
in-dragonos-path = "/"
# 清除相关信息
[clean]
# （可选）清除命令
clean-command = "make clean"
# （可选）依赖项
# 注意：如果没有依赖项，忽略此项，不允许只留一个[[depends]]
# 由于原配置中没有依赖项，此处省略[[depends]]部分
# （可选）环境变量
# 由于原配置中没有环境变量，此处省略[[envs]]部分
user/dadk/config/all/test_sqlite3-3.42.0.toml
-52
View File
@@ -1,52 +0,0 @@
# 用户程序名称
name = "test_sqlite3"
# 版本号
version = "3.42.0"
# 用户程序描述信息
description = "测试sqlite3"
# （可选）默认: false 是否只构建一次，如果为true，DADK会在构建成功后，将构建结果缓存起来，下次构建时，直接使用缓存的构建结果
build-once = false
# (可选) 默认: false 是否只安装一次，如果为true，DADK会在安装成功后，不再重复安装
install-once = false
# 目标架构
# 可选值："x86_64", "aarch64", "riscv64"
target-arch = ["x86_64"]
# 任务源
[task-source]
# 构建类型
# 可选值："build-from_source", "install-from-prebuilt"
type = "build-from-source"
# 构建来源
# "build_from_source" 可选值："git", "local", "archive"
# "install_from_prebuilt" 可选值："local", "archive"
source = "local"
# 路径或URL
source-path = "user/apps/test_sqlite3"
# 构建相关信息
[build]
# （可选）构建命令
build-command = "make download_sqlite3 && make install"
# 安装相关信息
[install]
# （可选）安装到DragonOS的路径
in-dragonos-path = "/bin"
# 清除相关信息
[clean]
# （可选）清除命令
clean-command = "make clean"
# （可选）依赖项
# 注意：如果没有依赖项，忽略此项，不允许只留一个[[depends]]
# [[depends]]
# name = "depend1"
# version = "0.1.1"
# [[depends]]
# name = "depend2"
# version = "0.1.2"
# （可选）环境变量
# 注意：如果没有环境变量，忽略此项，不允许只留一个[[envs]]
# [[envs]]
# key = "PATH"
# value = "/usr/bin"
# [[envs]]
# key = "LD_LIBRARY_PATH"
# value = "/usr/lib"
user/dadk/config/all/test_tokio_0_1_0.toml
-36
View File
@@ -1,36 +0,0 @@
# 用户程序名称
name = "test_tokio"
# 版本号
version = "0.1.0"
# 用户程序描述信息
description = ""
# （可选）是否只构建一次，如果为true，DADK会在构建成功后，将构建结果缓存起来，下次构建时，直接使用缓存的构建结果
build-once = false
# (可选) 是否只安装一次，如果为true，DADK会在安装成功后，不再重复安装
install-once = false
# 目标架构
# 可选值："x86_64", "aarch64", "riscv64"
target-arch = ["x86_64"]
# 任务源
[task-source]
# 构建类型
# 可选值："build-from_source", "install-from-prebuilt"
type = "build-from-source"
# 构建来源
# "build_from_source" 可选值："git", "local", "archive"
# "install_from_prebuilt" 可选值："local", "archive"
source = "local"
# 路径或URL
source-path = "user/apps/test_tokio"
# 构建相关信息
[build]
# （可选）构建命令
build-command = "make install"
# 安装相关信息
[install]
# （可选）安装到DragonOS的路径
in-dragonos-path = "/bin"
# 清除相关信息
[clean]
# （可选）清除命令
clean-command = "make clean"
user/dadk/config/sets/default/dragon_reach-0.1.0.toml
-1
View File
@@ -1 +0,0 @@
../../all/dragon_reach-0.1.0.toml
user/dadk/config/sets/default/test_seqpacket_0_1_0.toml
-1
View File
@@ -1 +0,0 @@
../../all/test_seqpacket_0_1_0.toml
user/dadk/config/sets/default/test_sqlite3-3.42.0.toml
-1
View File
@@ -1 +0,0 @@
../../all/test_sqlite3-3.42.0.toml
user/dadk/config/sets/default/test_tokio_0_1_0.toml
-1
View File
@@ -1 +0,0 @@
../../all/test_tokio_0_1_0.toml