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." <开发者_StackOverflow社区< 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!

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.)

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;
     }
 }

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