This source file includes following definitions.
- __wait_on_buffer
- sync_buffers
- sync_dev
- fsync_dev
- sys_sync
- file_fsync
- sys_fsync
- sys_fdatasync
- invalidate_buffers
- remove_from_hash_queue
- remove_from_lru_list
- remove_from_free_list
- remove_from_queues
- put_last_lru
- put_last_free
- insert_into_queues
- find_buffer
- get_hash_table
- set_blocksize
- refill_freelist
- getblk
- set_writetime
- refile_buffer
- __brelse
- __bforget
- bread
- breada
- put_unused_buffer_head
- get_more_buffer_heads
- recover_reusable_buffer_heads
- get_unused_buffer_head
- create_buffers
- brw_page
- mark_buffer_uptodate
- unlock_buffer
- generic_readpage
- grow_buffers
- try_to_free_buffer
- age_buffer
- maybe_shrink_lav_buffers
- shrink_specific_buffers
- show_buffers
- try_to_reassign
- reassign_cluster
- try_to_generate_cluster
- generate_cluster
- buffer_init
- wakeup_bdflush
- sync_old_buffers
- sys_bdflush
- bdflush
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 #include <linux/sched.h>
22 #include <linux/kernel.h>
23 #include <linux/major.h>
24 #include <linux/string.h>
25 #include <linux/locks.h>
26 #include <linux/errno.h>
27 #include <linux/malloc.h>
28 #include <linux/pagemap.h>
29 #include <linux/swap.h>
30 #include <linux/swapctl.h>
31 #include <linux/smp.h>
32 #include <linux/smp_lock.h>
33
34 #include <asm/system.h>
35 #include <asm/segment.h>
36 #include <asm/io.h>
37
38 #define NR_SIZES 5
39 static char buffersize_index[17] =
40 {-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, 4};
41 static short int bufferindex_size[NR_SIZES] = {512, 1024, 2048, 4096, 8192};
42
43 #define BUFSIZE_INDEX(X) ((int) buffersize_index[(X)>>9])
44 #define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
45
46 static int grow_buffers(int pri, int size);
47 static int shrink_specific_buffers(unsigned int priority, int size);
48 static int maybe_shrink_lav_buffers(int);
49
50 static int nr_hash = 0;
51 static struct buffer_head ** hash_table;
52 static struct buffer_head * lru_list[NR_LIST] = {NULL, };
53
54
55
56 static struct buffer_head * next_to_age[NR_LIST] = {NULL, };
57 static struct buffer_head * free_list[NR_SIZES] = {NULL, };
58
59 static struct buffer_head * unused_list = NULL;
60 struct buffer_head * reuse_list = NULL;
61 static struct wait_queue * buffer_wait = NULL;
62
63 int nr_buffers = 0;
64 int nr_buffers_type[NR_LIST] = {0,};
65 int nr_buffers_size[NR_SIZES] = {0,};
66 int nr_buffers_st[NR_SIZES][NR_LIST] = {{0,},};
67 int buffer_usage[NR_SIZES] = {0,};
68 int buffers_lav[NR_SIZES] = {0,};
69 int nr_free[NR_SIZES] = {0,};
70 int buffermem = 0;
71 int nr_buffer_heads = 0;
72 extern int *blksize_size[];
73
74
75
76
77
78 static void wakeup_bdflush(int);
79
80 #define N_PARAM 9
81 #define LAV
82
83 union bdflush_param{
84 struct {
85 int nfract;
86
87 int ndirty;
88
89 int nrefill;
90
91 int nref_dirt;
92
93 int clu_nfract;
94
95 int age_buffer;
96
97 int age_super;
98
99 int lav_const;
100
101 int lav_ratio;
102
103
104 } b_un;
105 unsigned int data[N_PARAM];
106 } bdf_prm = {{60, 500, 64, 256, 15, 30*HZ, 5*HZ, 1884, 2}};
107
108
109
110
111
112
113
114 int bdflush_min[N_PARAM] = { 0, 10, 5, 25, 0, 100, 100, 1, 1};
115 int bdflush_max[N_PARAM] = {100,5000, 2000, 2000,100, 60000, 60000, 2047, 5};
116
117
118
119
120
121
122
123
124
125
126 void __wait_on_buffer(struct buffer_head * bh)
127 {
128 struct wait_queue wait = { current, NULL };
129
130 bh->b_count++;
131 add_wait_queue(&bh->b_wait, &wait);
132 repeat:
133 run_task_queue(&tq_disk);
134 current->state = TASK_UNINTERRUPTIBLE;
135 if (buffer_locked(bh)) {
136 schedule();
137 goto repeat;
138 }
139 remove_wait_queue(&bh->b_wait, &wait);
140 bh->b_count--;
141 current->state = TASK_RUNNING;
142 }
143
144
145
146
147
148
149
150
151
152
153
154 static int sync_buffers(kdev_t dev, int wait)
155 {
156 int i, retry, pass = 0, err = 0;
157 int nlist, ncount;
158 struct buffer_head * bh, *next;
159
160
161
162
163
164 repeat:
165 retry = 0;
166 repeat2:
167 ncount = 0;
168
169
170 for(nlist = 0; nlist < NR_LIST; nlist++)
171 {
172 repeat1:
173 bh = lru_list[nlist];
174 if(!bh) continue;
175 for (i = nr_buffers_type[nlist]*2 ; i-- > 0 ; bh = next) {
176 if(bh->b_list != nlist) goto repeat1;
177 next = bh->b_next_free;
178 if(!lru_list[nlist]) break;
179 if (dev && bh->b_dev != dev)
180 continue;
181 if (buffer_locked(bh))
182 {
183
184
185 if (!wait || !pass) {
186 retry = 1;
187 continue;
188 }
189 wait_on_buffer (bh);
190 goto repeat2;
191 }
192
193
194 if (wait && buffer_req(bh) && !buffer_locked(bh) &&
195 !buffer_dirty(bh) && !buffer_uptodate(bh)) {
196 err = 1;
197 continue;
198 }
199
200
201 if (!buffer_dirty(bh) || pass>=2)
202 continue;
203
204 if (buffer_locked(bh))
205 continue;
206 bh->b_count++;
207 bh->b_flushtime = 0;
208 ll_rw_block(WRITE, 1, &bh);
209
210 if(nlist != BUF_DIRTY) {
211 printk("[%d %s %ld] ", nlist,
212 kdevname(bh->b_dev), bh->b_blocknr);
213 ncount++;
214 };
215 bh->b_count--;
216 retry = 1;
217 }
218 }
219 if (ncount)
220 printk("sys_sync: %d dirty buffers not on dirty list\n", ncount);
221
222
223
224
225
226 if (wait && retry && ++pass<=2)
227 goto repeat;
228 return err;
229 }
230
231 void sync_dev(kdev_t dev)
232 {
233 sync_buffers(dev, 0);
234 sync_supers(dev);
235 sync_inodes(dev);
236 sync_buffers(dev, 0);
237 sync_dquots(dev, -1);
238 }
239
240 int fsync_dev(kdev_t dev)
241 {
242 sync_buffers(dev, 0);
243 sync_supers(dev);
244 sync_inodes(dev);
245 sync_dquots(dev, -1);
246 return sync_buffers(dev, 1);
247 }
248
249 asmlinkage int sys_sync(void)
250 {
251 fsync_dev(0);
252 return 0;
253 }
254
255 int file_fsync (struct inode *inode, struct file *filp)
256 {
257 return fsync_dev(inode->i_dev);
258 }
259
260 asmlinkage int sys_fsync(unsigned int fd)
261 {
262 struct file * file;
263 struct inode * inode;
264
265 if (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))
266 return -EBADF;
267 if (!file->f_op || !file->f_op->fsync)
268 return -EINVAL;
269 if (file->f_op->fsync(inode,file))
270 return -EIO;
271 return 0;
272 }
273
274 asmlinkage int sys_fdatasync(unsigned int fd)
275 {
276 struct file * file;
277 struct inode * inode;
278
279 if (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))
280 return -EBADF;
281 if (!file->f_op || !file->f_op->fsync)
282 return -EINVAL;
283
284 if (file->f_op->fsync(inode,file))
285 return -EIO;
286 return 0;
287 }
288
289 void invalidate_buffers(kdev_t dev)
290 {
291 int i;
292 int nlist;
293 struct buffer_head * bh;
294
295 for(nlist = 0; nlist < NR_LIST; nlist++) {
296 bh = lru_list[nlist];
297 for (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bh->b_next_free) {
298 if (bh->b_dev != dev)
299 continue;
300 wait_on_buffer(bh);
301 if (bh->b_dev != dev)
302 continue;
303 if (bh->b_count)
304 continue;
305 bh->b_flushtime = 0;
306 clear_bit(BH_Protected, &bh->b_state);
307 clear_bit(BH_Uptodate, &bh->b_state);
308 clear_bit(BH_Dirty, &bh->b_state);
309 clear_bit(BH_Req, &bh->b_state);
310 }
311 }
312 }
313
314 #define _hashfn(dev,block) (((unsigned)(HASHDEV(dev)^block))%nr_hash)
315 #define hash(dev,block) hash_table[_hashfn(dev,block)]
316
317 static inline void remove_from_hash_queue(struct buffer_head * bh)
318 {
319 if (bh->b_next)
320 bh->b_next->b_prev = bh->b_prev;
321 if (bh->b_prev)
322 bh->b_prev->b_next = bh->b_next;
323 if (hash(bh->b_dev,bh->b_blocknr) == bh)
324 hash(bh->b_dev,bh->b_blocknr) = bh->b_next;
325 bh->b_next = bh->b_prev = NULL;
326 }
327
328 static inline void remove_from_lru_list(struct buffer_head * bh)
329 {
330 if (!(bh->b_prev_free) || !(bh->b_next_free))
331 panic("VFS: LRU block list corrupted");
332 if (bh->b_dev == B_FREE)
333 panic("LRU list corrupted");
334 bh->b_prev_free->b_next_free = bh->b_next_free;
335 bh->b_next_free->b_prev_free = bh->b_prev_free;
336
337 if (lru_list[bh->b_list] == bh)
338 lru_list[bh->b_list] = bh->b_next_free;
339 if (lru_list[bh->b_list] == bh)
340 lru_list[bh->b_list] = NULL;
341 if (next_to_age[bh->b_list] == bh)
342 next_to_age[bh->b_list] = bh->b_next_free;
343 if (next_to_age[bh->b_list] == bh)
344 next_to_age[bh->b_list] = NULL;
345
346 bh->b_next_free = bh->b_prev_free = NULL;
347 }
348
349 static inline void remove_from_free_list(struct buffer_head * bh)
350 {
351 int isize = BUFSIZE_INDEX(bh->b_size);
352 if (!(bh->b_prev_free) || !(bh->b_next_free))
353 panic("VFS: Free block list corrupted");
354 if(bh->b_dev != B_FREE)
355 panic("Free list corrupted");
356 if(!free_list[isize])
357 panic("Free list empty");
358 nr_free[isize]--;
359 if(bh->b_next_free == bh)
360 free_list[isize] = NULL;
361 else {
362 bh->b_prev_free->b_next_free = bh->b_next_free;
363 bh->b_next_free->b_prev_free = bh->b_prev_free;
364 if (free_list[isize] == bh)
365 free_list[isize] = bh->b_next_free;
366 }
367 bh->b_next_free = bh->b_prev_free = NULL;
368 }
369
370 static inline void remove_from_queues(struct buffer_head * bh)
371 {
372 if(bh->b_dev == B_FREE) {
373 remove_from_free_list(bh);
374
375 return;
376 };
377 nr_buffers_type[bh->b_list]--;
378 nr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]--;
379 remove_from_hash_queue(bh);
380 remove_from_lru_list(bh);
381 }
382
383 static inline void put_last_lru(struct buffer_head * bh)
384 {
385 if (!bh)
386 return;
387 if (bh == lru_list[bh->b_list]) {
388 lru_list[bh->b_list] = bh->b_next_free;
389 if (next_to_age[bh->b_list] == bh)
390 next_to_age[bh->b_list] = bh->b_next_free;
391 return;
392 }
393 if(bh->b_dev == B_FREE)
394 panic("Wrong block for lru list");
395 remove_from_lru_list(bh);
396
397
398 if(!lru_list[bh->b_list]) {
399 lru_list[bh->b_list] = bh;
400 lru_list[bh->b_list]->b_prev_free = bh;
401 }
402 if (!next_to_age[bh->b_list])
403 next_to_age[bh->b_list] = bh;
404
405 bh->b_next_free = lru_list[bh->b_list];
406 bh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
407 lru_list[bh->b_list]->b_prev_free->b_next_free = bh;
408 lru_list[bh->b_list]->b_prev_free = bh;
409 }
410
411 static inline void put_last_free(struct buffer_head * bh)
412 {
413 int isize;
414 if (!bh)
415 return;
416
417 isize = BUFSIZE_INDEX(bh->b_size);
418 bh->b_dev = B_FREE;
419
420 if(!free_list[isize]) {
421 free_list[isize] = bh;
422 bh->b_prev_free = bh;
423 };
424
425 nr_free[isize]++;
426 bh->b_next_free = free_list[isize];
427 bh->b_prev_free = free_list[isize]->b_prev_free;
428 free_list[isize]->b_prev_free->b_next_free = bh;
429 free_list[isize]->b_prev_free = bh;
430 }
431
432 static inline void insert_into_queues(struct buffer_head * bh)
433 {
434
435 if(bh->b_dev == B_FREE) {
436 put_last_free(bh);
437 return;
438 }
439 if(!lru_list[bh->b_list]) {
440 lru_list[bh->b_list] = bh;
441 bh->b_prev_free = bh;
442 }
443 if (!next_to_age[bh->b_list])
444 next_to_age[bh->b_list] = bh;
445 if (bh->b_next_free) panic("VFS: buffer LRU pointers corrupted");
446 bh->b_next_free = lru_list[bh->b_list];
447 bh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
448 lru_list[bh->b_list]->b_prev_free->b_next_free = bh;
449 lru_list[bh->b_list]->b_prev_free = bh;
450 nr_buffers_type[bh->b_list]++;
451 nr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]++;
452
453 bh->b_prev = NULL;
454 bh->b_next = NULL;
455 if (!(bh->b_dev))
456 return;
457 bh->b_next = hash(bh->b_dev,bh->b_blocknr);
458 hash(bh->b_dev,bh->b_blocknr) = bh;
459 if (bh->b_next)
460 bh->b_next->b_prev = bh;
461 }
462
463 static inline struct buffer_head * find_buffer(kdev_t dev, int block, int size)
464 {
465 struct buffer_head * tmp;
466
467 for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
468 if (tmp->b_blocknr == block && tmp->b_dev == dev)
469 if (tmp->b_size == size)
470 return tmp;
471 else {
472 printk("VFS: Wrong blocksize on device %s\n",
473 kdevname(dev));
474 return NULL;
475 }
476 return NULL;
477 }
478
479
480
481
482
483
484
485
486 struct buffer_head * get_hash_table(kdev_t dev, int block, int size)
487 {
488 struct buffer_head * bh;
489
490 for (;;) {
491 if (!(bh=find_buffer(dev,block,size)))
492 return NULL;
493 bh->b_count++;
494 wait_on_buffer(bh);
495 if (bh->b_dev == dev && bh->b_blocknr == block
496 && bh->b_size == size)
497 return bh;
498 bh->b_count--;
499 }
500 }
501
502 void set_blocksize(kdev_t dev, int size)
503 {
504 int i, nlist;
505 struct buffer_head * bh, *bhnext;
506
507 if (!blksize_size[MAJOR(dev)])
508 return;
509
510 if (size > PAGE_SIZE)
511 size = 0;
512
513 switch (size) {
514 default: panic("Invalid blocksize passed to set_blocksize");
515 case 512: case 1024: case 2048: case 4096: case 8192: ;
516 }
517
518 if (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
519 blksize_size[MAJOR(dev)][MINOR(dev)] = size;
520 return;
521 }
522 if (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
523 return;
524 sync_buffers(dev, 2);
525 blksize_size[MAJOR(dev)][MINOR(dev)] = size;
526
527
528
529
530 for(nlist = 0; nlist < NR_LIST; nlist++) {
531 bh = lru_list[nlist];
532 for (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bhnext) {
533 if(!bh) break;
534 bhnext = bh->b_next_free;
535 if (bh->b_dev != dev)
536 continue;
537 if (bh->b_size == size)
538 continue;
539
540 wait_on_buffer(bh);
541 if (bh->b_dev == dev && bh->b_size != size) {
542 clear_bit(BH_Dirty, &bh->b_state);
543 clear_bit(BH_Uptodate, &bh->b_state);
544 clear_bit(BH_Req, &bh->b_state);
545 bh->b_flushtime = 0;
546 }
547 remove_from_hash_queue(bh);
548 }
549 }
550 }
551
552 #define BADNESS(bh) (buffer_dirty(bh) || buffer_locked(bh))
553
554 void refill_freelist(int size)
555 {
556 struct buffer_head * bh, * tmp;
557 struct buffer_head * candidate[NR_LIST];
558 unsigned int best_time, winner;
559 int isize = BUFSIZE_INDEX(size);
560 int buffers[NR_LIST];
561 int i;
562 int needed;
563
564
565
566
567
568 if (nr_free[isize] > 100)
569 return;
570
571
572
573
574
575
576 needed =bdf_prm.b_un.nrefill * size;
577
578 while (nr_free_pages > min_free_pages*2 && needed > 0 &&
579 grow_buffers(GFP_BUFFER, size)) {
580 needed -= PAGE_SIZE;
581 }
582
583 if(needed <= 0) return;
584
585
586
587
588 while(maybe_shrink_lav_buffers(size))
589 {
590 if(!grow_buffers(GFP_BUFFER, size)) break;
591 needed -= PAGE_SIZE;
592 if(needed <= 0) return;
593 };
594
595
596
597
598
599
600
601 repeat0:
602 for(i=0; i<NR_LIST; i++){
603 if(i == BUF_DIRTY || i == BUF_SHARED ||
604 nr_buffers_type[i] == 0) {
605 candidate[i] = NULL;
606 buffers[i] = 0;
607 continue;
608 }
609 buffers[i] = nr_buffers_type[i];
610 for (bh = lru_list[i]; buffers[i] > 0; bh = tmp, buffers[i]--)
611 {
612 if(buffers[i] < 0) panic("Here is the problem");
613 tmp = bh->b_next_free;
614 if (!bh) break;
615
616 if (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
617 buffer_dirty(bh)) {
618 refile_buffer(bh);
619 continue;
620 }
621
622 if (bh->b_count || buffer_protected(bh) || bh->b_size != size)
623 continue;
624
625
626
627
628
629 if (buffer_locked(bh) && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
630 buffers[i] = 0;
631 break;
632 }
633
634 if (BADNESS(bh)) continue;
635 break;
636 };
637 if(!buffers[i]) candidate[i] = NULL;
638 else candidate[i] = bh;
639 if(candidate[i] && candidate[i]->b_count) panic("Here is the problem");
640 }
641
642 repeat:
643 if(needed <= 0) return;
644
645
646
647 winner = best_time = UINT_MAX;
648 for(i=0; i<NR_LIST; i++){
649 if(!candidate[i]) continue;
650 if(candidate[i]->b_lru_time < best_time){
651 best_time = candidate[i]->b_lru_time;
652 winner = i;
653 }
654 }
655
656
657 if(winner != UINT_MAX) {
658 i = winner;
659 bh = candidate[i];
660 candidate[i] = bh->b_next_free;
661 if(candidate[i] == bh) candidate[i] = NULL;
662 if (bh->b_count || bh->b_size != size)
663 panic("Busy buffer in candidate list\n");
664 if (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1)
665 panic("Shared buffer in candidate list\n");
666 if (buffer_protected(bh))
667 panic("Protected buffer in candidate list\n");
668 if (BADNESS(bh)) panic("Buffer in candidate list with BADNESS != 0\n");
669
670 if(bh->b_dev == B_FREE)
671 panic("Wrong list");
672 remove_from_queues(bh);
673 bh->b_dev = B_FREE;
674 put_last_free(bh);
675 needed -= bh->b_size;
676 buffers[i]--;
677 if(buffers[i] < 0) panic("Here is the problem");
678
679 if(buffers[i] == 0) candidate[i] = NULL;
680
681
682
683 if(candidate[i] && buffers[i] > 0){
684 if(buffers[i] <= 0) panic("Here is another problem");
685 for (bh = candidate[i]; buffers[i] > 0; bh = tmp, buffers[i]--) {
686 if(buffers[i] < 0) panic("Here is the problem");
687 tmp = bh->b_next_free;
688 if (!bh) break;
689
690 if (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
691 buffer_dirty(bh)) {
692 refile_buffer(bh);
693 continue;
694 };
695
696 if (bh->b_count || buffer_protected(bh) || bh->b_size != size)
697 continue;
698
699
700
701
702
703 if (buffer_locked(bh) && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
704 buffers[i] = 0;
705 break;
706 }
707
708 if (BADNESS(bh)) continue;
709 break;
710 };
711 if(!buffers[i]) candidate[i] = NULL;
712 else candidate[i] = bh;
713 if(candidate[i] && candidate[i]->b_count)
714 panic("Here is the problem");
715 }
716
717 goto repeat;
718 }
719
720 if(needed <= 0) return;
721
722
723
724 if (nr_free_pages > min_free_pages + 5) {
725 if (grow_buffers(GFP_BUFFER, size)) {
726 needed -= PAGE_SIZE;
727 goto repeat0;
728 };
729 }
730
731
732 if (!grow_buffers(GFP_ATOMIC, size))
733 wakeup_bdflush(1);
734 needed -= PAGE_SIZE;
735 goto repeat0;
736 }
737
738
739
740
741
742
743
744
745
746
747
748 struct buffer_head * getblk(kdev_t dev, int block, int size)
749 {
750 struct buffer_head * bh;
751 int isize = BUFSIZE_INDEX(size);
752
753
754 buffer_usage[isize]++;
755
756
757
758
759 repeat:
760 bh = get_hash_table(dev, block, size);
761 if (bh) {
762 if (!buffer_dirty(bh)) {
763 if (buffer_uptodate(bh))
764 put_last_lru(bh);
765 bh->b_flushtime = 0;
766 }
767 set_bit(BH_Touched, &bh->b_state);
768 return bh;
769 }
770
771 while(!free_list[isize]) refill_freelist(size);
772
773 if (find_buffer(dev,block,size))
774 goto repeat;
775
776 bh = free_list[isize];
777 remove_from_free_list(bh);
778
779
780
781 bh->b_count=1;
782 bh->b_flushtime=0;
783 bh->b_state=(1<<BH_Touched);
784 bh->b_dev=dev;
785 bh->b_blocknr=block;
786 insert_into_queues(bh);
787 return bh;
788 }
789
790 void set_writetime(struct buffer_head * buf, int flag)
791 {
792 int newtime;
793
794 if (buffer_dirty(buf)) {
795
796 newtime = jiffies + (flag ? bdf_prm.b_un.age_super :
797 bdf_prm.b_un.age_buffer);
798 if(!buf->b_flushtime || buf->b_flushtime > newtime)
799 buf->b_flushtime = newtime;
800 } else {
801 buf->b_flushtime = 0;
802 }
803 }
804
805
806 void refile_buffer(struct buffer_head * buf)
807 {
808 int dispose;
809
810 if(buf->b_dev == B_FREE) {
811 printk("Attempt to refile free buffer\n");
812 return;
813 }
814 if (buffer_dirty(buf))
815 dispose = BUF_DIRTY;
816 else if ((mem_map[MAP_NR((unsigned long) buf->b_data)].count > 1) || buffer_protected(buf))
817 dispose = BUF_SHARED;
818 else if (buffer_locked(buf))
819 dispose = BUF_LOCKED;
820 else if (buf->b_list == BUF_SHARED)
821 dispose = BUF_UNSHARED;
822 else
823 dispose = BUF_CLEAN;
824 if(dispose == BUF_CLEAN) buf->b_lru_time = jiffies;
825 if(dispose != buf->b_list) {
826 if(dispose == BUF_DIRTY || dispose == BUF_UNSHARED)
827 buf->b_lru_time = jiffies;
828 if(dispose == BUF_LOCKED &&
829 (buf->b_flushtime - buf->b_lru_time) <= bdf_prm.b_un.age_super)
830 dispose = BUF_LOCKED1;
831 remove_from_queues(buf);
832 buf->b_list = dispose;
833 insert_into_queues(buf);
834 if(dispose == BUF_DIRTY && nr_buffers_type[BUF_DIRTY] >
835 (nr_buffers - nr_buffers_type[BUF_SHARED]) *
836 bdf_prm.b_un.nfract/100)
837 wakeup_bdflush(0);
838 }
839 }
840
841
842
843
844 void __brelse(struct buffer_head * buf)
845 {
846 wait_on_buffer(buf);
847
848
849 set_writetime(buf, 0);
850 refile_buffer(buf);
851
852 if (buf->b_count) {
853 buf->b_count--;
854 return;
855 }
856 printk("VFS: brelse: Trying to free free buffer\n");
857 }
858
859
860
861
862
863
864 void __bforget(struct buffer_head * buf)
865 {
866 wait_on_buffer(buf);
867 mark_buffer_clean(buf);
868 clear_bit(BH_Protected, &buf->b_state);
869 buf->b_count--;
870 remove_from_hash_queue(buf);
871 buf->b_dev = NODEV;
872 refile_buffer(buf);
873 }
874
875
876
877
878
879 struct buffer_head * bread(kdev_t dev, int block, int size)
880 {
881 struct buffer_head * bh;
882
883 if (!(bh = getblk(dev, block, size))) {
884 printk("VFS: bread: READ error on device %s\n",
885 kdevname(dev));
886 return NULL;
887 }
888 if (buffer_uptodate(bh))
889 return bh;
890 ll_rw_block(READ, 1, &bh);
891 wait_on_buffer(bh);
892 if (buffer_uptodate(bh))
893 return bh;
894 brelse(bh);
895 return NULL;
896 }
897
898
899
900
901
902
903
904 #define NBUF 16
905
906 struct buffer_head * breada(kdev_t dev, int block, int bufsize,
907 unsigned int pos, unsigned int filesize)
908 {
909 struct buffer_head * bhlist[NBUF];
910 unsigned int blocks;
911 struct buffer_head * bh;
912 int index;
913 int i, j;
914
915 if (pos >= filesize)
916 return NULL;
917
918 if (block < 0 || !(bh = getblk(dev,block,bufsize)))
919 return NULL;
920
921 index = BUFSIZE_INDEX(bh->b_size);
922
923 if (buffer_uptodate(bh))
924 return bh;
925
926 blocks = ((filesize & (bufsize - 1)) - (pos & (bufsize - 1))) >> (9+index);
927
928 if (blocks > (read_ahead[MAJOR(dev)] >> index))
929 blocks = read_ahead[MAJOR(dev)] >> index;
930 if (blocks > NBUF)
931 blocks = NBUF;
932
933 bhlist[0] = bh;
934 j = 1;
935 for(i=1; i<blocks; i++) {
936 bh = getblk(dev,block+i,bufsize);
937 if (buffer_uptodate(bh)) {
938 brelse(bh);
939 break;
940 }
941 bhlist[j++] = bh;
942 }
943
944
945 ll_rw_block(READ, j, bhlist);
946
947 for(i=1; i<j; i++)
948 brelse(bhlist[i]);
949
950
951 bh = bhlist[0];
952 wait_on_buffer(bh);
953 if (buffer_uptodate(bh))
954 return bh;
955 brelse(bh);
956 return NULL;
957 }
958
959
960
961
962 static void put_unused_buffer_head(struct buffer_head * bh)
963 {
964 struct wait_queue * wait;
965
966 wait = ((volatile struct buffer_head *) bh)->b_wait;
967 memset(bh,0,sizeof(*bh));
968 ((volatile struct buffer_head *) bh)->b_wait = wait;
969 bh->b_next_free = unused_list;
970 unused_list = bh;
971 wake_up(&buffer_wait);
972 }
973
974 static void get_more_buffer_heads(void)
975 {
976 int i;
977 struct buffer_head * bh;
978
979 for (;;) {
980 if (unused_list)
981 return;
982
983
984
985
986
987
988 bh = (struct buffer_head *) get_free_page(GFP_ATOMIC);
989 if (bh)
990 break;
991
992
993
994
995
996
997 run_task_queue(&tq_disk);
998 sleep_on(&buffer_wait);
999 }
1000
1001 for (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
1002 bh->b_next_free = unused_list;
1003 unused_list = bh++;
1004 }
1005 }
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020 static inline void recover_reusable_buffer_heads(void)
1021 {
1022 if (reuse_list) {
1023 struct buffer_head *bh;
1024 unsigned long flags;
1025
1026 save_flags(flags);
1027 do {
1028 cli();
1029 bh = reuse_list;
1030 reuse_list = bh->b_next_free;
1031 restore_flags(flags);
1032 put_unused_buffer_head(bh);
1033 } while (reuse_list);
1034 }
1035 }
1036
1037 static struct buffer_head * get_unused_buffer_head(void)
1038 {
1039 struct buffer_head * bh;
1040
1041 recover_reusable_buffer_heads();
1042 get_more_buffer_heads();
1043 if (!unused_list)
1044 return NULL;
1045 bh = unused_list;
1046 unused_list = bh->b_next_free;
1047 bh->b_next_free = NULL;
1048 bh->b_data = NULL;
1049 bh->b_size = 0;
1050 bh->b_state = 0;
1051 return bh;
1052 }
1053
1054
1055
1056
1057
1058
1059
1060 static struct buffer_head * create_buffers(unsigned long page, unsigned long size)
1061 {
1062 struct buffer_head *bh, *head;
1063 unsigned long offset;
1064
1065 head = NULL;
1066 offset = PAGE_SIZE;
1067 while ((offset -= size) < PAGE_SIZE) {
1068 bh = get_unused_buffer_head();
1069 if (!bh)
1070 goto no_grow;
1071 bh->b_this_page = head;
1072 head = bh;
1073 bh->b_data = (char *) (page+offset);
1074 bh->b_size = size;
1075 bh->b_dev = B_FREE;
1076 }
1077 return head;
1078
1079
1080
1081 no_grow:
1082 bh = head;
1083 while (bh) {
1084 head = bh;
1085 bh = bh->b_this_page;
1086 put_unused_buffer_head(head);
1087 }
1088 return NULL;
1089 }
1090
1091 int brw_page(int rw, unsigned long address, kdev_t dev, int b[], int size, int bmap)
1092 {
1093 struct buffer_head *bh, *prev, *next, *arr[MAX_BUF_PER_PAGE];
1094 int block, nr;
1095 struct page *page;
1096
1097 page = mem_map + MAP_NR(address);
1098 page->uptodate = 0;
1099 bh = create_buffers(address, size);
1100 if (!bh)
1101 return -ENOMEM;
1102 nr = 0;
1103 next = bh;
1104 do {
1105 struct buffer_head * tmp;
1106 block = *(b++);
1107
1108 set_bit(BH_FreeOnIO, &next->b_state);
1109 next->b_list = BUF_CLEAN;
1110 next->b_dev = dev;
1111 next->b_blocknr = block;
1112 next->b_count = 1;
1113 next->b_flushtime = 0;
1114 set_bit(BH_Uptodate, &next->b_state);
1115
1116
1117
1118
1119
1120
1121 if (bmap && !block) {
1122 memset(next->b_data, 0, size);
1123 next->b_count--;
1124 continue;
1125 }
1126 tmp = get_hash_table(dev, block, size);
1127 if (tmp) {
1128 if (!buffer_uptodate(tmp)) {
1129 if (rw == READ)
1130 ll_rw_block(READ, 1, &tmp);
1131 wait_on_buffer(tmp);
1132 }
1133 if (rw == READ)
1134 memcpy(next->b_data, tmp->b_data, size);
1135 else {
1136 memcpy(tmp->b_data, next->b_data, size);
1137 mark_buffer_dirty(tmp, 0);
1138 }
1139 brelse(tmp);
1140 next->b_count--;
1141 continue;
1142 }
1143 if (rw == READ)
1144 clear_bit(BH_Uptodate, &next->b_state);
1145 else
1146 set_bit(BH_Dirty, &next->b_state);
1147 arr[nr++] = next;
1148 } while (prev = next, (next = next->b_this_page) != NULL);
1149 prev->b_this_page = bh;
1150
1151 if (nr)
1152 ll_rw_block(rw, nr, arr);
1153 else {
1154 unsigned long flags;
1155 page->locked = 0;
1156 page->uptodate = 1;
1157 wake_up(&page->wait);
1158 next = bh;
1159 save_flags(flags);
1160 cli();
1161 do {
1162 next->b_next_free = reuse_list;
1163 reuse_list = next;
1164 next = next->b_this_page;
1165 } while (next != bh);
1166 restore_flags(flags);
1167 }
1168 ++current->maj_flt;
1169 return 0;
1170 }
1171
1172 void mark_buffer_uptodate(struct buffer_head * bh, int on)
1173 {
1174 if (on) {
1175 struct buffer_head *tmp = bh;
1176 int page_uptodate = 1;
1177 set_bit(BH_Uptodate, &bh->b_state);
1178 do {
1179 if (!test_bit(BH_Uptodate, &tmp->b_state)) {
1180 page_uptodate = 0;
1181 break;
1182 }
1183 tmp=tmp->b_this_page;
1184 } while (tmp && tmp != bh);
1185 if (page_uptodate)
1186 mem_map[MAP_NR(bh->b_data)].uptodate = 1;
1187 } else
1188 clear_bit(BH_Uptodate, &bh->b_state);
1189 }
1190
1191 void unlock_buffer(struct buffer_head * bh)
1192 {
1193 struct buffer_head *tmp;
1194 unsigned long flags;
1195 struct page *page;
1196
1197 clear_bit(BH_Lock, &bh->b_state);
1198 wake_up(&bh->b_wait);
1199
1200 if (!test_bit(BH_FreeOnIO, &bh->b_state))
1201 return;
1202 page = mem_map + MAP_NR(bh->b_data);
1203 if (!page->locked) {
1204 printk ("Whoops: unlock_buffer: "
1205 "async io complete on unlocked page\n");
1206 return;
1207 }
1208 if (bh->b_count != 1) {
1209 printk ("Whoops: unlock_buffer: b_count != 1 on async io.\n");
1210 return;
1211 }
1212
1213
1214
1215
1216 bh->b_count--;
1217 for (tmp = bh; tmp=tmp->b_this_page, tmp!=bh; ) {
1218 if (test_bit(BH_Lock, &tmp->b_state) || tmp->b_count)
1219 return;
1220 }
1221
1222
1223 save_flags(flags);
1224 page->locked = 0;
1225 wake_up(&page->wait);
1226 cli();
1227 tmp = bh;
1228 do {
1229 if (!test_bit(BH_FreeOnIO, &tmp->b_state)) {
1230 printk ("Whoops: unlock_buffer: "
1231 "async IO mismatch on page.\n");
1232 restore_flags(flags);
1233 return;
1234 }
1235 tmp->b_next_free = reuse_list;
1236 reuse_list = tmp;
1237 clear_bit(BH_FreeOnIO, &tmp->b_state);
1238 tmp = tmp->b_this_page;
1239 } while (tmp != bh);
1240 restore_flags(flags);
1241 if (page->free_after) {
1242 extern int nr_async_pages;
1243 nr_async_pages--;
1244 page->free_after = 0;
1245 free_page(page_address(page));
1246 }
1247 wake_up(&buffer_wait);
1248 }
1249
1250
1251
1252
1253
1254
1255
1256
1257 int generic_readpage(struct inode * inode, struct page * page)
1258 {
1259 unsigned long block, address;
1260 int *p, nr[PAGE_SIZE/512];
1261 int i;
1262
1263 address = page_address(page);
1264 page->count++;
1265 page->locked = 1;
1266
1267 i = PAGE_SIZE >> inode->i_sb->s_blocksize_bits;
1268 block = page->offset >> inode->i_sb->s_blocksize_bits;
1269 p = nr;
1270 do {
1271 *p = inode->i_op->bmap(inode, block);
1272 i--;
1273 block++;
1274 p++;
1275 } while (i > 0);
1276
1277
1278 brw_page(READ, address, inode->i_dev, nr, inode->i_sb->s_blocksize, 1);
1279 free_page(address);
1280 return 0;
1281 }
1282
1283
1284
1285
1286
1287 static int grow_buffers(int pri, int size)
1288 {
1289 unsigned long page;
1290 struct buffer_head *bh, *tmp;
1291 struct buffer_head * insert_point;
1292 int isize;
1293
1294 if ((size & 511) || (size > PAGE_SIZE)) {
1295 printk("VFS: grow_buffers: size = %d\n",size);
1296 return 0;
1297 }
1298
1299 isize = BUFSIZE_INDEX(size);
1300
1301 if (!(page = __get_free_page(pri)))
1302 return 0;
1303 bh = create_buffers(page, size);
1304 if (!bh) {
1305 free_page(page);
1306 return 0;
1307 }
1308
1309 insert_point = free_list[isize];
1310
1311 tmp = bh;
1312 while (1) {
1313 nr_free[isize]++;
1314 if (insert_point) {
1315 tmp->b_next_free = insert_point->b_next_free;
1316 tmp->b_prev_free = insert_point;
1317 insert_point->b_next_free->b_prev_free = tmp;
1318 insert_point->b_next_free = tmp;
1319 } else {
1320 tmp->b_prev_free = tmp;
1321 tmp->b_next_free = tmp;
1322 }
1323 insert_point = tmp;
1324 ++nr_buffers;
1325 if (tmp->b_this_page)
1326 tmp = tmp->b_this_page;
1327 else
1328 break;
1329 }
1330 free_list[isize] = bh;
1331 mem_map[MAP_NR(page)].buffers = bh;
1332 tmp->b_this_page = bh;
1333 buffermem += PAGE_SIZE;
1334 return 1;
1335 }
1336
1337
1338
1339
1340
1341
1342
1343
1344 int try_to_free_buffer(struct buffer_head * bh, struct buffer_head ** bhp,
1345 int priority)
1346 {
1347 unsigned long page;
1348 struct buffer_head * tmp, * p;
1349 int isize = BUFSIZE_INDEX(bh->b_size);
1350
1351 *bhp = bh;
1352 page = (unsigned long) bh->b_data;
1353 page &= PAGE_MASK;
1354 tmp = bh;
1355 do {
1356 if (!tmp)
1357 return 0;
1358 if (tmp->b_count || buffer_protected(tmp) ||
1359 buffer_dirty(tmp) || buffer_locked(tmp) || tmp->b_wait)
1360 return 0;
1361 if (priority && buffer_touched(tmp))
1362 return 0;
1363 tmp = tmp->b_this_page;
1364 } while (tmp != bh);
1365 tmp = bh;
1366 do {
1367 p = tmp;
1368 tmp = tmp->b_this_page;
1369 nr_buffers--;
1370 nr_buffers_size[isize]--;
1371 if (p == *bhp)
1372 {
1373 *bhp = p->b_prev_free;
1374 if (p == *bhp)
1375 *bhp = NULL;
1376 }
1377 remove_from_queues(p);
1378 put_unused_buffer_head(p);
1379 } while (tmp != bh);
1380 buffermem -= PAGE_SIZE;
1381 mem_map[MAP_NR(page)].buffers = NULL;
1382 free_page(page);
1383 return !mem_map[MAP_NR(page)].count;
1384 }
1385
1386
1387
1388 static inline void age_buffer(struct buffer_head *bh)
1389 {
1390 struct buffer_head *tmp = bh;
1391 int touched = 0;
1392
1393
1394
1395
1396
1397
1398
1399
1400 if (clear_bit(BH_Has_aged, &bh->b_state))
1401 return;
1402
1403 do {
1404 touched |= clear_bit(BH_Touched, &tmp->b_state);
1405 tmp = tmp->b_this_page;
1406 set_bit(BH_Has_aged, &tmp->b_state);
1407 } while (tmp != bh);
1408 clear_bit(BH_Has_aged, &bh->b_state);
1409
1410 if (touched)
1411 touch_page(mem_map + MAP_NR((unsigned long) bh->b_data));
1412 else
1413 age_page(mem_map + MAP_NR((unsigned long) bh->b_data));
1414 }
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428 static int maybe_shrink_lav_buffers(int size)
1429 {
1430 int nlist;
1431 int isize;
1432 int total_lav, total_n_buffers, n_sizes;
1433
1434
1435
1436
1437
1438
1439 total_lav = total_n_buffers = n_sizes = 0;
1440 for(nlist = 0; nlist < NR_SIZES; nlist++)
1441 {
1442 total_lav += buffers_lav[nlist];
1443 if(nr_buffers_size[nlist]) n_sizes++;
1444 total_n_buffers += nr_buffers_size[nlist];
1445 total_n_buffers -= nr_buffers_st[nlist][BUF_SHARED];
1446 }
1447
1448
1449
1450
1451 isize = (size ? BUFSIZE_INDEX(size) : -1);
1452
1453 if (n_sizes > 1)
1454 for(nlist = 0; nlist < NR_SIZES; nlist++)
1455 {
1456 if(nlist == isize) continue;
1457 if(nr_buffers_size[nlist] &&
1458 bdf_prm.b_un.lav_const * buffers_lav[nlist]*total_n_buffers <
1459 total_lav * (nr_buffers_size[nlist] - nr_buffers_st[nlist][BUF_SHARED]))
1460 if(shrink_specific_buffers(6, bufferindex_size[nlist]))
1461 return 1;
1462 }
1463 return 0;
1464 }
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478 static int shrink_specific_buffers(unsigned int priority, int size)
1479 {
1480 struct buffer_head *bh;
1481 int nlist;
1482 int i, isize, isize1;
1483
1484 #ifdef DEBUG
1485 if(size) printk("Shrinking buffers of size %d\n", size);
1486 #endif
1487
1488
1489 isize1 = (size ? BUFSIZE_INDEX(size) : -1);
1490
1491 for(isize = 0; isize<NR_SIZES; isize++){
1492 if(isize1 != -1 && isize1 != isize) continue;
1493 bh = free_list[isize];
1494 if(!bh) continue;
1495 for (i=0 ; !i || bh != free_list[isize]; bh = bh->b_next_free, i++) {
1496 if (bh->b_count || buffer_protected(bh) ||
1497 !bh->b_this_page)
1498 continue;
1499 if (!age_of((unsigned long) bh->b_data) &&
1500 try_to_free_buffer(bh, &bh, 6))
1501 return 1;
1502 if(!bh) break;
1503
1504
1505 }
1506 }
1507
1508
1509
1510 for(nlist = 0; nlist < NR_LIST; nlist++) {
1511 repeat1:
1512 if(priority > 2 && nlist == BUF_SHARED) continue;
1513 i = nr_buffers_type[nlist];
1514 i = ((BUFFEROUT_WEIGHT * i) >> 10) >> priority;
1515 for ( ; i > 0; i-- ) {
1516 bh = next_to_age[nlist];
1517 if (!bh)
1518 break;
1519 next_to_age[nlist] = bh->b_next_free;
1520
1521
1522 age_buffer(bh);
1523
1524
1525 if(bh->b_list != nlist) goto repeat1;
1526 if (bh->b_count || buffer_protected(bh) ||
1527 !bh->b_this_page)
1528 continue;
1529 if(size && bh->b_size != size) continue;
1530 if (buffer_locked(bh))
1531 if (priority)
1532 continue;
1533 else
1534 wait_on_buffer(bh);
1535 if (buffer_dirty(bh)) {
1536 bh->b_count++;
1537 bh->b_flushtime = 0;
1538 ll_rw_block(WRITEA, 1, &bh);
1539 bh->b_count--;
1540 continue;
1541 }
1542
1543
1544
1545 if ((age_of((unsigned long) bh->b_data) >>
1546 (6-priority)) > 0)
1547 continue;
1548 if (try_to_free_buffer(bh, &bh, 0))
1549 return 1;
1550 if(!bh) break;
1551 }
1552 }
1553 return 0;
1554 }
1555
1556
1557
1558
1559 void show_buffers(void)
1560 {
1561 struct buffer_head * bh;
1562 int found = 0, locked = 0, dirty = 0, used = 0, lastused = 0;
1563 int protected = 0;
1564 int shared;
1565 int nlist, isize;
1566
1567 printk("Buffer memory: %6dkB\n",buffermem>>10);
1568 printk("Buffer heads: %6d\n",nr_buffer_heads);
1569 printk("Buffer blocks: %6d\n",nr_buffers);
1570
1571 for(nlist = 0; nlist < NR_LIST; nlist++) {
1572 shared = found = locked = dirty = used = lastused = protected = 0;
1573 bh = lru_list[nlist];
1574 if(!bh) continue;
1575 do {
1576 found++;
1577 if (buffer_locked(bh))
1578 locked++;
1579 if (buffer_protected(bh))
1580 protected++;
1581 if (buffer_dirty(bh))
1582 dirty++;
1583 if (mem_map[MAP_NR(((unsigned long) bh->b_data))].count != 1)
1584 shared++;
1585 if (bh->b_count)
1586 used++, lastused = found;
1587 bh = bh->b_next_free;
1588 } while (bh != lru_list[nlist]);
1589 printk("Buffer[%d] mem: %d buffers, %d used (last=%d), "
1590 "%d locked, %d protected, %d dirty %d shrd\n",
1591 nlist, found, used, lastused,
1592 locked, protected, dirty, shared);
1593 };
1594 printk("Size [LAV] Free Clean Unshar Lck Lck1 Dirty Shared \n");
1595 for(isize = 0; isize<NR_SIZES; isize++){
1596 printk("%5d [%5d]: %7d ", bufferindex_size[isize],
1597 buffers_lav[isize], nr_free[isize]);
1598 for(nlist = 0; nlist < NR_LIST; nlist++)
1599 printk("%7d ", nr_buffers_st[isize][nlist]);
1600 printk("\n");
1601 }
1602 }
1603
1604
1605
1606
1607
1608
1609
1610
1611 static inline int try_to_reassign(struct buffer_head * bh, struct buffer_head ** bhp,
1612 kdev_t dev, unsigned int starting_block)
1613 {
1614 unsigned long page;
1615 struct buffer_head * tmp, * p;
1616
1617 *bhp = bh;
1618 page = (unsigned long) bh->b_data;
1619 page &= PAGE_MASK;
1620 if(mem_map[MAP_NR(page)].count != 1) return 0;
1621 tmp = bh;
1622 do {
1623 if (!tmp)
1624 return 0;
1625
1626 if (tmp->b_count || buffer_protected(tmp) ||
1627 buffer_dirty(tmp) || buffer_locked(tmp))
1628 return 0;
1629 tmp = tmp->b_this_page;
1630 } while (tmp != bh);
1631 tmp = bh;
1632
1633 while((unsigned long) tmp->b_data & (PAGE_SIZE - 1))
1634 tmp = tmp->b_this_page;
1635
1636
1637 bh = tmp;
1638 do {
1639 p = tmp;
1640 tmp = tmp->b_this_page;
1641 remove_from_queues(p);
1642 p->b_dev = dev;
1643 mark_buffer_uptodate(p, 0);
1644 clear_bit(BH_Req, &p->b_state);
1645 p->b_blocknr = starting_block++;
1646 insert_into_queues(p);
1647 } while (tmp != bh);
1648 return 1;
1649 }
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665 static int reassign_cluster(kdev_t dev,
1666 unsigned int starting_block, int size)
1667 {
1668 struct buffer_head *bh;
1669 int isize = BUFSIZE_INDEX(size);
1670 int i;
1671
1672
1673
1674
1675
1676 while(nr_free[isize] < 32) refill_freelist(size);
1677
1678 bh = free_list[isize];
1679 if(bh)
1680 for (i=0 ; !i || bh != free_list[isize] ; bh = bh->b_next_free, i++) {
1681 if (!bh->b_this_page) continue;
1682 if (try_to_reassign(bh, &bh, dev, starting_block))
1683 return 4;
1684 }
1685 return 0;
1686 }
1687
1688
1689
1690
1691
1692 static unsigned long try_to_generate_cluster(kdev_t dev, int block, int size)
1693 {
1694 struct buffer_head * bh, * tmp, * arr[MAX_BUF_PER_PAGE];
1695 int isize = BUFSIZE_INDEX(size);
1696 unsigned long offset;
1697 unsigned long page;
1698 int nblock;
1699
1700 page = get_free_page(GFP_NOBUFFER);
1701 if(!page) return 0;
1702
1703 bh = create_buffers(page, size);
1704 if (!bh) {
1705 free_page(page);
1706 return 0;
1707 };
1708 nblock = block;
1709 for (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
1710 if (find_buffer(dev, nblock++, size))
1711 goto not_aligned;
1712 }
1713 tmp = bh;
1714 nblock = 0;
1715 while (1) {
1716 arr[nblock++] = bh;
1717 bh->b_count = 1;
1718 bh->b_flushtime = 0;
1719 bh->b_state = 0;
1720 bh->b_dev = dev;
1721 bh->b_list = BUF_CLEAN;
1722 bh->b_blocknr = block++;
1723 nr_buffers++;
1724 nr_buffers_size[isize]++;
1725 insert_into_queues(bh);
1726 if (bh->b_this_page)
1727 bh = bh->b_this_page;
1728 else
1729 break;
1730 }
1731 buffermem += PAGE_SIZE;
1732 mem_map[MAP_NR(page)].buffers = bh;
1733 bh->b_this_page = tmp;
1734 while (nblock-- > 0)
1735 brelse(arr[nblock]);
1736 return 4;
1737 not_aligned:
1738 while ((tmp = bh) != NULL) {
1739 bh = bh->b_this_page;
1740 put_unused_buffer_head(tmp);
1741 }
1742 free_page(page);
1743 return 0;
1744 }
1745
1746 unsigned long generate_cluster(kdev_t dev, int b[], int size)
1747 {
1748 int i, offset;
1749
1750 for (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
1751 if(i && b[i]-1 != b[i-1]) return 0;
1752 if(find_buffer(dev, b[i], size)) return 0;
1753 };
1754
1755
1756
1757
1758
1759 if(maybe_shrink_lav_buffers(size))
1760 {
1761 int retval;
1762 retval = try_to_generate_cluster(dev, b[0], size);
1763 if(retval) return retval;
1764 };
1765
1766 if (nr_free_pages > min_free_pages*2)
1767 return try_to_generate_cluster(dev, b[0], size);
1768 else
1769 return reassign_cluster(dev, b[0], size);
1770 }
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782 void buffer_init(void)
1783 {
1784 int i;
1785 int isize = BUFSIZE_INDEX(BLOCK_SIZE);
1786 long memsize = MAP_NR(high_memory) << PAGE_SHIFT;
1787
1788 if (memsize >= 4*1024*1024) {
1789 if(memsize >= 16*1024*1024)
1790 nr_hash = 16381;
1791 else
1792 nr_hash = 4093;
1793 } else {
1794 nr_hash = 997;
1795 };
1796
1797 hash_table = (struct buffer_head **) vmalloc(nr_hash *
1798 sizeof(struct buffer_head *));
1799
1800
1801 for (i = 0 ; i < nr_hash ; i++)
1802 hash_table[i] = NULL;
1803 lru_list[BUF_CLEAN] = 0;
1804 grow_buffers(GFP_KERNEL, BLOCK_SIZE);
1805 if (!free_list[isize])
1806 panic("VFS: Unable to initialize buffer free list!");
1807 return;
1808 }
1809
1810
1811
1812
1813
1814
1815
1816
1817 struct wait_queue * bdflush_wait = NULL;
1818 struct wait_queue * bdflush_done = NULL;
1819
1820 static void wakeup_bdflush(int wait)
1821 {
1822 run_task_queue(&tq_disk);
1823 wake_up(&bdflush_wait);
1824 if(wait) sleep_on(&bdflush_done);
1825 }
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836 asmlinkage int sync_old_buffers(void)
1837 {
1838 int i, isize;
1839 int ndirty, nwritten;
1840 int nlist;
1841 int ncount;
1842 struct buffer_head * bh, *next;
1843
1844 sync_supers(0);
1845 sync_inodes(0);
1846
1847 ncount = 0;
1848 #ifdef DEBUG
1849 for(nlist = 0; nlist < NR_LIST; nlist++)
1850 #else
1851 for(nlist = BUF_DIRTY; nlist <= BUF_DIRTY; nlist++)
1852 #endif
1853 {
1854 ndirty = 0;
1855 nwritten = 0;
1856 repeat:
1857 bh = lru_list[nlist];
1858 if(bh)
1859 for (i = nr_buffers_type[nlist]; i-- > 0; bh = next) {
1860
1861 if(bh->b_list != nlist) goto repeat;
1862 next = bh->b_next_free;
1863 if(!lru_list[nlist]) {
1864 printk("Dirty list empty %d\n", i);
1865 break;
1866 }
1867
1868
1869 if (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
1870 {
1871 refile_buffer(bh);
1872 continue;
1873 }
1874
1875 if (buffer_locked(bh) || !buffer_dirty(bh))
1876 continue;
1877 ndirty++;
1878 if(bh->b_flushtime > jiffies) continue;
1879 nwritten++;
1880 bh->b_count++;
1881 bh->b_flushtime = 0;
1882 #ifdef DEBUG
1883 if(nlist != BUF_DIRTY) ncount++;
1884 #endif
1885 ll_rw_block(WRITE, 1, &bh);
1886 bh->b_count--;
1887 }
1888 }
1889 #ifdef DEBUG
1890 if (ncount) printk("sync_old_buffers: %d dirty buffers not on dirty list\n", ncount);
1891 printk("Wrote %d/%d buffers\n", nwritten, ndirty);
1892 #endif
1893
1894
1895
1896
1897 for(isize = 0; isize<NR_SIZES; isize++){
1898 CALC_LOAD(buffers_lav[isize], bdf_prm.b_un.lav_const, buffer_usage[isize]);
1899 buffer_usage[isize] = 0;
1900 };
1901 return 0;
1902 }
1903
1904
1905
1906
1907
1908
1909
1910 asmlinkage int sys_bdflush(int func, long data)
1911 {
1912 int i, error;
1913
1914 if (!suser())
1915 return -EPERM;
1916
1917 if (func == 1)
1918 return sync_old_buffers();
1919
1920
1921 if (func >= 2) {
1922 i = (func-2) >> 1;
1923 if (i < 0 || i >= N_PARAM)
1924 return -EINVAL;
1925 if((func & 1) == 0) {
1926 error = verify_area(VERIFY_WRITE, (void *) data, sizeof(int));
1927 if (error)
1928 return error;
1929 put_user(bdf_prm.data[i], (int*)data);
1930 return 0;
1931 };
1932 if (data < bdflush_min[i] || data > bdflush_max[i])
1933 return -EINVAL;
1934 bdf_prm.data[i] = data;
1935 return 0;
1936 }
1937
1938
1939
1940
1941
1942 return 0;
1943 }
1944
1945
1946
1947
1948
1949 int bdflush(void * unused)
1950 {
1951 int i;
1952 int ndirty;
1953 int nlist;
1954 int ncount;
1955 struct buffer_head * bh, *next;
1956
1957
1958
1959
1960
1961
1962
1963 current->session = 1;
1964 current->pgrp = 1;
1965 sprintf(current->comm, "kflushd");
1966
1967
1968
1969
1970
1971
1972
1973 #ifdef __SMP__
1974 lock_kernel();
1975 syscall_count++;
1976 #endif
1977
1978 for (;;) {
1979 #ifdef DEBUG
1980 printk("bdflush() activated...");
1981 #endif
1982
1983 ncount = 0;
1984 #ifdef DEBUG
1985 for(nlist = 0; nlist < NR_LIST; nlist++)
1986 #else
1987 for(nlist = BUF_DIRTY; nlist <= BUF_DIRTY; nlist++)
1988 #endif
1989 {
1990 ndirty = 0;
1991 repeat:
1992 bh = lru_list[nlist];
1993 if(bh)
1994 for (i = nr_buffers_type[nlist]; i-- > 0 && ndirty < bdf_prm.b_un.ndirty;
1995 bh = next) {
1996
1997 if(bh->b_list != nlist) goto repeat;
1998 next = bh->b_next_free;
1999 if(!lru_list[nlist]) {
2000 printk("Dirty list empty %d\n", i);
2001 break;
2002 }
2003
2004
2005 if (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
2006 {
2007 refile_buffer(bh);
2008 continue;
2009 }
2010
2011 if (buffer_locked(bh) || !buffer_dirty(bh))
2012 continue;
2013
2014
2015 bh->b_count++;
2016 ndirty++;
2017 bh->b_flushtime = 0;
2018 ll_rw_block(WRITE, 1, &bh);
2019 #ifdef DEBUG
2020 if(nlist != BUF_DIRTY) ncount++;
2021 #endif
2022 bh->b_count--;
2023 }
2024 }
2025 #ifdef DEBUG
2026 if (ncount) printk("sys_bdflush: %d dirty buffers not on dirty list\n", ncount);
2027 printk("sleeping again.\n");
2028 #endif
2029 run_task_queue(&tq_disk);
2030 wake_up(&bdflush_done);
2031
2032
2033
2034
2035 if(nr_buffers_type[BUF_DIRTY] <= (nr_buffers - nr_buffers_type[BUF_SHARED]) *
2036 bdf_prm.b_un.nfract/100) {
2037 current->signal = 0;
2038 interruptible_sleep_on(&bdflush_wait);
2039 }
2040 }
2041 }
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059