리눅스 문자디바이스 드라이버만드는건데요... write를 계속 수행하려면 어찌해야하나요?

int M = 5; 
 
int N = 15; 
 
module_param(M, int, 0);
 
module_param(N, int, 0);
 
char *store_buffer;
 
char *tmp_buffer;
 
char *temp_s; 	
 
int index_buffer = 0;	
 
int *writeSize_buffer = &N;
 
int *readSize_buffer = &M;
 
int index=0;
 
 
 
void chr_exit(void) { 
 
	printk("exit run\n");
 
	unregister_chrdev(MEM_DEV_MAJOR, MEM_DEV_NAME);
 
	if (store_buffer) { 
 
		kfree(store_buffer); 
 
	}  
 
} 
 
 
 
int chr_open(struct inode *inode, struct file *filp) { 
 
	printk("open run\n");
 
	return 0; 
 
} 
 
 
 
ssize_t chr_write( struct file *filp, char *buf, size_t count, loff_t *f_pos) { 
 
	printk("write run\n");
 
	if(*f_pos == 0) {
 
		*f_pos += 1;
 
		copy_from_user(store_buffer, buf, *writeSize_buffer);
 
		return *writeSize_buffer+1;
 
	}
 
	return 0;
 
} 
 
ssize_t chr_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) {
 
	printk("read run\n"); 
 
	if(*f_pos == 0) {
 
		*f_pos += 1;
 
		if(index_buffer >= *writeSize_buffer){
 
			return 0;
 
		}
 
		else if(strlen(store_buffer) > *readSize_buffer) {
 
			char *tmp = kmalloc(*readSize_buffer, GFP_KERNEL);
 
			strncpy(tmp, store_buffer, *readSize_buffer);
 
			tmp[*readSize_buffer]='\n';
 
			index_buffer += *readSize_buffer;
 
			copy_to_user(buf, tmp, *readSize_buffer+1);
 
			strcpy(store_buffer, &store_buffer[*readSize_buffer]);
 
			return *readSize_buffer+1;
 
		}
 
		else if(strlen(store_buffer) <= *readSize_buffer)  {
 
			store_buffer[strlen(store_buffer)]='\n';
 
			index_buffer += strlen(store_buffer);
 
			copy_to_user(buf, store_buffer, strlen(store_buffer)+1);
 
			strcpy(store_buffer, &store_buffer[*readSize_buffer]);
 
			return strlen(store_buffer)+1;
 
		}	
 
	}
 
	else {
 
		return 0;
 
	}
 
 
 
 
 
} 
 
 
 
int chr_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
 
{
 
	printk("ioctl run\n");
 
	switch(cmd)	{
 
		case 0 :
 
			*readSize_buffer = arg; break;
 
		case 1 : 			
 
			*writeSize_buffer  = arg;
 
			tmp_buffer = kmalloc(*writeSize_buffer, GFP_KERNEL);		
 
			strncpy(tmp_buffer,store_buffer, *writeSize_buffer-index_buffer);
 
			kfree(store_buffer); store_buffer = kmalloc(*writeSize_buffer+2, GFP_KERNEL); 
 
			strcpy(store_buffer, tmp_buffer);
 
			store_buffer[strlen(store_buffer)]='\n';
 
 
 
			break;
 
	}
 
	return 0;
 
}
 
 
 
int chr_release(struct inode *inode, struct file *filp) { 
 
	printk("release run\n");
 
	return 0; 
 
} 
 
 
 
struct file_operations chr_fops = { 
 
	.owner	 = THIS_MODULE,
 
	.read	 = chr_read, 
 
	.write	 = chr_write, 
 
	.open	 = chr_open, 
 
  	.release = chr_release,
 
	.ioctl 	 = chr_ioctl,
 
}; 
 
 
 
int chr_init(void) { 
 
	printk("init run\n");
 
	int result; 
 
	result = register_chrdev(MEM_DEV_MAJOR, MEM_DEV_NAME, &chr_fops); 
 
	if (result < 0) { 
 
    		return -1; 
 
  	}
 
	store_buffer = kmalloc(*writeSize_buffer+1, GFP_KERNEL);
 
	tmp_buffer = kmalloc(*writeSize_buffer, GFP_KERNEL);
 
 
 
	return 0; 
 
}