Exemple #1
0
/* Routine to go up tree */
static char *recurser(char *path_buf, int path_size, dev_t root_dev, ino_t root_ino,int depth)
{
	struct stat st;
	dev_t this_dev;
	ino_t this_ino;
  
	//printf ("recurser(%i): %s\n",depth,path_buf);
	
	if (stat(path_buf, &st) < 0) {
	  if (errno != EFAULT) {
	      __set_errno(ERANGE);
	  }
	    return 0;
	}
	this_dev = st.st_dev;
	this_ino = st.st_ino;
	if (this_dev == root_dev && this_ino == root_ino) {
		if (path_size < 2) {
		  __set_errno(ERANGE);
		    return 0;
		}
		strcpy(path_buf, "/");
		return path_buf;
	}
	if (strlen(path_buf) + 4 > path_size) {
	      __set_errno(ERANGE);
		    return 0;
	}
	strcat(path_buf, "/..");
	if (recurser(path_buf, path_size, root_dev, root_ino,++depth) == 0)
		return 0;
	
	return search_dir(this_dev, this_ino, path_buf, path_size);
}
Exemple #2
0
static inline
int __syscall_getcwd(char * buf, unsigned long size)
{
    int len;
    char *cwd;
    struct stat st;
    int olderrno;

    olderrno = errno;
    len = -1;

    /* get stat for root to have a valid parameters for the terminating condition */
    if (stat("/", &st) < 0) {
	/* root dir not found! */
	return -1;
    }
    /* start with actual dir */
    if (buf) strncpy(buf, ".", size);

    cwd = recurser(buf, size, st.st_dev, st.st_ino);
    if (cwd) {
	len = strlen(buf);
	__set_errno(olderrno);
    }
    return len;
}
Exemple #3
0
static inline
int __syscall_getcwd(char * buf, unsigned long size)
{
    int len;
    char *cwd;
    struct stat st;
    int olderrno,depth = 0;

    if (buf == NULL) {
      printf("<fixme> libc-getcwd: warning allocating memory for buffer\n");
      buf = malloc(size);
    }
    
    if (stat("/", &st) < 0) {
      return EINVAL;
    }
    strcpy(buf, ".");
    
    olderrno = errno;
    len = -1;
    cwd = recurser(buf, size, st.st_dev, st.st_ino,depth);
    if (cwd) {
	len = strlen(buf);
	__set_errno(olderrno);
    }
    return len;
}
Exemple #4
0
bool recurser(int n, int origin)
{
	bool ret = true;
	int level = origin - n + 1;

	std11::lock_guard<std11::recursive_mutex> l(rm);
	printf("Th[%08x] %s acquired Level %d lock\n",
			hash(std11::this_thread::get_id()), bracket_indent[level - 1],
			level);

	if (--n)
	{
		recurser(n, origin);
	}
	else
	{
		shared_resource += origin;
		printf("Th[%08x] incremented %d. (shared_resource = %d)\n",
				hash(std11::this_thread::get_id()), origin, shared_resource);
		if (shared_resource >= LIMIT)
		{
			ret = false;
		}
	}
	printf("Th[%08x] %s released Level %d lock\n",
			hash(std11::this_thread::get_id()), bracket_indent[level - 1],
			level);

	return ret;
}
Exemple #5
0
/* Routine to go up tree */
static char *recurser(char *path_buf, int path_size, dev_t root_dev, ino_t root_ino)
{
	struct stat st;
	dev_t this_dev;
	ino_t this_ino;

	if (stat(path_buf, &st) < 0) {
	    if (errno != EFAULT)
		goto oops;
	    return 0;
	}
	this_dev = st.st_dev;
	this_ino = st.st_ino;
	if (this_dev == root_dev && this_ino == root_ino) {
		if (path_size < 2) {
		    goto oops;
		}
		strcpy(path_buf, "/");
		return path_buf;
	}
	if (strlen(path_buf) + 4 > path_size) {
	    goto oops;
	}
	strcat(path_buf, "/..");
	if (recurser(path_buf, path_size, root_dev, root_ino) == 0)
		return 0;

	return search_dir(this_dev, this_ino, path_buf, path_size);
oops:
	__set_errno(ERANGE);
	return 0;
}
Exemple #6
0
char *getcwd(char *buf, int size)
{
    struct stat st;

    if (size == 0) {
	if (buf != NULL) {
	    __set_errno(EINVAL);
	    return NULL;
	}
	size = PATH_MAX;
    }
    if (size < 3) {
	__set_errno(ERANGE);
	return NULL;
    }

    if (buf == NULL) {
	buf = malloc (size);
	if (buf == NULL)
	    return NULL;
    }

    strcpy(buf, ".");
    if (stat("/", &st) < 0) {
	return NULL;
    }

    return recurser(buf, size, st.st_dev, st.st_ino);
}
Exemple #7
0
void recurser (int  x)
{
  int  local_x;

  if (x > 0)
    recurser (x-1);
  local_x = x;
}
Exemple #8
0
void worker()
{
	bool cont = true;
	do
	{
		int n = RANDOM(MIN_LEVEL, MAX_LEVEL);
		printf("Th[%08x] calling recurse(%d) ...\n",
				hash(std11::this_thread::get_id()), n);
		cont = recurser(n, n);
		std11::this_thread::yield();
	} while (cont);
}
Exemple #9
0
int main ()
{
  struct1.val = 1;
  struct2.val = 2;
  ptr1 = &struct1;
  ptr2 = &struct2;
  marker1 ();
  func1 ();
  for (count = 0; count < 4; count++) {
    ival1 = count;
    ival3 = count; ival4 = count;
  }
  ival1 = count; /* Outside loop */
  ival2 = count;
  ival3 = count; ival4 = count;
  marker2 ();
  if (doread)
    {
      static char msg[] = "type stuff for buf now:";
      write (1, msg, sizeof (msg) - 1);
      read (0, &buf[0], 5);
    }
  marker4 ();

  /* We have a watchpoint on ptr1->val.  It should be triggered if
     ptr1's value changes.  */
  ptr1 = ptr2;

  /* This should not trigger the watchpoint.  If it does, then we
     used the wrong value chain to re-insert the watchpoints or we
     are not evaluating the watchpoint expression correctly.  */
  struct1.val = 5;
  marker5 ();

  /* We have a watchpoint on ptr1->val.  It should be triggered if
     ptr1's value changes.  */
  ptr1 = ptr2;

  /* This should not trigger the watchpoint.  If it does, then we
     used the wrong value chain to re-insert the watchpoints or we
     are not evaluating the watchpoint expression correctly.  */
  struct1.val = 5;
  marker5 ();

  /* We're going to watch locals of func2, to see that out-of-scope
     watchpoints are detected and properly deleted.
     */
  marker6 ();

  /* This invocation is used for watches of a single
     local variable. */
  func2 ();

  /* This invocation is used for watches of an expression
     involving a local variable. */
  func2 ();

  /* This invocation is used for watches of a static
     (non-stack-based) local variable. */
  func2 ();

  /* This invocation is used for watches of a local variable
     when recursion happens.
     */
  marker6 ();
  recurser (2);

  marker6 ();

  func3 ();

  func4 ();

  return 0;
} /* end of main */
void middle() {
  sleeper();
  sibling();
  recurser();
}