Esempio n. 1
0
void
edit_typeset_rep::get_data (new_data& data) {
  data->style= get_style ();
  data->init = get_init ();
  data->fin  = get_fin ();
  data->att  = get_att ();
}
Esempio n. 2
0
int
dc_close2(int fd)
{
	int              res = 0;
	struct vsp_node *node;
	int32_t          size;


#ifdef DC_CALL_TRACE
	showTraceBack();
#endif

	/* nothing wrong ... yet */
	dc_errno = DEOK;

	node = delete_vsp_node(fd);
	if (node == NULL) {
		/* we have not such file descriptor, so lets give a try to system */
		return system_close(fd);
	}


	dc_real_fsync( node );


	if(node->unsafeWrite) {

		size = htonl(-1); /* send end of data */
		writen(node->dataFd, (char *) &size, sizeof(size), NULL);
		/* FIXME: error detection missing */

		if (get_fin(node) < 0) {
			dc_debug(DC_ERROR, "dc_close: mover did not FIN the data blocks.");
			res = -1;
		}
	}

	close_data_socket(node->dataFd);

	deleteQueue(node->queueID);

	m_unlock(&node->mux);

	node_destroy(node);

	return res;
}
Esempio n. 3
0
off64_t
dc_real_lseek(struct vsp_node *node, off64_t offset, int whence)
{

	int64_t         off;
	int32_t         lseekmsg[5];
	int32_t         size;
	int             tmp;
	int             use_ahead = 0;
	ConfirmationBlock result;


	if( (node->ahead != NULL) && ( node->ahead->buffer != NULL) && node->ahead->used) {
		use_ahead = 1;
	}


	if( whence == SEEK_SET ) {
		/* if already at requested position, do nothing  */
		result.lseek = dc_real_lseek( node, 0, SEEK_CUR );
		if ( result.lseek == offset ) {
			dc_debug(DC_IO, "[%d] SEEK_SET to the current position, skipping", node->dataFd);
			return offset;
		}

	}


	if( (whence == SEEK_CUR) && (offset == 0) ) {
		/* position request, do nothing.... */
		if( use_ahead && node->ahead->used) {


			switch( node->whence ) {
				/* node->ahead->base already contains seek information */
				case SEEK_SET:
					off = node->seek + node->ahead->cur;
					break;
				case SEEK_CUR:
					off = node->ahead->base + node->ahead->cur;
					break;
				default:
					off = node->ahead->base + node->ahead->cur;
			}


		}else{
			switch( node->whence ) {

				case SEEK_SET:
					off = node->seek;
					break;
				case SEEK_CUR:
					off = node->pos + node->seek;
					break;
				default:
					off = node->pos;
			}
		}

		return off;
	}



	if( use_ahead ) {
		dc_real_fsync(node);
	}

    /* funish unsafe write operation
          if node->unsafeWrite flag > 1 : transaction in progress */

	if(node->unsafeWrite > 1) {

		size = htonl(-1); /* send end of data */
		writen(node->dataFd, (char *) &size, sizeof(size), NULL);
		/* FIXME: error detection missing */

		if (get_fin(node) < 0) {
			dc_debug(DC_ERROR, "dc_lseek: mover did not FIN the data block.");
			dc_errno = DEUOF;
			return -1;
		}


		node->unsafeWrite = 1;
	}



	/* to be fast in seek+read, do not realy seeks now. Do it only read
	  calls as SEEK_AND_READ command */

	switch (whence) {
	case SEEK_SET:
		/* TODO: what happens, if user will requests
		   offset out of file size ?*/

		if( use_ahead && ( (off64_t)(node->ahead->base + node->ahead->used) > offset) &&
					(offset >= (off64_t)node->ahead->base) ) {
			node->ahead->cur = offset - node->ahead->base;
			dc_debug(DC_IO, "[%d] SEEK_SET inside Read-ahead buffer. Expected position %ld",
					node->dataFd, node->ahead->base + node->ahead->cur);
			node->whence = -1;
			return offset;
		}

		if( use_ahead ) {
			node->ahead->used = 0;
			node->ahead->cur = 0;
			node->ahead->base = 0;
		}

		node->seek = offset;
		node->whence = SEEK_SET;
		dc_debug(DC_IO, "[%d] Expected seek offset: %ld.", node->dataFd, node->seek);
		return offset;


	case SEEK_CUR:
		if(node->whence == -1) {
			if( use_ahead && (node->ahead->cur + offset >= 0) &&
						(node->ahead->cur + offset  <= node->ahead->used ) ) {
				node->ahead->cur += offset;
				dc_debug(DC_IO, "[%d] SEEK_CUR inside Read-ahead buffer. Expected position %ld",
						node->dataFd, node->ahead->base + node->ahead->cur);

				result.lseek = node->ahead->base + node->ahead->cur;
				return (off64_t)result.lseek;
			}
		}

		if(use_ahead) {
			node->seek  = offset +  node->ahead->cur - node->ahead->used;
			node->ahead->used = 0;
		}else{
			node->seek += offset;
		}
		if(node->whence != SEEK_SET ) {
			node->whence = SEEK_CUR;
			result.lseek = node->pos + node->seek;
		}else{ /* SEEK_SET */
			result.lseek = node->seek;
		}

		dc_debug(DC_IO, "[%d] SEEK_CUR offset: %ld expected position %ld.", node->dataFd, node->seek, node->pos + node->seek);

		return (off64_t)result.lseek;

	case SEEK_END:

		/* we have to replay sone thing on SEEK_END,
		   so lets make real seek*/
		lseekmsg[0] = htonl(16);
		lseekmsg[1] = htonl(IOCMD_SEEK);
		lseekmsg[4] = htonl(IOCMD_SEEK_END);
		break;
	default:
		dc_debug(DC_ERROR, "dc_lseek: illegal value of whence parameter [%d].", whence);
		dc_debug(DC_ERROR, "          Valid values are %d ( SEEK_SET), %d (SEEK_CUR), %d (SEEK_END)", SEEK_SET, SEEK_CUR, SEEK_END);
		errno = EINVAL;
		return -1;
	}

	off = htonll(offset);
	memcpy( (char *) &lseekmsg[2],(char *) &off, sizeof(off));

	tmp = sendDataMessage(node, (char *) lseekmsg, sizeof(lseekmsg), ASCII_NULL, &result);

	if (tmp != COMM_SENT) {
		dc_debug(DC_ERROR, "sendDataMessage failed.");
		return -1;
	}

	node->pos = (off64_t)result.lseek;
	if( node->ahead != NULL ) {
		node->ahead->cur = 0;
		node->ahead->used = 0;
		node->ahead->isDirty = 0;
		node->ahead->base = 0;
	}
	node->whence = -1;
	return (off64_t)result.lseek;
}
Esempio n. 4
0
int
dc_close(int fd)
{
	int             res = 0;
	int             tmp;
	int32_t         size;
	int32_t         closemsg[6];
	int             msglen;
	struct vsp_node *node;


#ifdef DC_CALL_TRACE
	showTraceBack();
#endif


	/* nothing wrong ... yet */
	dc_errno = DEOK;

	node = delete_vsp_node(fd);
	if (node == NULL) {
		/* we have not such file descriptor, so lets give a try to system */
		dc_debug(DC_INFO, "Using system native close for [%d].", fd);
		return system_close(fd);
	}


	if ( node->lcb != NULL ) {
		dc_lcb_clean( node );
	}

	dc_real_fsync( node );

	if(node->unsafeWrite > 1) {

		size = htonl(-1); /* send end of data */
		writen(node->dataFd, (char *) &size, sizeof(size), NULL);
		/* FIXME: error detection missing */

		if (get_fin(node) < 0) {
			dc_debug(DC_ERROR, "dc_close: mover did not FIN the data blocks.");
			res = -1;
		}
	}

	if(node->reference == 0 ) {

		if( (node->sum != NULL) && ( node->sum->isOk == 1 ) ) {
			closemsg[0] = htonl(20);
			closemsg[2] = htonl(12);
			closemsg[3] = htonl(DCAP_DATA_SUM);
			closemsg[4] = htonl(node->sum->type);
			closemsg[5] = htonl(node->sum->sum);

			msglen = 6;
			dc_debug(DC_INFO, "File checksum is: %u", node->sum->sum);
		}else{
			closemsg[0] = htonl(4);
			msglen = 2;
		}

		closemsg[1] = htonl(IOCMD_CLOSE); /* actual command */

		dc_debug(DC_IO, "Sending CLOSE for fd:%d ID:%d.", node->dataFd, node->queueID);
		check_timeout_envar();
		dcap_set_alarm(closeTimeOut > 0 ? closeTimeOut : DCAP_IO_TIMEOUT/4);
		tmp = sendDataMessage(node, (char *) closemsg, msglen*sizeof(int32_t), ASCII_OK, NULL);
		/* FIXME: error detection missing */
		if( tmp < 0 ) {
			dc_debug(DC_ERROR, "sendDataMessage failed.");
			/* ignore close errors if file was open for read */
			if(node->flags & O_WRONLY) {
				res = -1;
			}

			if(isIOFailed) {
				isIOFailed = 0;
				/* command line dwon */
				if(!ping_pong(node)) {
					/* remove file descriptor from the list of control lines in use */
					lockMember();
					deleteMemberByValue(node->fd);
					unlockMember();
					pollDelete(node->fd);
					close_control_socket(node->fd, node->tunnel);
				}
			}
		}
		dcap_set_alarm(0);
		deleteQueue(node->queueID);

	}

	/*
	 * Even if there is still a reference to the dcap session,
	 * we have to close local socket descriptor.
	 */
	close_data_socket(node->dataFd);
	node_destroy(node);

	return res;
}
Esempio n. 5
0
ssize_t
dc_real_write( struct vsp_node *node, const void *buff, size_t buflen)
{

	int32_t         writemsg[5];
	int             tmp;
	int32_t         datamsg[2];
	int32_t         size;
	int64_t         offt;
	int             msglen;
	size_t          len;
	size_t          dataLen;
	int             use_io_buf = 0;
	size_t          wr_buffer = 0;


	if( (node->ahead == NULL) && ( getenv("DCACHE_WRBUFFER") != NULL ) ) {
		dc_debug(DC_INFO, "Switching on write buffer.");
		if(getenv("DCACHE_WA_BUFFER") != NULL) {
			wr_buffer = atoi( getenv("DCACHE_WA_BUFFER") );
		}
		dc_setNodeBufferSize(node, wr_buffer == 0 ? IO_BUFFER_SIZE : wr_buffer);
	}

	if( (node->ahead != NULL) && ( node->ahead->buffer != NULL) ) {
		use_io_buf = 1;
	}

	if( use_io_buf ) {

		if( ! node->ahead->isDirty ) {

			if( node->ahead->used ) {
				switch( node->whence ){
					case SEEK_SET:
						break;
					case SEEK_CUR:
						break;
					default:
						node->whence = SEEK_CUR;
						node->seek = -(node->ahead->used - node->ahead->cur);
						break;
				}
			}

			/* keep current position, including seeks */
			node->ahead->base = dc_real_lseek(node, (off64_t)0, SEEK_CUR);

			node->ahead->isDirty = 1;
			node->ahead->cur = 0;
			node->ahead->used = 0;
		}


		len = node->ahead->size - node->ahead->cur;
		if( buflen && ( len > buflen ) ) {
			memcpy( node->ahead->buffer +node->ahead->cur ,  buff, buflen );
			dc_debug( DC_IO, "[%d] Filling %ld bytes into IO buffer. Available %ld",
						node->dataFd, buflen, len - buflen);
			node->ahead->cur += buflen;
			if( node->ahead->cur > node->ahead->used ) {
				node->ahead->used = node->ahead->cur;
			}
			return buflen;
		}

		if( !buflen ) {
			dc_debug(DC_IO, "[%d] Flushing %d bytes of IO buffer.", node->dataFd, node->ahead->cur);
		}

	}


	/*
		node->unsafeWrite == 0 : regular write operation
		node->unsafeWrite == 1 : unsafeWrite, IO request not sended yet
		node->unsafeWrite >1   : unsafeWrite, IO request sended
	*/

	/* do following part allways for regular write and once of unsafe write */
	if(!node->unsafeWrite || (node->unsafeWrite == 1 ) ){

		if(node->whence == -1) {
			writemsg[0] = htonl(4);
			writemsg[1] = htonl(IOCMD_WRITE);

			msglen = 2;
			dc_debug(DC_IO,"[%d] Sending IOCMD_WRITE.", node->dataFd);

		}else{


			/* in case of seeks and write, there is no way to keep track of check summ */
			if( node->sum != NULL ) {
				node->sum->isOk = 0 ;
			}


			writemsg[0] = htonl(16);
			writemsg[1] = htonl(IOCMD_SEEK_WRITE);

			offt = htonll(node->seek);
			memcpy( (char *) &writemsg[2],(char *) &offt, sizeof(offt));

			if(node->whence == SEEK_SET) {
				writemsg[4] = htonl(IOCMD_SEEK_SET);
			}else{
				writemsg[4] = htonl(IOCMD_SEEK_CURRENT);
			}

			dc_debug(DC_IO,"[%d] Sending IOCMD_SEEK_WRITE.", node->dataFd);
			msglen = 5;
		}

		tmp = sendDataMessage(node, (char *) writemsg, msglen*sizeof(int32_t), ASCII_NULL, NULL);

		if (tmp != COMM_SENT) {
			m_unlock(&node->mux);
			dc_debug(DC_ERROR, "sendDataMessage failed.");
			return -1;
		}

		datamsg[0] = htonl(4);
		datamsg[1] = htonl(IOCMD_DATA);

		tmp = writen(node->dataFd, (char *) datamsg, sizeof(datamsg), NULL);

		/* do this part only once if unsafeWrite requaried */
		if(node->unsafeWrite) {
			node->unsafeWrite = 2;
		}
	}


	dataLen = buflen;
	if( use_io_buf )
		dataLen  += node->ahead->cur;

	size = htonl(dataLen);

	writen(node->dataFd, (char *) &size, sizeof(size), NULL); /* send data size */
	if( use_io_buf ) {
		writen(node->dataFd, (const char *)node->ahead->buffer, node->ahead->cur, NULL); /* send data */
	}

	writen(node->dataFd, (const char *)buff, buflen, NULL); /* send data */

	/* update the ckecksum */
	if( (node->sum != NULL ) && (node->sum->isOk == 1) ) {
		if( use_io_buf ) {
			update_checkSum(node->sum, (unsigned char *)node->ahead->buffer, node->ahead->cur);
		}

		/*
		 *  we do not need to calculate checksum if buff == NULL ( flush operation )
		 *  if we do so, then check sum well be reseted to default value;
		 */
		if( buff != NULL ) {
			update_checkSum(node->sum, (unsigned char *)buff, buflen);
		}
	}

	if(!node->unsafeWrite) {

		size = htonl(-1); /* send end of data */
		writen(node->dataFd, (char *) &size, sizeof(size), NULL);
		/* FIXME: error detection missing */

		if (get_fin(node) < 0) {
			dc_debug(DC_ERROR, "dc_write: mover did not FIN the data block.");
			return -1;
		}
	}

	if( node->whence == SEEK_SET ) {
		node->pos = dataLen + node->seek;
	} else { /* SEEK_CUR */
		node->pos += (node->seek + dataLen);
	}

	node->seek = 0;
	node->whence = -1;

	if( use_io_buf ) {
		node->ahead->cur = 0;
		node->ahead->used = 0;
		node->ahead->base = 0;
		node->ahead->isDirty = 0;
	}

#ifndef WIN32
	dc_debug(DC_IO, "[%d] Expected position: %lld @ %ld bytes written.", node->dataFd, (long long int)node->pos, dataLen);
#else
	dc_debug(DC_IO, "[%d] Expected position: %lld @ %ld bytes written.", node->dataFd, (long int)node->pos, dataLen);
#endif
	return buflen;
}