AVR Freaks

I'm trying aligned_alloc but I get the following error during compilation.

aligned_alloc.o): In function `aligned_alloc':
aligned_alloc.c:(.text.aligned_alloc+0xa): undefined reference to `posix_memalign'

My guess is that I need a compiler flag.  Any ideas?

found the following function:

unsigned char * cache = (unsigned char *)memalign(32, cluster_size(file));

Same problem, it only works 2 deep in the recursion.  I've included the full code for the function below:

void delete_folder_contents(FILEX * file){

	unsigned int root_address = file->cluster_nr;

	unsigned int source = file->dir_clusters->sequence;
	dir_insert_cluster(file);

	/**
	 * Using the GNU Compiler Collection (GCC) aligned (alignment) This
	 * attribute specifies a minimum alignment for the variable or
	 * structure field, measured in bytes. For example, the
	 * declaration: int x __attribute__ ( (aligned (16))) = 0;
	 * causes the compiler to allocate the global variable x on a
	 * 16-byte boundary.
	 */
	// Allocate Memory of the Stack for the recursive call
	//unsigned char cache[cluster_size(file) + 1]__attribute__((aligned(32)));

	unsigned char * cache = (unsigned char *)memalign(32, cluster_size(file));

	// perform DMA read of directory location to ensure the data is up-to-date
	dma_hardware_read(1, file->cluster_addr, sectors_per_cluster(file), cache, 0);


	struct directory_entry     * directory = (struct directory_entry * )cache;
	struct stream_extension    * streamExt;
	struct file_name_extension * nameExt;


	char entry_name[255];
	unsigned char violation = 0;

	unsigned char entry_type = 0;

	// begin search
	while(1){

		if(directory->entry_type == DATAEXT){

			if(directory->file_attributes[0] == exFOLDER)
				entry_type = exFOLDER;
			else
				entry_type = exFILEX;

			streamExt = (struct stream_extension    *) directory + 1;


			// handle boundary violation!!!
			if(boudary_configure(file, cache, (unsigned char **)&streamExt, (unsigned char **)&directory, &violation) == 0)
				break;



			if(streamExt->entry_type == STREAMEXT){

				int name_length = streamExt->name_length;

				nameExt = (struct file_name_extension *) streamExt + 1;

				// handle boundary violation!!!
				if(boudary_configure(file, cache, (unsigned char **)&nameExt, (unsigned char **)&directory, &violation) == 0)
					break;



				if(nameExt->entry_type == FILEXEXT){

					unsigned char * ptr = nameExt->file_name;

					/** exFAT files have only one name, which is encoded as Unicode on disk and can have up to 255 characters. */
					int i;
					for(i = 0; i < name_length; i++){
						

						if(((i % 15) == 0) && (i != 0)){
							nameExt++;

							// handle boundary violation!!!
							if(boudary_configure(file, cache, (unsigned char **)&nameExt, (unsigned char **)&directory, &violation) == 0)
								break;


							if(nameExt->entry_type != FILEXEXT)
								goto escape;
							
							ptr = &nameExt->file_name[0];
							
						}entry_name[i] = * ptr; ptr += 2;
					}entry_name[i] = '\0';

					if(violation)
						prev_cluster(file);


					if(entry_type == exFOLDER){

						// Open Folder & Delete the contents
						exfat_open_folder(file, &entry_name[0]);

						/**
						 * Recursion: In programming terms, a recursive function can be defined as a routine that calls
						 * itself directly or indirectly. Using the recursive algorithm, certain problems can be solved
						 * quite easily. Towers of Hanoi (TOH) is one such programming exercise. Try to write an
						 * iterative algorithm for TOH. Moreover, every recursive program can be written using iterative
						 * methods.
						 */
						delete_folder_contents(file);
						exfat_return(file);

						c_printf("\r[m]Deleting %s", &entry_name[0]);
						exfat_delete_general_entry(file, &entry_name[0], root_address);
					}
					else{
						c_printf("\r[m]Deleting %s", &entry_name[0]);
						exfat_delete_general_entry(file, &entry_name[0], root_address);
					}

					if(violation)
						next_cluster(file);
				}
			}
		}
		directory++;

		// handle boundary violation!!!
		if(boudary_configure(file, cache, (unsigned char **)&directory, (unsigned char **)&directory, &violation) == 0)
			break;

		escape:
		violation = 0;
	}
	return_to_source(file, source);
}