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