Thread: Create File of X size

I know how in Windows to create a file with an exact size x

Using the Win32 API, CreateFile, SetFilePointerEx, SetEndOfFile, and CloseHandle in that same order but how could I do something similar in Linux to a NTFS partition (ntfs-3g driver) without having to write all zeros to the file. I see falloc.h but does this only work for ext filesystems.. not ntfs? any tricks that don't require writing all zeros first?

another trick maybe see if there is adequate space on the disk for the file before writing so the data array of size t can be guaranteed to fit?

free to use asm, c, c++... just looking for ideas.

Thanks,
John

Originally Posted by vart

To the second question - if you are using Win API - http://msdn.microsoft.com/en-us/libr...37(VS.85).aspx

Thanks but I stated that above.

Originally Posted by brewbuck

Just seeking won't do it -- you have to write a byte.

yep..

Originally Posted by matsp

I'm not entirely sure that even that is completely reliable - In the sense that the filesystem may still keep track of what you have written to, and "compress" all unwritten block into "nothing".

The only absolutely sure way to guarantee that a file fits on the disk is to write the content onto the disk ([disk here means "any device that can hold a filesystem"]).

--
Mats

completely understand.. does the Linux kernel prevent you from talking to an NTFS driver directly to check drivespace? or is there a better way in C to find out the available disk space, what/how would you hook into the kernel level driver in C .. basically I need to flip to an alternate path rather than fail...

Originally Posted by Dino

Just fseek to the offset you want and close the file.

The only problem I see with this is that it doesn't reserve space on the disk, using the code below I was able to write 10 files of 640MB each to a 1GB pen drive. This method creates sparse files correct?.. is there a way to reserve the space on the disk without writing all zeros to the file (Linux on a NTFS partition using ntfs-3g driver or mod of such)?

Code:

/*simple file IO test*/
#include <stdio.h>

FILE* getFile(const char*,int);

int main(void){
	
	
		for (int i=0;i<10;i++){
			char str[50];
			int res = sprintf(str,"/mnt/destination/myTest%d.txt",i);
			FILE *testFile = getFile(str,671088640);
			if(testFile !=NULL){
			fputs("good test",testFile);
			fclose(testFile);
			}else
			  printf("error creating file %d \n",i);
		}
	
		
	
		
	

    return 0;
}
FILE* getFile(const char* path,int sizeBytes){
	FILE *pfile;
	int result;
	
	if(pfile = fopen(path,"w")){
		fseek(pfile,sizeBytes,SEEK_SET);
		fputs("\n",pfile);
		fclose(pfile);
		pfile = fopen(path,"r+");
		fseek(pfile,0,SEEK_SET);
	}

  return pfile;
}

Originally Posted by brewbuck

I don't know enough about NTFS to say for sure, but on most filesystems which support sparse files, the unallocated blocks are reserved in the available block count. Suppose you had 10000 blocks available, and you allocate 1000 sparse blocks. Even though the specific blocks are not allocated in the block map, the count of available blocks is reduced by 1000.

If filesystems didn't work this way, there would never be a way to tell how much space you REALLY had available.

Thanks for the suggestion but NTFS is not a block based file system

found my own answer.. maybe

Windows uses unbuffered disk IO whereas Linux uses unbuffered file IO

http://www.developer.com/net/cplus/a...0919_2119781_5

nice help how to do on either platform via C