/** readv against a gridfs file
* timeout_msec is unused */
ssize_t
mongoc_gridfs_file_readv (mongoc_gridfs_file_t *file,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
uint32_t timeout_msec)
{
uint32_t bytes_read = 0;
int32_t r;
size_t i;
uint32_t iov_pos;
ENTRY;
BSON_ASSERT (file);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
/* Reading when positioned past the end does nothing */
if (file->pos >= file->length) {
return 0;
}
/* Try to get the current chunk */
if (!file->page && !_mongoc_gridfs_file_refresh_page (file)) {
return -1;
}
for (i = 0; i < iovcnt; i++) {
iov_pos = 0;
for (;;) {
r = _mongoc_gridfs_file_page_read (
file->page,
(uint8_t *) iov[i].iov_base + iov_pos,
(uint32_t) (iov[i].iov_len - iov_pos));
BSON_ASSERT (r >= 0);
iov_pos += r;
file->pos += r;
bytes_read += r;
if (iov_pos == iov[i].iov_len) {
/* filled a bucket, keep going */
break;
} else if (file->length == file->pos) {
/* we're at the end of the file. So we're done */
RETURN (bytes_read);
} else if (bytes_read >= min_bytes) {
/* we need a new page, but we've read enough bytes to stop */
RETURN (bytes_read);
} else if (!_mongoc_gridfs_file_refresh_page (file)) {
return -1;
}
}
}
RETURN (bytes_read);
}
/** readv against a gridfs file */
ssize_t
mongoc_gridfs_file_readv (mongoc_gridfs_file_t *file,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
uint32_t timeout_msec)
{
uint32_t bytes_read = 0;
int32_t r;
size_t i;
uint32_t iov_pos;
ENTRY;
BSON_ASSERT (file);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
BSON_ASSERT (timeout_msec <= INT_MAX);
/* TODO: we should probably do something about timeout_msec here */
if (!file->page) {
_mongoc_gridfs_file_refresh_page (file);
}
for (i = 0; i < iovcnt; i++) {
iov_pos = 0;
for (;; ) {
r = _mongoc_gridfs_file_page_read (file->page,
(uint8_t *)iov[i].iov_base + iov_pos,
(uint32_t)(iov[i].iov_len - iov_pos));
BSON_ASSERT (r >= 0);
iov_pos += r;
file->pos += r;
bytes_read += r;
if (iov_pos == iov[i].iov_len) {
/* filled a bucket, keep going */
break;
} else if (file->length == file->pos) {
/* we're at the end of the file. So we're done */
RETURN (bytes_read);
} else if (bytes_read >= min_bytes) {
/* we need a new page, but we've read enough bytes to stop */
RETURN (bytes_read);
} else {
/* more to read, just on a new page */
_mongoc_gridfs_file_refresh_page (file);
}
}
}
RETURN (bytes_read);
}
/** writev against a gridfs file */
ssize_t
mongoc_gridfs_file_writev (mongoc_gridfs_file_t *file,
mongoc_iovec_t *iov,
size_t iovcnt,
uint32_t timeout_msec)
{
uint32_t bytes_written = 0;
int32_t r;
size_t i;
uint32_t iov_pos;
ENTRY;
BSON_ASSERT (file);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
BSON_ASSERT (timeout_msec <= INT_MAX);
/* TODO: we should probably do something about timeout_msec here */
for (i = 0; i < iovcnt; i++) {
iov_pos = 0;
for (;; ) {
if (!file->page) {
_mongoc_gridfs_file_refresh_page (file);
}
r = _mongoc_gridfs_file_page_write (file->page,
(uint8_t *)iov[i].iov_base + iov_pos,
(uint32_t)(iov[i].iov_len - iov_pos));
BSON_ASSERT (r >= 0);
iov_pos += r;
file->pos += r;
bytes_written += r;
file->length = BSON_MAX (file->length, (int64_t)file->pos);
if (iov_pos == iov[i].iov_len) {
/** filled a bucket, keep going */
break;
} else {
/** flush the buffer, the next pass through will bring in a new page
*
* Our file pointer is now on the new page, so push it back one so
* that flush knows to flush the old page rather than a new one.
* This is a little hacky
*/
file->pos--;
_mongoc_gridfs_file_flush_page (file);
file->pos++;
}
}
}
file->is_dirty = 1;
RETURN (bytes_written);
}
/**
* _mongoc_gridfs_file_extend:
*
* Extend a GridFS file to the current position pointer. Zeros will be
* appended to the end of the file until file->length is even with
* file->pos.
*
* If file->length >= file->pos, the function exits successfully with no
* operation performed.
*
* Parameters:
* @file: A mongoc_gridfs_file_t.
*
* Returns:
* The number of zero bytes written, or -1 on failure.
*/
static ssize_t
_mongoc_gridfs_file_extend (mongoc_gridfs_file_t *file)
{
int64_t target_length;
ssize_t diff;
ENTRY;
BSON_ASSERT (file);
if (file->length >= file->pos) {
RETURN (0);
}
diff = (ssize_t) (file->pos - file->length);
target_length = file->pos;
if (-1 == mongoc_gridfs_file_seek (file, 0, SEEK_END)) {
RETURN (-1);
}
while (true) {
if (!file->page && !_mongoc_gridfs_file_refresh_page (file)) {
RETURN (-1);
}
/* Set bytes until we reach the limit or fill a page */
file->pos += _mongoc_gridfs_file_page_memset0 (file->page,
target_length - file->pos);
if (file->pos == target_length) {
/* We're done */
break;
} else if (!_mongoc_gridfs_file_flush_page (file)) {
/* We tried to flush a full buffer, but an error occurred */
RETURN (-1);
}
}
file->length = target_length;
file->is_dirty = true;
RETURN (diff);
}
/** writev against a gridfs file
* timeout_msec is unused */
ssize_t
mongoc_gridfs_file_writev (mongoc_gridfs_file_t *file,
const mongoc_iovec_t *iov,
size_t iovcnt,
uint32_t timeout_msec)
{
uint32_t bytes_written = 0;
int32_t r;
size_t i;
uint32_t iov_pos;
ENTRY;
BSON_ASSERT (file);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
/* Pull in the correct page */
if (!file->page && !_mongoc_gridfs_file_refresh_page (file)) {
return -1;
}
/* When writing past the end-of-file, fill the gap with zeros */
if (file->pos > file->length && !_mongoc_gridfs_file_extend (file)) {
return -1;
}
for (i = 0; i < iovcnt; i++) {
iov_pos = 0;
for (;;) {
if (!file->page && !_mongoc_gridfs_file_refresh_page (file)) {
return -1;
}
/* write bytes until an iov is exhausted or the page is full */
r = _mongoc_gridfs_file_page_write (
file->page,
(uint8_t *) iov[i].iov_base + iov_pos,
(uint32_t) (iov[i].iov_len - iov_pos));
BSON_ASSERT (r >= 0);
iov_pos += r;
file->pos += r;
bytes_written += r;
file->length = BSON_MAX (file->length, (int64_t) file->pos);
if (iov_pos == iov[i].iov_len) {
/** filled a bucket, keep going */
break;
} else {
/** flush the buffer, the next pass through will bring in a new page
*/
if (!_mongoc_gridfs_file_flush_page (file)) {
return -1;
}
}
}
}
file->is_dirty = 1;
RETURN (bytes_written);
}
