- android - 多次调用 OnPrimaryClipChangedListener
- android - 无法更新 RecyclerView 中的 TextView 字段
- android.database.CursorIndexOutOfBoundsException : Index 0 requested, 光标大小为 0
- android - 使用 AppCompat 时,我们是否需要明确指定其 UI 组件(Spinner、EditText)颜色
我必须使用 setjmp/longjmp 实现用户级线程库作为作业。这是我写的代码:
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/select.h>
#include <time.h>
#include <errno.h>
#include <signal.h>
#include <setjmp.h>
#define STACKSIZE 128*1024 //approriate stack size
typedef void (*ult_func)();
struct tcb_str; //forward declaration
typedef struct tcb_str {
//fill this struct with statusinformations
stack_t stack; //stack for local vars
jmp_buf buf;
int id;
void (*threadfunc)();
int waitingfor; //ID of Thread/ Filediscriptor the Thread is currently waiting for
int waitingtype; //0 = Thread, 1 = fd
int exitnumber; //Is set on exit
} tcb;
typedef struct queue queue;
struct queue *runqueue;
struct queue *blockedqueue;
struct queue *zombiequeue;
jmp_buf backtonormal;
int counter = 0;
struct queue {
struct queue_node *start;
struct queue_node *end;
};
struct queue_node {
struct tcb_str *element;
struct queue_node *next;
};
struct queue_node* pop(struct queue *qu) {
if (qu == NULL || qu->start == NULL) {
return NULL;
}
struct queue_node *node = qu->start;
qu->start = node->next;
if (qu->start == NULL) {
qu->end = NULL;
}
node->next = NULL;
return node;
}
int push(struct queue *qu, struct queue_node *node) {
if (qu == NULL) {
return -1;
}
node->next = NULL;
if (qu->end == NULL) {
qu->start = qu->end = node;
} else {
qu->end->next = node;
qu->end = node;
}
return 1;
}
struct queue_node* removeByTid(struct queue *qu, int tid) {
struct queue_node* tmp = qu->start;
struct queue_node* previous = qu->start;
if(tmp->element->id == tid) {
pop(qu);
return tmp;
}
do {
if(tmp->element->id == tid) {
//What if first and only
previous->next = tmp->next;
//What if only one left after
tmp->next = NULL;
if(qu->start->next == NULL) {
qu->end = qu->start;
}
return tmp;
}
previous = tmp;
}
while((tmp = tmp->next));
return NULL;
}
struct queue *initqueue() {
queue *qu = malloc(sizeof(*qu));
if (qu == NULL) {
return NULL;
}
qu->start = qu->end = NULL;
return qu;
}
int checkfordata(int fd) {
int data; //returns != 0 if data is available
struct timeval tv_str;
fd_set fds;
FD_ZERO(&fds);
if (!FD_ISSET(fd, &fds)) {
FD_SET(fd, &fds); //Creating fd_set for select()
}
tv_str.tv_sec = 0;
tv_str.tv_usec = 0;
//is data available?
data = select(fd + 1, &fds, NULL, NULL, &tv_str);
FD_CLR(fd, &fds);
return data;
}
void schedulerThread() {
while(1) {
//Check blocked Threads
struct queue_node* tmp = blockedqueue->start;
fd_set fds;
FD_ZERO(&fds);
if(tmp != NULL) {
//Go through blocked Threads
do {
int data = checkfordata(tmp->element->waitingfor);
if(data > 0) {
removeByTid(blockedqueue, tmp->element->id);
//Add to running queue (at start)
tmp->next = runqueue->start;
runqueue->start = tmp;
return;
}
else {
FD_SET(tmp->element->waitingfor, &fds);
}
}
while((tmp = tmp->next));
}
if(runqueue->start == NULL) {
if(blockedqueue->start == NULL) {
free(runqueue);
free(blockedqueue);
struct queue_node* qu;
while((qu = pop(zombiequeue)) != NULL) {
free(qu->element->stack.ss_sp);
free(qu);
}
free(zombiequeue);
return;
}
else {
struct timeval tv_str;
tv_str.tv_sec = 0;
tv_str.tv_usec = 800 * 1000;
//We have to copy fds, as select will mess it up
fd_set fdset = fds;
select(FD_SETSIZE, &fdset, NULL, NULL, &tv_str);
}
}
else {
return;
}
}
}
/*
This function only exists to tell the process to use an empty stack for the thread
*/
void signalHandlerSpawn( int arg ) {
if ( setjmp( runqueue->start->element->buf ) ) {
runqueue->start->element->threadfunc();
longjmp(backtonormal, 1);
}
return;
}
int ult_spawn(ult_func f) {
struct tcb_str* tcb = malloc(sizeof(struct tcb_str));
tcb->threadfunc = f;
tcb->waitingfor = -1;
tcb->waitingtype = -1;
tcb->id = ++counter;
tcb->stack.ss_flags = 0;
tcb->stack.ss_size = STACKSIZE;
tcb->stack.ss_sp = malloc(STACKSIZE);
if ( tcb->stack.ss_sp == 0 ) {
perror( "Could not allocate stack." );
exit( 1 );
}
stack_t oldStack;
sigaltstack( &(tcb->stack), 0 );
struct sigaction sa;
struct sigaction oldHandler;
sa.sa_handler = &signalHandlerSpawn;
sa.sa_flags = SA_ONSTACK;
sigemptyset( &sa.sa_mask );
sigaction( SIGUSR1, &sa, &oldHandler );
struct queue_node* node = malloc(sizeof(struct queue_node));
node->element = tcb;
push(runqueue, node);
struct queue_node* q = runqueue->start;
runqueue->start = runqueue->end;
raise( SIGUSR1 );
/* Restore the original stack and handler */
sigaltstack( &oldStack, 0 );
sigaction( SIGUSR1, &oldHandler, 0 );
runqueue->start = q;
return tcb->id;
}
void ult_yield() {
if(runqueue->start == NULL) {
exit(1);
//TODO clean up
}
//We're the only one, so no need to schedule
if(runqueue->start == runqueue->end && blockedqueue->start == NULL && runqueue->start != NULL) {
return;
}
else {
if (setjmp(runqueue->start->element->buf))
return;
else {
struct queue_node* tmp = pop(runqueue);
push(runqueue, tmp);
longjmp(backtonormal, 1);
}
}
}
int ult_read(int fd, void *buf, int count) {
if (setjmp(runqueue->start->element->buf)) {
return read(fd, buf, count);
}
else {
struct queue_node* tmp = pop(runqueue);
tmp->element->waitingfor = fd;
tmp->element->waitingtype = 1;
push(blockedqueue, tmp);
longjmp(backtonormal, 1);
}
return -1;
}
void ult_init(ult_func f) {
runqueue = initqueue();
blockedqueue = initqueue();
zombiequeue = initqueue();
ult_spawn(f);
while(1) {
if(setjmp(backtonormal))
continue;
else {
schedulerThread();
if(runqueue->start == NULL)
return; //TODO clean up
longjmp(runqueue->start->element->buf, 1);
}
}
}
void threadA()
{
int fd;
char *inpt = "/dev/random";
char buf[8];
fd = open(inpt, O_RDONLY, O_NONBLOCK);
if (fd == -1)
{
perror("open()");
}
while(1)
{
memset(buf, 0, 8);
ult_read(fd, &buf, sizeof(buf));
}
}
void threadB()
{
char input[512] = {0};
while(1)
{
memset(input, 0, 512);
ult_read(STDIN_FILENO, &input, 512);
if(strcmp(input, "stats\n") == 0)
{
//print stats
continue;
}
}
}
void myInit()
{
int status;
ult_spawn(&threadA);
ult_spawn(&threadB);
while(1) {
ult_yield();
}
}
int main() {
ult_init(&myInit);
return 0;
}
问题出现在ult_read。一旦这个函数被调用,它会先跳回调度器。调度器检查数据是否可用(防止整个进程阻塞),一旦有数据可读,就跳回函数。现在当函数返回时我得到一个段错误。 Valgrind 告诉我:
Jump to the invalid address stated on the next line
==20408== at 0x0: ???
==20408== Address 0x0 is not stack'd, malloc'd or (recently) free'd
Ult_yield 工作得很好,尽管它使用的是相同的技术。我检查了这个问题SetJmp/LongJmp: Why is this throwing a segfault? ,但我认为这是一个不同的问题,因为我正在为每个“线程”创建一个单独的堆栈。任何人都可以向我解释问题是什么以及如何解决吗?
最佳答案
我看不出您的代码有任何明显的错误,但它不是 MVCE ,所以很难说——您的调度程序或推送和弹出功能可能有问题。
似乎有问题的一件事是 ult_yield
和 ult_read
中的测试:
if(runqueue->start == NULL && blockedqueue->start == NULL) ...
这些都应该是:
if (runqueue->start == NULL) {
printf("Scheduler queue corrupted");
abort(); }
因为调用这些函数时,runqueue->start
必须指向当前线程的 tcb/queue 节点。
您的 valgrind 错误看起来像是在尝试通过无效的 jmp_buf
执行 longjmp
,因此请尝试回溯以查看它来自何处以及如何进入该状态。
您还应该取消设置 ult_spawn
末尾的信号处理程序(或使用 SA_RESETHAND
),以免某个地方的虚假 SIGUSR1
导致事物的腐败。
关于c - setjmp longjmp 与堆栈,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/38038549/
我想使用 setjmp/longjmp 在主函数中重用一些代码(注意:这只是一个练习,而不是我在现实世界中认真计划做的事情)。 以下代码是我想出的: #include #include jmp_b
根据我的理解,setjmp 保存当前上下文,它应该在调用 longjmp 时恢复它。然而,下一段代码打印出 15(我使用 -g 编译并且没有进行任何优化)。我是不是误解了这个结构,还是遗漏了其他任何东
来自问题: Is it good programming practice to use setjmp and longjmp in C? 留下的两条评论说: "You can't throw an
我正在使用以下代码尝试读取来自用户的输入,如果超过 5 秒则超时并退出。这是通过 setjmp/longjmp 和 SIGALRM 信号的组合来实现的。 代码如下: #include #includ
Michael Kerrisk 的“Linux 编程接口(interface)”中的练习 6.2 要求: Write a program to see what happens if we try t
我需要了解 longjmp 函数的工作原理;我知道它的作用,但我需要知道它是如何做到的。 我试图对 gdb 中的代码进行 disas,但我无法理解某些步骤。代码是: 0xb7ead420 :
下面的代码无法正常工作。谁能指出原因 #define STACK_SIZE 1524 static void mt_allocate_stack(struct thread_struct *mythr
这是我的代码: #include #include #include jmp_buf buf; void handler(int s); int main(int argc, char **ar
一段代码在这里 jmp_buf mark; int Sub_Func() { int be_modify, jmpret; be_modify = 0; jmp
我的问题针对的是 setjmp/longjmp 关于局部变量的行为。 示例代码: jmp_buf env; void abc() { int error; ... if(error)
我必须使用 setjmp/longjmp 实现用户级线程库作为作业。这是我写的代码: #include #include #include #include #include #includ
我正在尝试使用 longjmp 在 c 中实现控制的重新反转,目前我有以下代码: #include #include jmp_buf env; int arg; typedef void (*fp
这个问题来自 SetJmp/LongJmp: Why is this throwing a segfault? 当我使用 Debug模式运行代码时,它确实按预期崩溃了。但是如果我使用 release
#include #include #include #include static jmp_buf env_alrm; static void sig_alarm(int signo) {
所以我有一个库(不是我写的),不幸的是它使用 abort() 来处理某些错误。在应用程序级别,这些错误是可恢复的,所以我想处理它们而不是让用户看到崩溃。所以我最终写了这样的代码: static jmp
我的问题针对的是 setjmp/longjmp 关于局部变量的行为。 示例代码: jmp_buf env; void abc() { int error; ... if(error)
我正在调查setjmp/longjmp,发现setjmp 保存指令指针、堆栈指针等寄存器... 然而,我在这里没有得到的是,在调用 setjmp 和 longjmp 之间,不能修改线程本身堆栈中的数据
在 Why volatile works for setjmp/longjmp , 用户 greggo评论: Actually modern C compilers do need to know t
据我了解,setjmp()的典型用法和 longjmp()是异常处理(libpng 中的用法应该是一个著名的例子)并且最多只有一次调用 longjmp()一个 setjmp()称呼。 是否允许安全地做
有没有办法使用 setjmp 来实现多任务处理?和 longjmp职能 最佳答案 这是所谓的用户空间上下文切换的一种形式。 这是可能的,但很容易出错,特别是如果您使用 setjmp 和 longjmp
我是一名优秀的程序员,十分优秀!