File s390-tools-sles11sp2-cmsfs-fuse_cont_write.patch of Package s390-tools
Description: cmsfs-fuse: Multiple write requests for fixed record format files
Symptom: Writing to a fixed record format file may fail.
Problem: If multiple write requests are performed on a fixed record format
file cmsfs-fuse looks at the record information to detect the
current write position. That can be wrong if a write request on a
fixed record format file is not issued on record boundaries.
Solution: Maintain a write pointer as long as the file is open and use this
write pointer for contiguous writes to a file.
Problem-ID: 75939
---
cmsfs-fuse/cmsfs-fuse.c | 105 ++++++++++++++++++++++++++++++------------------
1 file changed, 67 insertions(+), 38 deletions(-)
--- a/cmsfs-fuse/cmsfs-fuse.c
+++ b/cmsfs-fuse/cmsfs-fuse.c
@@ -116,6 +116,7 @@ static char CODEPAGE_LINUX[] = "ISO-8859
#define RWS_RECORD_INCOMPLETE 0x4
#define RWS_RECORD_COMPLETE 0x8
+#define BWS_BLOCK_NOT_INIT 0x0
#define BWS_BLOCK_NEW 0x1
#define BWS_BLOCK_USED 0x2
@@ -172,6 +173,15 @@ struct file_operations {
static struct file_operations fops_fixed;
static struct file_operations fops_variable;
+struct write_state {
+ int block_state;
+ /* number of free bytes in the current block */
+ int block_free;
+ int var_record_state;
+ /* remaining record bytes for a write request */
+ int var_record_len;
+};
+
/*
* File object for operations that follow open
*/
@@ -204,8 +214,8 @@ struct file {
int pad_bytes;
/* old levels value, needed to rewrite pointers */
int old_levels;
- /* record write state for variable headers */
- struct var_record_state *vrstate;
+ /* state information needed for a write request */
+ struct write_state *wstate;
/* path name for open and unlink */
char path[MAX_FNAME + 1];
/* counter for pseudo null length records */
@@ -232,12 +242,6 @@ struct file {
int unlinked;
};
-struct var_record_state {
- int rlen;
- int record_state;
- int block_state;
-};
-
struct xattr {
char name[20];
size_t size;
@@ -3388,6 +3392,12 @@ static int examine_last_block(struct fil
if (!f->fst->nr_blocks || !f->fst->nr_records)
return 0;
+ /*
+ * For subsequent writes we know how much is left on the current block.
+ * */
+ if (f->wstate->block_state != BWS_BLOCK_NOT_INIT)
+ return f->wstate->block_free;
+
last_bnr = f->fst->nr_blocks - 1;
rec = &f->rlist[f->fst->nr_records - 1];
@@ -3454,6 +3464,16 @@ static off_t disk_end(struct file *f)
if (!f->fst->nr_records)
return 0;
+ /*
+ * Only the first write on a newly opened file should set the write_ptr
+ * according to what is on the disk. Subsequent writes should use the
+ * actual write_ptr. This avoids the problem for fixed records that
+ * for a record that is not yet completely written the calculated
+ * write_ptr would be wrong.
+ */
+ if (f->wstate->block_state != BWS_BLOCK_NOT_INIT)
+ return f->write_ptr;
+
rec = &f->rlist[f->fst->nr_records - 1];
if (rec->ext == NULL) {
if (rec->disk_start == NULL_BLOCK)
@@ -3481,7 +3501,7 @@ static off_t disk_end(struct file *f)
void store_displacement(struct file *f, int disp)
{
f->blist[f->fst->nr_blocks - 1].disp = disp;
- f->vrstate->block_state = BWS_BLOCK_USED;
+ f->wstate->block_state = BWS_BLOCK_USED;
}
/*
@@ -3537,13 +3557,12 @@ static int write_prepare_block(struct fi
}
if (new_block) {
- if (f->fst->record_format == RECORD_LEN_VARIABLE)
- f->vrstate->block_state = BWS_BLOCK_NEW;
+ f->wstate->block_state = BWS_BLOCK_NEW;
f->blist[f->fst->nr_blocks].disk_addr = f->write_ptr;
if (!f->write_ptr && f->fst->record_format == RECORD_LEN_FIXED)
f->nr_null_blocks++;
-
+ f->wstate->block_free = cmsfs.blksize;
f->fst->nr_blocks++;
}
return len;
@@ -3557,23 +3576,24 @@ static int write_var_header(struct file
u8 half_vheader;
int rc;
- if (f->vrstate->record_state == RWS_HEADER_COMPLETE ||
- f->vrstate->record_state == RWS_RECORD_INCOMPLETE)
+ if (f->wstate->var_record_state == RWS_HEADER_COMPLETE ||
+ f->wstate->var_record_state == RWS_RECORD_INCOMPLETE)
return 0;
- if (f->vrstate->record_state == RWS_HEADER_STARTED) {
+ if (f->wstate->var_record_state == RWS_HEADER_STARTED) {
/* write secord header byte */
half_vheader = vheader & 0xff;
rc = _write(&half_vheader, 1, f->write_ptr);
if (rc < 0)
return rc;
f->write_ptr++;
- f->vrstate->record_state = RWS_HEADER_COMPLETE;
+ f->wstate->block_free--;
+ f->wstate->var_record_state = RWS_HEADER_COMPLETE;
return 1;
}
/* block cannot be spanned if a header starts on it */
- if (f->vrstate->block_state == BWS_BLOCK_NEW)
+ if (f->wstate->block_state == BWS_BLOCK_NEW)
store_displacement(f, f->write_ptr & DATA_BLOCK_MASK);
if (len >= 2) {
@@ -3581,8 +3601,9 @@ static int write_var_header(struct file
if (rc < 0)
return rc;
f->write_ptr += 2;
- f->vrstate->rlen = vheader;
- f->vrstate->record_state = RWS_HEADER_COMPLETE;
+ f->wstate->block_free -= 2;
+ f->wstate->var_record_len = vheader;
+ f->wstate->var_record_state = RWS_HEADER_COMPLETE;
return 2;
} else {
/* len = 1, write first header byte */
@@ -3591,8 +3612,9 @@ static int write_var_header(struct file
if (rc < 0)
return rc;
f->write_ptr++;
- f->vrstate->rlen = vheader;
- f->vrstate->record_state = RWS_HEADER_STARTED;
+ f->wstate->block_free--;
+ f->wstate->var_record_len = vheader;
+ f->wstate->var_record_state = RWS_HEADER_STARTED;
return 1;
}
}
@@ -3611,6 +3633,7 @@ static int extend_block_fixed(struct fil
if (rc < 0)
return rc;
f->write_ptr += len;
+ f->wstate->block_free -= len;
}
return len;
}
@@ -3638,15 +3661,16 @@ static int extend_block_variable(struct
if (len < rlen)
rlen = len;
/* remaining record data less than block len */
- if (f->vrstate->rlen < rlen)
- rlen = f->vrstate->rlen;
+ if (f->wstate->var_record_len < rlen)
+ rlen = f->wstate->var_record_len;
rc = _write(buf, rlen, f->write_ptr);
if (rc < 0)
return rc;
f->write_ptr += rlen;
+ f->wstate->block_free -= rlen;
- if (f->vrstate->block_state == BWS_BLOCK_NEW) {
+ if (f->wstate->block_state == BWS_BLOCK_NEW) {
/*
* If the second byte of a split header was written
* (blocksize - 1) is enough to make the block spanned.
@@ -3663,11 +3687,11 @@ static int extend_block_variable(struct
copied += rlen;
size -= rlen;
len -= rlen;
- f->vrstate->rlen -= rlen;
+ f->wstate->var_record_len -= rlen;
- BUG(f->vrstate->rlen < 0);
- if (!f->vrstate->rlen) {
- f->vrstate->record_state = RWS_RECORD_COMPLETE;
+ BUG(f->wstate->var_record_len < 0);
+ if (!f->wstate->var_record_len) {
+ f->wstate->var_record_state = RWS_RECORD_COMPLETE;
/* reset rlen for the next record */
rlen = get_record_len(f, size);
}
@@ -3678,7 +3702,7 @@ static int extend_block_variable(struct
}
/* record is not yet finished */
- f->vrstate->record_state = RWS_RECORD_INCOMPLETE;
+ f->wstate->var_record_state = RWS_RECORD_INCOMPLETE;
return copied;
}
@@ -3923,6 +3947,12 @@ static int update_last_block_vptr(struct
return update_last_block_vptr(f, ABS(vptr->next), level, vptr);
}
+static void reset_write_state(struct file *f)
+{
+ f->wstate->var_record_state = RWS_RECORD_COMPLETE;
+ f->wstate->var_record_len = 0;
+}
+
/*
* Append records at current file end. If buf is NULL write zero bytes.
*/
@@ -3950,8 +3980,7 @@ static int write_append(struct file *f,
if (f->fst->nr_blocks + nblocks > 1)
reserve_meta_blocks(f, f->fst->nr_blocks, nblocks, 1);
- if (f->fst->record_format == RECORD_LEN_VARIABLE)
- f->vrstate->record_state = RWS_RECORD_COMPLETE;
+ reset_write_state(f);
/* first use existing last block */
if (last) {
@@ -4286,10 +4315,10 @@ static struct file *create_file_object(s
else
f->ptr_per_block = cmsfs.var_ptrs_per_block;
- f->vrstate = malloc(sizeof(*f->vrstate));
- if (f->vrstate == NULL)
+ f->wstate = malloc(sizeof(*f->wstate));
+ if (f->wstate == NULL)
goto oom_fst;
- memset(f->vrstate, 0, sizeof(*f->vrstate));
+ memset(f->wstate, 0, sizeof(*f->wstate));
/*
* Prevent calloc for zero records since it returns a pointer != NULL
@@ -4300,7 +4329,7 @@ static struct file *create_file_object(s
f->rlist = calloc(f->fst->nr_records, sizeof(struct record));
if (f->rlist == NULL)
- goto oom_vrstate;
+ goto oom_wstate;
f->blist = calloc(f->fst->nr_blocks, sizeof(struct block));
if (f->blist == NULL)
@@ -4316,8 +4345,8 @@ error:
*rc = -ENOMEM;
oom_rlist:
free(f->rlist);
-oom_vrstate:
- free(f->vrstate);
+oom_wstate:
+ free(f->wstate);
oom_fst:
free(f->fst);
oom_f:
@@ -4333,7 +4362,7 @@ static void destroy_file_object(struct f
int i;
free(f->wcache);
- free(f->vrstate);
+ free(f->wstate);
for (i = 0; i < f->fst->nr_records; i++) {
rec = &f->rlist[i];
