Esempio n. 1
0
s32 DI_Config_Load(struct dipConfigState *cfg)
{
	s32 fd, ret;

#ifdef DEBUG
	svc_write("DIP: Config_Load(): Loading config file ");
	svc_write(__dip_cfg_filename);
	svc_write("\n");
#endif

	/* Open config file */
	fd = os_open(__dip_cfg_filename, ISFS_OPEN_READ);

#ifdef DEBUG
	svc_write("DIP: Config_Load(): Config file ");
	svc_write(fd < 0 ? "NOT found\n" : "found\n");
#endif

	if (fd < 0)
		return fd;

	/* Read config */
	ret = os_read(fd, cfg, sizeof(struct dipConfigState));

	if (ret == sizeof(struct dipConfigState)) {
		if (cfg->mode == MODE_FRAG) {
			s32 ret2;

			/* Read frag list */
			memset(&fraglist_data, 0, sizeof(fraglist_data));
			if (cfg->frag_size > sizeof(fraglist_data)) {
				ret2 = -1;
			} else {	   
				ret2 = os_read(fd, &fraglist_data, cfg->frag_size);
			}
			if (ret2 != cfg->frag_size)
				ret = -1;
		}
	}
	else if (ret >= 0)
		ret = -1;

	/* Close config */
	os_close(fd);

	/* Delete config file */
	__Config_Delete(__dip_cfg_filename);

#ifdef DEBUG
	if (ret < 0)
		svc_write("DIP: Config_Load(): Config file has unexpected size!!!\n");
#endif

	return ret;
}
Esempio n. 2
0
ssize_t os_read_no_block(int fd, void *buf, size_t count)
{
	const int flags = fcntl(fd, F_GETFL, 0);

	fcntl(fd, F_SETFL, flags | O_NONBLOCK);
	return os_read(fd, buf, count);
}
Esempio n. 3
0
static unsigned long host_block_read(struct udevice *dev,
				     unsigned long start, lbaint_t blkcnt,
				     void *buffer)
{
	struct host_block_dev *host_dev = dev_get_priv(dev);
	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);

#else
static unsigned long host_block_read(struct blk_desc *block_dev,
				     unsigned long start, lbaint_t blkcnt,
				     void *buffer)
{
	int dev = block_dev->devnum;
	struct host_block_dev *host_dev = find_host_device(dev);

	if (!host_dev)
		return -1;
#endif

	if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
			-1) {
		printf("ERROR: Invalid block %lx\n", start);
		return -1;
	}
	ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
	if (len >= 0)
		return len / block_dev->blksz;
	return -1;
}
Esempio n. 4
0
/*
 * Simple wrapper around os_read that passes any previously processed
 * data to os->writer and then discards it to make room in
 * the buffer, while ensuring at least MAX_HEADER_SIZE bytes remain.
 * Returns the number of new data bytes in the buffer.
 */
static int getter_section(const char **text, void *cookie)
{
	output_section_t *os = cookie;
	size_t prevconsumed;

	if (os->consumed < os->len)
		goto done;

	if (os->len == sizeof(os->buf)) {
		if (os->consumed <= MAX_HEADER_SIZE)
			goto done;

		if (os->in_section) {
			os->writer(os->name, os->content_type, os->buf, os->consumed - MAX_HEADER_SIZE, os->pos - os->len);

		}
		os_discard(os, os->consumed - MAX_HEADER_SIZE);
		os->consumed = MAX_HEADER_SIZE;
	}

	if (os_read(os) <= 0)
		return 0;

done:
	prevconsumed = os->consumed;
	os->consumed = os->len;
	*text = os->buf + prevconsumed;
	return os->consumed - prevconsumed;
}
Esempio n. 5
0
void 
req_echo_str(FILE *fp, int fd, const struct sockaddr *destaddr, socklen_t addrlen)
{
	char sbuf[MAXLINE], rbuf[MAXLINE];
	int n;
	struct sockaddr reply_addr;
	socklen_t len;

	os_connect(fd, destaddr, addrlen);

	while (fgets(sbuf, MAXLINE, fp) != NULL) {
		//printf("[send]: %s", sbuf);
		os_write(fd, sbuf, strlen(sbuf));
		len = addrlen;	
		n =	os_read(fd, rbuf, MAXLINE);

#if 0
		if (len != addrlen || memcmp(destaddr, &reply_addr, addrlen) != 0) {
			printf("packet not for us\n");
			continue;
		} 
#endif
		rbuf[n] = 0;
		fputs(rbuf, stdout);
	}
}
Esempio n. 6
0
static void tiger_tree_fd(OS_FD fd, OFF_T len, OFF_T pos, OFF_T block_size, char *digest)
{
  static char tiger_buffer[BLOCK_SIZE+1];
  if(block_size == BLOCK_SIZE){
    OFF_T length = (len - pos > BLOCK_SIZE) ? BLOCK_SIZE : len - pos;
    char *s = tiger_buffer+1;
    size_t toread = length;
    char *curs = s;
      while (toread!=0){
      int max_nread = toread;
/* HASH_BUFFER_LEN > toread ? toread : HASH_BUFFER_LEN; */

      ssize_t nread = os_read (fd, curs, max_nread);

        if(nread <= 0) {
        unix_error(errno, "tiger_safe_fd: Read", Nothing);
      }
      curs += nread;
      toread -= nread;
    }

    tiger_hash(0, s, length, digest);
  } else {    
    if(pos+block_size/2 >=len){
      tiger_tree_fd(fd, len, pos, block_size/2, digest);
    } else {
      char digests_prefixed[1+DIGEST_LEN * 2];
      char *digests = digests_prefixed+1;
      tiger_tree_fd(fd, len, pos, block_size/2, digests);
      tiger_tree_fd(fd, len, pos+block_size/2, block_size/2, digests+DIGEST_LEN);
      tiger_hash(1,digests, 2*DIGEST_LEN, digest);
    }
  }
}
Esempio n. 7
0
/* Fill a given buffer with the given block in volume.
 */
