原帖由 思一克 于 2007-8-3 19:39 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7156157&ptid=971102]
你写可重入函数时候要考虑到保证不可重入部分不重入, 还有保证整个函数必须可重入.
__do_IRQ就是如此.
所以说"调用了不可重入函数的函数不一定是不可重入的"是正确的.
而"调用了不可重入函数的函数一定是不可 ... 

原帖由 ypxing 于 2007-8-3 20:49 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7156295&ptid=971102]
那么,怎么才能保证不可重入的部分不被重入呢?

 

原帖由 思一克 于 2007-8-3 19:39 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7156157&ptid=971102]
你写可重入函数时候要考虑到保证不可重入部分不重入, 还有保证整个函数必须可重入.
__do_IRQ就是如此.
所以说"调用了不可重入函数的函数不一定是不可重入的"是正确的.
而"调用了不可重入函数的函数一定是不可重入的"是不对的(语句A).因为有十分多的反例.


调用了不可重入函数的函数不一定是不可重入的。"这句是不对的(语句B),
因为你无法保证被调用的不可重入函数部分不被重入

原帖由 飞灰橙 于 2007-8-3 22:18 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7156605&ptid=971102]


越看越糊涂了，撇开讨论的问题不谈, 上面的语句A和语句B，必定有一句是错的 

原帖由 飞灰橙 于 2007-8-3 22:18 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7156605&ptid=971102]


越看越糊涂了，撇开讨论的问题不谈, 上面的语句A和语句B，必定有一句是错的 

原帖由 ypxing 于 2007-8-8 23:05 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7176529&ptid=971102]
这两天写了一个测试程序来验证malloc的不可重入性
但是malloc一直没有crash,有点郁闷

过段时间把自己的测试代码贴出来,让大家来帮忙看看 

原帖由 bluster 于 2007-8-9 10:08 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7177603&ptid=971102]

多线程条件下，signal的handler有可能在一个单独的线程中执行，如果这样那么malloc用锁保护就够了。 

main.c

/*这是主程序,用来调用malloc*/



#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <string.h>

#include <sys/types.h>

#include <unistd.h>



void setUnblock()

{

  sigset_t sigset;

  sigemptyset(&sigset);

  sigprocmask(SIG_SETMASK, &sigset, NULL);

      

}





void usr1Handler (int signal_number)        /*处理SIGUSR1信号*/

{

  setUnblock(); /*使得SIGUSR1可以被嵌套*/

  free((int*)malloc(sizeof(int)*1000));

  //printf("enter handlern");

  //getchar();

}



int main ()

{

  int *pi;

  struct sigaction sa;

  

  memset(&sa, 0, sizeof(sa));

  sa.sa_handler = &usr1Handler;

  sigaction(SIGUSR1, &sa, NULL);



  pause();

  

  return 0;

}

kill.c 



/*这个是用来发送SIGUSR1信号的*/

#include <stdlib.h>

#include <stdio.h>

#include <string.h>



int main(int argc,char *argv[])

{

  int i;

  char killstr[30]="kill -USR1 ";

  if (argc == 2)

  {

    strcat(killstr, argv[1]);

  }

   for (i=0; i<3; i++)

  {

   fork();        /*这样会有8个进程同时发送*/

  }

  

  while(1)

  {

    system(killstr);

  }

  

  return 0;

}

原帖由 ypxing 于 2007-8-8 23:05 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7176529&ptid=971102]
这两天写了一个测试程序来验证malloc的不可重入性
但是malloc一直没有crash,有点郁闷

过段时间把自己的测试代码贴出来,让大家来帮忙看看 

原帖由 ypxing 于 2007-8-9 16:22 发表 [url=http://bbs.chinaunix.net/redirect.php?goto=findpost&pid=7180404&ptid=971102]
试图测试malloc不可重入性的代码如下:


main.c
/*这是主程序,用来调用malloc*/

#include 
#include 
#include 
#include 
#include 
#include 

void setUnblock()
{
  sigset_t sigset;
  s ... 

#include <sys/types.h>

#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <unistd.h>



#if	0

#define	PRINT(a)	do {	

	printf a;		

	fflush(stdout);		

}while(0)

#else

#define	PRINT(a)

#endif



static void

run_malloc(void)

{

	void	*mem[8];

	int	sz;

	int	i;



	for (i = 0; i < (sizeof(mem)/sizeof(mem[0])); i++) {

		sz = random() % (1024 * 1024);

		if (sz <= 0)

			sz = 1024;

		mem = malloc(sz);

		if (mem == NULL) {

			PRINT (("[%d] malloc null...n", i));

			exit(-1);

		}

		PRINT(("%dn", i));

		snprintf(mem, sz, "this is a test...");

	}



	for (--i; i >= 0; i--) {

		free(mem);

	}

}



static void

sighandler(int signo)

{

	static void *mem = NULL;



	PRINT ((".n"));

	if (mem == NULL) {

		mem = malloc(1024);

	} else {

		free(mem);

		mem = NULL;

	}

}



static void

malloc_loop(void)

{



	for (;;)

		run_malloc();

}



static void

signal_loop(pid_t child)

{

	int	usec;



	for (;;) {

		kill(child, SIGUSR1);

		usec = ((unsigned int)random()) % 10;

		usleep(usec);

	}

}



int

main(int argc, char **argv)

{

	pid_t	child;



	if ((child = fork()) < 0) {

		perror("fork()");

		exit(-1);

	} else if (child == 0) {

		/* child */

		if (signal(SIGUSR1, sighandler) < 0) {

			perror("signal");

			exit(-1);

		}

		malloc_loop();

	} else {

		/* parent */

		signal_loop(child);

	}



	return	0;

}