[PATCH] ufs cleanup
[linux-2.6.git] / fs / ufs / balloc.c
1 /*
2  *  linux/fs/ufs/balloc.c
3  *
4  * Copyright (C) 1998
5  * Daniel Pirkl <daniel.pirkl@email.cz>
6  * Charles University, Faculty of Mathematics and Physics
7  */
8
9 #include <linux/fs.h>
10 #include <linux/ufs_fs.h>
11 #include <linux/stat.h>
12 #include <linux/time.h>
13 #include <linux/string.h>
14 #include <linux/quotaops.h>
15 #include <linux/buffer_head.h>
16 #include <linux/capability.h>
17 #include <linux/sched.h>
18 #include <linux/bitops.h>
19 #include <asm/byteorder.h>
20
21 #include "swab.h"
22 #include "util.h"
23
24 #undef UFS_BALLOC_DEBUG
25
26 #ifdef UFS_BALLOC_DEBUG
27 #define UFSD(x) printk("(%s, %d), %s:", __FILE__, __LINE__, __FUNCTION__); printk x;
28 #else
29 #define UFSD(x)
30 #endif
31
32 static unsigned ufs_add_fragments (struct inode *, unsigned, unsigned, unsigned, int *);
33 static unsigned ufs_alloc_fragments (struct inode *, unsigned, unsigned, unsigned, int *);
34 static unsigned ufs_alloccg_block (struct inode *, struct ufs_cg_private_info *, unsigned, int *);
35 static unsigned ufs_bitmap_search (struct super_block *, struct ufs_cg_private_info *, unsigned, unsigned);
36 static unsigned char ufs_fragtable_8fpb[], ufs_fragtable_other[];
37 static void ufs_clusteracct(struct super_block *, struct ufs_cg_private_info *, unsigned, int);
38
39 /*
40  * Free 'count' fragments from fragment number 'fragment'
41  */
42 void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count) {
43         struct super_block * sb;
44         struct ufs_sb_private_info * uspi;
45         struct ufs_super_block_first * usb1;
46         struct ufs_cg_private_info * ucpi;
47         struct ufs_cylinder_group * ucg;
48         unsigned cgno, bit, end_bit, bbase, blkmap, i, blkno, cylno;
49         
50         sb = inode->i_sb;
51         uspi = UFS_SB(sb)->s_uspi;
52         usb1 = ubh_get_usb_first(uspi);
53         
54         UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
55         
56         if (ufs_fragnum(fragment) + count > uspi->s_fpg)
57                 ufs_error (sb, "ufs_free_fragments", "internal error");
58         
59         lock_super(sb);
60         
61         cgno = ufs_dtog(fragment);
62         bit = ufs_dtogd(fragment);
63         if (cgno >= uspi->s_ncg) {
64                 ufs_panic (sb, "ufs_free_fragments", "freeing blocks are outside device");
65                 goto failed;
66         }
67                 
68         ucpi = ufs_load_cylinder (sb, cgno);
69         if (!ucpi) 
70                 goto failed;
71         ucg = ubh_get_ucg (UCPI_UBH);
72         if (!ufs_cg_chkmagic(sb, ucg)) {
73                 ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);
74                 goto failed;
75         }
76
77         end_bit = bit + count;
78         bbase = ufs_blknum (bit);
79         blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
80         ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1);
81         for (i = bit; i < end_bit; i++) {
82                 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i))
83                         ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i);
84                 else 
85                         ufs_error (sb, "ufs_free_fragments",
86                                    "bit already cleared for fragment %u", i);
87         }
88         
89         DQUOT_FREE_BLOCK (inode, count);
90
91         
92         fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
93         fs32_add(sb, &usb1->fs_cstotal.cs_nffree, count);
94         fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
95         blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
96         ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);
97
98         /*
99          * Trying to reassemble free fragments into block
100          */
101         blkno = ufs_fragstoblks (bbase);
102         if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
103                 fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb);
104                 fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, uspi->s_fpb);
105                 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, uspi->s_fpb);
106                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
107                         ufs_clusteracct (sb, ucpi, blkno, 1);
108                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
109                 fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
110                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
111                 cylno = ufs_cbtocylno (bbase);
112                 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(bbase)), 1);
113                 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
114         }
115         
116         ubh_mark_buffer_dirty (USPI_UBH);
117         ubh_mark_buffer_dirty (UCPI_UBH);
118         if (sb->s_flags & MS_SYNCHRONOUS) {
119                 ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
120                 ubh_wait_on_buffer (UCPI_UBH);
121         }
122         sb->s_dirt = 1;
123         
124         unlock_super (sb);
125         UFSD(("EXIT\n"))
126         return;
127
128 failed:
129         unlock_super (sb);
130         UFSD(("EXIT (FAILED)\n"))
131         return;
132 }
133
134 /*
135  * Free 'count' fragments from fragment number 'fragment' (free whole blocks)
136  */
137 void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
138         struct super_block * sb;
139         struct ufs_sb_private_info * uspi;
140         struct ufs_super_block_first * usb1;
141         struct ufs_cg_private_info * ucpi;
142         struct ufs_cylinder_group * ucg;
143         unsigned overflow, cgno, bit, end_bit, blkno, i, cylno;
144         
145         sb = inode->i_sb;
146         uspi = UFS_SB(sb)->s_uspi;
147         usb1 = ubh_get_usb_first(uspi);
148
149         UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
150         
151         if ((fragment & uspi->s_fpbmask) || (count & uspi->s_fpbmask)) {
152                 ufs_error (sb, "ufs_free_blocks", "internal error, "
153                         "fragment %u, count %u\n", fragment, count);
154                 goto failed;
155         }
156
157         lock_super(sb);
158         
159 do_more:
160         overflow = 0;
161         cgno = ufs_dtog (fragment);
162         bit = ufs_dtogd (fragment);
163         if (cgno >= uspi->s_ncg) {
164                 ufs_panic (sb, "ufs_free_blocks", "freeing blocks are outside device");
165                 goto failed;
166         }
167         end_bit = bit + count;
168         if (end_bit > uspi->s_fpg) {
169                 overflow = bit + count - uspi->s_fpg;
170                 count -= overflow;
171                 end_bit -= overflow;
172         }
173
174         ucpi = ufs_load_cylinder (sb, cgno);
175         if (!ucpi) 
176                 goto failed;
177         ucg = ubh_get_ucg (UCPI_UBH);
178         if (!ufs_cg_chkmagic(sb, ucg)) {
179                 ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);
180                 goto failed;
181         }
182
183         for (i = bit; i < end_bit; i += uspi->s_fpb) {
184                 blkno = ufs_fragstoblks(i);
185                 if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
186                         ufs_error(sb, "ufs_free_blocks", "freeing free fragment");
187                 }
188                 ubh_setblock(UCPI_UBH, ucpi->c_freeoff, blkno);
189                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
190                         ufs_clusteracct (sb, ucpi, blkno, 1);
191                 DQUOT_FREE_BLOCK(inode, uspi->s_fpb);
192
193                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
194                 fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
195                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
196                 cylno = ufs_cbtocylno(i);
197                 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(i)), 1);
198                 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
199         }
200
201         ubh_mark_buffer_dirty (USPI_UBH);
202         ubh_mark_buffer_dirty (UCPI_UBH);
203         if (sb->s_flags & MS_SYNCHRONOUS) {
204                 ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
205                 ubh_wait_on_buffer (UCPI_UBH);
206         }
207
208         if (overflow) {
209                 fragment += count;
210                 count = overflow;
211                 goto do_more;
212         }
213
214         sb->s_dirt = 1;
215         unlock_super (sb);
216         UFSD(("EXIT\n"))
217         return;
218
219 failed:
220         unlock_super (sb);
221         UFSD(("EXIT (FAILED)\n"))
222         return;
223 }
224
225
226
227 #define NULLIFY_FRAGMENTS \
228         for (i = oldcount; i < newcount; i++) { \
229                 bh = sb_getblk(sb, result + i); \
230                 memset (bh->b_data, 0, sb->s_blocksize); \
231                 set_buffer_uptodate(bh); \
232                 mark_buffer_dirty (bh); \
233                 if (IS_SYNC(inode)) \
234                         sync_dirty_buffer(bh); \
235                 brelse (bh); \
236         }
237
238 unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
239         unsigned goal, unsigned count, int * err )
240 {
241         struct super_block * sb;
242         struct ufs_sb_private_info * uspi;
243         struct ufs_super_block_first * usb1;
244         struct buffer_head * bh;
245         unsigned cgno, oldcount, newcount, tmp, request, i, result;
246         
247         UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count))
248         
249         sb = inode->i_sb;
250         uspi = UFS_SB(sb)->s_uspi;
251         usb1 = ubh_get_usb_first(uspi);
252         *err = -ENOSPC;
253
254         lock_super (sb);
255         
256         tmp = fs32_to_cpu(sb, *p);
257         if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
258                 ufs_warning (sb, "ufs_new_fragments", "internal warning"
259                         " fragment %u, count %u", fragment, count);
260                 count = uspi->s_fpb - ufs_fragnum(fragment); 
261         }
262         oldcount = ufs_fragnum (fragment);
263         newcount = oldcount + count;
264
265         /*
266          * Somebody else has just allocated our fragments
267          */
268         if (oldcount) {
269                 if (!tmp) {
270                         ufs_error (sb, "ufs_new_fragments", "internal error, "
271                                 "fragment %u, tmp %u\n", fragment, tmp);
272                         unlock_super (sb);
273                         return (unsigned)-1;
274                 }
275                 if (fragment < UFS_I(inode)->i_lastfrag) {
276                         UFSD(("EXIT (ALREADY ALLOCATED)\n"))
277                         unlock_super (sb);
278                         return 0;
279                 }
280         }
281         else {
282                 if (tmp) {
283                         UFSD(("EXIT (ALREADY ALLOCATED)\n"))
284                         unlock_super(sb);
285                         return 0;
286                 }
287         }
288
289         /*
290          * There is not enough space for user on the device
291          */
292         if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(usb1, UFS_MINFREE) <= 0) {
293                 unlock_super (sb);
294                 UFSD(("EXIT (FAILED)\n"))
295                 return 0;
296         }
297
298         if (goal >= uspi->s_size) 
299                 goal = 0;
300         if (goal == 0) 
301                 cgno = ufs_inotocg (inode->i_ino);
302         else
303                 cgno = ufs_dtog (goal);
304          
305         /*
306          * allocate new fragment
307          */
308         if (oldcount == 0) {
309                 result = ufs_alloc_fragments (inode, cgno, goal, count, err);
310                 if (result) {
311                         *p = cpu_to_fs32(sb, result);
312                         *err = 0;
313                         inode->i_blocks += count << uspi->s_nspfshift;
314                         UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
315                         NULLIFY_FRAGMENTS
316                 }
317                 unlock_super(sb);
318                 UFSD(("EXIT, result %u\n", result))
319                 return result;
320         }
321
322         /*
323          * resize block
324          */
325         result = ufs_add_fragments (inode, tmp, oldcount, newcount, err);
326         if (result) {
327                 *err = 0;
328                 inode->i_blocks += count << uspi->s_nspfshift;
329                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
330                 NULLIFY_FRAGMENTS
331                 unlock_super(sb);
332                 UFSD(("EXIT, result %u\n", result))
333                 return result;
334         }
335
336         /*
337          * allocate new block and move data
338          */
339         switch (fs32_to_cpu(sb, usb1->fs_optim)) {
340             case UFS_OPTSPACE:
341                 request = newcount;
342                 if (uspi->s_minfree < 5 || fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree) 
343                     > uspi->s_dsize * uspi->s_minfree / (2 * 100) )
344                         break;
345                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
346                 break;
347             default:
348                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
349         
350             case UFS_OPTTIME:
351                 request = uspi->s_fpb;
352                 if (fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree) < uspi->s_dsize *
353                     (uspi->s_minfree - 2) / 100)
354                         break;
355                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
356                 break;
357         }
358         result = ufs_alloc_fragments (inode, cgno, goal, request, err);
359         if (result) {
360                 for (i = 0; i < oldcount; i++) {
361                         bh = sb_bread(sb, tmp + i);
362                         if(bh)
363                         {
364                                 clear_buffer_dirty(bh);
365                                 bh->b_blocknr = result + i;
366                                 mark_buffer_dirty (bh);
367                                 if (IS_SYNC(inode))
368                                         sync_dirty_buffer(bh);
369                                 brelse (bh);
370                         }
371                         else
372                         {
373                                 printk(KERN_ERR "ufs_new_fragments: bread fail\n");
374                                 unlock_super(sb);
375                                 return 0;
376                         }
377                 }
378                 *p = cpu_to_fs32(sb, result);
379                 *err = 0;
380                 inode->i_blocks += count << uspi->s_nspfshift;
381                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
382                 NULLIFY_FRAGMENTS
383                 unlock_super(sb);
384                 if (newcount < request)
385                         ufs_free_fragments (inode, result + newcount, request - newcount);
386                 ufs_free_fragments (inode, tmp, oldcount);
387                 UFSD(("EXIT, result %u\n", result))
388                 return result;
389         }
390
391         unlock_super(sb);
392         UFSD(("EXIT (FAILED)\n"))
393         return 0;
394 }               
395
396 static unsigned
397 ufs_add_fragments (struct inode * inode, unsigned fragment,
398                    unsigned oldcount, unsigned newcount, int * err)
399 {
400         struct super_block * sb;
401         struct ufs_sb_private_info * uspi;
402         struct ufs_super_block_first * usb1;
403         struct ufs_cg_private_info * ucpi;
404         struct ufs_cylinder_group * ucg;
405         unsigned cgno, fragno, fragoff, count, fragsize, i;
406         
407         UFSD(("ENTER, fragment %u, oldcount %u, newcount %u\n", fragment, oldcount, newcount))
408         
409         sb = inode->i_sb;
410         uspi = UFS_SB(sb)->s_uspi;
411         usb1 = ubh_get_usb_first (uspi);
412         count = newcount - oldcount;
413         
414         cgno = ufs_dtog(fragment);
415         if (fs32_to_cpu(sb, UFS_SB(sb)->fs_cs(cgno).cs_nffree) < count)
416                 return 0;
417         if ((ufs_fragnum (fragment) + newcount) > uspi->s_fpb)
418                 return 0;
419         ucpi = ufs_load_cylinder (sb, cgno);
420         if (!ucpi)
421                 return 0;
422         ucg = ubh_get_ucg (UCPI_UBH);
423         if (!ufs_cg_chkmagic(sb, ucg)) {
424                 ufs_panic (sb, "ufs_add_fragments",
425                         "internal error, bad magic number on cg %u", cgno);
426                 return 0;
427         }
428
429         fragno = ufs_dtogd (fragment);
430         fragoff = ufs_fragnum (fragno);
431         for (i = oldcount; i < newcount; i++)
432                 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
433                         return 0;
434         /*
435          * Block can be extended
436          */
437         ucg->cg_time = cpu_to_fs32(sb, get_seconds());
438         for (i = newcount; i < (uspi->s_fpb - fragoff); i++)
439                 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
440                         break;
441         fragsize = i - oldcount;
442         if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
443                 ufs_panic (sb, "ufs_add_fragments",
444                         "internal error or corrupted bitmap on cg %u", cgno);
445         fs32_sub(sb, &ucg->cg_frsum[fragsize], 1);
446         if (fragsize != count)
447                 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
448         for (i = oldcount; i < newcount; i++)
449                 ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, fragno + i);
450         if(DQUOT_ALLOC_BLOCK(inode, count)) {
451                 *err = -EDQUOT;
452                 return 0;
453         }
454
455         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
456         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
457         fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
458         
459         ubh_mark_buffer_dirty (USPI_UBH);
460         ubh_mark_buffer_dirty (UCPI_UBH);
461         if (sb->s_flags & MS_SYNCHRONOUS) {
462                 ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
463                 ubh_wait_on_buffer (UCPI_UBH);
464         }
465         sb->s_dirt = 1;
466
467         UFSD(("EXIT, fragment %u\n", fragment))
468         
469         return fragment;
470 }
471
472 #define UFS_TEST_FREE_SPACE_CG \
473         ucg = (struct ufs_cylinder_group *) UFS_SB(sb)->s_ucg[cgno]->b_data; \
474         if (fs32_to_cpu(sb, ucg->cg_cs.cs_nbfree)) \
475                 goto cg_found; \
476         for (k = count; k < uspi->s_fpb; k++) \
477                 if (fs32_to_cpu(sb, ucg->cg_frsum[k])) \
478                         goto cg_found; 
479
480 static unsigned ufs_alloc_fragments (struct inode * inode, unsigned cgno,
481         unsigned goal, unsigned count, int * err)
482 {
483         struct super_block * sb;
484         struct ufs_sb_private_info * uspi;
485         struct ufs_super_block_first * usb1;
486         struct ufs_cg_private_info * ucpi;
487         struct ufs_cylinder_group * ucg;
488         unsigned oldcg, i, j, k, result, allocsize;
489         
490         UFSD(("ENTER, ino %lu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count))
491
492         sb = inode->i_sb;
493         uspi = UFS_SB(sb)->s_uspi;
494         usb1 = ubh_get_usb_first(uspi);
495         oldcg = cgno;
496         
497         /*
498          * 1. searching on preferred cylinder group
499          */
500         UFS_TEST_FREE_SPACE_CG
501
502         /*
503          * 2. quadratic rehash
504          */
505         for (j = 1; j < uspi->s_ncg; j *= 2) {
506                 cgno += j;
507                 if (cgno >= uspi->s_ncg) 
508                         cgno -= uspi->s_ncg;
509                 UFS_TEST_FREE_SPACE_CG
510         }
511
512         /*
513          * 3. brute force search
514          * We start at i = 2 ( 0 is checked at 1.step, 1 at 2.step )
515          */
516         cgno = (oldcg + 1) % uspi->s_ncg;
517         for (j = 2; j < uspi->s_ncg; j++) {
518                 cgno++;
519                 if (cgno >= uspi->s_ncg)
520                         cgno = 0;
521                 UFS_TEST_FREE_SPACE_CG
522         }
523         
524         UFSD(("EXIT (FAILED)\n"))
525         return 0;
526
527 cg_found:
528         ucpi = ufs_load_cylinder (sb, cgno);
529         if (!ucpi)
530                 return 0;
531         ucg = ubh_get_ucg (UCPI_UBH);
532         if (!ufs_cg_chkmagic(sb, ucg)) 
533                 ufs_panic (sb, "ufs_alloc_fragments",
534                         "internal error, bad magic number on cg %u", cgno);
535         ucg->cg_time = cpu_to_fs32(sb, get_seconds());
536
537         if (count == uspi->s_fpb) {
538                 result = ufs_alloccg_block (inode, ucpi, goal, err);
539                 if (result == (unsigned)-1)
540                         return 0;
541                 goto succed;
542         }
543
544         for (allocsize = count; allocsize < uspi->s_fpb; allocsize++)
545                 if (fs32_to_cpu(sb, ucg->cg_frsum[allocsize]) != 0)
546                         break;
547         
548         if (allocsize == uspi->s_fpb) {
549                 result = ufs_alloccg_block (inode, ucpi, goal, err);
550                 if (result == (unsigned)-1)
551                         return 0;
552                 goal = ufs_dtogd (result);
553                 for (i = count; i < uspi->s_fpb; i++)
554                         ubh_setbit (UCPI_UBH, ucpi->c_freeoff, goal + i);
555                 i = uspi->s_fpb - count;
556                 DQUOT_FREE_BLOCK(inode, i);
557
558                 fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
559                 fs32_add(sb, &usb1->fs_cstotal.cs_nffree, i);
560                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, i);
561                 fs32_add(sb, &ucg->cg_frsum[i], 1);
562                 goto succed;
563         }
564
565         result = ufs_bitmap_search (sb, ucpi, goal, allocsize);
566         if (result == (unsigned)-1)
567                 return 0;
568         if(DQUOT_ALLOC_BLOCK(inode, count)) {
569                 *err = -EDQUOT;
570                 return 0;
571         }
572         for (i = 0; i < count; i++)
573                 ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, result + i);
574         
575         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
576         fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
577         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
578         fs32_sub(sb, &ucg->cg_frsum[allocsize], 1);
579
580         if (count != allocsize)
581                 fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1);
582
583 succed:
584         ubh_mark_buffer_dirty (USPI_UBH);
585         ubh_mark_buffer_dirty (UCPI_UBH);
586         if (sb->s_flags & MS_SYNCHRONOUS) {
587                 ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
588                 ubh_wait_on_buffer (UCPI_UBH);
589         }
590         sb->s_dirt = 1;
591
592         result += cgno * uspi->s_fpg;
593         UFSD(("EXIT3, result %u\n", result))
594         return result;
595 }
596
597 static unsigned ufs_alloccg_block (struct inode * inode,
598         struct ufs_cg_private_info * ucpi, unsigned goal, int * err)
599 {
600         struct super_block * sb;
601         struct ufs_sb_private_info * uspi;
602         struct ufs_super_block_first * usb1;
603         struct ufs_cylinder_group * ucg;
604         unsigned result, cylno, blkno;
605
606         UFSD(("ENTER, goal %u\n", goal))
607
608         sb = inode->i_sb;
609         uspi = UFS_SB(sb)->s_uspi;
610         usb1 = ubh_get_usb_first(uspi);
611         ucg = ubh_get_ucg(UCPI_UBH);
612
613         if (goal == 0) {
614                 goal = ucpi->c_rotor;
615                 goto norot;
616         }
617         goal = ufs_blknum (goal);
618         goal = ufs_dtogd (goal);
619         
620         /*
621          * If the requested block is available, use it.
622          */
623         if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, ufs_fragstoblks(goal))) {
624                 result = goal;
625                 goto gotit;
626         }
627         
628 norot:  
629         result = ufs_bitmap_search (sb, ucpi, goal, uspi->s_fpb);
630         if (result == (unsigned)-1)
631                 return (unsigned)-1;
632         ucpi->c_rotor = result;
633 gotit:
634         blkno = ufs_fragstoblks(result);
635         ubh_clrblock (UCPI_UBH, ucpi->c_freeoff, blkno);
636         if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
637                 ufs_clusteracct (sb, ucpi, blkno, -1);
638         if(DQUOT_ALLOC_BLOCK(inode, uspi->s_fpb)) {
639                 *err = -EDQUOT;
640                 return (unsigned)-1;
641         }
642
643         fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1);
644         fs32_sub(sb, &usb1->fs_cstotal.cs_nbfree, 1);
645         fs32_sub(sb, &UFS_SB(sb)->fs_cs(ucpi->c_cgx).cs_nbfree, 1);
646         cylno = ufs_cbtocylno(result);
647         fs16_sub(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(result)), 1);
648         fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1);
649         
650         UFSD(("EXIT, result %u\n", result))
651
652         return result;
653 }
654
655 static unsigned ufs_bitmap_search (struct super_block * sb,
656         struct ufs_cg_private_info * ucpi, unsigned goal, unsigned count)
657 {
658         struct ufs_sb_private_info * uspi;
659         struct ufs_super_block_first * usb1;
660         struct ufs_cylinder_group * ucg;
661         unsigned start, length, location, result;
662         unsigned possition, fragsize, blockmap, mask;
663         
664         UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count))
665
666         uspi = UFS_SB(sb)->s_uspi;
667         usb1 = ubh_get_usb_first (uspi);
668         ucg = ubh_get_ucg(UCPI_UBH);
669
670         if (goal)
671                 start = ufs_dtogd(goal) >> 3;
672         else
673                 start = ucpi->c_frotor >> 3;
674                 
675         length = ((uspi->s_fpg + 7) >> 3) - start;
676         location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff + start, length,
677                 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
678                 1 << (count - 1 + (uspi->s_fpb & 7))); 
679         if (location == 0) {
680                 length = start + 1;
681                 location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff, length, 
682                         (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
683                         1 << (count - 1 + (uspi->s_fpb & 7)));
684                 if (location == 0) {
685                         ufs_error (sb, "ufs_bitmap_search",
686                         "bitmap corrupted on cg %u, start %u, length %u, count %u, freeoff %u\n",
687                         ucpi->c_cgx, start, length, count, ucpi->c_freeoff);
688                         return (unsigned)-1;
689                 }
690                 start = 0;
691         }
692         result = (start + length - location) << 3;
693         ucpi->c_frotor = result;
694
695         /*
696          * found the byte in the map
697          */
698         blockmap = ubh_blkmap(UCPI_UBH, ucpi->c_freeoff, result);
699         fragsize = 0;
700         for (possition = 0, mask = 1; possition < 8; possition++, mask <<= 1) {
701                 if (blockmap & mask) {
702                         if (!(possition & uspi->s_fpbmask))
703                                 fragsize = 1;
704                         else 
705                                 fragsize++;
706                 }
707                 else {
708                         if (fragsize == count) {
709                                 result += possition - count;
710                                 UFSD(("EXIT, result %u\n", result))
711                                 return result;
712                         }
713                         fragsize = 0;
714                 }
715         }
716         if (fragsize == count) {
717                 result += possition - count;
718                 UFSD(("EXIT, result %u\n", result))
719                 return result;
720         }
721         ufs_error (sb, "ufs_bitmap_search", "block not in map on cg %u\n", ucpi->c_cgx);
722         UFSD(("EXIT (FAILED)\n"))
723         return (unsigned)-1;
724 }
725
726 static void ufs_clusteracct(struct super_block * sb,
727         struct ufs_cg_private_info * ucpi, unsigned blkno, int cnt)
728 {
729         struct ufs_sb_private_info * uspi;
730         int i, start, end, forw, back;
731         
732         uspi = UFS_SB(sb)->s_uspi;
733         if (uspi->s_contigsumsize <= 0)
734                 return;
735
736         if (cnt > 0)
737                 ubh_setbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
738         else
739                 ubh_clrbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
740
741         /*
742          * Find the size of the cluster going forward.
743          */
744         start = blkno + 1;
745         end = start + uspi->s_contigsumsize;
746         if ( end >= ucpi->c_nclusterblks)
747                 end = ucpi->c_nclusterblks;
748         i = ubh_find_next_zero_bit (UCPI_UBH, ucpi->c_clusteroff, end, start);
749         if (i > end)
750                 i = end;
751         forw = i - start;
752         
753         /*
754          * Find the size of the cluster going backward.
755          */
756         start = blkno - 1;
757         end = start - uspi->s_contigsumsize;
758         if (end < 0 ) 
759                 end = -1;
760         i = ubh_find_last_zero_bit (UCPI_UBH, ucpi->c_clusteroff, start, end);
761         if ( i < end) 
762                 i = end;
763         back = start - i;
764         
765         /*
766          * Account for old cluster and the possibly new forward and
767          * back clusters.
768          */
769         i = back + forw + 1;
770         if (i > uspi->s_contigsumsize)
771                 i = uspi->s_contigsumsize;
772         fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (i << 2)), cnt);
773         if (back > 0)
774                 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (back << 2)), cnt);
775         if (forw > 0)
776                 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (forw << 2)), cnt);
777 }
778
779
780 static unsigned char ufs_fragtable_8fpb[] = {
781         0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08,
782         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x08, 0x10,
783         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
784         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x04, 0x05, 0x05, 0x06, 0x08, 0x09, 0x10, 0x20,
785         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, 
786         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
787         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A,
788         0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x08, 0x09, 0x09, 0x0A, 0x10, 0x11, 0x20, 0x40,
789         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
790         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
791         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
792         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x05, 0x05, 0x05, 0x07, 0x09, 0x09, 0x11, 0x21,
793         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A,
794         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x02, 0x03, 0x03, 0x02, 0x06, 0x07, 0x0A, 0x12,
795         0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x05, 0x07, 0x06, 0x07, 0x04, 0x0C,
796         0x08, 0x09, 0x09, 0x0A, 0x09, 0x09, 0x0A, 0x0C, 0x10, 0x11, 0x11, 0x12, 0x20, 0x21, 0x40, 0x80,
797 };
798
799 static unsigned char ufs_fragtable_other[] = {
800         0x00, 0x16, 0x16, 0x2A, 0x16, 0x16, 0x26, 0x4E, 0x16, 0x16, 0x16, 0x3E, 0x2A, 0x3E, 0x4E, 0x8A,
801         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
802         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
803         0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA,
804         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
805         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
806         0x26, 0x36, 0x36, 0x2E, 0x36, 0x36, 0x26, 0x6E, 0x36, 0x36, 0x36, 0x3E, 0x2E, 0x3E, 0x6E, 0xAE,
807         0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE,
808         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
809         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
810         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
811         0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE,
812         0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA,
813         0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE,
814         0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE,
815         0x8A, 0x9E, 0x9E, 0xAA, 0x9E, 0x9E, 0xAE, 0xCE, 0x9E, 0x9E, 0x9E, 0xBE, 0xAA, 0xBE, 0xCE, 0x8A,
816 };