int
volume_readinbuf(volume * vol,void* buf, long block)
{
	UInt16 blksize_bits;
	ASSERT( block < vol->maxblocks);

	blksize_bits = vol->blksize_bits;
	block	+= vol->startblock;
	if( os_seek(vol->os_fd, block, blksize_bits) == block)
		if( 1 == os_read(vol->os_fd, buf, 1, blksize_bits))
			return 0;
	return -1;
}
Esempio n. 8
0
bool system_identifier_read(system_identifier_t *system_id)
{
	os_read(system_id->os, sizeof(system_id->os));
	system_serial_read(system_id->system, sizeof(system_id->system));
	chassis_serial_read(system_id->chassis, sizeof(system_id->chassis));
	baseboard_serial_read(system_id->baseboard, sizeof(system_id->baseboard));

	unsigned char mac[6];
	mac_read(mac, sizeof(mac));
	sha1_calc(mac, sizeof(mac), system_id->mac, sizeof(system_id->mac));

	return true;
}
Esempio n. 9
0
/*
 * Read into buffer until a newline is found.
 * Note: searches any existing data in the buffer, so discard
 * any previously processed data before calling.
 * Returns offset of newline, or 0 if buffer is full before found.
 */
static ssize_t os_getline(output_section_t *os)
{
	size_t len = 0;
	char *p;

	for (;;) {
		p = memchr(os->buf + len, '\n', os->len - len);
		if (p)
			return p - os->buf + 1;
		len = os->len;
		if (os_read(os) <= 0)
			return 0;
	}
}
Esempio n. 10
0
bool
module_file_has_module_header(const char *filename)
{
    bool res = false;
    struct mach_header hdr;
    file_t fd = os_open(filename, OS_OPEN_READ);
    if (fd == INVALID_FILE)
        return false;
    if (os_read(fd, &hdr, sizeof(hdr)) == sizeof(hdr) &&
        is_macho_header((app_pc)&hdr, sizeof(hdr)))
        res = true;
    os_close(fd);
    return res;
}
Esempio n. 11
0
static int server_read( u8 *p )
{
  int fd;
  u32 count;
  
  log_msg( "server_read: request handler starting\n" );
  if( remotefs_read_read_request( p, &fd, &count ) == ELUARPC_ERR )
  {
    log_msg( "server_read: unable to read request\n" );
    return SERVER_ERR;
  }
  log_msg( "server_read: fd = %d, count = %u\n", fd, ( unsigned )count );
  count = ( u32 )os_read( fd, p + ELUARPC_READ_BUF_OFFSET, count );
  log_msg( "server_read: OS response is %u\n", ( unsigned )count );
  remotefs_read_write_response( p, count );
  return SERVER_OK;
}
Esempio n. 12
0
static unsigned long host_block_read(int dev, unsigned long start,
				     lbaint_t blkcnt, void *buffer)
{
	struct host_block_dev *host_dev = find_host_device(dev);

	if (!host_dev)
		return -1;
	if (os_lseek(host_dev->fd,
		     start * host_dev->blk_dev.blksz,
		     OS_SEEK_SET) == -1) {
		printf("ERROR: Invalid position\n");
		return -1;
	}
	ssize_t len = os_read(host_dev->fd, buffer,
			      blkcnt * host_dev->blk_dev.blksz);
	if (len >= 0)
		return len / host_dev->blk_dev.blksz;
	return -1;
}
Esempio n. 13
0
/* Read a file into memory and return a pointer to it */
static int read_file(struct unit_test_state *uts, const char *fname,
		     ulong *addrp)
{
	int buf_size = 100000;
	ulong addr = 0;
	int size, fd;
	char *buf;

	buf = map_sysmem(addr, 0);
	ut_assert(buf != NULL);
	fd = os_open(fname, OS_O_RDONLY);
	ut_assert(fd >= 0);
	size = os_read(fd, buf, buf_size);
	ut_assert(size >= 0);
	ut_assert(size < buf_size);
	os_close(fd);
	*addrp = addr;

	return 0;
}
Esempio n. 14
0
long sandbox_fs_read_at(const char *filename, unsigned long pos,
			     void *buffer, unsigned long maxsize)
{
	ssize_t size;
	int fd, ret;

	fd = os_open(filename, OS_O_RDONLY);
	if (fd < 0)
		return fd;
	ret = os_lseek(fd, pos, OS_SEEK_SET);
	if (ret == -1) {
		os_close(fd);
		return ret;
	}
	if (!maxsize)
		maxsize = os_get_filesize(filename);
	size = os_read(fd, buffer, maxsize);
	os_close(fd);

	return size;
}
Esempio n. 15
0
int sandbox_read_fdt_from_file(void)
{
	struct sandbox_state *state = state_get_current();
	const char *fname = state->fdt_fname;
	void *blob;
	loff_t size;
	int err;
	int fd;

	blob = map_sysmem(CONFIG_SYS_FDT_LOAD_ADDR, 0);
	if (!state->fdt_fname) {
		err = fdt_create_empty_tree(blob, 256);
		if (!err)
			goto done;
		printf("Unable to create empty FDT: %s\n", fdt_strerror(err));
		return -EINVAL;
	}

	err = os_get_filesize(fname, &size);
	if (err < 0) {
		printf("Failed to file FDT file '%s'\n", fname);
		return err;
	}
	fd = os_open(fname, OS_O_RDONLY);
	if (fd < 0) {
		printf("Failed to open FDT file '%s'\n", fname);
		return -EACCES;
	}
	if (os_read(fd, blob, size) != size) {
		os_close(fd);
		return -EIO;
	}
	os_close(fd);

done:
	gd->fdt_blob = blob;

	return 0;
}
Esempio n. 16
0
s32 FFS_Config_Load(struct ffsConfigState *cfg)
{
	s32 fd, ret;

#ifdef DEBUG
	svc_write("DIP: Config_Load(): Loading config file ");
	svc_write(__ffs_cfg_filename);
	svc_write("\n");
#endif

	/* Open config file */
	fd = os_open(__ffs_cfg_filename, ISFS_OPEN_READ);

#ifdef DEBUG
	svc_write("DIP: Config_Load(): Config file ");
	svc_write(fd < 0 ? "NOT found\n" : "found\n");
#endif

	if (fd < 0)
		return fd;
                    
	/* Read config */
	ret = os_read(fd, cfg, sizeof(struct ffsConfigState));
	if (ret != sizeof(struct ffsConfigState)) {
#ifdef DEBUG
		svc_write("DIP: Config_Load(): Config file has unexpected size!!!\n");
#endif
		ret = -1;
	}

	/* Close config */
	os_close(fd);

	/* Delete config file */
	__Config_Delete(__ffs_cfg_filename);

	return ret;
}
Esempio n. 17
0
static int state_read_file(struct sandbox_state *state, const char *fname)
{
    loff_t size;
    int ret;
    int fd;

    ret = os_get_filesize(fname, &size);
    if (ret < 0) {
        printf("Cannot find sandbox state file '%s'\n", fname);
        return ret;
    }
    state->state_fdt = os_malloc(size);
    if (!state->state_fdt) {
        puts("No memory to read sandbox state\n");
        return -ENOMEM;
    }
    fd = os_open(fname, OS_O_RDONLY);
    if (fd < 0) {
        printf("Cannot open sandbox state file '%s'\n", fname);
        ret = -EPERM;
        goto err_open;
    }
    if (os_read(fd, state->state_fdt, size) != size) {
        printf("Cannot read sandbox state file '%s'\n", fname);
        ret = -EIO;
        goto err_read;
    }
    os_close(fd);

    return 0;
err_read:
    os_close(fd);
err_open:
    os_free(state->state_fdt);
    state->state_fdt = NULL;

    return ret;
}
Esempio n. 18
0
int sandbox_fs_read_at(const char *filename, loff_t pos, void *buffer,
		       loff_t maxsize, loff_t *actread)
{
	loff_t size;
	int fd, ret;

	fd = os_open(filename, OS_O_RDONLY);
	if (fd < 0)
		return fd;
	ret = os_lseek(fd, pos, OS_SEEK_SET);
	if (ret == -1) {
		os_close(fd);
		return ret;
	}
	if (!maxsize) {
		ret = os_get_filesize(filename, &size);
		if (ret) {
			os_close(fd);
			return ret;
		}

		maxsize = size;
	}

	size = os_read(fd, buffer, maxsize);
	os_close(fd);

	if (size < 0) {
		ret = -1;
	} else {
		ret = 0;
		*actread = size;
	}

	return ret;
}
Esempio n. 19
0
int 
main(int argc, char *argv[])
{
	int listenfd;
	int connfd;
	int on = 1;
	struct sockaddr_in serv_addr, cli_addr;
	socklen_t cli_len;
	int client_fd[FD_SETSIZE];/* each for every client  */
	fd_set allset; /* save interested descriptors */
	fd_set rdset; /* select on this set */
	int maxfd;
	int max_indx; /* max index in client_fd[] array */
	int i, n;
	int nready;
	char buf[MAXLINE];

	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr, "socket error: %s\n", strerror(errno));
		exit(1);
	}

	os_setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	bzero(&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(SERV_PORT);

	if (bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
		fprintf(stderr, "bind error: %s\n", strerror(errno));
		exit(1);
	}
	
	if (listen(listenfd,  LISTEN_QUEUE) < 0) {
		fprintf(stderr, "listern error: %s\n", strerror(errno));
		exit(1);
	}

	for (i=0; i < FD_SETSIZE; i++)
		client_fd[i] = -1;
	
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
	maxfd = listenfd;
	max_indx = 0;
	for (; ;) {
		rdset = allset;
		nready  = os_select(maxfd + 1, &rdset, NULL, NULL, NULL); /* select will modify rdset once return */

		/* task 1: listen... accept new connection */
		if(FD_ISSET(listenfd, &rdset)) {
			cli_len = sizeof(cli_addr);
			connfd = os_accept(listenfd, (struct sockaddr *)&cli_addr, &cli_len);

			for (i=0; i < FD_SETSIZE; i++) { /* a new client coming, select a useable fd */
				if (client_fd[i] == -1) {
					client_fd[i] = connfd;
					maxfd = (connfd > maxfd) ? connfd : maxfd;
					break;
				}
			}
			FD_SET(connfd, &allset);
			if (i > max_indx)
				max_indx = i;
			if (--nready <= 0)
				continue;  /* no more readable descriptors */
		}
		
		/* task 2: deal with all  clients' data  */
		for (i=0; i < maxfd; i++) {
			if (client_fd[i] == -1)
				continue;
			if (FD_ISSET(client_fd[i], &rdset)) {
				if ((n = os_read(client_fd[i], buf, MAXLINE)) == 0) {
					close(client_fd[i]);
					FD_CLR(client_fd[i], &allset);
					client_fd[i] = -1;
				}
				else {
#ifdef DEBUG
					os_write(fileno(stdout), buf, n);
#endif
					os_write(client_fd[i], buf, n);
				}
			}
			if (--nready <= 0)
				break;  /* no more readable descriptors */
		}
#if 0

		cli_len = sizeof(cli_addr);
	    if ((connfd = accept(listenfd, (struct sockaddr *)&cli_addr, &cli_len)) < 0) {
			if (errno == EINTR)
				continue;
			else
				os_err_sys("accept error");
		}

			
		if ((childpid = fork()) == 0) {
			close(listenfd);
			echo_string(connfd);
			exit(1);
		}
		close(connfd);
#endif
	}
	return 0;
}
Esempio n. 20
0
s32   FFS_Read(s32 fd, void *d, s32 len)
{
	return os_read(fd, d, len);
}
Esempio n. 21
0
int cgi_extract_sections(output_buffer_function *writer)
{
	int content_length;
	const char *p;
	char *boundary;
	int boundary_length;
	int match;
	output_section_t os;

	p = getenv("REQUEST_METHOD");
	if (!p || strcmp(p, "POST") != 0) {
		syslog(LOG_WARNING, "cgi_filefetch not POST");
		return(CGIPARSE_ERR_FORMAT);
	}

	p = getenv("CONTENT_LENGTH");
	if (!p || ((content_length = atoi(p)) == 0)) {
		syslog(LOG_WARNING, "cgi_filefetch bad content length");
		return(CGIPARSE_ERR_DATA);
	}

	p = getenv("CONTENT_TYPE");
	if (!p || strncmp(p, MULTIPART_FORM_DATA, sizeof(MULTIPART_FORM_DATA) - 1) != 0) {
		syslog(LOG_WARNING, "cgi_filefetch not type: %s", MULTIPART_FORM_DATA);
		return(CGIPARSE_ERR_DATA);
	}

	/* Now search for boundary=XXX */
	p = strstr(p, "boundary=");
	if (!p) {
		syslog(LOG_WARNING, "cgi_filefetch bad or missing boundary specification");
		return(CGIPARSE_ERR_DATA);
	}
	p = strchr(p, '=') + 1;
	debug("Got boundary=[%s]\n", p);

	/* Now search for --<boundary>
	 * Note that we don't search for \r\n--<boundary> since
	 * sometimes?? the first \r\n is missing
	 */

	boundary_length = strlen(p) + 2;
	boundary = alloca(boundary_length + 1);
	sprintf(boundary, "--%s", p);

	os.timeout = 0;
	os.len = 0;
	os.pos = 0;
	os.consumed = 0;
	os.in_section = 0;
	os.writer = writer;

	set_nonblock(0);

	/* Now iterate through each item separated by the boundary */
	while ((match = KMP(boundary, boundary_length, getter_section, &os)) >= 0) {
		debug("Found match at %d\n", match - boundary_length);

		/* Flush all the bytes up until the match. */
		os.consumed = os.len - (os.pos - match);
		if (os.in_section) {
			/* We have been outputting this section. Back up by the boundary length
			 * (plus 2 for the \r\n) and flush the buffer
			 */
			debug("reached end of section, match=%d, os.len=%d, os.pos=%d, boundary_length=%d\n", match, (int)os.len, (int)os.pos, boundary_length);
			assert(os.consumed >= boundary_length + 2);
			os.writer(os.name, os.content_type, os.buf,
					os.consumed - boundary_length - 2,
					os.pos - os.len);
		}
		os_discard(&os, os.consumed);
		os.consumed = 0;

		while (os.len < 2)
			if (os_read(&os) <= 0)
				goto err;
		char ch1 = os.buf[0];
		char ch2 = os.buf[1];
		os_discard(&os, 2);

		if (ch1 == '\r' && ch2 == '\n') {
			/* we are at a boundary, so process this section */
			if (process_section(&os) <= 0)
				goto err;
		}
		else if (ch1 == '-' && ch2 == '-') {
			debug("This is the last section\n");
			return CGIPARSE_ERR_NONE;
		}
		else {
			debug("Warning: Ignoring section with unknown terminator: '%c%c'\n", ch1, ch2);
		}
		os.pos = os.len;
	}

err:
	if (os.timeout) {
		return CGIPARSE_ERR_TIMEDOUT;
	} else {
		return CGIPARSE_ERR_DATA;
	}
}
Esempio n. 22
0
bool
memquery_iterator_next(memquery_iter_t *iter)
{
    maps_iter_t *mi = (maps_iter_t *) &iter->internal;
    char perm[16];
    char *line;
    int len;
    app_pc prev_start = iter->vm_start;
    ASSERT((iter->may_alloc && OWN_MUTEX(&maps_iter_buf_lock)) ||
           (!iter->may_alloc && OWN_MUTEX(&memory_info_buf_lock)));
    if (mi->newline == NULL) {
        mi->bufwant = BUFSIZE-1;
        mi->bufread = os_read(mi->maps, mi->buf, mi->bufwant);
        ASSERT(mi->bufread <= mi->bufwant);
        LOG(GLOBAL, LOG_VMAREAS, 6,
            "get_memory_info_from_os: bytes read %d/want %d\n",
            mi->bufread, mi->bufwant);
        if (mi->bufread <= 0)
            return false;
        mi->buf[mi->bufread] = '\0';
        mi->newline = strchr(mi->buf, '\n');
        line = mi->buf;
    } else {
        line = mi->newline + 1;
        mi->newline = strchr(line, '\n');
        if (mi->newline == NULL) {
            /* FIXME clean up: factor out repetitive code */
            /* shift 1st part of line to start of buf, then read in rest */
            /* the memory for the processed part can be reused  */
            mi->bufwant = line - mi->buf;
            ASSERT(mi->bufwant <= mi->bufread);
            len = mi->bufread - mi->bufwant; /* what is left from last time */
            /* since strings may overlap, should use memmove, not strncpy */
            /* FIXME corner case: if len == 0, nothing to move */
            memmove(mi->buf, line, len);
            mi->bufread = os_read(mi->maps, mi->buf+len, mi->bufwant);
            ASSERT(mi->bufread <= mi->bufwant);
            if (mi->bufread <= 0)
                return false;
            mi->bufread += len; /* bufread is total in buf */
            mi->buf[mi->bufread] = '\0';
            mi->newline = strchr(mi->buf, '\n');
            line = mi->buf;
        }
    }
    LOG(GLOBAL, LOG_VMAREAS, 6,
        "\nget_memory_info_from_os: newline=[%s]\n",
        mi->newline ? mi->newline : "(null)");

    /* Buffer is big enough to hold at least one line: if not, the file changed
     * underneath us after we hit the end.  Just bail.
     */
    if (mi->newline == NULL)
        return false;
    *mi->newline = '\0';
    LOG(GLOBAL, LOG_VMAREAS, 6,
        "\nget_memory_info_from_os: line=[%s]\n", line);
    mi->comment_buffer[0]='\0';
    len = sscanf(line,
#ifdef IA32_ON_IA64
                 MAPS_LINE_FORMAT8, /* cross-compiling! */
#else
                 sizeof(void*) == 4 ? MAPS_LINE_FORMAT4 : MAPS_LINE_FORMAT8,
#endif
                 (unsigned long*)&iter->vm_start, (unsigned long*)&iter->vm_end,
                 perm, (unsigned long*)&iter->offset, &iter->inode,
                 mi->comment_buffer);
    if (iter->vm_start == iter->vm_end) {
        /* i#366 & i#599: Merge an empty regions caused by stack guard pages
         * into the stack region if the stack region is less than one page away.
         * Otherwise skip it.  Some Linux kernels (2.6.32 has been observed)
         * have empty entries for the stack guard page.  We drop the permissions
         * on the guard page, because Linux always insists that it has rwxp
         * perms, no matter how we change the protections.  The actual stack
         * region has the perms we expect.
         * XXX: We could get more accurate info if we looked at
         * /proc/self/smaps, which has a Size: 4k line for these "empty"
         * regions.
         */
        app_pc empty_start = iter->vm_start;
        bool r;
        LOG(GLOBAL, LOG_VMAREAS, 2,
            "maps_iterator_next: skipping or merging empty region 0x%08x\n",
            iter->vm_start);
        /* don't trigger the maps-file-changed check.
         * slight risk of a race where we'll pass back earlier/overlapping
         * region: we'll live with it.
         */
        iter->vm_start = NULL;
        r = memquery_iterator_next(iter);
        /* We could check to see if we're combining with the [stack] section,
         * but that doesn't work if there are multiple stacks or the stack is
         * split into multiple maps entries, so we merge any empty region within
         * one page of the next region.
         */
        if (empty_start <= iter->vm_start &&
            iter->vm_start <= empty_start + PAGE_SIZE) {
            /* Merge regions if the next region was zero or one page away. */
            iter->vm_start = empty_start;
        }
        return r;
    }
    if (iter->vm_start <= prev_start) {
        /* the maps file has expanded underneath us (presumably due to our
         * own committing while iterating): skip ahead */
        LOG(GLOBAL, LOG_VMAREAS, 2,
            "maps_iterator_next: maps file changed: skipping 0x%08x\n", prev_start);
        iter->vm_start = prev_start;
        return memquery_iterator_next(iter);
    }
    if (len<6)
        mi->comment_buffer[0]='\0';
    iter->prot = permstr_to_memprot(perm);
#ifdef ANDROID
    /* i#1861: the Android kernel supports custom comments which can't merge */
    if (iter->comment[0] != '\0')
        iter->prot |= MEMPROT_HAS_COMMENT;
#endif
    return true;
}
Esempio n. 23
0
static int sandbox_sf_xfer(void *priv, const u8 *rx, u8 *tx,
		uint bytes)
{
	struct sandbox_spi_flash *sbsf = priv;
	uint cnt, pos = 0;
	int ret;

	debug("sandbox_sf: state:%x(%s) bytes:%u\n", sbsf->state,
	      sandbox_sf_state_name(sbsf->state), bytes);

	if (sbsf->state == SF_CMD) {
		/* Figure out the initial state */
		if (sandbox_sf_process_cmd(sbsf, rx, tx))
			return 1;
		++pos;
	}

	/* Process the remaining data */
	while (pos < bytes) {
		switch (sbsf->state) {
		case SF_ID: {
			u8 id;

			debug(" id: off:%u tx:", sbsf->off);
			if (sbsf->off < IDCODE_LEN)
				id = sbsf->data->idcode[sbsf->off];
			else
				id = 0;
			debug("%02x\n", id);
			tx[pos++] = id;
			++sbsf->off;
			break;
		}
		case SF_ADDR:
			debug(" addr: bytes:%u rx:%02x ", sbsf->addr_bytes,
			      rx[pos]);

			if (sbsf->addr_bytes++ < SF_ADDR_LEN)
				sbsf->off = (sbsf->off << 8) | rx[pos];
			debug("addr:%06x\n", sbsf->off);

			sandbox_spi_tristate(&tx[pos++], 1);

			/* See if we're done processing */
			if (sbsf->addr_bytes <
					SF_ADDR_LEN + sbsf->pad_addr_bytes)
				break;

			/* Next state! */
			if (os_lseek(sbsf->fd, sbsf->off, OS_SEEK_SET) < 0) {
				puts("sandbox_sf: os_lseek() failed");
				return 1;
			}
			switch (sbsf->cmd) {
			case CMD_READ_ARRAY_FAST:
			case CMD_READ_ARRAY_SLOW:
				sbsf->state = SF_READ;
				break;
			case CMD_PAGE_PROGRAM:
				sbsf->state = SF_WRITE;
				break;
			default:
				/* assume erase state ... */
				sbsf->state = SF_ERASE;
				goto case_sf_erase;
			}
			debug(" cmd: transition to %s state\n",
			      sandbox_sf_state_name(sbsf->state));
			break;
		case SF_READ:
			/*
			 * XXX: need to handle exotic behavior:
			 *      - reading past end of device
			 */

			cnt = bytes - pos;
			debug(" tx: read(%u)\n", cnt);
			ret = os_read(sbsf->fd, tx + pos, cnt);
			if (ret < 0) {
				puts("sandbox_spi: os_read() failed\n");
				return 1;
			}
			pos += ret;
			break;
		case SF_READ_STATUS:
			debug(" read status: %#x\n", sbsf->status);
			cnt = bytes - pos;
			memset(tx + pos, sbsf->status, cnt);
			pos += cnt;
			break;
		case SF_READ_STATUS1:
			debug(" read status: %#x\n", sbsf->status);
			cnt = bytes - pos;
			memset(tx + pos, sbsf->status >> 8, cnt);
			pos += cnt;
			break;
		case SF_WRITE:
			/*
			 * XXX: need to handle exotic behavior:
			 *      - unaligned addresses
			 *      - more than a page (256) worth of data
			 *      - reading past end of device
			 */
			if (!(sbsf->status & STAT_WEL)) {
				puts("sandbox_sf: write enable not set before write\n");
				goto done;
			}

			cnt = bytes - pos;
			debug(" rx: write(%u)\n", cnt);
			sandbox_spi_tristate(&tx[pos], cnt);
			ret = os_write(sbsf->fd, rx + pos, cnt);
			if (ret < 0) {
				puts("sandbox_spi: os_write() failed\n");
				return 1;
			}
			pos += ret;
			sbsf->status &= ~STAT_WEL;
			break;
		case SF_ERASE:
 case_sf_erase: {
			const struct sandbox_spi_flash_erase_commands *
						erase_cmd = sbsf->cmd_data;

			if (!(sbsf->status & STAT_WEL)) {
				puts("sandbox_sf: write enable not set before erase\n");
				goto done;
			}

			/* verify address is aligned */
			if (sbsf->off & (erase_cmd->size - 1)) {
				debug(" sector erase: cmd:%#x needs align:%#x, but we got %#x\n",
				      erase_cmd->cmd, erase_cmd->size,
				      sbsf->off);
				sbsf->status &= ~STAT_WEL;
				goto done;
			}

			debug(" sector erase addr: %u\n", sbsf->off);

			cnt = bytes - pos;
			sandbox_spi_tristate(&tx[pos], cnt);
			pos += cnt;

			/*
			 * TODO([email protected]): latch WIP in status, and
			 * delay before clearing it ?
			 */
			ret = sandbox_erase_part(sbsf, erase_cmd->size);
			sbsf->status &= ~STAT_WEL;
			if (ret) {
				debug("sandbox_sf: Erase failed\n");
				goto done;
			}
			goto done;
		}
		default:
			debug(" ??? no idea what to do ???\n");
			goto done;
		}
	}

 done:
	return pos == bytes ? 0 : 1;
}
Esempio n. 24
0
static int sandbox_sf_xfer(struct udevice *dev, unsigned int bitlen,
			   const void *rxp, void *txp, unsigned long flags)
{
	struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
	const uint8_t *rx = rxp;
	uint8_t *tx = txp;
	uint cnt, pos = 0;
	int bytes = bitlen / 8;
	int ret;

	debug("sandbox_sf: state:%x(%s) bytes:%u\n", sbsf->state,
	      sandbox_sf_state_name(sbsf->state), bytes);

	if ((flags & SPI_XFER_BEGIN))
		sandbox_sf_cs_activate(dev);

	if (sbsf->state == SF_CMD) {
		/* Figure out the initial state */
		ret = sandbox_sf_process_cmd(sbsf, rx, tx);
		if (ret)
			return ret;
		++pos;
	}

	/* Process the remaining data */
	while (pos < bytes) {
		switch (sbsf->state) {
		case SF_ID: {
			u8 id;

			debug(" id: off:%u tx:", sbsf->off);
			if (sbsf->off < IDCODE_LEN) {
				/* Extract correct byte from ID 0x00aabbcc */
				id = sbsf->data->jedec >>
					(8 * (IDCODE_LEN - 1 - sbsf->off));
			} else {
				id = 0;
			}
			debug("%d %02x\n", sbsf->off, id);
			tx[pos++] = id;
			++sbsf->off;
			break;
		}
		case SF_ADDR:
			debug(" addr: bytes:%u rx:%02x ", sbsf->addr_bytes,
			      rx[pos]);

			if (sbsf->addr_bytes++ < SF_ADDR_LEN)
				sbsf->off = (sbsf->off << 8) | rx[pos];
			debug("addr:%06x\n", sbsf->off);

			if (tx)
				sandbox_spi_tristate(&tx[pos], 1);
			pos++;

			/* See if we're done processing */
			if (sbsf->addr_bytes <
					SF_ADDR_LEN + sbsf->pad_addr_bytes)
				break;

			/* Next state! */
			if (os_lseek(sbsf->fd, sbsf->off, OS_SEEK_SET) < 0) {
				puts("sandbox_sf: os_lseek() failed");
				return -EIO;
			}
			switch (sbsf->cmd) {
			case CMD_READ_ARRAY_FAST:
			case CMD_READ_ARRAY_SLOW:
				sbsf->state = SF_READ;
				break;
			case CMD_PAGE_PROGRAM:
				sbsf->state = SF_WRITE;
				break;
			default:
				/* assume erase state ... */
				sbsf->state = SF_ERASE;
				goto case_sf_erase;
			}
			debug(" cmd: transition to %s state\n",
			      sandbox_sf_state_name(sbsf->state));
			break;
		case SF_READ:
			/*
			 * XXX: need to handle exotic behavior:
			 *      - reading past end of device
			 */

			cnt = bytes - pos;
			debug(" tx: read(%u)\n", cnt);
			assert(tx);
			ret = os_read(sbsf->fd, tx + pos, cnt);
			if (ret < 0) {
				puts("sandbox_sf: os_read() failed\n");
				return -EIO;
			}
			pos += ret;
			break;
		case SF_READ_STATUS:
			debug(" read status: %#x\n", sbsf->status);
			cnt = bytes - pos;
			memset(tx + pos, sbsf->status, cnt);
			pos += cnt;
			break;
		case SF_READ_STATUS1:
			debug(" read status: %#x\n", sbsf->status);
			cnt = bytes - pos;
			memset(tx + pos, sbsf->status >> 8, cnt);
			pos += cnt;
			break;
		case SF_WRITE_STATUS:
			debug(" write status: %#x (ignored)\n", rx[pos]);
			pos = bytes;
			break;
		case SF_WRITE:
			/*
			 * XXX: need to handle exotic behavior:
			 *      - unaligned addresses
			 *      - more than a page (256) worth of data
			 *      - reading past end of device
			 */
			if (!(sbsf->status & STAT_WEL)) {
				puts("sandbox_sf: write enable not set before write\n");
				goto done;
			}

			cnt = bytes - pos;
			debug(" rx: write(%u)\n", cnt);
			if (tx)
				sandbox_spi_tristate(&tx[pos], cnt);
			ret = os_write(sbsf->fd, rx + pos, cnt);
			if (ret < 0) {
				puts("sandbox_spi: os_write() failed\n");
				return -EIO;
			}
			pos += ret;
			sbsf->status &= ~STAT_WEL;
			break;
		case SF_ERASE:
 case_sf_erase: {
			if (!(sbsf->status & STAT_WEL)) {
				puts("sandbox_sf: write enable not set before erase\n");
				goto done;
			}

			/* verify address is aligned */
			if (sbsf->off & (sbsf->erase_size - 1)) {
				debug(" sector erase: cmd:%#x needs align:%#x, but we got %#x\n",
				      sbsf->cmd, sbsf->erase_size,
				      sbsf->off);
				sbsf->status &= ~STAT_WEL;
				goto done;
			}

			debug(" sector erase addr: %u, size: %u\n", sbsf->off,
			      sbsf->erase_size);

			cnt = bytes - pos;
			if (tx)
				sandbox_spi_tristate(&tx[pos], cnt);
			pos += cnt;

			/*
			 * TODO([email protected]): latch WIP in status, and
			 * delay before clearing it ?
			 */
			ret = sandbox_erase_part(sbsf, sbsf->erase_size);
			sbsf->status &= ~STAT_WEL;
			if (ret) {
				debug("sandbox_sf: Erase failed\n");
				goto done;
			}
			goto done;
		}
		default:
			debug(" ??? no idea what to do ???\n");
			goto done;
		}
Esempio n. 25
0
static int sandbox_flash_bulk(struct udevice *dev, struct usb_device *udev,
			      unsigned long pipe, void *buff, int len)
{
	struct sandbox_flash_plat *plat = dev_get_platdata(dev);
	struct sandbox_flash_priv *priv = dev_get_priv(dev);
	int ep = usb_pipeendpoint(pipe);
	struct umass_bbb_cbw *cbw = buff;

	debug("%s: dev=%s, pipe=%lx, ep=%x, len=%x, phase=%d\n", __func__,
	      dev->name, pipe, ep, len, priv->phase);
	switch (ep) {
	case SANDBOX_FLASH_EP_OUT:
		switch (priv->phase) {
		case PHASE_START:
			priv->alloc_len = 0;
			priv->read_len = 0;
			if (priv->error || len != UMASS_BBB_CBW_SIZE ||
			    cbw->dCBWSignature != CBWSIGNATURE)
				goto err;
			if ((cbw->bCBWFlags & CBWFLAGS_SBZ) ||
			    cbw->bCBWLUN != 0)
				goto err;
			if (cbw->bCDBLength < 1 || cbw->bCDBLength >= 0x10)
				goto err;
			priv->transfer_len = cbw->dCBWDataTransferLength;
			priv->tag = cbw->dCBWTag;
			return handle_ufi_command(plat, priv, cbw->CBWCDB,
						  cbw->bCDBLength);
		case PHASE_DATA:
			debug("data out\n");
			break;
		default:
			break;
		}
	case SANDBOX_FLASH_EP_IN:
		switch (priv->phase) {
		case PHASE_DATA:
			debug("data in, len=%x, alloc_len=%x, priv->read_len=%x\n",
			      len, priv->alloc_len, priv->read_len);
			if (priv->read_len) {
				ulong bytes_read;

				bytes_read = os_read(priv->fd, buff, len);
				if (bytes_read != len)
					return -EIO;
				priv->read_len -= len / SANDBOX_FLASH_BLOCK_LEN;
				if (!priv->read_len)
					priv->phase = PHASE_STATUS;
			} else {
				if (priv->alloc_len && len > priv->alloc_len)
					len = priv->alloc_len;
				memcpy(buff, priv->buff, len);
				priv->phase = PHASE_STATUS;
			}
			return len;
		case PHASE_STATUS:
			debug("status in, len=%x\n", len);
			if (len > sizeof(priv->status))
				len = sizeof(priv->status);
			memcpy(buff, &priv->status, len);
			priv->phase = PHASE_START;
			return len;
		default:
			break;
		}
	}
err:
	priv->error = true;
	debug("%s: Detected transfer error\n", __func__);
	return 0;
}