Example #1
0
void
wr_fin(void)
{
	if (bufpt > buf) {
		memset(bufpt, 0, bufend - bufpt);
		bufpt = bufend;
		(void)buf_flush(blksz);
	}
}
Example #2
0
INLINE
void outputconst(buffer_unit_t w, size_t bits)
{
  if (buf_writeconst(outbuf_ptr, w, bits))
  {
    if (outbuf_stack.size == 0)
    {
      buf_flush(outbuf_ptr);
    }
  }
}
Example #3
0
/* Flush a compression buffer.  */
static int
compress_buffer_flush (void *closure)
{
    struct compress_buffer *cb = closure;

    /* This is only used within the while loop below, but allocated here for
     * efficiency.
     */
    static char *buffer = NULL;
    if (!buffer)
	buffer = pagealign_xalloc (BUFFER_DATA_SIZE);

    cb->zstr.avail_in = 0;
    cb->zstr.next_in = NULL;

    while (1)
    {
	int zstatus;

	cb->zstr.avail_out = BUFFER_DATA_SIZE;
	cb->zstr.next_out = (unsigned char *) buffer;

	zstatus = deflate (&cb->zstr, Z_SYNC_FLUSH);

	/* The deflate function will return Z_BUF_ERROR if it can't do
           anything, which in this case means that all data has been
           flushed.  */
	if (zstatus == Z_BUF_ERROR)
	    break;

	if (zstatus != Z_OK)
	{
	    compress_error (0, zstatus, &cb->zstr, "deflate flush");
	    return EIO;
	}

	if (cb->zstr.avail_out != BUFFER_DATA_SIZE)
	    buf_output (cb->buf, buffer,
			BUFFER_DATA_SIZE - cb->zstr.avail_out);

	/* If the deflate function did not fill the output buffer,
           then all data has been flushed.  */
	if (cb->zstr.avail_out > 0)
	    break;
    }

    /* Now flush the underlying buffer.  Note that if the original
       call to buf_flush passed 1 for the BLOCK argument, then the
       buffer will already have been set into blocking mode, so we
       should always pass 0 here.  */
    return buf_flush (cb->buf, 0);
}
Example #4
0
void flush_outbuf()
{
  if (outbuf.bitpos % BUFFER_UNIT_BITS != 0)
  {
    outputconst(0, BUFFER_UNIT_BITS);
  }
  if (outbuf_stack.size > 0)
  {
    fprintf(stderr, "Error: buffer stack ended non-empty\n");
    exit(1);
  }
  buf_flush(&outbuf);
}
Example #5
0
void buf_add(unsigned int type, char* str)
{
    int i;
    if (buf_type != type)
        buf_flush();
    buf_type = type;
    for (i = 0; i < 100; i++) {
        if (strcmp(text[i], "") == 0) {
            strcpy(text[i], str);
            break;
        }
    }
}
Example #6
0
int
wr_skip(off_t skcnt)
{
	int cnt;

	/*
	 * loop while there is more padding to add
	 */
	while (skcnt > 0L) {
		cnt = bufend - bufpt;
		if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0))
			return(-1);
		cnt = MIN(cnt, skcnt);
		memset(bufpt, 0, cnt);
		bufpt += cnt;
		skcnt -= cnt;
	}
	return(0);
}
Example #7
0
/* Shut down an output buffer.  */
static int
compress_buffer_shutdown_output (struct buffer *buf)
{
    struct compress_buffer *cb = buf->closure;
    int zstatus, status;

    /* This is only used within the while loop below, but allocated here for
     * efficiency.
     */
    static char *buffer = NULL;
    if (!buffer)
	buffer = pagealign_xalloc (BUFFER_DATA_SIZE);

    do
    {
	cb->zstr.avail_out = BUFFER_DATA_SIZE;
	cb->zstr.next_out = (unsigned char *) buffer;

	zstatus = deflate (&cb->zstr, Z_FINISH);
	if (zstatus != Z_OK && zstatus != Z_STREAM_END)
	{
	    compress_error (0, zstatus, &cb->zstr, "deflate finish");
	    return EIO;
	}

	if (cb->zstr.avail_out != BUFFER_DATA_SIZE)
	    buf_output (cb->buf, buffer,
			BUFFER_DATA_SIZE - cb->zstr.avail_out);
    } while (zstatus != Z_STREAM_END);

    zstatus = deflateEnd (&cb->zstr);
    if (zstatus != Z_OK)
    {
	compress_error (0, zstatus, &cb->zstr, "deflateEnd");
	return EIO;
    }

    status = buf_flush (cb->buf, 1);
    if (status != 0)
	return status;

    return buf_shutdown (cb->buf);
}
Example #8
0
int
wr_rdfile(ARCHD *arcn, int ifd, off_t *left)
{
	int cnt;
	int res = 0;
	off_t size = arcn->sb.st_size;
	struct stat sb;

	/*
	 * while there are more bytes to write
	 */
	while (size > 0L) {
		cnt = bufend - bufpt;
		if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0)) {
			*left = size;
			return(-1);
		}
		cnt = MIN(cnt, size);
		if ((res = read(ifd, bufpt, cnt)) <= 0)
			break;
		size -= res;
		bufpt += res;
	}

	/*
	 * better check the file did not change during this operation
	 * or the file read failed.
	 */
	if (res < 0)
		syswarn(1, errno, "Read fault on %s", arcn->org_name);
	else if (size != 0L)
		paxwarn(1, "File changed size during read %s", arcn->org_name);
	else if (fstat(ifd, &sb) < 0)
		syswarn(1, errno, "Failed stat on %s", arcn->org_name);
	else if (arcn->sb.st_mtime != sb.st_mtime)
		paxwarn(1, "File %s was modified during copy to archive",
			arcn->org_name);
	*left = size;
	return(0);
}
Example #9
0
PRIVATE int buf_free (HTStream * me)
{
    int status = HT_OK;

    /*
    **  If the buffer has not been flushed explicit and we are a pipe buffer
    **  then we don't free it.
    */ 
    if (me->mode & HT_BM_PIPE && me->state != HT_BS_TRANSPARENT) {
	HTTRACE(STREAM_TRACE, "PipeBuffer Waiting to be flushed\n");
	return HT_OK;
    }

    /*
    **  Should we count the content length and assign it to the
    **  anchor?
    */
    if (me->mode & HT_BM_COUNT && me->request) {
	HTParentAnchor * anchor = HTRequest_anchor(me->request);
	HTTRACE(STREAM_TRACE, "Buffer........ Calculated content-length: %d\n" _ me->conlen);
	HTAnchor_setLength(anchor, me->conlen);
    }

    /*
    **  Flush the buffered data - even if we are paused. That is, we always
    **  flush - except if we have already flushed the buffer, of course.
    **  Also, we don't flush if we are a PIPE buffer. Then the flush MUST be
    **  called explicitly and the buffer can not be freed before this 
    **  happens.
    */
    if ((status = buf_flush(me)) != HT_OK)
	return status;
    if ((status = (*me->target->isa->_free)(me->target)) != HT_OK)
	return status;
    HT_FREE(me);
    return status;
}
Example #10
0
int
wr_rdbuf(char *out, int outcnt)
{
	int cnt;

	/*
	 * while there is data to copy copy into the write buffer. when the
	 * write buffer fills, flush it to the archive and continue
	 */
	while (outcnt > 0) {
		cnt = bufend - bufpt;
		if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0))
			return(-1);
		/*
		 * only move what we have space for
		 */
		cnt = MIN(cnt, outcnt);
		memcpy(bufpt, out, cnt);
		bufpt += cnt;
		out += cnt;
		outcnt -= cnt;
	}
	return(0);
}
Example #11
0
static void process_strm(u8_t *pkt, int len) {
	struct strm_packet *strm = (struct strm_packet *)pkt;

	LOG_INFO("strm command %c", strm->command);

	switch(strm->command) {
	case 't':
		sendSTAT("STMt", strm->replay_gain); // STMt replay_gain is no longer used to track latency, but support it
		break;
	case 'q':
		output_flush();
		status.frames_played = 0;
		stream_disconnect();
		sendSTAT("STMf", 0);
		buf_flush(streambuf);
		break;
	case 'f':
		output_flush();
		status.frames_played = 0;
		if (stream_disconnect()) {
			sendSTAT("STMf", 0);
		}
		buf_flush(streambuf);
		break;
	case 'p':
		{
			unsigned interval = unpackN(&strm->replay_gain);
			LOCK_O;
			output.pause_frames = interval * status.current_sample_rate / 1000;
			output.state = interval ? OUTPUT_PAUSE_FRAMES : OUTPUT_STOPPED;				
			UNLOCK_O;
			if (!interval) sendSTAT("STMp", 0);
			LOG_INFO("pause interval: %u", interval);
		}
		break;
	case 'a':
		{
			unsigned interval = unpackN(&strm->replay_gain);
			LOCK_O;
			output.skip_frames = interval * status.current_sample_rate / 1000;
			output.state = OUTPUT_SKIP_FRAMES;				
			UNLOCK_O;
			LOG_INFO("skip ahead interval: %u", interval);
		}
		break;
	case 'u':
		{
			unsigned jiffies = unpackN(&strm->replay_gain);
			LOCK_O;
			output.state = jiffies ? OUTPUT_START_AT : OUTPUT_RUNNING;
			output.start_at = jiffies;
			UNLOCK_O;
			LOCK_D;
			decode.state = DECODE_RUNNING;
			UNLOCK_D;
			LOG_INFO("unpause at: %u now: %u", jiffies, gettime_ms());
			sendSTAT("STMr", 0);
		}
		break;
	case 's':
		{
			unsigned header_len = len - sizeof(struct strm_packet);
			char *header = (char *)(pkt + sizeof(struct strm_packet));
			in_addr_t ip = (in_addr_t)strm->server_ip; // keep in network byte order
			u16_t port = strm->server_port; // keep in network byte order
			if (ip == 0) ip = slimproto_ip; 

			LOG_INFO("strm s autostart: %c transition period: %u transition type: %u", 
					 strm->autostart, strm->transition_period, strm->transition_type - '0');

			autostart = strm->autostart - '0';
			sendSTAT("STMf", 0);
			if (header_len > MAX_HEADER -1) {
				LOG_WARN("header too long: %u", header_len);
				break;
			}
			codec_open(strm->format, strm->pcm_sample_size, strm->pcm_sample_rate, strm->pcm_channels, strm->pcm_endianness);
			if (ip == LOCAL_PLAYER_IP && port == LOCAL_PLAYER_PORT) {
				// extension to slimproto for LocalPlayer - header is filename not http header, don't expect cont
				stream_file(header, header_len, strm->threshold * 1024);
				autostart -= 2;
			} else {
				stream_sock(ip, port, header, header_len, strm->threshold * 1024, autostart >= 2);
			}
			sendSTAT("STMc", 0);
			sentSTMu = sentSTMo = sentSTMl = false;
			LOCK_O;
			output.threshold = strm->output_threshold;
			output.next_replay_gain = unpackN(&strm->replay_gain);
			output.fade_mode = strm->transition_type - '0';
			output.fade_secs = strm->transition_period;
			LOG_INFO("set fade mode: %u", output.fade_mode);
			UNLOCK_O;
		}
		break;
	default:
		LOG_INFO("unhandled strm %c", strm->command);
		break;
	}
}
Example #12
0
PRIVATE int buf_put_block (HTStream * me, const char * b, int l)
{
    /*
    **  If we are in pause mode then don't write anything but return PAUSE.
    **  The upper stream should then respect it and don't write any more data.
    */
    if (me->state == HT_BS_PAUSE) return HT_PAUSE;

    /*
    **  Start handling the incoming data. If we are still buffering then add
    **  it to the buffer. Otherwise just pump it through. Note that we still
    **  count the length - even if we have given up buffering!
    */
    me->conlen += l;
    if (me->state != HT_BS_TRANSPARENT) {

	/*
	**  If there is still room in the existing chunk then fill it up.
	**  Otherwise create a new chunk and add it to the linked list of
	**  chunks. If the buffer fills up then either return HT_PAUSE or
	**  flush it and go transparent.
	*/
	if (me->tmp_buf && me->tmp_max-me->tmp_ind >= l) {     /* Still room */
	    memcpy(me->tmp_buf + me->tmp_ind, b, l);
	    me->tmp_ind += l;
	    return HT_OK;
	} else {

	    /*
	    **  Add the temporary buffer (if any) to the list of chunks
	    */
	    if (me->tmp_buf) append_buf(me);

	    /*
	    **  Find the right size of the next chunk. We increase the size
	    **  exponentially until we reach HT_MAX_BLOCK in order to minimize
	    **  the number of mallocs.
	    */
	    if (me->cur_size < HT_MAX_BLOCK) {
		int newsize = me->cur_size ? me->cur_size : HT_MIN_BLOCK;
		while (l > newsize && newsize < HT_MAX_BLOCK) newsize *= 2;
		me->cur_size = newsize;
	    }

	    if (alloc_new(me, me->cur_size)) {
		/* Buffer could accept the new data */
		memcpy(me->tmp_buf, b, l);
		me->tmp_ind = l;
	    } else if (me->mode & HT_BM_DELAY) {
		/* Buffer ran full and we pause */
		me->state = HT_BS_PAUSE;
		HTTRACE(STREAM_TRACE, "Buffer....... Paused\n");
		return HT_PAUSE;
	    } else {
		/* Buffer ran full and we flush and go transparent */
		int status = buf_flush(me);
		if (status != HT_OK) return status;
	    }
	}
    }

    /*
    **  If we couldn't buffer the data then check whether we should give up
    **  or pause the stream. If we are in transparent mode then put the rest
    **  of the data down the pipe.
    */
    if (me->state == HT_BS_TRANSPARENT) return PUTBLOCK(b, l);
    return HT_OK;
}
Example #13
0
void element_out_without_content(char* tag_name)
{
    buf_flush();
    printf("<%s />\n", tag_name);
}
Example #14
0
void wiki_out(Database* db, char* page_name)
{
    Wiki* wiki_a = wiki_new();
    char* line_a;
    char* c;
    char* p;
    LineMode mode = LINE_MODE_NORMAL;

    wiki_a = db_get_newest_wiki(db, page_name, wiki_a);
    p = wiki_a->content;
    /* FIXME 非効率だけど、安全のために、1行分のバッファに全文の長さを確保する。 */
    line_a = xalloc(sizeof(char) * strlen(wiki_a->content));
    buf_clear();
    while ((strlen(p) != 0)) {
        if ((c = strchr(p, '\n')) != NULL) {
            int len = c - p;
            strncpy(line_a, p, len);
            line_a[len] = '\0';
            p += len + 1;
        } else {
            strcpy(line_a, p);
            p += strlen(p);
        }
        if (mode == LINE_MODE_PRE && strncmp(line_a, "|<", strlen("|<")) != 0) {
            /* LINE_MODE_PRE中は、成形済ブロック */
            buf_add(TYPE_PRE, line_a);
        } else if (mode == LINE_MODE_NORMAL && strncmp(line_a, ">|", strlen(">|")) == 0) {
            /* 成形済ブロック終了 */
            buf_flush();
            mode = LINE_MODE_PRE;
        } else if (mode == LINE_MODE_PRE && strncmp(line_a, "|<", strlen("|<")) == 0) {
            /* 成形済ブロック開始 */
            buf_flush();
            mode = LINE_MODE_NORMAL;
        } else if (strncmp(line_a, "****", strlen("****")) == 0) {
            buf_flush();
            element_out("h6", line_a + strlen("****"));
        } else if (strncmp(line_a, "***", strlen("***")) == 0) {
            buf_flush();
            element_out("h5", line_a + strlen("***"));
        } else if (strncmp(line_a, "**", strlen("**")) == 0) {
            buf_flush();
            element_out("h4", line_a + strlen("**"));
        } else if (strncmp(line_a, "*", strlen("*")) == 0) {
            buf_flush();
            element_out("h3", line_a + strlen("*"));
        } else if (strncmp(line_a, "----", strlen("----")) == 0) {
            buf_flush();
            element_out_without_content("hr");
        } else if (strncmp(line_a, "-", strlen("-")) == 0) {
            buf_add(TYPE_LI, line_a + strlen("-"));
        } else if (strncmp(line_a, "\n", strlen("\n")) == 0) {
            buf_flush();
        } else {
            buf_add(TYPE_TEXT, line_a);
        }
    }
    buf_flush();
    xfree(line_a);
    wiki_free(wiki_a);
}
Example #15
0
/* dumps the in-memory table to a file */
void dump_table(void *table_base, char *out_file, unsigned int file_size)
{
	int fd;
	unsigned int nflows, f_max_entries;
	unsigned int start_time;
	unsigned int offset;
	unsigned int flow_idx;
	struct flow_entry *flow;
	struct flow_entry *flow_table;
	struct pna_log_hdr *log_header;
	struct pna_log_entry *log;
	char buf[BUF_SIZE];
	int buf_idx;

	/* record the current time */
	start_time = time(NULL);

	/* convert into max number of entries */
	f_max_entries = file_size / sizeof(*flow);

	/* open up the output file */
	fd = open(out_file, O_CREAT | O_RDWR);
	if (fd < 0) {
		perror("open out_file");
		return;
	}
	fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
	lseek(fd, sizeof(struct pna_log_hdr), SEEK_SET);

	buf_idx = 0;
	nflows = 0;

	flow_table = (struct flow_entry*)table_base;

	/* now we loop through the tables ... */
	for (flow_idx = 0; flow_idx < f_max_entries; flow_idx++) {
		/* get the first level entry */
		flow = &flow_table[flow_idx];

		/* make sure it is active */
		if (flowkey_match(&flow->key, &null_key))
			continue;

		/* set up monitor buffer */
		log = (struct pna_log_entry*)&buf[buf_idx];
		buf_idx += sizeof(struct pna_log_entry);

		/* copy the flow entry */
		log->local_ip = flow->key.local_ip;
		log->remote_ip = flow->key.remote_ip;
		log->local_port = flow->key.local_port;
		log->remote_port = flow->key.remote_port;
		log->local_domain = flow->key.local_domain;
		log->remote_domain = flow->key.remote_domain;
		log->packets[PNA_DIR_OUTBOUND] =
			flow->data.packets[PNA_DIR_OUTBOUND];
		log->packets[PNA_DIR_INBOUND] =
			flow->data.packets[PNA_DIR_INBOUND];
		log->bytes[PNA_DIR_OUTBOUND] = flow->data.bytes[PNA_DIR_OUTBOUND];
		log->bytes[PNA_DIR_INBOUND] = flow->data.bytes[PNA_DIR_INBOUND];
		log->flags[PNA_DIR_OUTBOUND] = flow->data.flags[PNA_DIR_OUTBOUND];
		log->flags[PNA_DIR_INBOUND] = flow->data.flags[PNA_DIR_INBOUND];
		log->first_tstamp = flow->data.first_tstamp;
		log->last_tstamp = flow->data.last_tstamp;
		log->l4_protocol = flow->key.l4_protocol;
		log->first_dir = flow->data.first_dir;
		log->pad[0] = 0x00;
		log->pad[1] = 0x00;
		nflows++;

		/* check if we can fit another entry */
		if (buf_idx + sizeof(struct pna_log_entry) >= BUF_SIZE)
			/* flush the buffer */
			buf_idx = buf_flush(fd, buf, buf_idx);
	}

	/* make sure we're flushed */
	buf_idx = buf_flush(fd, buf, buf_idx);

	/* display the number of entries we got */
	if (verbose)
		printf("%d flows to '%s'\n", nflows, out_file);

	/* write out header data */
	lseek(fd, 0, SEEK_SET);
	log_header = (struct pna_log_hdr*)&buf[buf_idx];
	log_header->magic[0] = PNA_LOG_MAGIC0;
	log_header->magic[1] = PNA_LOG_MAGIC1;
	log_header->magic[2] = PNA_LOG_MAGIC2;
	log_header->version = PNA_LOG_VERSION;
	log_header->start_time = start_time;
	log_header->end_time = time(NULL);
	log_header->size = nflows * sizeof(struct pna_log_entry);
	write(fd, log_header, sizeof(*log_header));

	close(fd);
}
Example #16
0
int main(int argc, char** argv)
{
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = SIG_IGN;
    sigaction(SIGCHLD, &sa, NULL);

    if (argc != 3)
    {
        fprintf(stderr, "Wrong uasge\nUsage: ./forking <port 1> <port 2>\n");
        return -1;
    }

    int fd1, fd2, acc_fd1, acc_fd2;

    if ((fd1 = get_socket_fd(argv[1])) == -1)
        return -1;

    if ((fd2 = get_socket_fd(argv[2])) == -1)
        return -1;

    sock_in receiver1;
    sock_in receiver2;
    socklen_t len1 = sizeof(receiver1);
    socklen_t len2 = sizeof(receiver2);
    buf_t* buf = buf_new(size);

    if (buf == NULL)
    {
        fprintf(stderr, "Couldn'y allocate memory for buffer\n");
        close(fd1);
        close(fd2);
        return -1;
    }

    while (1)
    {
        if ((acc_fd1 = accept(fd1, (struct sockaddr*) &receiver1, &len1)) == -1)
        {
            fprintf(stderr, "%s\n", strerror(errno));
            close(fd1);
            close(fd2);
            return -1;
        }

        if ((acc_fd2 = accept(fd2, (struct sockaddr*) &receiver2, &len2)) == -1)
        {
            fprintf(stderr, "%s\n", strerror(errno));
            close(fd1);
            close(fd2);
            return -1;
        }

        pid_t process_id = fork();

        if (process_id == -1)
        {
            fprintf(stderr, "%s\n", strerror(errno));
            close(fd1);
            close(fd2);
            close(acc_fd1);
            close(acc_fd2);
            return -1;
        }

        if (process_id == 0)
        {
            while (1)
            {
                ssize_t rhave = buf_fill(acc_fd1, buf, 1);

                if (rhave == -1)
                {
                    fprintf(stderr, "Error in reading\n");
                    buf_free(buf);
                    close(fd1);
                    close(fd2);
                    close(acc_fd1);
                    close(acc_fd2);
                    _exit(-1);
                }

                if (rhave == 0)
                   _exit(0);
            
                ssize_t whave = buf_flush(acc_fd2, buf, buf -> size);

                if (whave == -1)
                {
                    fprintf(stderr, "Error in writing\n");
                    buf_free(buf);
                    close(fd1);
                    close(fd2);
                    close(acc_fd1);
                    close(acc_fd2);
                    _exit(-1);
                }
            }
        }

        process_id = fork();

        if (process_id == -1)
        {
            fprintf(stderr, "%s\n", strerror(errno));
            close(fd1);
            close(fd2);
            close(acc_fd1);
            close(acc_fd2);
            return -1;
        }

        if (process_id != 0)
        {
            close(acc_fd1);
            close(acc_fd2);
            continue;
        }

        while (1)
        {
            ssize_t rhave = buf_fill(acc_fd2, buf, 1);

            if (rhave == -1)
            {
                fprintf(stderr, "Error in reading\n");
                buf_free(buf);
                close(fd1);
                close(fd2);
                close(acc_fd1);
                close(acc_fd2);
                _exit(-1);
            }

            if (rhave == 0)
                _exit(0);

            ssize_t whave = buf_flush(acc_fd1, buf, buf -> size);

            if (whave == -1)
            {
                fprintf(stderr, "Error in writing\n");
                buf_free(buf);
                close(fd1);
                close(fd2);
                close(acc_fd1);
                close(acc_fd2);
                _exit(-1);
            }
        }
    }

    buf_free(buf);

    return 0;
}
Example #17
0
void
dumpsys(struct dumperinfo *di)
{
	struct sparc64_dump_hdr hdr;
	vm_size_t size, totsize, hdrsize;
	int error, i, nreg;

	/* Calculate dump size. */
	size = 0;
	nreg = sparc64_nmemreg;
	for (i = 0; i < sparc64_nmemreg; i++)
		size += sparc64_memreg[i].mr_size;
	/* Account for the header size. */
	hdrsize = roundup2(sizeof(hdr) + sizeof(struct sparc64_dump_reg) * nreg,
	    DEV_BSIZE);
	size += hdrsize;

	totsize = size + 2 * sizeof(kdh);
	if (totsize > di->mediasize) {
		printf("Insufficient space on device (need %ld, have %ld), "
		    "refusing to dump.\n", (long)totsize,
		    (long)di->mediasize);
		error = ENOSPC;
		goto fail;
	}

	/* Determine dump offset on device. */
	dumplo = di->mediaoffset + di->mediasize - totsize;

	mkdumpheader(&kdh, KERNELDUMPMAGIC, KERNELDUMP_SPARC64_VERSION, size,
	    di->blocksize);

	printf("Dumping %lu MB (%d chunks)\n", (u_long)(size >> 20), nreg);

	/* Dump leader */
	error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
	if (error)
		goto fail;
	dumplo += sizeof(kdh);

	/* Dump the private header. */
	hdr.dh_hdr_size = hdrsize;
	hdr.dh_tsb_pa = tsb_kernel_phys;
	hdr.dh_tsb_size = tsb_kernel_size;
	hdr.dh_tsb_mask = tsb_kernel_mask;
	hdr.dh_nregions = nreg;

	if (buf_write(di, (char *)&hdr, sizeof(hdr)) != 0)
		goto fail;

	dumppos = hdrsize;
	/* Now, write out the region descriptors. */
	for (i = 0; i < sparc64_nmemreg; i++) {
		error = reg_write(di, sparc64_memreg[i].mr_start,
		    sparc64_memreg[i].mr_size);
		if (error != 0)
			goto fail;
	}
	buf_flush(di);

	/* Dump memory chunks. */
	for (i = 0; i < sparc64_nmemreg; i++) {
		error = blk_dump(di, sparc64_memreg[i].mr_start,
		    sparc64_memreg[i].mr_size);
		if (error != 0)
			goto fail;
	}

	/* Dump trailer */
	error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
	if (error)
		goto fail;

	/* Signal completion, signoff and exit stage left. */
	dump_write(di, NULL, 0, 0, 0);
	printf("\nDump complete\n");
	return;

 fail:
	/* XXX It should look more like VMS :-) */
	printf("** DUMP FAILED (ERROR %d) **\n", error);
}
Example #18
0
state_t pback_start_strands(pback_t *pback, node_t *leaf, int8_t mode)
{
    state_t state;
    
    /* check if libao is initialised */
    if (!g_data.started.audio)
    {
        error("pback_start_strands(): libao isn't running! Bailing out.\n");
        return ERR_AUDIO;
    }

    /* make sure we're not trying to play a branch */
    if (!node_isleaf(leaf))
    {
        error("pback_start_strands(): node parameter wasn't a leaf! Bailing out.\n");
        return ERR_NODE;
    }
    
    /* If we weren't already playing, make a buffer and an output strand. */
    if (mode == TR_START)
    {
        buf_init(&pback->buf, g_opts.au.numbufs);
        strand_outp_init(&pback->outp, &pback->buf, &leaf->t->au, &pback->outp.state);
    }
    /* Otherwise, delete the old decoder; a new one will be made below. */
    else
    {
        strand_uninit(&pback->dec);
        
        /* If we're changing to a new track immediately, flush the buffer. */
        if (mode == TR_CHANGE)
            buf_flush(&pback->buf);

        /* If the output strand encountered an error, it should also be
         * restarted. */
        if (IS_ERR(pback->outp.state))
        {
            buf_flush(&pback->buf);
            strand_uninit(&pback->outp);
            strand_outp_init(&pback->outp, &pback->buf, &leaf->t->au, &pback->outp.state);
        }
    }
    
    /* Now, create the new decoder. This is done every time a new track is
     * started, for obvious reasons. */
    if (pback->dec.inited)
    {
        warn("pback_start_strands(): decoder already inited.\n");
        strand_uninit(&pback->dec);
    }
    
    strand_dec_init(&pback->dec, leaf->t, &pback->buf, fmt_getfmts()[leaf->t->au.fmt], &pback->dec.state);
   
    if ((state = strand_setup(&pback->dec)) == OK) /* the decoder is happy */
    {
        pback->dec.state = ST_STARTING;
        
        if ((state = strand_start(&pback->dec)) == OK) /* The decoder is running */
        {
            /* the decoder started, so wipe the slate clean for this track */
            leaf->t->avail = true;
            leaf->t->sane = true;
            
            lists.newleaf = leaf;
            
            if ((mode == TR_START) || IS_ERR(pback->outp.state)) /* The output strand must also be started */
            {
                if ((state = strand_setup(&pback->outp)) == OK) /* the output strand is happy */
                {
                    pback->outp.state = ST_STARTING;

                    if ((state = strand_start(&pback->outp)) == OK) /* The output strand is running */
                    {
                        g_data.state = ST_PLAYING;
						pback->buf.lock = false;
                        
                        state = OK;
                    }
                    else
                    {
                        info("pback_start_strands(): strand_start(pback->outp) failed!\n");
                        pback->outp.state = state;
                    }
                }
                else
                {
                    info("pback_start_strands(): strand_setup(&pback->outp) failed!\n");
                    pback->outp.state = state;
                }
            }
            else /* the output strand was already running */
            {
				pback->buf.lock = false;
                state = OK;
            }
        }
        else
        {
            info("pback_start_strands(): strand_start(pback->dec) failed!\n");
            pback->dec.state = state;
        }
    }
    else
    {
        info("pback_start_strands(): strand_setup(&pback->dec) failed!\n");
        pback->dec.state = state;
        leaf->t->sane = false;
    }
   
    return state;
}