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
- after_unlock_page
- free_async_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 (grow_buffers(GFP_ATOMIC, size)) {
725 needed -= PAGE_SIZE;
726 goto repeat0;
727 }
728 wakeup_bdflush(1);
729 goto repeat0;
730 }
731
732
733
734
735
736
737
738
739
740
741
742 struct buffer_head * getblk(kdev_t dev, int block, int size)
743 {
744 struct buffer_head * bh;
745 int isize = BUFSIZE_INDEX(size);
746
747
748 buffer_usage[isize]++;
749
750
751
752
753 repeat:
754 bh = get_hash_table(dev, block, size);
755 if (bh) {
756 if (!buffer_dirty(bh)) {
757 if (buffer_uptodate(bh))
758 put_last_lru(bh);
759 bh->b_flushtime = 0;
760 }
761 set_bit(BH_Touched, &bh->b_state);
762 return bh;
763 }
764
765 while(!free_list[isize]) refill_freelist(size);
766
767 if (find_buffer(dev,block,size))
768 goto repeat;
769
770 bh = free_list[isize];
771 remove_from_free_list(bh);
772
773
774
775 bh->b_count=1;
776 bh->b_flushtime=0;
777 bh->b_state=(1<<BH_Touched);
778 bh->b_dev=dev;
779 bh->b_blocknr=block;
780 insert_into_queues(bh);
781 return bh;
782 }
783
784 void set_writetime(struct buffer_head * buf, int flag)
785 {
786 int newtime;
787
788 if (buffer_dirty(buf)) {
789
790 newtime = jiffies + (flag ? bdf_prm.b_un.age_super :
791 bdf_prm.b_un.age_buffer);
792 if(!buf->b_flushtime || buf->b_flushtime > newtime)
793 buf->b_flushtime = newtime;
794 } else {
795 buf->b_flushtime = 0;
796 }
797 }
798
799
800
801
802
803
804 void refile_buffer(struct buffer_head * buf)
805 {
806 int dispose;
807
808 if(buf->b_dev == B_FREE) {
809 printk("Attempt to refile free buffer\n");
810 return;
811 }
812 if (buffer_dirty(buf))
813 dispose = BUF_DIRTY;
814 else if ((mem_map[MAP_NR((unsigned long) buf->b_data)].count > 1) || buffer_protected(buf))
815 dispose = BUF_SHARED;
816 else if (buffer_locked(buf))
817 dispose = BUF_LOCKED;
818 else if (buf->b_list == BUF_SHARED)
819 dispose = BUF_UNSHARED;
820 else
821 dispose = BUF_CLEAN;
822 if(dispose == BUF_CLEAN) buf->b_lru_time = jiffies;
823 if(dispose != buf->b_list) {
824 if(dispose == BUF_DIRTY || dispose == BUF_UNSHARED)
825 buf->b_lru_time = jiffies;
826 if(dispose == BUF_LOCKED &&
827 (buf->b_flushtime - buf->b_lru_time) <= bdf_prm.b_un.age_super)
828 dispose = BUF_LOCKED1;
829 remove_from_queues(buf);
830 buf->b_list = dispose;
831 insert_into_queues(buf);
832 if(dispose == BUF_DIRTY && nr_buffers_type[BUF_DIRTY] >
833 (nr_buffers - nr_buffers_type[BUF_SHARED]) *
834 bdf_prm.b_un.nfract/100)
835 wakeup_bdflush(0);
836 }
837 }
838
839
840
841
842 void __brelse(struct buffer_head * buf)
843 {
844 wait_on_buffer(buf);
845
846
847 set_writetime(buf, 0);
848 refile_buffer(buf);
849
850 if (buf->b_count) {
851 buf->b_count--;
852 return;
853 }
854 printk("VFS: brelse: Trying to free free buffer\n");
855 }
856
857
858
859
860
861
862 void __bforget(struct buffer_head * buf)
863 {
864 wait_on_buffer(buf);
865 mark_buffer_clean(buf);
866 clear_bit(BH_Protected, &buf->b_state);
867 buf->b_count--;
868 remove_from_hash_queue(buf);
869 buf->b_dev = NODEV;
870 refile_buffer(buf);
871 }
872
873
874
875
876
877 struct buffer_head * bread(kdev_t dev, int block, int size)
878 {
879 struct buffer_head * bh;
880
881 if (!(bh = getblk(dev, block, size))) {
882 printk("VFS: bread: READ error on device %s\n",
883 kdevname(dev));
884 return NULL;
885 }
886 if (buffer_uptodate(bh))
887 return bh;
888 ll_rw_block(READ, 1, &bh);
889 wait_on_buffer(bh);
890 if (buffer_uptodate(bh))
891 return bh;
892 brelse(bh);
893 return NULL;
894 }
895
896
897
898
899
900
901
902 #define NBUF 16
903
904 struct buffer_head * breada(kdev_t dev, int block, int bufsize,
905 unsigned int pos, unsigned int filesize)
906 {
907 struct buffer_head * bhlist[NBUF];
908 unsigned int blocks;
909 struct buffer_head * bh;
910 int index;
911 int i, j;
912
913 if (pos >= filesize)
914 return NULL;
915
916 if (block < 0 || !(bh = getblk(dev,block,bufsize)))
917 return NULL;
918
919 index = BUFSIZE_INDEX(bh->b_size);
920
921 if (buffer_uptodate(bh))
922 return(bh);
923 else ll_rw_block(READ, 1, &bh);
924
925 blocks = (filesize - pos) >> (9+index);
926
927 if (blocks < (read_ahead[MAJOR(dev)] >> index))
928 blocks = read_ahead[MAJOR(dev)] >> index;
929 if (blocks > NBUF)
930 blocks = NBUF;
931
932
933
934
935 bhlist[0] = bh;
936 j = 1;
937 for(i=1; i<blocks; i++) {
938 bh = getblk(dev,block+i,bufsize);
939 if (buffer_uptodate(bh)) {
940 brelse(bh);
941 break;
942 }
943 else bhlist[j++] = bh;
944 }
945
946
947 if (j>1)
948 ll_rw_block(READA, (j-1), bhlist+1);
949 for(i=1; i<j; i++)
950 brelse(bhlist[i]);
951
952
953 bh = bhlist[0];
954 wait_on_buffer(bh);
955 if (buffer_uptodate(bh))
956 return bh;
957 brelse(bh);
958 return NULL;
959 }
960
961
962
963
964 static void put_unused_buffer_head(struct buffer_head * bh)
965 {
966 struct wait_queue * wait;
967
968 wait = ((volatile struct buffer_head *) bh)->b_wait;
969 memset(bh,0,sizeof(*bh));
970 ((volatile struct buffer_head *) bh)->b_wait = wait;
971 bh->b_next_free = unused_list;
972 unused_list = bh;
973 wake_up(&buffer_wait);
974 }
975
976 static void get_more_buffer_heads(void)
977 {
978 int i;
979 struct buffer_head * bh;
980
981 for (;;) {
982 if (unused_list)
983 return;
984
985
986
987
988
989
990 bh = (struct buffer_head *) get_free_page(GFP_ATOMIC);
991 if (bh)
992 break;
993
994
995
996
997
998
999 run_task_queue(&tq_disk);
1000 sleep_on(&buffer_wait);
1001 }
1002
1003 for (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
1004 bh->b_next_free = unused_list;
1005 unused_list = bh++;
1006 }
1007 }
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022 static inline void recover_reusable_buffer_heads(void)
1023 {
1024 if (reuse_list) {
1025 struct buffer_head *bh;
1026 unsigned long flags;
1027
1028 save_flags(flags);
1029 do {
1030 cli();
1031 bh = reuse_list;
1032 reuse_list = bh->b_next_free;
1033 restore_flags(flags);
1034 put_unused_buffer_head(bh);
1035 } while (reuse_list);
1036 }
1037 }
1038
1039 static struct buffer_head * get_unused_buffer_head(void)
1040 {
1041 struct buffer_head * bh;
1042
1043 recover_reusable_buffer_heads();
1044 get_more_buffer_heads();
1045 if (!unused_list)
1046 return NULL;
1047 bh = unused_list;
1048 unused_list = bh->b_next_free;
1049 bh->b_next_free = NULL;
1050 bh->b_data = NULL;
1051 bh->b_size = 0;
1052 bh->b_state = 0;
1053 return bh;
1054 }
1055
1056
1057
1058
1059
1060
1061
1062 static struct buffer_head * create_buffers(unsigned long page, unsigned long size)
1063 {
1064 struct buffer_head *bh, *head;
1065 unsigned long offset;
1066
1067 head = NULL;
1068 offset = PAGE_SIZE;
1069 while ((offset -= size) < PAGE_SIZE) {
1070 bh = get_unused_buffer_head();
1071 if (!bh)
1072 goto no_grow;
1073 bh->b_this_page = head;
1074 head = bh;
1075 bh->b_data = (char *) (page+offset);
1076 bh->b_size = size;
1077 bh->b_dev = B_FREE;
1078 }
1079 return head;
1080
1081
1082
1083 no_grow:
1084 bh = head;
1085 while (bh) {
1086 head = bh;
1087 bh = bh->b_this_page;
1088 put_unused_buffer_head(head);
1089 }
1090 return NULL;
1091 }
1092
1093
1094 static inline void after_unlock_page (struct page * page)
1095 {
1096 if (clear_bit(PG_decr_after, &page->flags))
1097 nr_async_pages--;
1098 if (clear_bit(PG_free_after, &page->flags))
1099 free_page(page_address(page));
1100 if (clear_bit(PG_swap_unlock_after, &page->flags))
1101 swap_after_unlock_page(page->swap_unlock_entry);
1102 }
1103
1104
1105 static inline void free_async_buffers (struct buffer_head * bh)
1106 {
1107 struct buffer_head * tmp;
1108 unsigned long flags;
1109
1110 tmp = bh;
1111 save_flags(flags);
1112 cli();
1113 do {
1114 if (!test_bit(BH_FreeOnIO, &tmp->b_state)) {
1115 printk ("Whoops: unlock_buffer: "
1116 "async IO mismatch on page.\n");
1117 restore_flags(flags);
1118 return;
1119 }
1120 tmp->b_next_free = reuse_list;
1121 reuse_list = tmp;
1122 clear_bit(BH_FreeOnIO, &tmp->b_state);
1123 tmp = tmp->b_this_page;
1124 } while (tmp != bh);
1125 restore_flags(flags);
1126 }
1127
1128
1129
1130
1131
1132
1133 int brw_page(int rw, unsigned long address, kdev_t dev, int b[], int size, int bmap)
1134 {
1135 struct buffer_head *bh, *prev, *next, *arr[MAX_BUF_PER_PAGE];
1136 int block, nr;
1137 struct page *page;
1138
1139 page = mem_map + MAP_NR(address);
1140 if (!PageLocked(page))
1141 panic("brw_page: page not locked for I/O");
1142 clear_bit(PG_uptodate, &page->flags);
1143
1144
1145
1146
1147
1148 bh = create_buffers(address, size);
1149 if (!bh) {
1150 clear_bit(PG_locked, &page->flags);
1151 wake_up(&page->wait);
1152 return -ENOMEM;
1153 }
1154 nr = 0;
1155 next = bh;
1156 do {
1157 struct buffer_head * tmp;
1158 block = *(b++);
1159
1160 set_bit(BH_FreeOnIO, &next->b_state);
1161 next->b_list = BUF_CLEAN;
1162 next->b_dev = dev;
1163 next->b_blocknr = block;
1164 next->b_count = 1;
1165 next->b_flushtime = 0;
1166 set_bit(BH_Uptodate, &next->b_state);
1167
1168
1169
1170
1171
1172
1173 if (bmap && !block) {
1174 memset(next->b_data, 0, size);
1175 next->b_count--;
1176 continue;
1177 }
1178 tmp = get_hash_table(dev, block, size);
1179 if (tmp) {
1180 if (!buffer_uptodate(tmp)) {
1181 if (rw == READ)
1182 ll_rw_block(READ, 1, &tmp);
1183 wait_on_buffer(tmp);
1184 }
1185 if (rw == READ)
1186 memcpy(next->b_data, tmp->b_data, size);
1187 else {
1188 memcpy(tmp->b_data, next->b_data, size);
1189 mark_buffer_dirty(tmp, 0);
1190 }
1191 brelse(tmp);
1192 next->b_count--;
1193 continue;
1194 }
1195 if (rw == READ)
1196 clear_bit(BH_Uptodate, &next->b_state);
1197 else
1198 set_bit(BH_Dirty, &next->b_state);
1199 arr[nr++] = next;
1200 } while (prev = next, (next = next->b_this_page) != NULL);
1201 prev->b_this_page = bh;
1202
1203 if (nr) {
1204 ll_rw_block(rw, nr, arr);
1205
1206
1207 } else {
1208 clear_bit(PG_locked, &page->flags);
1209 set_bit(PG_uptodate, &page->flags);
1210 wake_up(&page->wait);
1211 free_async_buffers(bh);
1212 after_unlock_page(page);
1213 }
1214 ++current->maj_flt;
1215 return 0;
1216 }
1217
1218
1219
1220
1221 void mark_buffer_uptodate(struct buffer_head * bh, int on)
1222 {
1223 if (on) {
1224 struct buffer_head *tmp = bh;
1225 int page_uptodate = 1;
1226 set_bit(BH_Uptodate, &bh->b_state);
1227
1228
1229 do {
1230 if (!test_bit(BH_Uptodate, &tmp->b_state)) {
1231 page_uptodate = 0;
1232 break;
1233 }
1234 tmp=tmp->b_this_page;
1235 } while (tmp && tmp != bh);
1236 if (page_uptodate)
1237 set_bit(PG_uptodate, &mem_map[MAP_NR(bh->b_data)].flags);
1238 } else
1239 clear_bit(BH_Uptodate, &bh->b_state);
1240 }
1241
1242
1243
1244
1245 void unlock_buffer(struct buffer_head * bh)
1246 {
1247 struct buffer_head *tmp;
1248 struct page *page;
1249
1250 clear_bit(BH_Lock, &bh->b_state);
1251 wake_up(&bh->b_wait);
1252
1253 if (!test_bit(BH_FreeOnIO, &bh->b_state))
1254 return;
1255
1256 page = mem_map + MAP_NR(bh->b_data);
1257 if (!PageLocked(page)) {
1258 printk ("Whoops: unlock_buffer: "
1259 "async io complete on unlocked page\n");
1260 return;
1261 }
1262 if (bh->b_count != 1) {
1263 printk ("Whoops: unlock_buffer: b_count != 1 on async io.\n");
1264 return;
1265 }
1266
1267
1268
1269
1270 bh->b_count--;
1271 for (tmp = bh; tmp=tmp->b_this_page, tmp!=bh; ) {
1272 if (test_bit(BH_Lock, &tmp->b_state) || tmp->b_count)
1273 return;
1274 }
1275
1276 clear_bit(PG_locked, &page->flags);
1277 wake_up(&page->wait);
1278 free_async_buffers(bh);
1279 after_unlock_page(page);
1280 wake_up(&buffer_wait);
1281 }
1282
1283
1284
1285
1286
1287
1288
1289
1290 int generic_readpage(struct inode * inode, struct page * page)
1291 {
1292 unsigned long block, address;
1293 int *p, nr[PAGE_SIZE/512];
1294 int i;
1295
1296 address = page_address(page);
1297 page->count++;
1298 set_bit(PG_locked, &page->flags);
1299 set_bit(PG_free_after, &page->flags);
1300
1301 i = PAGE_SIZE >> inode->i_sb->s_blocksize_bits;
1302 block = page->offset >> inode->i_sb->s_blocksize_bits;
1303 p = nr;
1304 do {
1305 *p = inode->i_op->bmap(inode, block);
1306 i--;
1307 block++;
1308 p++;
1309 } while (i > 0);
1310
1311
1312 brw_page(READ, address, inode->i_dev, nr, inode->i_sb->s_blocksize, 1);
1313 return 0;
1314 }
1315
1316
1317
1318
1319
1320 static int grow_buffers(int pri, int size)
1321 {
1322 unsigned long page;
1323 struct buffer_head *bh, *tmp;
1324 struct buffer_head * insert_point;
1325 int isize;
1326
1327 if ((size & 511) || (size > PAGE_SIZE)) {
1328 printk("VFS: grow_buffers: size = %d\n",size);
1329 return 0;
1330 }
1331
1332 isize = BUFSIZE_INDEX(size);
1333
1334 if (!(page = __get_free_page(pri)))
1335 return 0;
1336 bh = create_buffers(page, size);
1337 if (!bh) {
1338 free_page(page);
1339 return 0;
1340 }
1341
1342 insert_point = free_list[isize];
1343
1344 tmp = bh;
1345 while (1) {
1346 nr_free[isize]++;
1347 if (insert_point) {
1348 tmp->b_next_free = insert_point->b_next_free;
1349 tmp->b_prev_free = insert_point;
1350 insert_point->b_next_free->b_prev_free = tmp;
1351 insert_point->b_next_free = tmp;
1352 } else {
1353 tmp->b_prev_free = tmp;
1354 tmp->b_next_free = tmp;
1355 }
1356 insert_point = tmp;
1357 ++nr_buffers;
1358 if (tmp->b_this_page)
1359 tmp = tmp->b_this_page;
1360 else
1361 break;
1362 }
1363 free_list[isize] = bh;
1364 mem_map[MAP_NR(page)].buffers = bh;
1365 tmp->b_this_page = bh;
1366 buffermem += PAGE_SIZE;
1367 return 1;
1368 }
1369
1370
1371
1372
1373
1374
1375
1376
1377 int try_to_free_buffer(struct buffer_head * bh, struct buffer_head ** bhp,
1378 int priority)
1379 {
1380 unsigned long page;
1381 struct buffer_head * tmp, * p;
1382 int isize = BUFSIZE_INDEX(bh->b_size);
1383
1384 *bhp = bh;
1385 page = (unsigned long) bh->b_data;
1386 page &= PAGE_MASK;
1387 tmp = bh;
1388 do {
1389 if (!tmp)
1390 return 0;
1391 if (tmp->b_count || buffer_protected(tmp) ||
1392 buffer_dirty(tmp) || buffer_locked(tmp) || tmp->b_wait)
1393 return 0;
1394 if (priority && buffer_touched(tmp))
1395 return 0;
1396 tmp = tmp->b_this_page;
1397 } while (tmp != bh);
1398 tmp = bh;
1399 do {
1400 p = tmp;
1401 tmp = tmp->b_this_page;
1402 nr_buffers--;
1403 nr_buffers_size[isize]--;
1404 if (p == *bhp)
1405 {
1406 *bhp = p->b_prev_free;
1407 if (p == *bhp)
1408 *bhp = NULL;
1409 }
1410 remove_from_queues(p);
1411 put_unused_buffer_head(p);
1412 } while (tmp != bh);
1413 buffermem -= PAGE_SIZE;
1414 mem_map[MAP_NR(page)].buffers = NULL;
1415 free_page(page);
1416 return !mem_map[MAP_NR(page)].count;
1417 }
1418
1419
1420
1421 static inline void age_buffer(struct buffer_head *bh)
1422 {
1423 struct buffer_head *tmp = bh;
1424 int touched = 0;
1425
1426
1427
1428
1429
1430
1431
1432
1433 if (clear_bit(BH_Has_aged, &bh->b_state))
1434 return;
1435
1436 do {
1437 touched |= clear_bit(BH_Touched, &tmp->b_state);
1438 tmp = tmp->b_this_page;
1439 set_bit(BH_Has_aged, &tmp->b_state);
1440 } while (tmp != bh);
1441 clear_bit(BH_Has_aged, &bh->b_state);
1442
1443 if (touched)
1444 touch_page(mem_map + MAP_NR((unsigned long) bh->b_data));
1445 else
1446 age_page(mem_map + MAP_NR((unsigned long) bh->b_data));
1447 }
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461 static int maybe_shrink_lav_buffers(int size)
1462 {
1463 int nlist;
1464 int isize;
1465 int total_lav, total_n_buffers, n_sizes;
1466
1467
1468
1469
1470
1471
1472 total_lav = total_n_buffers = n_sizes = 0;
1473 for(nlist = 0; nlist < NR_SIZES; nlist++)
1474 {
1475 total_lav += buffers_lav[nlist];
1476 if(nr_buffers_size[nlist]) n_sizes++;
1477 total_n_buffers += nr_buffers_size[nlist];
1478 total_n_buffers -= nr_buffers_st[nlist][BUF_SHARED];
1479 }
1480
1481
1482
1483
1484 isize = (size ? BUFSIZE_INDEX(size) : -1);
1485
1486 if (n_sizes > 1)
1487 for(nlist = 0; nlist < NR_SIZES; nlist++)
1488 {
1489 if(nlist == isize) continue;
1490 if(nr_buffers_size[nlist] &&
1491 bdf_prm.b_un.lav_const * buffers_lav[nlist]*total_n_buffers <
1492 total_lav * (nr_buffers_size[nlist] - nr_buffers_st[nlist][BUF_SHARED]))
1493 if(shrink_specific_buffers(6, bufferindex_size[nlist]))
1494 return 1;
1495 }
1496 return 0;
1497 }
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511 static int shrink_specific_buffers(unsigned int priority, int size)
1512 {
1513 struct buffer_head *bh;
1514 int nlist;
1515 int i, isize, isize1;
1516
1517 #ifdef DEBUG
1518 if(size) printk("Shrinking buffers of size %d\n", size);
1519 #endif
1520
1521
1522 isize1 = (size ? BUFSIZE_INDEX(size) : -1);
1523
1524 for(isize = 0; isize<NR_SIZES; isize++){
1525 if(isize1 != -1 && isize1 != isize) continue;
1526 bh = free_list[isize];
1527 if(!bh) continue;
1528 for (i=0 ; !i || bh != free_list[isize]; bh = bh->b_next_free, i++) {
1529 if (bh->b_count || buffer_protected(bh) ||
1530 !bh->b_this_page)
1531 continue;
1532 if (!age_of((unsigned long) bh->b_data) &&
1533 try_to_free_buffer(bh, &bh, 6))
1534 return 1;
1535 if(!bh) break;
1536
1537
1538 }
1539 }
1540
1541
1542
1543 for(nlist = 0; nlist < NR_LIST; nlist++) {
1544 repeat1:
1545 if(priority > 2 && nlist == BUF_SHARED) continue;
1546 i = nr_buffers_type[nlist];
1547 i = ((BUFFEROUT_WEIGHT * i) >> 10) >> priority;
1548 for ( ; i > 0; i-- ) {
1549 bh = next_to_age[nlist];
1550 if (!bh)
1551 break;
1552 next_to_age[nlist] = bh->b_next_free;
1553
1554
1555 age_buffer(bh);
1556
1557
1558 if(bh->b_list != nlist) goto repeat1;
1559 if (bh->b_count || buffer_protected(bh) ||
1560 !bh->b_this_page)
1561 continue;
1562 if(size && bh->b_size != size) continue;
1563 if (buffer_locked(bh))
1564 if (priority)
1565 continue;
1566 else
1567 wait_on_buffer(bh);
1568 if (buffer_dirty(bh)) {
1569 bh->b_count++;
1570 bh->b_flushtime = 0;
1571 ll_rw_block(WRITEA, 1, &bh);
1572 bh->b_count--;
1573 continue;
1574 }
1575
1576
1577
1578 if ((age_of((unsigned long) bh->b_data) >>
1579 (6-priority)) > 0)
1580 continue;
1581 if (try_to_free_buffer(bh, &bh, 0))
1582 return 1;
1583 if(!bh) break;
1584 }
1585 }
1586 return 0;
1587 }
1588
1589
1590
1591
1592 void show_buffers(void)
1593 {
1594 struct buffer_head * bh;
1595 int found = 0, locked = 0, dirty = 0, used = 0, lastused = 0;
1596 int protected = 0;
1597 int shared;
1598 int nlist, isize;
1599
1600 printk("Buffer memory: %6dkB\n",buffermem>>10);
1601 printk("Buffer heads: %6d\n",nr_buffer_heads);
1602 printk("Buffer blocks: %6d\n",nr_buffers);
1603
1604 for(nlist = 0; nlist < NR_LIST; nlist++) {
1605 shared = found = locked = dirty = used = lastused = protected = 0;
1606 bh = lru_list[nlist];
1607 if(!bh) continue;
1608 do {
1609 found++;
1610 if (buffer_locked(bh))
1611 locked++;
1612 if (buffer_protected(bh))
1613 protected++;
1614 if (buffer_dirty(bh))
1615 dirty++;
1616 if (mem_map[MAP_NR(((unsigned long) bh->b_data))].count != 1)
1617 shared++;
1618 if (bh->b_count)
1619 used++, lastused = found;
1620 bh = bh->b_next_free;
1621 } while (bh != lru_list[nlist]);
1622 printk("Buffer[%d] mem: %d buffers, %d used (last=%d), "
1623 "%d locked, %d protected, %d dirty %d shrd\n",
1624 nlist, found, used, lastused,
1625 locked, protected, dirty, shared);
1626 };
1627 printk("Size [LAV] Free Clean Unshar Lck Lck1 Dirty Shared \n");
1628 for(isize = 0; isize<NR_SIZES; isize++){
1629 printk("%5d [%5d]: %7d ", bufferindex_size[isize],
1630 buffers_lav[isize], nr_free[isize]);
1631 for(nlist = 0; nlist < NR_LIST; nlist++)
1632 printk("%7d ", nr_buffers_st[isize][nlist]);
1633 printk("\n");
1634 }
1635 }
1636
1637
1638
1639
1640
1641
1642
1643
1644 static inline int try_to_reassign(struct buffer_head * bh, struct buffer_head ** bhp,
1645 kdev_t dev, unsigned int starting_block)
1646 {
1647 unsigned long page;
1648 struct buffer_head * tmp, * p;
1649
1650 *bhp = bh;
1651 page = (unsigned long) bh->b_data;
1652 page &= PAGE_MASK;
1653 if(mem_map[MAP_NR(page)].count != 1) return 0;
1654 tmp = bh;
1655 do {
1656 if (!tmp)
1657 return 0;
1658
1659 if (tmp->b_count || buffer_protected(tmp) ||
1660 buffer_dirty(tmp) || buffer_locked(tmp))
1661 return 0;
1662 tmp = tmp->b_this_page;
1663 } while (tmp != bh);
1664 tmp = bh;
1665
1666 while((unsigned long) tmp->b_data & (PAGE_SIZE - 1))
1667 tmp = tmp->b_this_page;
1668
1669
1670 bh = tmp;
1671 do {
1672 p = tmp;
1673 tmp = tmp->b_this_page;
1674 remove_from_queues(p);
1675 p->b_dev = dev;
1676 mark_buffer_uptodate(p, 0);
1677 clear_bit(BH_Req, &p->b_state);
1678 p->b_blocknr = starting_block++;
1679 insert_into_queues(p);
1680 } while (tmp != bh);
1681 return 1;
1682 }
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698 static int reassign_cluster(kdev_t dev,
1699 unsigned int starting_block, int size)
1700 {
1701 struct buffer_head *bh;
1702 int isize = BUFSIZE_INDEX(size);
1703 int i;
1704
1705
1706
1707
1708
1709 while(nr_free[isize] < 32) refill_freelist(size);
1710
1711 bh = free_list[isize];
1712 if(bh)
1713 for (i=0 ; !i || bh != free_list[isize] ; bh = bh->b_next_free, i++) {
1714 if (!bh->b_this_page) continue;
1715 if (try_to_reassign(bh, &bh, dev, starting_block))
1716 return 4;
1717 }
1718 return 0;
1719 }
1720
1721
1722
1723
1724
1725 static unsigned long try_to_generate_cluster(kdev_t dev, int block, int size)
1726 {
1727 struct buffer_head * bh, * tmp, * arr[MAX_BUF_PER_PAGE];
1728 int isize = BUFSIZE_INDEX(size);
1729 unsigned long offset;
1730 unsigned long page;
1731 int nblock;
1732
1733 page = get_free_page(GFP_NOBUFFER);
1734 if(!page) return 0;
1735
1736 bh = create_buffers(page, size);
1737 if (!bh) {
1738 free_page(page);
1739 return 0;
1740 };
1741 nblock = block;
1742 for (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
1743 if (find_buffer(dev, nblock++, size))
1744 goto not_aligned;
1745 }
1746 tmp = bh;
1747 nblock = 0;
1748 while (1) {
1749 arr[nblock++] = bh;
1750 bh->b_count = 1;
1751 bh->b_flushtime = 0;
1752 bh->b_state = 0;
1753 bh->b_dev = dev;
1754 bh->b_list = BUF_CLEAN;
1755 bh->b_blocknr = block++;
1756 nr_buffers++;
1757 nr_buffers_size[isize]++;
1758 insert_into_queues(bh);
1759 if (bh->b_this_page)
1760 bh = bh->b_this_page;
1761 else
1762 break;
1763 }
1764 buffermem += PAGE_SIZE;
1765 mem_map[MAP_NR(page)].buffers = bh;
1766 bh->b_this_page = tmp;
1767 while (nblock-- > 0)
1768 brelse(arr[nblock]);
1769 return 4;
1770 not_aligned:
1771 while ((tmp = bh) != NULL) {
1772 bh = bh->b_this_page;
1773 put_unused_buffer_head(tmp);
1774 }
1775 free_page(page);
1776 return 0;
1777 }
1778
1779 unsigned long generate_cluster(kdev_t dev, int b[], int size)
1780 {
1781 int i, offset;
1782
1783 for (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
1784 if(i && b[i]-1 != b[i-1]) return 0;
1785 if(find_buffer(dev, b[i], size)) return 0;
1786 };
1787
1788
1789
1790
1791
1792 if(maybe_shrink_lav_buffers(size))
1793 {
1794 int retval;
1795 retval = try_to_generate_cluster(dev, b[0], size);
1796 if(retval) return retval;
1797 };
1798
1799 if (nr_free_pages > min_free_pages*2)
1800 return try_to_generate_cluster(dev, b[0], size);
1801 else
1802 return reassign_cluster(dev, b[0], size);
1803 }
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815 void buffer_init(void)
1816 {
1817 int i;
1818 int isize = BUFSIZE_INDEX(BLOCK_SIZE);
1819 long memsize = MAP_NR(high_memory) << PAGE_SHIFT;
1820
1821 if (memsize >= 4*1024*1024) {
1822 if(memsize >= 16*1024*1024)
1823 nr_hash = 16381;
1824 else
1825 nr_hash = 4093;
1826 } else {
1827 nr_hash = 997;
1828 };
1829
1830 hash_table = (struct buffer_head **) vmalloc(nr_hash *
1831 sizeof(struct buffer_head *));
1832
1833
1834 for (i = 0 ; i < nr_hash ; i++)
1835 hash_table[i] = NULL;
1836 lru_list[BUF_CLEAN] = 0;
1837 grow_buffers(GFP_KERNEL, BLOCK_SIZE);
1838 if (!free_list[isize])
1839 panic("VFS: Unable to initialize buffer free list!");
1840 return;
1841 }
1842
1843
1844
1845
1846
1847
1848
1849
1850 struct wait_queue * bdflush_wait = NULL;
1851 struct wait_queue * bdflush_done = NULL;
1852
1853 static void wakeup_bdflush(int wait)
1854 {
1855 wake_up(&bdflush_wait);
1856 if (wait) {
1857 run_task_queue(&tq_disk);
1858 sleep_on(&bdflush_done);
1859 }
1860 }
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871 asmlinkage int sync_old_buffers(void)
1872 {
1873 int i, isize;
1874 int ndirty, nwritten;
1875 int nlist;
1876 int ncount;
1877 struct buffer_head * bh, *next;
1878
1879 sync_supers(0);
1880 sync_inodes(0);
1881
1882 ncount = 0;
1883 #ifdef DEBUG
1884 for(nlist = 0; nlist < NR_LIST; nlist++)
1885 #else
1886 for(nlist = BUF_DIRTY; nlist <= BUF_DIRTY; nlist++)
1887 #endif
1888 {
1889 ndirty = 0;
1890 nwritten = 0;
1891 repeat:
1892 bh = lru_list[nlist];
1893 if(bh)
1894 for (i = nr_buffers_type[nlist]; i-- > 0; bh = next) {
1895
1896 if(bh->b_list != nlist) goto repeat;
1897 next = bh->b_next_free;
1898 if(!lru_list[nlist]) {
1899 printk("Dirty list empty %d\n", i);
1900 break;
1901 }
1902
1903
1904 if (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
1905 {
1906 refile_buffer(bh);
1907 continue;
1908 }
1909
1910 if (buffer_locked(bh) || !buffer_dirty(bh))
1911 continue;
1912 ndirty++;
1913 if(bh->b_flushtime > jiffies) continue;
1914 nwritten++;
1915 bh->b_count++;
1916 bh->b_flushtime = 0;
1917 #ifdef DEBUG
1918 if(nlist != BUF_DIRTY) ncount++;
1919 #endif
1920 ll_rw_block(WRITE, 1, &bh);
1921 bh->b_count--;
1922 }
1923 }
1924 #ifdef DEBUG
1925 if (ncount) printk("sync_old_buffers: %d dirty buffers not on dirty list\n", ncount);
1926 printk("Wrote %d/%d buffers\n", nwritten, ndirty);
1927 #endif
1928
1929
1930
1931
1932 for(isize = 0; isize<NR_SIZES; isize++){
1933 CALC_LOAD(buffers_lav[isize], bdf_prm.b_un.lav_const, buffer_usage[isize]);
1934 buffer_usage[isize] = 0;
1935 }
1936 return 0;
1937 }
1938
1939
1940
1941
1942
1943
1944
1945 asmlinkage int sys_bdflush(int func, long data)
1946 {
1947 int i, error;
1948
1949 if (!suser())
1950 return -EPERM;
1951
1952 if (func == 1)
1953 return sync_old_buffers();
1954
1955
1956 if (func >= 2) {
1957 i = (func-2) >> 1;
1958 if (i < 0 || i >= N_PARAM)
1959 return -EINVAL;
1960 if((func & 1) == 0) {
1961 error = verify_area(VERIFY_WRITE, (void *) data, sizeof(int));
1962 if (error)
1963 return error;
1964 put_user(bdf_prm.data[i], (int*)data);
1965 return 0;
1966 };
1967 if (data < bdflush_min[i] || data > bdflush_max[i])
1968 return -EINVAL;
1969 bdf_prm.data[i] = data;
1970 return 0;
1971 };
1972
1973
1974
1975
1976
1977 return 0;
1978 }
1979
1980
1981
1982
1983
1984 int bdflush(void * unused)
1985 {
1986 int i;
1987 int ndirty;
1988 int nlist;
1989 int ncount;
1990 struct buffer_head * bh, *next;
1991
1992
1993
1994
1995
1996
1997
1998 current->session = 1;
1999 current->pgrp = 1;
2000 sprintf(current->comm, "kflushd");
2001
2002
2003
2004
2005
2006
2007
2008 #ifdef __SMP__
2009 lock_kernel();
2010 syscall_count++;
2011 #endif
2012
2013 for (;;) {
2014 #ifdef DEBUG
2015 printk("bdflush() activated...");
2016 #endif
2017
2018 ncount = 0;
2019 #ifdef DEBUG
2020 for(nlist = 0; nlist < NR_LIST; nlist++)
2021 #else
2022 for(nlist = BUF_DIRTY; nlist <= BUF_DIRTY; nlist++)
2023 #endif
2024 {
2025 ndirty = 0;
2026 repeat:
2027 bh = lru_list[nlist];
2028 if(bh)
2029 for (i = nr_buffers_type[nlist]; i-- > 0 && ndirty < bdf_prm.b_un.ndirty;
2030 bh = next) {
2031
2032 if(bh->b_list != nlist) goto repeat;
2033 next = bh->b_next_free;
2034 if(!lru_list[nlist]) {
2035 printk("Dirty list empty %d\n", i);
2036 break;
2037 }
2038
2039
2040 if (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
2041 {
2042 refile_buffer(bh);
2043 continue;
2044 }
2045
2046 if (buffer_locked(bh) || !buffer_dirty(bh))
2047 continue;
2048
2049
2050 bh->b_count++;
2051 ndirty++;
2052 bh->b_flushtime = 0;
2053 ll_rw_block(WRITE, 1, &bh);
2054 #ifdef DEBUG
2055 if(nlist != BUF_DIRTY) ncount++;
2056 #endif
2057 bh->b_count--;
2058 }
2059 }
2060 #ifdef DEBUG
2061 if (ncount) printk("sys_bdflush: %d dirty buffers not on dirty list\n", ncount);
2062 printk("sleeping again.\n");
2063 #endif
2064 run_task_queue(&tq_disk);
2065 wake_up(&bdflush_done);
2066
2067
2068
2069
2070 if(nr_buffers_type[BUF_DIRTY] <= (nr_buffers - nr_buffers_type[BUF_SHARED]) *
2071 bdf_prm.b_un.nfract/100) {
2072 current->signal = 0;
2073 interruptible_sleep_on(&bdflush_wait);
2074 }
2075 }
2076 }
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094