1 diff -urN orig/fs/cifs/file.c cifs-devel/fs/cifs/file.c
   2 --- orig/fs/cifs/file.c	2006-03-19 23:44:15.052372800 +0530
   3 +++ cifs-devel/fs/cifs/file.c	2006-03-19 23:47:07.244195664 +0530
   4 @@ -1,4 +1,8 @@
   5 -/*
   6 +/*	 <modified file.c>
   7 + *	 modified function cifs_readpages()
   8 + *	 added function cifs_readpages_threadfn()
   9 + *	 (Nitin Gupta: nitingupta910@gmail.com)
  10 + *
  11   *   fs/cifs/file.c
  12   *
  13   *   vfs operations that deal with files
  14 @@ -35,6 +39,38 @@
  15  #include "cifs_debug.h"
  16  #include "cifs_fs_sb.h"
  17  
  18 +#include <asm/atomic.h>
  19 +#include <asm/spinlock.h>
  20 +#include <linux/kthread.h>
  21 +
  22 +#define FIN_WAIT 1
  23 +#define FIN_ERR  3
  24 +
  25 +struct per_thread_data {
  26 +	int interrupted;
  27 +	wait_queue_head_t wq_h;
  28 +	
  29 +	int xid, rsize_in_pages;
  30 +	struct file *file;
  31 +	struct address_space *mapping;
  32 +	struct list_head *page_list;
  33 +	struct pagevec lru_pvec;
  34 +	struct cifsFileInfo * open_file;
  35 +	struct cifs_sb_info *cifs_sb;
  36 +	struct cifsTconInfo *pTcon;
  37 +	
  38 +	spinlock_t sl_page_pool;
  39 +	spinlock_t sl_cache_lock;
  40 +	struct semaphore threadsem;
  41 +	volatile struct list_head *page_pool;
  42 +	
  43 +	atomic_t pages_left;
  44 +	atomic_t read_state;
  45 +	atomic_t thread_count;
  46 +	atomic_t threads_required;
  47 +};
  48 +
  49 +
  50  int
  51  cifs_open(struct inode *inode, struct file *file)
  52  {
  53 @@ -1093,49 +1129,109 @@
  54  }
  55  
  56  
  57 -static int
  58 -cifs_readpages(struct file *file, struct address_space *mapping,
  59 -		struct list_head *page_list, unsigned num_pages)
  60 +int cifs_readpages_threadfn (void *data)
  61  {
  62 -	int rc = -EACCES;
  63 -	int xid;
  64 -	loff_t offset;
  65 -	struct page * page;
  66 -	struct cifs_sb_info *cifs_sb;
  67 -	struct cifsTconInfo *pTcon;
  68 -	int bytes_read = 0;
  69 -	unsigned int read_size,i;
  70 -	char * smb_read_data = NULL;
  71 -	struct smb_com_read_rsp * pSMBr;
  72 -	struct pagevec lru_pvec;
  73 -	struct cifsFileInfo * open_file;
  74  
  75 -	xid = GetXid();
  76 -	if (file->private_data == NULL) {
  77 -		FreeXid(xid);
  78 -		return -EBADF;
  79 +int i, rc;
  80 +unsigned num_pages;
  81 +char *smb_read_data = NULL;
  82 +struct page *page;
  83 +
  84 +struct list_head page_list_head;
  85 +struct list_head *page_list;
  86 +
  87 +
  88 +struct per_thread_data *t = (struct per_thread_data *)data;
  89 +
  90 +while ( atomic_read(&t->pages_left) > 0 )
  91 +{
  92 +	
  93 +	INIT_LIST_HEAD(&page_list_head);
  94 +	
  95 +	if (atomic_read(&t->read_state) == FIN_ERR || (t->interrupted == 1)) break;
  96 +
  97 +
  98 +spin_lock(&t->sl_page_pool);
  99 +	
 100 +	if (atomic_read(&t->threads_required) < atomic_read(&t->thread_count)) {
 101 +		spin_unlock(&t->sl_page_pool);
 102 +		atomic_dec(&t->thread_count);
 103 +		return 0;
 104 +	}		
 105 +
 106 +	if (atomic_read(&t->read_state) == FIN_ERR) /* if error */ {
 107 +		spin_unlock(&t->sl_page_pool);
 108 +		break;
 109  	}
 110 -	open_file = (struct cifsFileInfo *)file->private_data;
 111 -	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
 112 -	pTcon = cifs_sb->tcon;
 113 +	/*	if(atomic_read(&t->thread_count)<=1) {
 114 +			atomic_dec(&t->thread_count);
 115 +			up(&t->threadsem);
 116 +			return 0;
 117 +		} else {
 118 +			atomic_dec(&t->thread_count);
 119 +			return 0;	
 120 +		}
 121 +	}*/
 122 +
 123 +	if (atomic_read(&t->read_state) == FIN_WAIT) { /* endwait state */ 
 124 +		if (atomic_read(&t->thread_count) <= 1) {
 125 +			spin_unlock(&t->sl_page_pool);
 126 +			atomic_dec(&t->thread_count);
 127 +			up(&t->threadsem);
 128 +			return 0;
 129 +		} else {
 130 +			atomic_dec(&t->thread_count);
 131 +			spin_unlock(&t->sl_page_pool);
 132 +			return 0;
 133 +		}
 134 +	}
 135 +
 136 +	//printk("\npages_left = %d\n", atomic_read(&t->pages_left));
 137 +	
 138 +	if (atomic_read(&t->pages_left) >= t->rsize_in_pages) {
 139 +		num_pages = t->rsize_in_pages;
 140 +	} else { 
 141 +		num_pages = atomic_read(&t->pages_left);
 142 +	}
 143 +	
 144 +	//num_pages = 1;
 145 +	atomic_sub(num_pages, &t->pages_left);
 146 +
 147 +	for (i=0; i<num_pages; i++) {
 148 +		page = list_entry(t->page_pool, struct page, lru);
 149 +		t->page_pool = t->page_pool->prev;
 150 +		list_del(&page->lru);
 151 +		list_add(&page->lru, &page_list_head);	
 152 +	}
 153 +
 154 +	//printk("\npages_left now = %d\n", atomic_read(&t->pages_left));
 155 +
 156 +	if ( atomic_read(&t->pages_left) <= 0 ) 
 157 +		atomic_set(&t->read_state, FIN_WAIT); /* set endwait state */
 158  
 159 -	pagevec_init(&lru_pvec, 0);
 160 +spin_unlock(&t->sl_page_pool);
 161  
 162 -	for(i = 0;i<num_pages;) {
 163 +	page_list = &page_list_head;	
 164 +
 165 +	for(i = 0; i < num_pages;) {
 166 +		struct page *tmp_page;
 167  		unsigned contig_pages;
 168 -		struct page * tmp_page;
 169  		unsigned long expected_index;
 170 -
 171 -		if(list_empty(page_list)) {
 172 -			break;
 173 -		}
 174 +		loff_t offset;
 175 +		unsigned int read_size;
 176 +		int bytes_read;
 177 +		struct smb_com_read_rsp * pSMBr;	
 178 +		
 179 +		smb_read_data = NULL;
 180 +		
 181 +		
 182  		page = list_entry(page_list->prev, struct page, lru);
 183  		offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
 184  
 185  		/* count adjacent pages that we will read into */
 186  		contig_pages = 0;
 187 -		expected_index = list_entry(page_list->prev,struct page,lru)->index;
 188 -		list_for_each_entry_reverse(tmp_page,page_list,lru) {
 189 +		expected_index = list_entry(page_list->prev,struct page,lru)->index;		
 190 +		list_for_each_entry_reverse(tmp_page, page_list,lru) {
 191  			if(tmp_page->index == expected_index) {
 192  				contig_pages++;
 193  				expected_index++;
 194 @@ -1143,83 +1239,81 @@
 195  				break; 
 196  			}
 197  		}
 198 -		if(contig_pages + i >  num_pages) {
 199 -			contig_pages = num_pages - i;
 200 -		}
 201 -
 202 -		/* for reads over a certain size could initiate async read ahead */
 203 +		//contig_pages = 1;
 204 +		
 205  
 206  		read_size = contig_pages * PAGE_CACHE_SIZE;
 207 -		/* Read size needs to be in multiples of one page */
 208 -		read_size = min_t(const unsigned int,read_size,cifs_sb->rsize & PAGE_CACHE_MASK);
 209 +
 210 +		//printk("\nread_size = %d\n", read_size);
 211 +		
 212 +		if (atomic_read(&t->read_state) == FIN_ERR) break;		
 213  
 214  		rc = -EAGAIN;
 215  		while(rc == -EAGAIN) {
 216 -			if ((open_file->invalidHandle) && (!open_file->closePend)) {
 217 -				rc = cifs_reopen_file(file->f_dentry->d_inode,
 218 -					file, TRUE);
 219 -				if(rc != 0)
 220 +			if ((t->open_file->invalidHandle) && (!t->open_file->closePend)) {
 221 +				rc = cifs_reopen_file(t->file->f_dentry->d_inode
 222 +							, t->file, TRUE);
 223 +				if(rc != 0) {
 224 +					atomic_set((&t->read_state), FIN_ERR);
 225  					break;
 226 +				}
 227  			}
 228  
 229 -			rc = CIFSSMBRead(xid, pTcon,
 230 -				open_file->netfid,
 231 +			rc = CIFSSMBRead(t->xid, t->pTcon,
 232 +				t->open_file->netfid,
 233  				read_size, offset,
 234  				&bytes_read, &smb_read_data);
 235 -			/* BB need to check return code here */
 236 -			if(rc== -EAGAIN) {
 237 +
 238 +			if(rc == -EAGAIN) {
 239  				if(smb_read_data) {
 240  					cifs_buf_release(smb_read_data);
 241  					smb_read_data = NULL;
 242  				}
 243  			}
 244  		}
 245 +		
 246 +		if (atomic_read(&t->read_state) == FIN_ERR) break;
 247 +		
 248  		if ((rc < 0) || (smb_read_data == NULL)) {
 249  			cFYI(1,("Read error in readpages: %d",rc));
 250 +
 251  			/* clean up remaing pages off list */
 252 -			while (!list_empty(page_list) && (i < num_pages)) {
 253 -				page = list_entry(page_list->prev, struct page, lru);
 254 -				list_del(&page->lru);
 255 -				page_cache_release(page);
 256 -			}
 257 +			atomic_set(&t->read_state, FIN_ERR);
 258  			break;
 259  		} else if (bytes_read > 0) {
 260  			pSMBr = (struct smb_com_read_rsp *)smb_read_data;
 261 -			cifs_copy_cache_pages(mapping, page_list, bytes_read,
 262 -				smb_read_data + 4 /* RFC1001 hdr */ +
 263 -				le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
 264 +			//printk("\nbefore cache\n");
 265 +			spin_lock(&t->sl_cache_lock);
 266 +			
 267 +			if (atomic_read(&t->read_state) == FIN_ERR) {
 268 +				spin_unlock(&t->sl_cache_lock);
 269 +				break;
 270 +			}
 271 +			cifs_copy_cache_pages(t->mapping, page_list, 
 272 +				bytes_read, smb_read_data + 4 /* RFC1001 hdr */
 273 +			 	+ le16_to_cpu(pSMBr->DataOffset),
 274 +				 &t->lru_pvec);
 275 +
 276 +			spin_unlock(&t->sl_cache_lock);
 277 +			//printk("\nafter cache\n");
 278  
 279  			i +=  bytes_read >> PAGE_CACHE_SHIFT;
 280  #ifdef CONFIG_CIFS_STATS
 281 -			atomic_inc(&pTcon->num_reads);
 282 -			spin_lock(&pTcon->stat_lock);
 283 -			pTcon->bytes_read += bytes_read;
 284 -			spin_unlock(&pTcon->stat_lock);
 285 +			atomic_inc(&t->pTcon->num_reads);
 286 +			spin_lock(&t->pTcon->stat_lock);
 287 +			t->pTcon->bytes_read += bytes_read;
 288 +			spin_unlock(&t->pTcon->stat_lock);
 289  #endif
 290  			if((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
 291 -				cFYI(1,("Partial page %d of %d read to cache",i++,num_pages));
 292 +				cFYI(1,("Partial page %d of %d read to cache",
 293 +								i, num_pages));
 294  
 295  				i++; /* account for partial page */
 296  
 297 -				/* server copy of file can have smaller size than client */
 298 -				/* BB do we need to verify this common case ? this case is ok - 
 299 -				if we are at server EOF we will hit it on next read */
 300 -
 301 -			/* while(!list_empty(page_list) && (i < num_pages)) {
 302 -					page = list_entry(page_list->prev,struct page, list);
 303 -					list_del(&page->list);
 304 -					page_cache_release(page);
 305 -				}
 306 -				break; */
 307  			}
 308  		} else {
 309  			cFYI(1,("No bytes read (%d) at offset %lld . Cleaning remaining pages from readahead list",bytes_read,offset)); 
 310 -			/* BB turn off caching and do new lookup on file size at server? */
 311 -			while (!list_empty(page_list) && (i < num_pages)) {
 312 -				page = list_entry(page_list->prev, struct page, lru);
 313 -				list_del(&page->lru);
 314 -				page_cache_release(page); /* BB removeme - replace with zero of page? */
 315 -			}
 316 +			atomic_set(&t->read_state, FIN_ERR);
 317  			break;
 318  		}
 319  		if(smb_read_data) {
 320 @@ -1227,20 +1321,169 @@
 321  			smb_read_data = NULL;
 322  		}
 323  		bytes_read = 0;
 324 -	}
 325  
 326 -	pagevec_lru_add(&lru_pvec);
 327 +		if (atomic_read(&t->read_state) == FIN_ERR) break;
 328 +		
 329 +	} //end of for(i = 0;i<num_pages;) 
 330 +	
 331  
 332 -/* need to free smb_read_data buf before exit */
 333 +	if (atomic_read(&t->read_state) == FIN_ERR) break;
 334 +	
 335 +	if (atomic_read(&t->read_state) == FIN_WAIT) {
 336 +		if (atomic_read(&t->thread_count) <= 1) {
 337 +			if(smb_read_data) {
 338 +				cifs_buf_release(smb_read_data);
 339 +				smb_read_data = NULL;
 340 +			}
 341 +			atomic_dec(&t->thread_count);
 342 +			up(&t->threadsem);
 343 +			return 0;
 344 +		} else {
 345 +			atomic_dec(&t->thread_count);
 346 +			return 0;
 347 +		}
 348 +	}
 349 +} // end of while
 350 +
 351 +if (atomic_read(&t->read_state) == FIN_ERR || (t->interrupted == 1))  { /* if error */		
 352  	if(smb_read_data) {
 353  		cifs_buf_release(smb_read_data);
 354  		smb_read_data = NULL;
 355 -	} 
 356 +	}
 357 +	atomic_dec(&t->thread_count);
 358 +	//printk("\nin tfn thread_count: %d\n", atomic_read(&t->thread_count)); 
 359 +	if ( (t->interrupted == 1) && (atomic_read(&t->thread_count) <= 0) ) 
 360 +		wake_up(&t->wq_h); 
 361 +	up(&t->threadsem);
 362 +	return 0;
 363 +}
 364  
 365 -	FreeXid(xid);
 366 +atomic_dec(&t->thread_count);
 367 +//up(&t->threadsem);
 368 +return 0;
 369 +
 370 +}
 371 +
 372 +
 373 +
 374 +static int
 375 +cifs_readpages(struct file *file, struct address_space *mapping,
 376 +		struct list_head *page_list, unsigned num_pages)
 377 +{
 378 +	int i, init_threads, xid, rc = -EACCES;
 379 +	struct page *page;
 380 +	struct per_thread_data thread_data;
 381 +	
 382 +	/* some hard-coded rules to set initial no of threads
 383 +	 * no of threads are then later controlled by some
 384 +	 * other function which changes threads_required var
 385 +	 * to change no of threads running.
 386 +	 */
 387 +
 388 +	/* setting rsize to higher values at mount time inc performance */
 389 +	if (num_pages <= 4 )
 390 +		init_threads = 1;
 391 +	else if (num_pages <= 8)
 392 +		init_threads = 4;
 393 +	else init_threads = 8;
 394 +	// init_threads = 8;
 395 +
 396 +
 397 +	/* setting all the data to be passed to threads */
 398 +	xid = GetXid();
 399 +	thread_data.xid = xid; 
 400 +	thread_data.sl_page_pool = SPIN_LOCK_UNLOCKED;
 401 +	thread_data.sl_cache_lock = SPIN_LOCK_UNLOCKED;
 402 +	thread_data.file = file;
 403 +	thread_data.mapping = mapping;
 404 +	thread_data.page_pool = page_list->prev;
 405 +
 406 +
 407 +	thread_data.open_file = (struct cifsFileInfo *)file->private_data;
 408 +	thread_data.cifs_sb = CIFS_SB(file->f_dentry->d_sb);
 409 +	thread_data.pTcon = thread_data.cifs_sb->tcon;
 410 +	thread_data.rsize_in_pages = (thread_data.cifs_sb->rsize) >> PAGE_CACHE_SHIFT;
 411 +	atomic_set(&thread_data.pages_left, num_pages);
 412 +	
 413 +	thread_data.interrupted = 0;
 414 +	init_waitqueue_head(&thread_data.wq_h);
 415 +
 416 +	/* read_state var --
 417 +	 * START (0)    : start the thread
 418 +	 * FIN_WAIT (1) : a thread has reached EOF 
 419 +	 * FIN_END  (3) : some error occured during read
 420 +	 */
 421 +	atomic_set(&thread_data.read_state, 0);
 422 +
 423 +	/* keep track of current no of threads */
 424 +	atomic_set(&thread_data.thread_count, init_threads);
 425 +	
 426 +	/* var: threads_required - current no of threads required. 
 427 +	 * This var is meant to be modified by some external
 428 +	 * function which determines current no of threads req
 429 +	 * acc to some criteria (such as variation in RTT over 
 430 +	 * a certain period) and set it to this var.
 431 +	 * Threads read this var and stop if required.
 432 +	 * Increase in no of threads (if reqd) is work for the 
 433 +	 * external function.
 434 +	 * Any such external function is not yet implemented.
 435 +	 */
 436 +	atomic_set(&thread_data.threads_required, init_threads);
 437 +
 438 +
 439 +	pagevec_init(&thread_data.lru_pvec, 0);
 440 +
 441 +	if (file->private_data == NULL) {
 442 +		FreeXid(thread_data.xid);
 443 +		return -EBADF;
 444 +	}
 445 +	
 446 +	sema_init(&thread_data.threadsem, 1);
 447 +
 448 +	down_interruptible(&thread_data.threadsem); 
 449 +	
 450 +	for (i=0; i<init_threads; i++)
 451 +		kthread_run(&cifs_readpages_threadfn, &thread_data, "cifsThread");
 452 +	
 453 +	if(down_interruptible(&thread_data.threadsem)) {
 454 +		thread_data.interrupted = 1;
 455 +		atomic_set(&thread_data.read_state, FIN_ERR);
 456 +		printk("\nCIFS: readpages interrupted by signal\n");
 457 +		sleep_on(&thread_data.wq_h);
 458 +
 459 +		while(!list_empty(page_list)) {
 460 +			page = list_entry(page_list->prev,struct page, lru);
 461 +			list_del(&page->lru);
 462 +			page_cache_release(page);
 463 +		}
 464 +		pagevec_lru_add(&thread_data.lru_pvec);
 465 +		FreeXid(thread_data.xid);
 466 +		return -ERESTARTSYS;	
 467 +	}
 468 +	
 469 +
 470 +	up(&thread_data.threadsem);		
 471 +	rc = 0;
 472 +	if (atomic_read(&thread_data.read_state) == FIN_ERR) {
 473 +		rc = -EACCES;
 474 +		printk("\nCIFS: some error occured during reading\n");
 475 +		wait_event_interruptible(thread_data.wq_h, (atomic_read(&thread_data.thread_count) <= 0) );
 476 +		while(!list_empty(page_list)) {
 477 +			page = list_entry(page_list->prev,struct page, lru);
 478 +			list_del(&page->lru);
 479 +			page_cache_release(page);
 480 +		}
 481 +	}
 482 +
 483 +	pagevec_lru_add(&thread_data.lru_pvec);
 484 +
 485 +	FreeXid(thread_data.xid);
 486  	return rc;
 487  }
 488  
 489 +
 490 +
 491 +
 492  static int cifs_readpage_worker(struct file *file, struct page *page, loff_t * poffset)
 493  {
 494  	char * read_data;