Am I using mmap correctly ?

Here is an example of what I'm attempting, on a larger scale.

Code:

#include <iostream>
#include<string>
#include<sstream>
#include<sys/mman.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<cstdlib>
#include<cstring>

void set_field(int n,void* m_ptr,const std::string& data, int field_width)
{
    memcpy(static_cast<char*>(m_ptr)+n*sizeof(char)*field_width,data.c_str(),field_width);
}
std::string get_field(int n,void* m_ptr, int field_width)
{
    char data[field_width];
    memcpy(data,static_cast<char*>(m_ptr)+n*sizeof(char)*field_width,field_width);
    return std::string(data);
}
int main()
{
    std::string filename;
    int file_size = 256;//Kb
    int field_width = 8;//bytes
    std::cout<<"Filename : ";
    std::cin>>filename;

    std::ostringstream dd_command;//"dd if=/dev/zero of=$filename count=$file_size bs=1024"
    dd_command<<"dd if=/dev/zero of="<<filename<<" count="<<file_size<<" bs=1024 2>/dev/null";
    system(dd_command.str().c_str()); // Any other way to do this ?
    
    int fd = open(filename.c_str(),O_RDWR);
    auto ptr=mmap(0,file_size*1024,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);

    if(fd==-1 || ptr==nullptr)return -1;
    
    set_field(6,ptr,"Manasij",field_width);
    std::cout<<get_field(6,ptr,field_width);

    munmap(ptr,file_size*1024);
    close(fd);

    return 0;
}

I'm creating an empty file of a given size and mapping it, to put a specific value somewhere within it and retrieve it.
I'll map small subsections of the file when doing this on large files, but other than that, is there anything wrong here ?

I'm creating an empty file of a given size and mapping it, to put a specific value somewhere within it and retrieve it.
I'll map small subsections of the file when doing this on large files, but other than that, is there anything wrong here ?

I think the mmap is fine, comparing it to the few times I've used it.

Originally Posted by manasij7479

Code:

    dd_command<<"dd if=/dev/zero of="<<filename<<" count="<<file_size<<" bs=1024 2>/dev/null";
    system(dd_command.str().c_str()); // Any other way to do this ?

How about:

Code:

char zeroKb[1024] = { 0 };
for (int i = 0; i < 256; i++) write(fd, zeroKb, 1024);

or putc(0) 256k times. "write()" is in unistd.h.

Originally Posted by MK27

Code:

char zeroKb[1024] = { 0 };
for (int i = 0; i < 256; i++) write(fd, zeroKb, 1024);

That was simple. I wonder if dd does something special to do this though. (I'll check out the coreutils sources tomorrow to find out.)

Originally Posted by manasij7479

That was simple. I wonder if dd does something special to do this though. (I'll check out the coreutils sources tomorrow to find out.)

Nah. dd is exact. You could always create a file both ways and run diff or look with hexdump, but I don't see what could complicate this. A 256KB file of zeros is a 256KB file of zeros.

The quickest way to create a 0 filled file is open(), lseek() to the end, and write a single 0 byte. Descent filesystems won't have to physically fill the gap with zero's.
https://www.kernel.org/doc/man-pages...2/lseek.2.html

gg