LinuxQuestions.org - vmap allocation for size 8192 failed

Quote:

Originally Posted by Mara (Post 4036600)

VmallocChunk: 8 kB means that the biggest free block in virtual memory is 8K.... Something made half of your memory disappear or has overwritten the allocator structures. In both cases, there's a big bug somewhere. Can you see more differences in /proc/meminfo?

Hi,

I did not find any such issues. Where ever i am allocating memory I am freeing it. Following is the part of driver source code. It write routine which i am calling

static ssize_t
fm25_ee_write(struct fm25_data *fm25, char *buf, loff_t off, size_t count)
{
ssize_t status = 0;
unsigned written = 0;
unsigned buf_size;
u8 *bounce;

/* Temp buffer starts with command and address */
buf_size = 0x1000;
//buf_size = fm25->chip.page_size;
if (buf_size > io_limit)
{
buf_size = io_limit;
printk("RVSDBG iolimit %lx \n",io_limit);
}
bounce = kmalloc(buf_size + fm25->addrlen + 1, GFP_KERNEL);
// bounce = vmalloc(buf_size + fm25->addrlen +1);
if (!bounce){
printk("RVSDBG = %s bounce data =%d\n",__FUNCTION__,bounce);
return -ENOMEM;
}

/* For write, rollover is within the page ... so we write at
* most one page, then manually roll over to the next page.
*/
bounce[0] = fm25_WRITE;
mutex_lock(&fm25->lock);
do {
unsigned long timeout, retries;
unsigned segment;
unsigned offset = (unsigned) off;
u8 *cp = bounce + 1;

*cp = fm25_WREN;
status = spi_write(fm25->spi, cp, 1);
if (status < 0) {
dev_dbg(&fm25->spi->dev, "WREN --> %d\n",
(int) status);
break;
}

/* 8/16/24-bit address is written MSB first */
switch (fm25->addrlen) {
default: /* case 3 */
*cp++ = offset >> 16;
case 2:
*cp++ = offset >> 8;
case 1:
case 0: /* can't happen: for better codegen */
*cp++ = offset >> 0;
}

/* Write as much of a page as we can */
segment = buf_size - (offset % buf_size);
if (segment > count)
segment = count;
memcpy(cp, buf, segment);
status = spi_write(fm25->spi, bounce,
segment + fm25->addrlen + 1);

dev_dbg(&fm25->spi->dev,
"write %u bytes at %u --> %d\n",
segment, offset, (int) status);

if (status < 0)
break;

/* REVISIT this should detect (or prevent) failed writes
* to readonly sections of the EEPROM...
*/

/* Wait for non-busy status */
timeout = jiffies + msecs_to_jiffies(EE_TIMEOUT);
retries = 0;
do {
int sr;

sr = spi_w8r8(fm25->spi, fm25_RDSR);
if (sr < 0 || (sr & fm25_SR_nRDY)) {
dev_dbg(&fm25->spi->dev,
"rdsr --> %d (%02x)\n", sr, sr);
/* at HZ=100, this is sloooow */
msleep(1);
continue;
}
if (!(sr & fm25_SR_nRDY))
break;
} while (retries++ < 3 || time_before_eq(jiffies, timeout));

if (time_after(jiffies, timeout)) {
dev_err(&fm25->spi->dev,
"write %d bytes offset %d, "
"timeout after %u msecs\n",
segment, offset,
jiffies_to_msecs(jiffies -
(timeout - EE_TIMEOUT)));
printk("RVSDBG %s timeout\n",__FUNCTION__);
status = -ETIMEDOUT;
break;
}

off += segment;
buf += segment;
count -= segment;
written += segment;

} while (count > 0);

mutex_unlock(&fm25->lock);

kfree(bounce);
// vfree(bounce);
return written ? written : status;
}

and here is the part of aaplicaiton which i am calling to tst my driver

#include<string.h>

#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

int main(int argc,char *argv[])
{
int dev_fd;
int count = 131072;
int ret_val = 0;
int i,offset,loop;

char temp[131072];
char tempread[131072];
char tempwrite[131072];
int num_of_byte_read = 0;
int iter = 0;

dev_fd = open("/sys/bus/spi/devices/spi32766.0/fram",O_RDWR);
if (dev_fd < 0)
{
perror(" device open err");
exit(-1);
}
while(1)
{
printf("iteration %d\t",iter);

/* Write */
printf("writing device\t");
memset(temp,0,131072);
memset(tempwrite,0,131072);
for(loop=0,offset=0;loop<32;loop++,offset ++)
{
for(i=0;i<4096;i++)
{
temp[i] = loop;
tempwrite[(4096*offset)+i] = loop;
}
lseek(dev_fd, (4096*offset), SEEK_SET);
ret_val = write(dev_fd,temp,count);
}
if(ret_val < 0)
{
perror("write err \n");
goto quit;
}
/* Read */
printf("Reading device\t");
memset(tempread,0,131072);
memset(temp,0,131072);
lseek(dev_fd, 0, SEEK_SET);
count = 131072;
do{
ret_val = read(dev_fd,temp,count);
// printf("ret_val : %d\n",ret_val);
count -= ret_val;
for(i=0;i<ret_val;i++)
tempread[i+num_of_byte_read] = temp[i];
#if 0
for(i=0;i<ret_val;i++)
{
printf("0x%x\t",tempread[i]);
}
#endif
num_of_byte_read += ret_val;
}while(ret_val != 0);
if(ret_val < 0)
{
perror("read err \n");
goto quit;
}
// printf("Total number of byte read :: %d\n",num_of_byte_read);
for(i=0;i<131072;i++)
{
if(tempread[i] != tempwrite[i])
{
printf("failed\n");
printf("at location 0x%x write : 0x%x\t read : 0x%x\n", i,tempwrite[i], tempread[i]);
goto quit;
}
}
printf("passed\n");
iter++;
num_of_byte_read = 0;
}
quit:
/* close the device file*/
close (dev_fd);

return ret_val;
}