CODEWITHSUNDEEP
c++linux
Patrick Hillert
Patrick Hillert

Reputation: 2439

Problems with pwrite() to a file in C/C++

I've a bad problem. I'm trying to write to a file via filedescriptor and memalign. I can write to it but only something like an wrong encoded char is written to a file.

Here's my code:

fdOutputFile = open(outputFile, O_CREAT | O_WRONLY | O_APPEND | O_DIRECT, 0644)

void writeThis(char* text) {
    while (*text != '\0') {
        // if my internal buffer is full -> write to disk
        if (buffPositionOutput == outputbuf.st_blksize) {
            posix_memalign((void **)&bufferO, outputbuf.st_blksize, outputbuf.st_blksize);

            cout << "wrote " << pwrite(fdOutputFile, bufferO, outputbuf.st_blksize, outputOffset*outputbuf.st_blksize) << " Bytes to disk." << endl;
            buffPositionOutput = 0;
            ++outputOffset;
        }

        // buffer the incoming text...
        bufferO[buffPositionOutput] = *text;
        ++text;
        ++buffPositionOutput;
    }
}

I think it's the alignment - can someone help me? It writes to the file but not the correct text, just a bunch of '[]'-chars.

Thanks in advance for your help!

Upvotes: 0

Views: 2410

Answers (3)

Walter Mundt
Walter Mundt

Reputation: 25281

Looking at your program, here is what happens:

  1. You fill the memory initially pointed to by buffer0+buffPositionOutput (Which is where, precisely? I don't know based on the code you give.) up to buffer0+outputbuf.st_blksize with data.
  2. You pass the address of the buffer0 pointer to posix_memalign, which ignores its current value and overwrites it with a pointer to outputbuf.st_blksize bytes of newly-allocated memory.
  3. You write data from the newly-allocated block to disk; this might be anything, since you just allocated memory and haven't written anything there yet.

This won't work, obviously. You probably want to initialize your buffer via posix_memalign at the top of your function, and then just overwrite the block's worth of data in it as you use your aligned buffer to repeatedly write data into the file. (Reset buffpositionoutput to zero after each time you write data, but don't re-allocate.) Make sure you free your buffer when you are done.

Also, why are you using pwrite instead of write?

Here's how I would implement writeThis (keeping your variable names so you can match it up with your version):

void writeThis(char *text) {
    char *buffer0;
    size_t buffPositionOutput = 0;
    posix_memalign(&buffer0, outputbuf.st_blksize, outputbuf.st_blksize);
    while (*text != 0) {
        ++text; ++buffPositionOutput;
        if (buffPositionOutput == outputbuf.st_blksize) {
            write(fdOutputFile, buffer0, outputbuf.st_blksize);
            buffPositionOuput = 0;
        }
    }
    if (buffPositionOutput != 0) {
        // what do you want to do with a partial block of data?  Not sure.
    }
}

(For speed, you might consider using memcpy calls instead of a loop. You would need to know the length of the data to write ahead of time though. Worry about that after you have a working solution that does not leak memory.)

Upvotes: 1

Mat
Mat

Reputation: 206909

You're re-allocating buffer0 every time you try to output it, and not freeing it. That's really not efficient (and leaks memory). I'd suggest you refactor your code a bit, because it's quite hard to follow whether your bounds checking on that buffer is correct or not.

Allocate buffer0 only once somewhere (form that snippet, storing it in outputbuf sounds like a good idea). Also store buffPositionOutput in that struct (or in another struct, but close to that buffer).

// in setup code
int rc = posix_memalign(&(outputbuf.data), outputbuf.st_blksize,
                                           outputbuf.st_blksize);
// check rc!
outputbuf.writePosition = 0;

// in cleanup code
free(outputbuf.data);

Then you can rewrite your function like this:

void writeThis(char *text) {
   while (*text != 0) {
     outputbuf.data[outputbuf.writePosition] = *text;
     outputbuf.writePosition++;
     text++;
     if (outputbuf.writePosition == outputbuf.block_size) {
        int rc = pwrite(...);
        // check rc!
        std::cout << ...;
        outputbuf.writePosition = 0;
     }
 }

Upvotes: 1

George Kastrinis
George Kastrinis

Reputation: 5182

I don't think C/C++ has encodings. ASCII only. Unless you use wchar http://en.wikipedia.org/wiki/Wide_character

Upvotes: 0

Related Questions